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

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

传真(Fax)编程

开发平台：

C/C++

FileTransfer.c++：源码内容
  1. /* $Id: FileTransfer.c++,v 1.5 2008/01/26 19:18:28 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 transfer commands.
  29.  */
  30. #include "HylaFAXServer.h"
  31. #include "Sys.h"
  32. #include "config.h"
  33. #include "zlib.h"
  34. #include "tiffio.h"
  36. #include <ctype.h>
  37. #include <limits.h>
  38. #ifdef HAVE_STDINT_H
  39. #include <stdint.h>
  40. #endif
  42. #ifndef CHAR_BIT
  43. #ifdef NBBY
  44. #define CHAR_BIT NBBY
  45. #else
  46. #define CHAR_BIT 8
  47. #endif
  48. #endif /* CHAR_BIT */
  50. static  const char* typenames[] =  { "ASCII", "EBCDIC", "Image", "Local" };
  51. static  const char* strunames[] =  { "File", "Record", "Page", "TIFF" };
  52. static  const char* modenames[] =  { "Stream", "Block", "Compressed", "ZIP" };
  54. /*
  55.  * Record a file transfer in the log file.
  56.  */
  57. void
  58. HylaFAXServer::logTransfer(const char* direction,
  59.     const SpoolDir& sd, const char* pathname, time_t start)
  60. {
  61.     time_t now = Sys::now();
  62.     time_t xferfaxtime = now - start;
  63.     if (xferfaxtime == 0)
  64. xferfaxtime++;
  65.     const char* filename = strrchr(pathname, '/');
  66.     fxStr msg(fxStr::format("%.24st%lut%st%lut%s/%st%st%sn"
  67. , ctime(&now)
  68. , (u_long) xferfaxtime
  69. , (const char*) remotehost
  70. , (u_long) byte_count
  71. , sd.pathname, filename ? filename+1 : pathname
  72. , direction
  73. , (const char*) the_user
  74.     ));
  75.     (void) Sys::write(xferfaxlog, msg, msg.length());
  76. }
  78. bool
  79. HylaFAXServer::restartSend(FILE* fd, off_t marker)
  80. {
  81.     if (type == TYPE_A) { // restart based on line count
  82. int c;
  83. while ((c = getc(fd)) != EOF)
  84.     if (c == 'n' && --marker == 0)
  85. return (true);
  86. return (false);
  87.     } else // restart based on file offset
  88. return (lseek(fileno(fd), marker, SEEK_SET) == marker);
  89. }
  91. /*
  92.  * RETRieve a file.
  93.  */
  94. void
  95. HylaFAXServer::retrieveCmd(const char* name)
  96. {
  97.     struct stat sb;
  98.     SpoolDir* sd = fileAccess(name, R_OK, sb);
  99.     if (sd) {
  100. FILE* fd = fopen(name, "r");
  101. if (fd != NULL) {
  102.     if (restart_point && !restartSend(fd, restart_point)) {
  103. perror_reply(550, name, errno);
  104.     } else {
  105. time_t start_time = Sys::now();
  106. int code;
  107. FILE* dout = openDataConn("w", code);
  108. if (dout != NULL) {
  109.     file_size = sb.st_size;
  110.     reply(code, "%s for %s (%lu bytes).",
  111. dataConnMsg(code), name, (u_long) file_size);
  112.     if (sendData(fd, dout))
  113. reply(226, "Transfer complete.");
  114.     if (TRACE(OUTXFERS) && xferfaxlog != -1)
  115. logTransfer("o", *sd, name, start_time);
  116.     closeDataConn(dout);
  117. }
  118.     }
  119.     fclose(fd);
  120. } else if (errno != 0)
  121.     perror_reply(550, name, errno);
  122. else
  123.     reply(550, "%s: Cannot open file.", name);
  124.     }
  125. }
  127. /*
  128.  * TIFF Directory Template used in returning
  129.  * a single IFD/image from a TIFF file.
  130.  */
  131. typedef struct {
  132.     TIFFDirEntry SubFileType;
  133.     TIFFDirEntry ImageWidth;
  134.     TIFFDirEntry ImageLength;
  135.     TIFFDirEntry BitsPerSample;
  136.     TIFFDirEntry Compression;
  137.     TIFFDirEntry Photometric;
  138.     TIFFDirEntry FillOrder;
  139.     TIFFDirEntry StripOffsets;
  140.     TIFFDirEntry Orientation;
  141.     TIFFDirEntry SamplesPerPixel;
  142.     TIFFDirEntry RowsPerStrip;
  143.     TIFFDirEntry StripByteCounts;
  144.     TIFFDirEntry XResolution;
  145.     TIFFDirEntry YResolution;
  146.     TIFFDirEntry Options; // T4 or T6
  147.     TIFFDirEntry ResolutionUnit;
  148.     TIFFDirEntry PageNumber;
  149.     TIFFDirEntry BadFaxLines;
  150.     TIFFDirEntry CleanFaxData;
  151.     TIFFDirEntry ConsecutiveBadFaxLines;
  152.     uint32 link; // offset to next directory
  153.     uint32 xres[2]; // X resolution indirect value
  154.     uint32 yres[2]; // Y resolution indirect value
  155. } DirTemplate;
  157. /*
  158.  * RETrieve one Page from a file.  For now the
  159.  * file must be a TIFF image; we might try to
  160.  * handle PostScript at a later time (but don't
  161.  * hold your breath as there's not much reason).
  162.  */
  163. void
  164. HylaFAXServer::retrievePageCmd(const char* name)
  165. {
  166.     TIFF* tif = cachedTIFF;
  167.     if (tif != NULL && streq(name, TIFFFileName(tif))) {
  168. /*
  169.  * Reuse the cached open file.  If no directory
  170.  * has been specified with a REST command then
  171.  * return the next consecutive directory in the file.
  172.  */
  173. if (restart_point == 0) // advance to next directory
  174.     restart_point = TIFFCurrentDirectory(tif)+1;
  175.     } else {
  176. if (tif) // close cached handle
  177.     TIFFClose(tif), cachedTIFF = NULL;
  178. tif = openTIFF(name);
  179.     }
  180.     if (tif != NULL) {
  181. if (restart_point && !TIFFSetDirectory(tif, (tdir_t) restart_point)) {
  182.     reply(550, "%s: Unable to access directory %lu.",
  183. name, (u_long) restart_point);
  184. } else {
  185.     time_t start_time = Sys::now();
  186.     int code;
  187.     FILE* dout = openDataConn("w", code);
  188.     if (dout != NULL) {
  189. /*
  190.  * Calculate "file size" by totalling up the
  191.  * amount of image data and then adding in
  192.  * the expected data for the TIFF headers.
  193.  */
  194. uint32* sb;
  195. TIFFGetField(tif, TIFFTAG_STRIPBYTECOUNTS, &sb);
  196. file_size = sizeof (DirTemplate) +
  197.     sizeof (TIFFHeader) + sizeof (uint16);
  198. for (tstrip_t s = 0, ns = TIFFNumberOfStrips(tif); s < ns; s++)
  199.     file_size += sb[s];
  200. reply(code, "%s for %s (%lu bytes).",
  201.     dataConnMsg(code), name, (u_long) file_size);
  202. if (sendTIFFData(tif, dout))
  203.     reply(226, "Transfer complete.");
  204. if (TRACE(OUTXFERS) && xferfaxlog != -1) {
  205.     struct stat sb;
  206.     SpoolDir* sd = fileAccess(name, R_OK, sb);
  207.     logTransfer("o", *sd, name, start_time);
  208. }
  209. closeDataConn(dout);
  210.     }
  211. }
  212. cachedTIFF = tif;
  213.     }
  214. }
  216. /*
  217.  * Open a file that is expected to hold a TIFF image.
  218.  */
  219. TIFF*
  220. HylaFAXServer::openTIFF(const char* name)
  221. {
  222.     struct stat sb;
  223.     SpoolDir* sd = fileAccess(name, R_OK, sb);
  224.     if (sd) {
  225. int fd = Sys::open(name, O_RDONLY);
  226. if (fd >= 0) {
  227.     union {
  228. char buf[512];
  229. TIFFHeader h;
  230.     } b;
  231.     ssize_t cc = Sys::read(fd, (char*) &b, sizeof (b));
  232.     if (cc > (ssize_t)sizeof (b.h) && b.h.tiff_version == TIFF_VERSION &&
  233.       (b.h.tiff_magic == TIFF_BIGENDIAN ||
  234.        b.h.tiff_magic == TIFF_LITTLEENDIAN)) {
  235. (void) lseek(fd, 0L, SEEK_SET); // rewind
  236. TIFF* tif = TIFFFdOpen(fd, name, "r");
  237. if (tif != NULL)
  238.     return (tif);
  239. else
  240.     reply(550, "%s: Incomplete or invalid TIFF file.", name);
  241.     } else
  242. reply(550, "%s: Not a TIFF file.", name);
  243.     Sys::close(fd);
  244. } else if (errno != 0)
  245.     perror_reply(550, name, errno);
  246. else
  247.     reply(550, "%s: Cannot open file.", name);
  248.     }
  249.     return (NULL);
  250. }
  252. /*
  253.  * Tranfer the current directory's contents of "tif" to "fdout".
  254.  */
  255. bool
  256. HylaFAXServer::sendTIFFData(TIFF* tif, FILE* fdout)
  257. {
  258.     state |= S_TRANSFER;
  259.     if (setjmp(urgcatch) != 0) {
  260. state &= ~S_TRANSFER;
  261. return (false);
  262.     }
  263. #define PACK(a,b) (((a)<<8)|(b))
  264.     switch (PACK(type,mode)) {
  265.     case PACK(TYPE_I,MODE_S):
  266.     case PACK(TYPE_L,MODE_S):
  267. if (sendTIFFHeader(tif, fileno(fdout)) &&
  268.     sendITIFFData(tif, fileno(fdout))) {
  269.     state &= ~S_TRANSFER;
  270.     return (true);
  271. }
  272. break;
  273.     default:
  274. reply(550, "TYPE %s, MODE %s not implemented."
  275.     , typenames[type]
  276.     , modenames[mode]
  277. );
  278. break;
  279.     }
  280. #undef PACK
  281.     state &= ~S_TRANSFER;
  282.     return (false);
  283. }
  285. static void
  286. getLong(TIFF* tif, TIFFDirEntry& de)
  287. {
  288.     TIFFGetField(tif, de.tdir_tag, &de.tdir_offset);
  289. }
  290. static void
  291. getShort(TIFF* tif, TIFFDirEntry& de)
  292. {
  293.     uint16 v;
  294.     TIFFGetField(tif, de.tdir_tag, &v);
  295.     de.tdir_offset = (uint32) v;
  296. }
  298. /*
  299.  * Send a TIFF header and IFD for the current directory
  300.  * in the open TIFF file.  The image data is expected to
  301.  * immediately follow this information (i.e. the value of
  302.  * the StripByteOffsets tag is setup to point to the offset
  303.  * immediately after this data) and it is assumed that
  304.  * all image data is concatenated into a single strip.
  305.  */
  306. bool
  307. HylaFAXServer::sendTIFFHeader(TIFF* tif, int fdout)
  308. {
  309.     static DirTemplate templ = {
  310. #define TIFFdiroff(v) 
  311.     (uint32) (sizeof (TIFFHeader) + sizeof (uint16) + 
  312.       (intptr_t) &(((DirTemplate*) 0)->v))
  313. { TIFFTAG_SUBFILETYPE, TIFF_LONG, 1 },
  314. { TIFFTAG_IMAGEWIDTH, TIFF_LONG, 1 },
  315. { TIFFTAG_IMAGELENGTH, TIFF_LONG,  1 },
  316. { TIFFTAG_BITSPERSAMPLE, TIFF_SHORT, 1,  1 },
  317. { TIFFTAG_COMPRESSION, TIFF_SHORT, 1 },
  318. { TIFFTAG_PHOTOMETRIC, TIFF_SHORT, 1 },
  319. { TIFFTAG_FILLORDER, TIFF_SHORT, 1 },
  320. { TIFFTAG_STRIPOFFSETS, TIFF_LONG, 1, TIFFdiroff(yres[2]) },
  321. { TIFFTAG_ORIENTATION, TIFF_SHORT, 1 },
  322. { TIFFTAG_SAMPLESPERPIXEL, TIFF_SHORT, 1,  1 },
  323. { TIFFTAG_ROWSPERSTRIP, TIFF_LONG, 1, (uint32) -1 },
  324. { TIFFTAG_STRIPBYTECOUNTS, TIFF_LONG, 1 },
  325. { TIFFTAG_XRESOLUTION, TIFF_RATIONAL, 1, TIFFdiroff(xres[0]) },
  326. { TIFFTAG_YRESOLUTION, TIFF_RATIONAL, 1, TIFFdiroff(yres[0]) },
  327. { TIFFTAG_GROUP3OPTIONS, TIFF_LONG, 1 },
  328. { TIFFTAG_RESOLUTIONUNIT, TIFF_SHORT, 1 },
  329. { TIFFTAG_PAGENUMBER, TIFF_SHORT, 2 },
  330. { TIFFTAG_BADFAXLINES, TIFF_LONG, 1 },
  331. { TIFFTAG_CLEANFAXDATA, TIFF_SHORT, 1 },
  332. { TIFFTAG_CONSECUTIVEBADFAXLINES,TIFF_LONG, 1 },
  333. 0, // next directory
  334. { 0, 1 }, { 0, 1 }, // x+y resolutions
  335.     };
  336. #define NTAGS ((TIFFdiroff(link)-TIFFdiroff(SubFileType)) / sizeof (TIFFDirEntry))
  337.     /*
  338.      * Construct the TIFF header for this IFD using
  339.      * the preconstructed template above.  We extract
  340.      * the necessary information from the open TIFF file.
  341.      * In case it's not obvious, this code assumes a lot
  342.      * of things about the contents of the TIFF file.
  343.      */
  344.     struct {
  345. TIFFHeader h;
  346. uint16 dircount;
  347. u_char dirstuff[sizeof (templ)];
  348.     } buf;
  349.     union { int32 i; char c[4]; } u; u.i = 1;
  350.     buf.h.tiff_magic = (u.c[0] == 0 ? TIFF_BIGENDIAN : TIFF_LITTLEENDIAN);
  351.     buf.h.tiff_version = TIFF_VERSION;
  352.     buf.h.tiff_diroff = sizeof (TIFFHeader);
  353.     buf.dircount = (uint16) NTAGS;
  354.     getLong(tif, templ.SubFileType);
  355.     getLong(tif, templ.ImageWidth);
  356.     getLong(tif, templ.ImageLength);
  357.     getShort(tif, templ.Compression);
  358.     getShort(tif, templ.Photometric);
  359.     getShort(tif, templ.FillOrder);
  360.     getShort(tif, templ.Orientation);
  361.     templ.StripByteCounts.tdir_offset = (uint32) file_size - sizeof (buf);
  362.     float res;
  363.     TIFFGetField(tif, TIFFTAG_XRESOLUTION, &res);
  364. templ.xres[0] = (uint32) res;
  365.     TIFFGetField(tif, TIFFTAG_YRESOLUTION, &res);
  366. templ.yres[0] = (uint32) res;
  367.     if (templ.Compression.tdir_offset == COMPRESSION_CCITTFAX3) {
  368. templ.Options.tdir_tag = TIFFTAG_GROUP3OPTIONS;
  369. getLong(tif, templ.Options);
  370.     } else if (templ.Compression.tdir_offset == COMPRESSION_CCITTFAX4) {
  371. templ.Options.tdir_tag = TIFFTAG_GROUP4OPTIONS;
  372. getLong(tif, templ.Options);
  373.     }
  374.     getShort(tif, templ.ResolutionUnit);
  375.     TIFFGetField(tif, TIFFTAG_PAGENUMBER,  &templ.PageNumber.tdir_offset);
  376.     getLong(tif, templ.BadFaxLines);
  377.     getShort(tif, templ.CleanFaxData);
  378.     getLong(tif, templ.ConsecutiveBadFaxLines);
  379.     if (buf.h.tiff_magic == TIFF_BIGENDIAN) {
  380. TIFFDirEntry* dp = &templ.SubFileType;
  381. for (u_int i = 0; i < NTAGS; i++) {
  382.     if (dp->tdir_type == TIFF_SHORT)
  383. dp->tdir_offset <<= 16;
  384.     dp++;
  385. }
  386.     }
  387.     memcpy(buf.dirstuff, &templ, sizeof (templ));
  388.     if (write(fdout, (const char*) &buf, sizeof (buf)) != sizeof (buf)) {
  389. perror_reply(426, "Data connection", errno);
  390. return (false);
  391.     } else {
  392. byte_count += sizeof (buf);
  393. return (true);
  394.     }
  395. #undef NTAGS
  396. #undef offsetof
  397. }
  399. /*
  400.  * Send the raw image data for the current directory
  401.  * in the open TIFF file.  If multiple strips are
  402.  * present in the file they are concatenated w/o
  403.  * consideration for any padding that might be present
  404.  * or might be needed.
  405.  */
  406. bool
  407. HylaFAXServer::sendITIFFData(TIFF* tif, int fdout)
  408. {
  409.     uint32* sb;
  410.     (void) TIFFGetField(tif, TIFFTAG_STRIPBYTECOUNTS, &sb);
  411.     tdata_t buf = _TIFFmalloc(sb[0]);
  412.     tsize_t bsize = sb[0];
  413.     for (tstrip_t s = 0, ns = TIFFNumberOfStrips(tif); s < ns; s++) {
  414. tsize_t cc = sb[s];
  415. if (cc > bsize) {
  416.     buf = _TIFFrealloc(buf, cc);
  417.     bsize = cc;
  418. }
  419. if (buf == NULL) {
  420.     reply(551, "Error allocating intermediate buffer");
  421.     return (false);
  422. }
  423. if (TIFFReadRawStrip(tif, s, buf, cc) != cc) {
  424.     reply(551, "Error reading input file at strip %u", s);
  425.     goto bad;
  426. }
  427. if (write(fdout, buf, (u_int) cc) != cc) {
  428.     perror_reply(426, "Data connection", errno);
  429.     goto bad;
  430. }
  431. byte_count += cc;
  432.     }
  433.     _TIFFfree(buf);
  434.     return (true);
  435. bad:
  436.     _TIFFfree(buf);
  437.     return (false);
  438. }
  440. const char*
  441. HylaFAXServer::dataConnMsg(int code)
  442. {
  443.     return (code == 125 ?
  444.  "Using existing data connection" : "Opening new data connection");
  445. }
  447. void
  448. HylaFAXServer::closeDataConn(FILE* fd)
  449. {
  450.     fclose(fd);
  451.     data = -1;
  452.     pdata = -1;
  453. }
  455. /*
  456.  * STORe a file.
  457.  */
  458. void
  459. HylaFAXServer::storeCmd(const char* name, const char* mode)
  460. {
  461.     struct stat sb;
  462.     SpoolDir* sd = fileAccess(name, W_OK, sb);
  463.     if (sd) {
  464. // check filename for magic characters
  465. for (const char* cp = name; *cp; cp++)
  466.     if (isspace(*cp) || !isgraph(*cp)) {
  467. reply(553, "Bad filename; includes invalid character.");
  468. return;
  469.     }
  470. mode_t omask = umask(027);
  471. FILE* fout = fopen(name, restart_point ? "r+w" : mode);
  472. if (fout != NULL) {
  473.     setFileOwner(name);
  474.     if (restart_point &&
  475.       lseek(fileno(fout), restart_point, SEEK_SET) != restart_point)
  476. perror_reply(550, name, errno);
  477.     else {
  478. time_t start_time = Sys::now();
  479. int code;
  480. FILE* din = openDataConn("r", code);
  481. if (din != NULL) {
  482.     reply(code, "%s for %s.", dataConnMsg(code), name);
  483.     file_size = -1;
  484.     if (recvData(din, fout))
  485. reply(226, "Transfer complete.");
  486.     if (TRACE(INXFERS) && xferfaxlog != -1)
  487. logTransfer("i", *sd, name, start_time);
  488.     closeDataConn(din);
  489. }
  490.     }
  491.     fclose(fout);
  492. } else
  493.     perror_reply(553, name, errno);
  494. (void) umask(omask);
  495.     }
  496. }
  498. /*
  499.  * STOU (STOre Unique) file.
  500.  * STOT (STOre unique Temporary) file.
  501.  *
  502.  * STOT differs from STOU in that files created with STOT
  503.  * are automatically unlinked when the process terminates
  504.  * while files created with STOU are not.  STOT is intended
  505.  * for clients creating documents that are to be sent and
  506.  * then expunged.  STOU is for documents that are intended
  507.  * be shared across multiple sessions.
  508.  */
  509. void
  510. HylaFAXServer::storeUniqueCmd(bool isTemp)
  511. {
  512.     fxStr emsg;
  513.     u_int seqnum = getDocumentNumber(emsg);
  514.     if (seqnum != (u_int) -1) {
  515. fxStr filename = fxStr::format("/%s/doc%u.%s"
  516.     , isTemp ? FAX_TMPDIR : FAX_DOCDIR
  517.     , seqnum
  518.     , formats[form].suffix
  519. );
  520. FILE* fout = fopen(filename, "w");
  521. if (fout != NULL) {
  522.     setFileOwner(filename);
  523.     FileCache::chmod(filename, 0640); // sync cache
  524.     if (isTemp)
  525. tempFiles.append(filename);
  526.     time_t start_time = Sys::now();
  527.     int code;
  528.     FILE* din = openDataConn("r", code);
  529.     if (din != NULL) {
  530. reply(code, "FILE: %s (%s).", (const char*) filename,
  531.     dataConnMsg(code));
  532. file_size = -1;
  533. if (recvData(din, fout))
  534.     reply(226, "Transfer complete (FILE: %s).",
  535. (const char*) filename);
  536. if (TRACE(INXFERS) && xferfaxlog != -1)
  537.     logTransfer("i"
  538. , *dirLookup(isTemp ? "/" FAX_TMPDIR : "/" FAX_DOCDIR)
  539. , filename
  540. , start_time
  541.     );
  542. closeDataConn(din);
  543.     }
  544.     fclose(fout);
  545. } else
  546.     perror_reply(553, filename, errno);
  547.     } else
  548. reply(553, "%s", (const char*)emsg);
  549. }
  551. /*
  552.  * Tranfer the contents of "fdin" to "fdout".
  553.  */
  554. bool
  555. HylaFAXServer::sendData(FILE* fdin, FILE* fdout)
  556. {
  557.     state |= S_TRANSFER;
  558.     if (setjmp(urgcatch) != 0) {
  559. state &= ~S_TRANSFER;
  560. return (false);
  561.     }
  562. #define PACK(a,b) (((a)<<8)|(b))
  563.     switch (PACK(type,mode)) {
  564.     case PACK(TYPE_I,MODE_S):
  565.     case PACK(TYPE_L,MODE_S):
  566. if (sendIData(fileno(fdin), fileno(fdout))) {
  567.     state &= ~S_TRANSFER;
  568.     return (true);
  569. }
  570. break;
  571.     case PACK(TYPE_I,MODE_Z):
  572.     case PACK(TYPE_L,MODE_Z):
  573. if (sendZData(fileno(fdin), fileno(fdout))) {
  574.     state &= ~S_TRANSFER;
  575.     return (true);
  576. }
  577. break;
  578.     case PACK(TYPE_A,MODE_S):
  579. for (;;) {
  580.     int c = getc(fdin);
  581.     if (c == EOF) {
  582. fflush(fdout);
  583. if (ferror(fdout)) {
  584.     perror_reply(426, "Data Connection", errno);
  585.     break;
  586. }
  587. if (ferror(fdin)) {
  588.     perror_reply(551, "Error on input file", errno);
  589.     break;
  590. }
  591. state &= ~S_TRANSFER;
  592. return (true);
  593.     }
  594.     byte_count++;
  595.     if (c == 'n') { // n -> rn
  596. if (ferror(fdout)) { // check at the end of each line
  597.     perror_reply(426, "Data connection", errno);
  598.     break;
  599. }
  600. putc('r', fdout);
  601.     }
  602.     putc(c, fdout);
  603. }
  604. break;
  605.     default:
  606. reply(550, "TYPE %s, MODE %s not implemented."
  607.     , typenames[type]
  608.     , modenames[mode]
  609. );
  610. break;
  611.     }
  612. #undef PACK
  613.     state &= ~S_TRANSFER;
  614.     return (false);
  615. }
  617. bool
  618. HylaFAXServer::sendIData(int fdin, int fdout)
  619. {
  620.     char buf[16*1024];
  621.     for (;;) {
  622. int cc = read(fdin, buf, sizeof (buf));
  623. if (cc == 0)
  624.     return (true);
  625. if (cc < 0) {
  626.     perror_reply(551, "Error reading input file", errno);
  627.     break;
  628. }
  629. if (write(fdout, buf, cc) != cc) {
  630.     perror_reply(426, "Data connection", errno);
  631.     break;
  632. }
  633. byte_count += cc;
  634.     }
  635.     return (false);
  636. }
  638. bool
  639. HylaFAXServer::sendZData(int fdin, int fdout)
  640. {
  641.     z_stream zstream;
  642.     zstream.zalloc = NULL;
  643.     zstream.zfree = NULL;
  644.     zstream.opaque = NULL;
  645.     zstream.data_type = Z_BINARY;
  646.     if (deflateInit(&zstream, Z_DEFAULT_COMPRESSION) == Z_OK) {
  647. char obuf[16*1024];
  648. zstream.next_out = (Bytef*) obuf;
  649. zstream.avail_out = sizeof (obuf);
  651. int cc;
  652. for (;;) {
  653.     char buf[16*1024];
  654.     cc = read(fdin, buf, sizeof (buf));
  655.     if (cc == 0)
  656. break;
  657.     if (cc < 0) {
  658. perror_reply(551, "Error reading input file", errno);
  659. goto bad;
  660.     }
  661.     zstream.next_in = (Bytef*) buf;
  662.     zstream.avail_in = cc;
  663.     do {
  664. if (deflate(&zstream, Z_NO_FLUSH) != Z_OK) {
  665.     reply(452, "Compressor error: %s", zstream.msg);
  666.     goto bad;
  667. }
  668. if (zstream.avail_out == 0) {
  669.     if (write(fdout, obuf, sizeof (obuf)) != sizeof (obuf)) {
  670. perror_reply(426, "Data connection", errno);
  671. goto bad;
  672.     }
  673.     byte_count += sizeof (obuf);
  674.     zstream.next_out = (Bytef*) obuf;
  675.     zstream.avail_out = sizeof (obuf);
  676. }
  677.     } while (zstream.avail_in > 0);
  678. }
  679. int state;
  680. do {
  681.     switch (state = deflate(&zstream, Z_FINISH)) {
  682.     case Z_STREAM_END:
  683.     case Z_OK:
  684. if (zstream.avail_out != sizeof (obuf)) {
  685.     cc = sizeof (obuf) - zstream.avail_out;
  686.     if (write(fdout, obuf, cc) != cc) {
  687. perror_reply(426, "Data connection", errno);
  688. goto bad;
  689.     }
  690.     byte_count += cc;
  691.     zstream.next_out = (Bytef*) obuf;
  692.     zstream.avail_out = sizeof (obuf);
  693. }
  694. break;
  695.     default:
  696. reply(426, "Compressor error: %s", zstream.msg);
  697. goto bad;
  698.     }
  699. } while (state != Z_STREAM_END);
  700. deflateEnd(&zstream);
  701. return (true);
  702. bad:
  703. deflateEnd(&zstream);
  704.     } else
  705. reply(452, "Can not initialize compression library: %s", zstream.msg);
  706.     return (false);
  707. }
  709. /*
  710.  * Transfer data from peer to file.
  711.  */
  712. bool
  713. HylaFAXServer::recvData(FILE* fdin, FILE* fdout)
  714. {
  715.     state |= S_TRANSFER;
  716.     if (setjmp(urgcatch) != 0) {
  717. state &= ~S_TRANSFER;
  718. return (false);
  719.     }
  720. #define PACK(a,b) (((a)<<8)|(b))
  721.     switch (PACK(type,mode)) {
  722.     case PACK(TYPE_I,MODE_S):
  723.     case PACK(TYPE_L,MODE_S):
  724. if (recvIData(fileno(fdin), fileno(fdout))) {
  725.     state &= ~S_TRANSFER;
  726.     return (true);
  727. }
  728. break;
  729.     case PACK(TYPE_I,MODE_Z):
  730.     case PACK(TYPE_L,MODE_Z):
  731. if (recvZData(fileno(fdin), fileno(fdout))) {
  732.     state &= ~S_TRANSFER;
  733.     return (true);
  734. }
  735. break;
  736.     case PACK(TYPE_A,MODE_S):
  737. for (;;) {
  738.     int c = getc(fdin);
  739.     if (c == EOF) {
  740. fflush(fdout);
  741. if (ferror(fdin)) {
  742.     perror_reply(426, "Data Connection", errno);
  743.     break;
  744. }
  745. if (ferror(fdout)) {
  746.     perror_reply(452, "Error writing output file", errno);
  747.     break;
  748. }
  749. state &= ~S_TRANSFER;
  750. return (true);
  751.     }
  752.     byte_count++;
  753.     if (c == 'r') { // rn -> n
  754. if (ferror(fdout)) { // check at the end of each line
  755.     perror_reply(452, "Error writing output file", errno);
  756.     break;
  757. }
  758. c = getc(fdin);
  759. if (c != 'n') {
  760.     putc('r', fdout);
  761.     if (c == EOF)
  762. continue;
  763. }
  764. byte_count++;
  765.     }
  766.     putc(c, fdout);
  767. }
  768. break;
  769.     default:
  770. reply(550, "TYPE %s, MODE %s not implemented."
  771.     , typenames[type]
  772.     , modenames[mode]
  773. );
  774. break;
  775.     }
  776. #undef PACK
  777.     state &= ~S_TRANSFER;
  778.     return (false);
  779. }
  781. bool
  782. HylaFAXServer::recvIData(int fdin, int fdout)
  783. {
  784.     char buf[16*1024]; // XXX better if page-aligned
  785.     for (;;) {
  786. int cc = read(fdin, buf, sizeof (buf));
  787. if (cc == 0)
  788.     return (true);
  789. if (cc < 0) {
  790.     perror_reply(426, "Data Connection", errno);
  791.     break;
  792. }
  793. if (write(fdout, buf, cc) != cc) {
  794.     perror_reply(452, "Error writing output file", errno);
  795.     break;
  796. }
  797. byte_count += cc;
  798.     }
  799.     return (false);
  800. }
  802. bool
  803. HylaFAXServer::recvZData(int fdin, int fdout)
  804. {
  805.     z_stream zstream;
  806.     zstream.zalloc = NULL;
  807.     zstream.zfree = NULL;
  808.     zstream.opaque = NULL;
  809.     zstream.data_type = Z_BINARY;
  810.     if (inflateInit(&zstream) == Z_OK) {
  811. char obuf[16*1024];
  812. zstream.next_out = (Bytef*) obuf;
  813. zstream.avail_out = sizeof (obuf);
  814. for (;;) {
  815.     char buf[16*1024];
  816.     int cc = read(fdin, buf, sizeof (buf));
  817.     if (cc == 0) {
  818. size_t occ = sizeof (obuf) - zstream.avail_out;
  819. if (occ > 0 && write(fdout, obuf, occ) != (ssize_t)occ) {
  820.     perror_reply(452, "Error writing output file", errno);
  821.     break;
  822. }
  823. (void) inflateEnd(&zstream);
  824. return (true);
  825.     }
  826.     if (cc < 0) {
  827. perror_reply(426, "Data Connection", errno);
  828. break;
  829.     }
  830.     byte_count += cc;
  831.     zstream.next_in = (Bytef*) buf;
  832.     zstream.avail_in = cc;
  833.     do {
  834. int state = inflate(&zstream, Z_PARTIAL_FLUSH);
  835. if (state == Z_STREAM_END)
  836.     break;
  837. if (state != Z_OK) {
  838.     reply(452, "Decoding error: %s", zstream.msg);
  839.     goto bad;
  840. }
  841. size_t occ = sizeof (obuf) - zstream.avail_out;
  842. if (write(fdout, obuf, occ) != (ssize_t)occ) {
  843.     perror_reply(452, "Error writing output file", errno);
  844.     goto bad;
  845. }
  846. zstream.next_out = (Bytef*) obuf;
  847. zstream.avail_out = sizeof (obuf);
  848.     } while (zstream.avail_in > 0);
  849. }
  850. bad:
  851. (void) inflateEnd(&zstream);
  852.     } else
  853. reply(452, "Can not initialize decoder: %s", zstream.msg);
  854.     return (false);
  855. }
  857. void
  858. HylaFAXServer::formHelpCmd(void)
  859. {
  860.     lreply(211, "Supported file formats:");
  861.     for (u_int i = 0, n = N(formats); i < n; i++)
  862. lreply(211, "%8s%s  %s"
  863.     , formats[i].name
  864.     , formats[i].supported ? " " : "*"
  865.     , formats[i].help
  866. );
  867.     reply(211, "Formats marked with a * are not supported.");
  868. }
  870. void
  871. HylaFAXServer::formCmd(const char* name)
  872. {
  873.     fxStr f(name);
  874.     f.raisecase();
  875.     for (u_int i = 0, n = N(formats); i < n; i++)
  876. if (f == formats[i].name) {
  877.     if (formats[i].supported) {
  878. form = i;
  879. reply(200, "Format set to %s.", (const char*) f);
  880.     } else
  881. reply(504, "Format %s not supported.", (const char*) f);
  882.     return;
  883. }
  884.     reply(504, "Unknown format %s.", name);
  885. }
  886. #undef N
  888. void
  889. HylaFAXServer::typeCmd(const char* name)
  890. {
  891.     if (strcasecmp(name, "I") == 0)
  892. type = TYPE_I;
  893.     else if (strcasecmp(name, "A") == 0)
  894. type = TYPE_A;
  895.     else if (strcasecmp(name, "L") == 0)
  896. type = TYPE_L;
  897.     else {
  898. reply(504, "Type %s not supported.", name);
  899. return;
  900.     }
  901.     reply(200, "Type set to %s.", typenames[type]);
  902. }
  904. void
  905. HylaFAXServer::modeCmd(const char* name)
  906. {
  907.     if (strcasecmp(name, "S") == 0)
  908. mode = MODE_S;
  909.     else if (strcasecmp(name, "Z") == 0)
  910. mode = MODE_Z;
  911.     else {
  912. reply(504, "Mode %s not supported.", name);
  913. return;
  914.     }
  915.     reply(200, "Mode set to %s.", modenames[mode]);
  916. }
  918. void
  919. HylaFAXServer::struCmd(const char* name)
  920. {
  921.     if (strcasecmp(name, "F") == 0)
  922. stru = STRU_F;
  923.     else if (strcasecmp(name, "T") == 0)
  924. stru = STRU_T;
  925.     else {
  926. reply(504, "Structure %s not supported.", name);
  927. return;
  928.     }
  929.     reply(200, "Structure set to %s.", strunames[stru]);
  930. }
  932. void
  933. HylaFAXServer::printTransferStatus(FILE* fd)
  934. {
  935.     if (restart_point)
  936. fprintf(fd, "    Data transfer restart pending at %lurn", 
  937.     (u_long) restart_point);
  938.     fprintf(fd, "    TYPE: %s", typenames[type]);
  939.     if (type == TYPE_L)
  940.         fprintf(fd, " %d", CHAR_BIT);
  941.     fprintf(fd, "; STRU: %s; MODE: %s; FORM: %srn"
  942. , strunames[stru]
  943. , modenames[mode]
  944. , formats[form].name
  945.     );
  946. }