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

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

传真(Fax)编程

开发平台：

C/C++

faxmail.c++：源码内容
  1. /* $Id: faxmail.c++,v 1.29 2009/09/29 11:46:01 faxguy Exp $ */
  2. /*
  3.  * Copyright (c) 1990-1996 Sam Leffler
  4.  * Copyright (c) 1991-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.  */
  26. #include "MsgFmt.h"
  27. #include "MIMEState.h"
  28. #include "StackBuffer.h"
  29. #include "StrArray.h"
  30. #include "Sys.h"
  31. #include "SendFaxClient.h"
  32. #include "config.h"
  34. #include <ctype.h>
  35. #include <errno.h>
  36. #if HAS_LOCALE
  37. extern "C" {
  38. #include <locale.h>
  39. }
  40. #endif
  42. class MySendFaxClient : public SendFaxClient {
  43. public:
  44.     MySendFaxClient();
  45.     ~MySendFaxClient();
  47.     void setup(bool);
  48.     bool setConfigItem(const char* tag, const char* value);
  49.     void fatal(const char* fmt ...);
  50. };
  51. MySendFaxClient::MySendFaxClient() {}
  52. MySendFaxClient::~MySendFaxClient() {}
  53. void
  54. MySendFaxClient::setup(bool b)
  55. {
  56.     resetConfig();
  57.     readConfig(FAX_SYSCONF);
  58.     readConfig(FAX_LIBDATA "/sendfax.conf");
  59.     readConfig(FAX_LIBDATA "/faxmail.conf");
  60.     readConfig(FAX_USERCONF);
  61.     setVerbose(b);
  62.     FaxClient::setVerbose(b);
  63. }
  64. bool MySendFaxClient::setConfigItem(const char* tag, const char* value)
  65.     { return SendFaxClient::setConfigItem(tag, value); }
  67. class faxMailApp : public TextFormat, public MsgFmt {
  68. private:
  69.     bool markDiscarded; // mark MIME parts not handled
  70.     bool withinFile; // between beginFile() & endFile()
  71.     fxStr mimeConverters; // pathname to MIME converter scripts
  72.     fxStr mailProlog; // site-specific prologue definitions
  73.     fxStr clientProlog; // client-specific prologue info
  74.     fxStr pageSize; // record specified page size
  75.     fxStr msgDivider; // digest message divider
  76.     fxStrArray tmps; // temp files
  78.     MySendFaxClient* client; // for direct delivery
  79.     SendFaxJob* job; // reference to outbound job
  80.     fxStr coverTempl; // coverpage template file
  81.     fxStr mailUser; // user ID for contacting server
  82.     fxStr notify; // notification request
  83.     fxStr tsi; // user-specified TSI string
  84.     bool autoCoverPage; // make cover page for direct delivery
  85.     bool formatEnvHeaders; // format envelope headers
  86.     bool trimText; // trim text parts
  88.     void formatMIME(FILE* fd, MIMEState& mime, MsgFmt& msg);
  89.     void formatText(FILE* fd, MIMEState& mime);
  90.     void formatMultipart(FILE* fd, MIMEState& mime, MsgFmt& msg);
  91.     void formatMessage(FILE* fd, MIMEState& mime, MsgFmt& msg);
  92.     void formatApplication(FILE* fd, MIMEState& mime);
  93.     void formatDiscarded(MIMEState& mime);
  94.     bool formatWithExternal(FILE* fd, const fxStr& app, MIMEState& mime);
  96.     void emitClientPrologue(FILE*);
  98.     void discardPart(FILE* fd, MIMEState& mime);
  99.     bool copyPart(FILE* fd, MIMEState& mime, fxStr& tmpFile);
  100.     bool runConverter(const fxStr& app, const fxStr& tmp, MIMEState& mime);
  101.     void copyFile(FILE* fd, const char* filename);
  103.     void resetConfig();
  104.     void setupConfig();
  105.     bool setConfigItem(const char* tag, const char* value);
  107.     void usage(void);
  108. public:
  109.     faxMailApp();
  110.     ~faxMailApp();
  112.     void run(int argc, char** argv);
  114.     void setVerbose(bool b) { verbose = b; }
  115.     void setBoldFont(const char* cp) { boldFont = cp; }
  116.     void setItalicFont(const char* cp) { italicFont = cp; }
  117. };
  119. faxMailApp::faxMailApp()
  120. {
  121.     client = NULL;
  123.     faxMailApp::setupConfig(); // NB: virtual
  124.     setTitle("HylaFAX-Mail");
  125. }
  126. faxMailApp::~faxMailApp()
  127. {
  128.     delete client;
  129.     for (u_int i = 0, n = tmps.length(); i < n; i++)
  130. Sys::unlink(tmps[i]);
  131. }
  133. void
  134. faxMailApp::run(int argc, char** argv)
  135. {
  136.     extern int optind;
  137.     extern char* optarg;
  138.     int c;
  140.     const char* mailPass = NULL;
  142.     resetConfig();
  143.     readConfig(FAX_SYSCONF);
  144.     readConfig(FAX_LIBDATA "/faxmail.conf");
  145.     readConfig(FAX_USERCONF);
  147.     bool deliver = false;
  148.     while ((c = Sys::getopt(argc, argv, "12b:cC:df:H:i:M:nNO:p:rRs:S:t:Tu:vW:")) != -1)
  149. switch (c) {
  150. case '1': case '2': // format in 1 or 2 columns
  151.     setNumberOfColumns(c - '0');
  152.     break;
  153. case 'b': // bold font for headers
  154.     setBoldFont(optarg);
  155.     break;
  156. case 'c': // truncate lines
  157.     setLineWrapping(false);
  158.     break;
  159. case 'C': // specify cover template to use
  160.     coverTempl = optarg;
  161.     break;
  162. case 'd': // enable direct delivery
  163.     deliver = true;
  164.     break;
  165. case 'f': // default font for text body
  166.     setTextFont(optarg);
  167.     break;
  168. case 'H': // page height
  169.     setPageHeight(atof(optarg));
  170.     break;
  171. case 'i': // italic font for headers
  172.     setItalicFont(optarg);
  173.     break;
  174. case 'M': // page margins
  175.     setPageMargins(optarg);
  176.     break;
  177. case 'n': // suppress cover page
  178.     autoCoverPage = false;
  179.     break;
  180. case 'N': // suppress formatting envelope headers
  181.     formatEnvHeaders = false;
  182.     break;
  183. case 'O':
  184.     readConfigItem(optarg);
  185.     break;
  186. case 'p': // point size
  187.     setTextPointSize(TextFormat::inch(optarg));
  188.     break;
  189. case 'r': // rotate page (landscape)
  190.     setPageOrientation(TextFormat::LANDSCAPE);
  191.     break;
  192. case 'R': // don't rotate page (portrait)
  193.     setPageOrientation(TextFormat::PORTRAIT);
  194.     break;
  195. case 's': // page size
  196.     pageSize = optarg;
  197.     setPageSize(pageSize);
  198.     break;
  199. case 'S': // set TSI
  200.     tsi = optarg;
  201.     break;
  202. case 't': // job state notification request
  203.     notify = optarg;
  204.     break;
  205. case 'T': // suppress formatting MIME text parts
  206.     trimText = true;
  207.     break;
  208. case 'u': // mail/login user
  209.     {
  210. char* pp = strchr(optarg, ':');
  211. if (pp && *(pp + 1) != '') {
  212.     *pp = '';
  213.     mailPass = pp + 1;
  214. }
  215.     }
  216.     mailUser = optarg;
  217.     break;
  218. case 'W': // page width
  219.     setPageWidth(atof(optarg));
  220.     break;
  221. case 'v': // trace work
  222.     setVerbose(true);
  223.     break;
  224. case '?':
  225.     usage();
  226.     /*NOTREACHED*/
  227. }
  229.     MIMEState mime("text", "plain");
  230.     parseHeaders(stdin, mime.lineno); // collect top-level headers
  232.     if (!getPageHeaders()) // narrow top+bottom margins
  233. setPageMargins("t=0.35in,b=0.25in");
  234.     else
  235. setPageMargins("t=0.6in,b=0.25in");
  237.     if (deliver) {
  238. /*
  239.  * Direct delivery was specified on the command line.
  240.  * Setup to submit the formatted facsimile directly
  241.  * to a server.
  242.  */
  243. client = new MySendFaxClient;
  244. client->setup(verbose);
  246. /*
  247.  * Setup the destination (dialstring and
  248.  * optionally a receipient).  Dialing stuff
  249.  * given on the command line is replaced by
  250.  * information in the envelope so that strings
  251.  * that contain characters that are invalid
  252.  * email addresses can be specified.
  253.  */
  254. job = &client->addJob();
  255. if (optind < argc) { // specified on command line
  256.     fxStr dest(argv[optind]); // [person@]number
  257.     u_int l = dest.next(0, '@');
  258.     if (l != dest.length()) {
  259. job->setCoverName(dest.head(l));
  260. dest.cut(0, l+1);
  261.     }
  262.     job->setDialString(dest);
  263. }
  264. const fxStr* s;
  265. if ((s = findHeader("x-fax-dialstring")))  // dialstring in envelope
  266.     job->setDialString(*s);
  267. if (job->getDialString() == "")
  268.     fxFatal("No Destination/Dialstring specified");
  270. /*
  271.  * Establish the sender's identity.
  272.  */
  273. if (optind+1 < argc) {
  274.     client->setFromIdentity(argv[optind+1]);
  275. } else if ((s = findHeader("from"))) {
  276.     client->setFromIdentity(*s);
  277. } else {
  278.     fxFatal("No From/Sender identity specified");
  279. }
  281. if (pageSize != "") {
  282.     job->setPageSize(pageSize);
  283. }
  285. if (notify != "") {
  286.     job->setNotification((const char*) notify);
  287. }
  289. if (tsi != "") {
  290.     job->setTSI((const char*) tsi);
  291. }
  293. /*
  294.  * Scan envelope for any meta-headers that
  295.  * control how job submission is to be done.
  296.  */
  297. job->setAutoCoverPage(autoCoverPage);
  298. for (u_int i = 0, n = fields.length();  i < n; i++) {
  299.     const fxStr& field = fields[i];
  300.     if (strncasecmp(field, "x-fax-", 6) != 0)
  301. continue;
  302.     fxStr tag(field.tail(field.length() - 6));
  303.     tag.lowercase();
  304.     if (job->setConfigItem(tag, MsgFmt::headers[i]))
  305. ;
  306.     else if (client->setConfigItem(tag, MsgFmt::headers[i]))
  307. ;
  308. }
  310. /*
  311.  * If a cover page is desired fill in any info
  312.  * from the envelope that might be useful.
  313.  */
  314. if (job->getAutoCoverPage()) {
  315.     if (coverTempl.length()) job->setCoverTemplate(coverTempl);
  316.     /*
  317.      * If nothing has been specified for a
  318.      * regarding field on the cover page and
  319.      * a subject line exists, use that info.
  320.      */
  321.     if (job->getCoverRegarding() == "" && (s = findHeader("subject"))) {
  322. fxStr subj(*s);
  323. decodeRFC2047(subj);
  324. while (subj.length() > 3 && strncasecmp(subj, "Re:", 3) == 0)
  325.     subj.remove(0, subj.skip(3, " t"));
  326. job->setCoverRegarding(subj);
  327.     }
  328.     /*
  329.      * Likewise for the receipient name.
  330.      */
  331.     if (job->getCoverName() == "" && ((s = findHeader("x-fax-to")) || (s = findHeader("to")))) {
  332. /*
  333.  * Try to extract a user name from the to information.
  334.  */
  335. fxStr to(*s);
  336. u_int l = to.next(0, '<');
  337. u_int tl = to.length();
  338. if (l == tl) {
  339.     l = to.next(0, '(');
  340.     if (l != tl) // joe@foobar (Joe Schmo), no longer works due to RFC822 compliance in parseHeaders (in-parenthesis are stripped as comments)
  341. l++, to = to.token(l, ')');
  342.     else { // joe@foobar
  343. l = to.next(0, '@');
  344. if (l != tl)
  345.     to = to.head(l);
  346.     }
  347. } else { // Joe Schmo <joe@foobar>
  348.     to = to.head(l);
  349. }
  350. // strip any leading&trailing white space or double-quotes
  351. to.remove(0, to.skip(0, " t""));
  352. to.resize(to.skipR(to.length(), " t""));
  353. job->setCoverName(to);
  354.     }
  355. }
  357. /*
  358.  * Redirect formatted output to a temp
  359.  * file and setup delivery of the file.
  360.  */
  361.     const char* templ = _PATH_TMP "/faxmail.XXXXXX";
  362.     char* buff = new char[strlen(templ) + 1];
  363.     strcpy(buff, templ);
  364.     int fd = Sys::mkstemp(buff);
  365. if (fd < 0) {
  366.         fxFatal("Cannot create temp file %s", (const char*) buff);
  367.     }
  368. tmps.append(buff);
  369. client->addFile(buff);
  370.     delete[] buff;
  371. beginFormatting(fdopen(fd, "w"));
  372.     } else
  373. beginFormatting(stdout); // NB: sets up page info
  375.     const fxStr* version = findHeader("MIME-Version");
  377.     if (version && stripComments(*version) == "1.0") {
  378. if (verbose)
  379.     fprintf(stderr, "faxmail: This is a MIME messagen");
  380. beginFile();
  381. withinFile = true;
  382.         if (formatEnvHeaders) formatHeaders(*this); // format top-level headers
  383. formatMIME(stdin, mime, *this); // parse MIME format
  384.         if (withinFile) endFile();
  385. withinFile = false;
  386.     } else {
  387. if (verbose)
  388.     fprintf(stderr, "faxmail: This is not a MIME messagen");
  389. beginFile();
  390. withinFile = true;
  391. if (formatEnvHeaders) formatHeaders(*this); // format top-level headers
  392. formatText(stdin, mime); // treat body as text/plain
  393.         if (withinFile) endFile();
  394. withinFile = false;
  395.     }
  396.     endFormatting(mime.external);
  398.     if (client) { // complete direct delivery
  399. bool status = false;
  400. fxStr emsg;
  401. const char* user = mailUser;
  402. if (user[0] == '') // null user =>'s use real uid
  403.     user = NULL;
  404. if (client->callServer(emsg)) {
  405.     status = client->login(user, mailPass, emsg)
  406.   && client->prepareForJobSubmissions(emsg)
  407.   && client->submitJobs(emsg);
  408.     client->hangupServer();
  409. }
  410. if (!status)
  411.     fxFatal("%s", (const char*) emsg);
  412.     }
  413. }
  415. /*
  416.  * Emit PostScript prologue stuff defined in
  417.  * system-wide prologue file and possibly
  418.  * supplied in a MIME-encoded body part.
  419.  */
  420. void
  421. faxMailApp::emitClientPrologue(FILE* fd)
  422. {
  423.     if (mailProlog != "") // site-specific prologue
  424. copyFile(fd, mailProlog);
  425.     if (clientProlog != "") // copy client-specific prologue
  426. copyFile(fd, clientProlog);
  427. }
  429. /*
  430.  * Parse MIME headers and dispatch to the appropriate
  431.  * formatter based on the content-type information.
  432.  */
  433. void
  434. faxMailApp::formatMIME(FILE* fd, MIMEState& mime, MsgFmt& msg)
  435. {
  436.     fxStr emsg;
  437.     if (mime.parse(msg, emsg)) {
  438. if (verbose)
  439.     mime.trace(stderr);
  440. /*
  441.  * In theory each MIME part could be in a different
  442.  * character set, and each text mail header (such as
  443.  * the subject header) could also be in multiple
  444.  * character sets.  Supporting this would probably 
  445.  * require faxmail to scan the entire mail beforehand
  446.  * to add the requisite font definitions early in
  447.  * the Postscript output... which isn't how faxmail
  448.  * does things right now.
  449.  *
  450.  * Fortunately, the likelihood of a mail being written
  451.  * in more than one character set (not including ASCII)
  452.  * would be extremely rare and quite possibly only in
  453.  * contrived scenarios.  So for now we just apply a single
  454.  * character set to the entire mail message.
  455.  *
  456.  * In the past we did this:
  457.  *
  458.  * setISO8859(mime.getCharset() != CS_USASCII);
  459.  *
  460.  * However, this makes it impossible for RFC-2047-encoded
  461.  * subject lines to show properly, as well as any 
  462.  * subsequent non-ASCII mail parts.
  463.  *
  464.  * Eventually it may be best to have the character set 
  465.  * be selected by a command-line argument, however, since
  466.  * TextFormat.c++ only supports ISO-8859-1 at the moment
  467.  * there is no point.  And since ASCII is completely 
  468.  * covered by ISO-8859-1 there is no reason to prefer
  469.  * ASCII over ISO-8859-1.
  470.  */
  471. setISO8859(true);
  473. /*
  474.  * Check first for any external script/command to
  475.  * use in converting the body part to PostScript.
  476.  * If something is present, then we just decode the
  477.  * body part into a temporary file and hand it to
  478.  * the script.  Otherwise we fallback on some builtin
  479.  * body part handlers that process the most common
  480.  * content types we expect to encounter.
  481.  *
  482.  * We expect externally formatted documents to be 
  483.  * complete Postscript pages in and of themselves.
  484.  * (Otherwise either the formatter would need to know
  485.  * numerous details about the current state and settings
  486.  * of the existing Postscript formatting and would need
  487.  * to make careful use of them, or we would need to 
  488.  * implement our own Postscript interpreter to filter 
  489.  * the external formatter output to suit.)
  490.  */
  491. mime.external = false;
  492. const fxStr& type = mime.getType();
  493. fxStr app = mimeConverters | "/" | type | "/" | mime.getSubType();
  494. if (Sys::access(app, X_OK) >= 0) {
  495.     mime.external = true;
  496.     if (mime.lineno > 1) endPage(); // new page
  497.     formatWithExternal(fd, app, mime);
  498. } else if (type == "text")
  499.     formatText(fd, mime);
  500. else if (type == "application")
  501.     formatApplication(fd, mime);
  502. else if (type == "multipart")
  503.     formatMultipart(fd, mime, msg);
  504. else if (type == "message")
  505.     formatMessage(fd, mime, msg);
  506. else { // cannot handle, discard
  507.     discardPart(fd, mime);
  508.     formatDiscarded(mime);
  509. }
  510.     } else
  511. error("%s", (const char*) emsg);
  512. }
  514. /*
  515.  * Format a text part.
  516.  */
  517. void
  518. faxMailApp::formatText(FILE* fd, MIMEState& mime)
  519. {
  520.     fxStackBuffer buf;
  521.     bool trim = trimText;
  522.     while (mime.getLine(fd, buf)) {
  523. if (trim) trim = ((buf.getLength() == 0) || (buf[0] == 0xA));
  524. if (!trim) format(buf, buf.getLength()); // NB: treat as text/plain
  525.     }
  526. }
  528. /*
  529.  * Format a multi-part part.
  530.  */
  531. void
  532. faxMailApp::formatMultipart(FILE* fd, MIMEState& mime, MsgFmt& msg)
  533. {
  534.     discardPart(fd, mime); // prologue
  535.     if (!mime.isLastPart()) {
  536. bool last = false;
  537. while (!last) {
  538.     int c = getc(fd);
  539.     if (c == EOF) {
  540. error("Badly formatted MIME; premature EOF");
  541. break;
  542.     }
  543.     ungetc(c, fd); // push back read ahead
  545.     MsgFmt bodyHdrs(msg); // parse any headers
  546.     bodyHdrs.parseHeaders(fd, mime.lineno);
  548.     MIMEState bodyMime(mime); // state for sub-part
  549.     formatMIME(fd, bodyMime, bodyHdrs);
  550.     last = bodyMime.isLastPart();
  551.     mime.external = bodyMime.external;
  552. }
  553.     }
  554. }
  556. /*
  557.  * Format a message part.
  558.  */
  559. void
  560. faxMailApp::formatMessage(FILE* fd, MIMEState& mime, MsgFmt& msg)
  561. {
  562.     if (mime.getSubType() == "rfc822") {
  563. MsgFmt bodyHdrs(msg);            
  564. bodyHdrs.parseHeaders(fd, mime.lineno);
  565. /*
  566.  * Calculate the amount of space required to format
  567.  * the message headers and any required inter-message
  568.  * divider mark.  If there isn't enough space to put
  569.  * the headers and one line of text together on the
  570.  * same column then break and start a new column.
  571.  */
  572. const char* divider = NULL;
  573. if (mime.isParent("multipart", "digest") && msgDivider != "") {
  574.     /*
  575.      * XXX, hack.  Avoid inserting a digest divider when
  576.      * the sub-part is a faxmail prologue or related part.
  577.      */
  578.     const fxStr* s = bodyHdrs.findHeader("Content-Type");
  579.     if (!s || !strneq(*s, "application/x-faxmail", 21))
  580. divider = msgDivider;
  581. }
  582. u_int nl = bodyHdrs.headerCount() // header lines
  583.     + (bodyHdrs.headerCount() > 0) // blank line following header
  584.     + (divider != NULL) // digest divider
  585.     + 1; // 1st text line of message
  586. reserveVSpace(nl*getTextLineHeight());
  587. if (divider) { // emit digest divider
  588.     beginLine();
  589. fprintf(getOutputFile(), " %s ", divider);
  590.     endLine();
  591. }
  592. if (nl > 0)
  593.     bodyHdrs.formatHeaders(*this); // emit formatted headers
  595. MIMEState subMime(mime);
  596. formatMIME(fd, subMime, bodyHdrs); // format message body
  597.     } else if (mime.getSubType() == "delivery-status") {
  598. formatText(fd, mime);
  599.     } else {
  600. discardPart(fd, mime);
  601. formatDiscarded(mime);
  602.     }
  603. }
  605. /*
  606.  * Format an application part.
  607.  */
  608. void
  609. faxMailApp::formatApplication(FILE* fd, MIMEState& mime)
  610. {
  611.     if (mime.getSubType() == "postscript") { // copy PS straight thru
  612. if (withinFile) endFile();
  613. withinFile = false;
  614. FILE* fout = getOutputFile();
  615. fxStackBuffer buf;
  616. int ignore;
  617. while (mime.getLine(fd, buf))
  618.     ignore = fwrite((const char*) buf, buf.getLength(), 1, fout);
  619. if (!withinFile) beginFile();
  620. withinFile = true;
  621.     } else if (mime.getSubType() == "x-faxmail-prolog") {
  622. copyPart(fd, mime, clientProlog); // save client PS prologue
  623.     } else {
  624. discardPart(fd, mime);
  625. formatDiscarded(mime);
  626.     }
  627. }
  629. /*
  630.  * Format a MIME part using an external conversion
  631.  * script to convert the decoded body to PostScript.
  632.  */
  633. bool
  634. faxMailApp::formatWithExternal(FILE* fd, const fxStr& app, MIMEState& mime)
  635. {
  636.     bool ok = false;
  637.     if (verbose)
  638. fprintf(stderr, "CONVERT: run %sn", (const char*) app);
  639.     fxStr tmp;
  640.     if (copyPart(fd, mime, tmp)) {
  641. flush(); // flush pending stuff
  642. ok = runConverter(app, tmp, mime);
  643. Sys::unlink(tmp);
  644.     }
  645.     return (ok);
  646. }
  648. /*
  649.  * Mark a discarded part if configured.
  650.  */
  651. void
  652. faxMailApp::formatDiscarded(MIMEState& mime)
  653. {
  654.     if (markDiscarded) {
  655. fxStackBuffer buf;
  656. buf.put("-----------------------------n");
  657. if (mime.getDescription() != "")
  658.     buf.fput("DISCARDED %s (%s/%s) GOES HEREn"
  659. , (const char*) mime.getDescription()
  660. , (const char*) mime.getType()
  661. , (const char*) mime.getSubType()
  662.     );
  663. else
  664.     buf.fput("DISCARDED %s/%s GOES HEREn"
  665. , (const char*) mime.getType()
  666. , (const char*) mime.getSubType()
  667.     );
  668. format((const char*)buf, buf.getLength());
  669.     }
  670.     if (mime.getDescription() != "")
  671. fprintf(stderr, "DISCARDED: %s (%s/%s)n",
  672.     (const char*) mime.getDescription(),
  673.     (const char*) mime.getType(),
  674.     (const char*) mime.getSubType());
  675.     else
  676. fprintf(stderr, "DISCARDED: %s/%sn",
  677.     (const char*) mime.getType(),
  678.     (const char*) mime.getSubType());
  679. }
  681. /*
  682.  * Discard input data up to the next boundary marker.
  683.  */
  684. void
  685. faxMailApp::discardPart(FILE* fd, MIMEState& mime)
  686. {
  687.     fxStackBuffer buf;
  688.     while (mime.getLine(fd, buf))
  689. ; // discard input data
  690. }
  692. /*
  693.  * Copy input data up to the next boundary marker.
  694.  * The data is stored in a temporary file that is
  695.  * either created or, if passed in, appended to.
  696.  * The latter is used, for example, to accumulate
  697.  * client-specified prologue data.
  698.  */
  699. bool
  700. faxMailApp::copyPart(FILE* fd, MIMEState& mime, fxStr& tmpFile)
  701. {
  702.     int ftmp;
  703.     if (tmpFile == "") {
  704.         const char* templ = _PATH_TMP "/faxmail.XXXXXX";
  705.         char* buff = new char[strlen(templ) + 1];
  706.         strcpy(buff, templ);
  707.         ftmp = Sys::mkstemp(buff);
  708.         tmpFile = buff;
  709.         delete[] buff;
  710.         tmps.append(tmpFile);
  711.     } else {
  712.         ftmp = Sys::open(tmpFile, O_WRONLY|O_APPEND);
  713.     }
  714.     if (ftmp >= 0) {
  715.         /*
  716.         if (!Sys::isRegularFile(tmpFile)) {
  717.             error("%s: is not a regular file", (const char*) tmpFile);
  718.             return(false);
  719.         }
  720.         */
  721.         fxStackBuffer buf;
  722.         bool ok = true;
  723.         while (mime.getLine(fd, buf) && ok) {
  724.         ok = ((u_int) Sys::write(ftmp, buf, buf.getLength()) == buf.getLength());
  725.         }
  726.         if (ok) {
  727.             Sys::close(ftmp);
  728.             return (true);
  729.         }
  730.         error("%s: write error: %s", (const char*) tmpFile, strerror(errno));
  731.         Sys::close(ftmp);
  732.     } else {
  733.     error("%s: Can not create temporary file", (const char*) tmpFile);
  734.     }
  735.     discardPart(fd, mime);
  736.     return (false);
  737. }
  739. /*
  740.  * Run an external converter program.
  741.  */
  742. bool
  743. faxMailApp::runConverter(const fxStr& app, const fxStr& tmp, MIMEState& mime)
  744. {
  745.     const char* av[6];
  746.     av[0] = strrchr(app, '/');
  747.     if (av[0] == NULL)
  748. av[0] = app;
  749.     // XXX should probably pass in MIME state like charset
  750.     u_int i = 1;
  751.     av[i++] = tmp;
  752.     fxStr label;
  753.     if (mime.getDescription() != "") {
  754. label = "description:";
  755. label.append(mime.getDescription());
  756. av[i++] = (const char*) label;
  757.     }
  758.     if (mime.getContentID() != "") {
  759. label = "id:";
  760. label.append(mime.getContentID());
  761. av[i++] = (const char*) label;
  762.     }
  763.     if (mime.getDisposition() != "") {
  764. label = "disposition:";
  765. label.append(mime.getDisposition());
  766. av[i++] = (const char*) label;
  767.     }
  768.     av[i++] = NULL;
  770.     pid_t pid = fork();
  771.     switch (pid) {
  772.     case -1: // error
  773. error("Error converting %s/%s; could not fork subprocess: %s"
  774.     , (const char*) mime.getType()
  775.     , (const char*) mime.getSubType()
  776.     , strerror(errno)
  777. );
  778. break;
  779.     case 0: // child, exec command
  780. dup2(fileno(getOutputFile()), STDOUT_FILENO);
  781. Sys::execv(app, (char* const*) av);
  782. _exit(-1);
  783. /*NOTREACHED*/
  784.     default:
  785. int status;
  786. if (Sys::waitpid(pid, status) == pid && status == 0)
  787.     return (true);
  788. error("Error converting %s/%s; command was "%s %s"; exit status %x"
  789.     , (const char*) mime.getType()
  790.     , (const char*) mime.getSubType()
  791.     , (const char*) app
  792.     , (const char*) tmp
  793.     , status
  794. );
  795. break;
  796.     }
  797.     return (false);
  798. }
  800. /*
  801.  * Copy the contents of the specified file to
  802.  * the output stream.
  803.  */
  804. void
  805. faxMailApp::copyFile(FILE* fd, const char* filename)
  806. {
  807.     int fp = Sys::open(filename, O_RDONLY);
  808.     if (fp >= 0) {
  809. char buf[16*1024];
  810. u_int cc, ignore;
  811. while ((cc = Sys::read(fp, buf, sizeof (buf))) > 0)
  812.     ignore = fwrite(buf, cc, 1, fd);
  813. Sys::close(fp);
  814.     }
  815. }
  817. /*
  818.  * Configuration support.
  819.  */
  821. void
  822. faxMailApp::setupConfig()
  823. {
  824.     markDiscarded = true;
  825.     mimeConverters = FAX_LIBDATA "/faxmail";
  826.     mailProlog = FAX_LIBDATA "/faxmail.ps";
  827.     msgDivider = "";
  828.     pageSize = "";
  829.     mailUser = ""; // default to real uid
  830.     notify = "";
  831.     tsi = "";
  832.     coverTempl = "";
  833.     autoCoverPage = true; // a la sendfax
  834.     formatEnvHeaders = true; // format envelope headers by default
  835.     trimText = false; // don't trim leading CRs from text parts by default
  837.     setPageHeaders(false); // disable normal page headers
  838.     setNumberOfColumns(1); // 1 input page per output page
  840.     setLineWrapping(true);
  841.     setISO8859(true);
  843.     MsgFmt::setupConfig();
  844. }
  846. void
  847. faxMailApp::resetConfig()
  848. {
  849.     TextFormat::resetConfig();
  850.     setupConfig();
  851. }
  853. #undef streq
  854. #define streq(a,b) (strcasecmp(a,b)==0)
  856. bool
  857. faxMailApp::setConfigItem(const char* tag, const char* value)
  858. {
  859.     if (streq(tag, "markdiscarded"))
  860. markDiscarded = getBoolean(value);
  861.     else if (streq(tag, "autocoverpage"))
  862. autoCoverPage = getBoolean(value);
  863.     else if (streq(tag, "formatenvheaders"))
  864. formatEnvHeaders = getBoolean(value);
  865.     else if (streq(tag, "trimtext"))
  866. trimText = getBoolean(value);
  867.     else if (streq(tag, "mimeconverters"))
  868. mimeConverters = value;
  869.     else if (streq(tag, "prologfile"))
  870. mailProlog = value;
  871.     else if (streq(tag, "digestdivider"))
  872. msgDivider = value;
  873.     else if (streq(tag, "mailuser"))
  874. mailUser = value;
  875.     else if (MsgFmt::setConfigItem(tag, value))
  876. ;
  877.     else if (TextFormat::setConfigItem(tag, value))
  878. ;
  879.     else
  880. return (false);
  881.     return (true);
  882. }
  883. #undef streq
  885. #include <signal.h>
  887. static faxMailApp* app = NULL;
  889. static void
  890. cleanup()
  891. {
  892.     faxMailApp* a = app;
  893.     app = NULL;
  894.     delete a;
  895. }
  897. static void
  898. sigDone(int)
  899. {
  900.     cleanup();
  901.     exit(-1);
  902. }
  904. int
  905. main(int argc, char** argv)
  906. {
  907. #ifdef LC_CTYPE
  908.     setlocale(LC_CTYPE, ""); // for <ctype.h> calls
  909. #endif
  911.     app = new faxMailApp;
  913.     app->run(argc, argv);
  914.     signal(SIGHUP, fxSIGHANDLER(SIG_IGN));
  915.     signal(SIGINT, fxSIGHANDLER(SIG_IGN));
  916.     signal(SIGTERM, fxSIGHANDLER(SIG_IGN));
  917.     cleanup();
  918.     return (0);
  919. }
  921. static void
  922. vfatal(FILE* fd, const char* fmt, va_list ap)
  923. {
  924.     fprintf(stderr, "faxmail: ");
  925.     vfprintf(fd, fmt, ap);
  926.     va_end(ap);
  927.     fputs(".n", fd);
  928.     sigDone(0);
  929. }
  931. void
  932. MySendFaxClient::fatal(const char* fmt ...)
  933. {
  934.     va_list ap;
  935.     va_start(ap, fmt);
  936.     vfatal(stderr, fmt, ap);
  937.     /*NOTTEACHED*/
  938. }
  940. void
  941. fxFatal(const char* fmt ...)
  942. {
  943.     va_list ap;
  944.     va_start(ap, fmt);
  945.     vfatal(stderr, fmt, ap);
  946.     /*NOTREACHED*/
  947. }
  949. void
  950. faxMailApp::usage()
  951. {
  952.     fxFatal("usage: faxmail"
  953. " [-b boldfont]"
  954. " [-C template]"
  955. " [-H pageheight]"
  956. " [-i italicfont]"
  957. " [-f textfont]"
  958. " [-p pointsize]"
  959. " [-s pagesize]"
  960. " [-t when]"
  961. " [-W pagewidth]"
  962. " [-M margins]"
  963. " [-u user]"
  964. " [-12cdnNrRTv]"
  965.     );
  966. }