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

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

传真(Fax)编程

开发平台：

C/C++

FaxClient.c++：源码内容
  1. /* $Id: FaxClient.c++,v 1.16 2009/09/29 10:56:42 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 "config.h"
  27. #include "Sys.h"
  28. #include "FaxClient.h"
  29. #include "Transport.h"
  30. #include "zlib.h"
  31. #include <pwd.h>
  32. #include <ctype.h>
  33. #include <sys/types.h>
  34. #include <arpa/telnet.h>
  35. #include <errno.h>
  36. #if HAS_MMAP
  37. #include <sys/mman.h>
  38. #endif
  40. #define N(a) (sizeof (a) / sizeof (a[0]))
  42. FaxClient::FaxClient()
  43. {
  44.     init();
  45. }
  47. FaxClient::FaxClient(const fxStr& hostarg)
  48. {
  49.     init();
  50.     setupHostModem(hostarg);
  51. }
  53. FaxClient::FaxClient(const char* hostarg)
  54. {
  55.     init();
  56.     setupHostModem(hostarg);
  57. }
  59. void
  60. FaxClient::init()
  61. {
  62.     transport = NULL;
  63.     fdIn = NULL;
  64.     fdOut = NULL;
  65.     fdData = -1;
  66.     state = 0;
  67.     pasv = false;
  69.     setupConfig();
  70. }
  72. void
  73. FaxClient::initServerState(void)
  74. {
  75.     type = TYPE_A;
  76.     mode = MODE_S;
  77.     stru = STRU_F;
  78.     format = FORM_UNKNOWN;
  79.     curjob = "DEFAULT";
  80.     tzone = TZ_GMT;
  81.     jobFmt = "";
  82.     recvFmt = "";
  83.     state &= ~(FS_TZPEND|FS_JFMTPEND|FS_RFMTPEND|FS_MFMTPEND|FS_FFMTPEND);
  84. }
  86. FaxClient::~FaxClient()
  87. {
  88.     (void) hangupServer();
  89. }
  91. void
  92. FaxClient::printError(const char* fmt ...)
  93. {
  94.     va_list ap;
  95.     va_start(ap, fmt);
  96.     vprintError(fmt, ap);
  97.     va_end(ap);
  98. }
  99. void
  100. FaxClient::vprintError(const char* fmt, va_list ap)
  101. {
  102.     vfprintf(stderr, fmt, ap);
  103.     fputs("n", stderr);
  104. }
  106. void
  107. FaxClient::printWarning(const char* fmt ...)
  108. {
  109.     va_list ap;
  110.     va_start(ap, fmt);
  111.     vprintWarning(fmt, ap);
  112.     va_end(ap);
  113. }
  114. void
  115. FaxClient::vprintWarning(const char* fmt, va_list ap)
  116. {
  117.     fprintf(stderr, "Warning, ");
  118.     vfprintf(stderr, fmt, ap);
  119.     fputs("n", stderr);
  120. }
  122. void
  123. FaxClient::traceServer(const char* fmt ...)
  124. {
  125.     va_list ap;
  126.     va_start(ap, fmt);
  127.     vtraceServer(fmt, ap);
  128.     va_end(ap);
  129. }
  130. void
  131. FaxClient::vtraceServer(const char* fmt, va_list ap)
  132. {
  133.     vfprintf(stdout, fmt, ap);
  134.     fputs("n", stdout);
  135. }
  137. /*
  138.  * Host, port, and modem can be specified using
  139.  *
  140.  *     modem@host:port
  141.  *
  142.  * e.g. ttyf2@flake.asd:9999.  Alternate forms
  143.  * are: modem@, modem@host, host, host:port.
  144.  * IPv6 IP addresses (many :) are supported in [xx:xx::x]:port
  145.  */
  146. void
  147. FaxClient::setupHostModem(const fxStr& s)
  148. {
  149.     u_int pos = s.next(0, '@');
  150.     if (pos != s.length()) {
  151. modem = s.head(pos);
  152. host = s.tail(s.length() - (pos+1));
  153.     } else
  154. host = s;
  156.     if (host.length() && host[0] == '[')
  157.     {
  158. host.remove(0,1);
  159. pos = host.next(0,']');
  160. if (pos == host.length())
  161.     printWarning("Couldn't parse IPv6 ip address string: "%s"", (const char*)s);
  162. else
  163. host.remove(pos,1);
  164.     pos = host.next(pos, ':');
  165.     } else
  166. pos = host.next(0, ':');
  167.     if (pos != host.length()) {
  168. port = atoi(host.tail(host.length() - (pos+1)));
  169. host.resize(pos);
  170.     }
  171. }
  172. void FaxClient::setupHostModem(const char* cp) { setupHostModem(fxStr(cp)); }
  174. void FaxClient::setHost(const fxStr& hostarg) { setupHostModem(hostarg); }
  175. void FaxClient::setHost(const char* hostarg) { setupHostModem(hostarg); }
  176. void FaxClient::setPort(int p) { port = p; }
  177. void FaxClient::setProtoName(const char* s) { proto = s; }
  179. void FaxClient::setModem(const fxStr& modemarg) { modem = modemarg; }
  180. void FaxClient::setModem(const char* modemarg) { modem = modemarg; }
  182. void
  183. FaxClient::setVerbose(bool v)
  184. {
  185.     if (v)
  186. state |= FS_VERBOSE;
  187.     else
  188. state &= ~FS_VERBOSE;
  189. }
  191. bool
  192. FaxClient::setupUserIdentity(fxStr& emsg)
  193. {
  194.     struct passwd* pwd = NULL;
  195.     const char* name = getenv("FAXUSER");
  196.     if (name)
  197. pwd = getpwnam(name);
  198.     else
  199. pwd = getpwuid(getuid());
  200.     if (!pwd) {
  201. if (name)
  202.     userName = name;
  203. else {
  204.     emsg = fxStr::format("Can not locate your password entry "
  205. "(uid %lu): %s", (u_long) getuid(), strerror(errno));
  206.     return (false);
  207. }
  208.     }
  209.     else
  210. userName = pwd->pw_name;
  211.     if (pwd && pwd->pw_gecos && pwd->pw_gecos[0] != '') {
  212. senderName = pwd->pw_gecos;
  213. senderName.resize(senderName.next(0, '(')); // strip SysV junk
  214. u_int l = senderName.next(0, '&');
  215. if (l < senderName.length()) {
  216.     /*
  217.      * Do the '&' substitution and raise the
  218.      * case of the first letter of the inserted
  219.      * string (the usual convention...)
  220.      */
  221.     senderName.remove(l);
  222.     senderName.insert(userName, l);
  223.     if (islower(senderName[l]))
  224. senderName[l] = toupper(senderName[l]);
  225. }
  226. senderName.resize(senderName.next(0,','));
  227.     } else
  228. senderName = userName;
  229.     if (senderName.length() == 0) {
  230. emsg = "Bad (null) user name; your password file entry"
  231.     " probably has bogus GECOS field information.";
  232. return (false);
  233.     } else
  234. return (true);
  235. }
  237. /*
  238.  * Configuration file support.
  239.  */
  241. FaxClient::F_stringtag FaxClient::strings[] = {
  242. { "protocol", &FaxClient::proto, FAX_PROTONAME },
  243. { "host", &FaxClient::host, NULL },
  244. { "modem", &FaxClient::modem, NULL },
  245. };
  246. FaxClient::F_numbertag FaxClient::numbers[] = {
  247. { "port", &FaxClient::port, (u_int) -1 },
  248. };
  250. void
  251. FaxClient::setupConfig()
  252. {
  253.     int i;
  255.     for (i = N(strings)-1; i >= 0; i--)
  256. (*this).*strings[i].p = (strings[i].def ? strings[i].def : "");
  257.     for (i = N(numbers)-1; i >= 0; i--)
  258. (*this).*numbers[i].p = numbers[i].def;
  259.     initServerState();
  260. }
  262. void
  263. FaxClient::resetConfig()
  264. {
  265.     setupConfig();
  266. }
  268. void
  269. FaxClient::configError(const char* fmt ...)
  270. {
  271.     va_list ap;
  272.     va_start(ap, fmt);
  273.     vprintError(fmt, ap);
  274.     va_end(ap);
  275. }
  277. void
  278. FaxClient::configTrace(const char* fmt ...)
  279. {
  280.     if (getVerbose()) {
  281. va_list ap;
  282. va_start(ap, fmt);
  283. vprintWarning(fmt, ap);
  284. va_end(ap);
  285.     }
  286. }
  288. bool
  289. FaxClient::setConfigItem(const char* tag, const char* value)
  290. {
  291.     u_int ix;
  292.     if (findTag(tag, (const tags*)strings, N(strings), ix)) {
  293. (*this).*strings[ix].p = value;
  294.     } else if (findTag(tag, (const tags*)numbers, N(numbers), ix)) {
  295. (*this).*numbers[ix].p = atoi(value);
  296.     } else if (streq(tag, "verbose")) {
  297. if (getBoolean(value))
  298.     state |= FS_VERBOSE;
  299. else
  300.     state &= ~FS_VERBOSE;
  301.     } else if (streq(tag, "timezone") || streq(tag, "tzone")) {
  302. setTimeZone(streq(value, "local") ? TZ_LOCAL : TZ_GMT);
  303.     } else if (streq(tag, "jobfmt")) {
  304. setJobStatusFormat(value);
  305.     } else if (streq(tag, "rcvfmt")) {
  306. setRecvStatusFormat(value);
  307.     } else if (streq(tag, "modemfmt")) {
  308. setModemStatusFormat(value);
  309.     } else if (streq(tag, "filefmt")) {
  310. setFileStatusFormat(value);
  311.     } else if (streq(tag, "passivemode")) {
  312. pasv = getBoolean(value);
  313.     } else
  314. return (false);
  315.     return (true);
  316. }
  318. bool
  319. FaxClient::callServer(fxStr& emsg)
  320. {
  321.     if (host.length() == 0) { // if host not specified by -h
  322. const char* cp = getenv("FAXSERVER");
  323. if (cp && *cp != '') {
  324.     if (modem != "") { // don't clobber specified modem
  325. fxStr m(modem);
  326. setupHostModem(cp);
  327. modem = m;
  328.     } else
  329. setupHostModem(cp);
  330. }
  331.     }
  332.     transport = &Transport::getTransport(*this, host);
  333.     if (transport->callServer(emsg)) {
  334. signal(SIGPIPE, fxSIGHANDLER(SIG_IGN));
  335. /*
  336.  * Transport code is expected to call back through
  337.  * setCtrlFds so fdIn should be properly setup...
  338.  */
  339. if (fdIn == NULL)
  340.     return (false);
  341. int rep = PRELIM;
  342. for (int i = 0; rep == PRELIM && i < 100; i++)
  343.     rep = getReply(false);
  344. return (rep == COMPLETE);
  345.     } else
  346. return (false);
  347. }
  349. bool
  350. FaxClient::hangupServer(void)
  351. {
  352.     if (fdIn != NULL) {
  353. if (transport) {
  354.     closeDataConn();
  355.     (void) transport->hangupServer();
  356. }
  357. fclose(fdIn), fdIn = NULL;
  358.     }
  359.     if (fdOut != NULL)
  360. fclose(fdOut), fdOut = NULL;
  361.     /*
  362.      * Reset state in case another call is placed.
  363.      */
  364.     delete transport, transport = NULL;
  365.     initServerState();
  366.     return (true);
  367. }
  369. void
  370. FaxClient::setCtrlFds(int in, int out)
  371. {
  372.     if (fdIn != NULL)
  373. fclose(fdIn);
  374.     fdIn = fdopen(in, "r");
  375.     if (fdOut != NULL)
  376. fclose(fdOut);
  377.     fdOut = fdopen(out, "w");
  378. }
  380. void
  381. FaxClient::setDataFd(int fd)
  382. {
  383.     if (fdData >= 0)
  384. Sys::close(fdData);
  385.     fdData = fd;
  386. }
  388. /*
  389.  * Do login procedure.
  390.  */
  391. bool
  392. FaxClient::login(const char* user, const char* pass, fxStr& emsg)
  393. {
  394.     if (user == NULL) {
  395. setupUserIdentity(emsg);
  396. user = userName;
  397.     }
  398.     if (*user == '') {
  399. emsg = "Malformed (null) username";
  400. return (false);
  401.     }
  402.     int n = command("USER %s", user);
  403.     if (n == CONTINUE)
  404. n = command("PASS %s", pass ? pass : getPasswd("Password:"));
  405.     if (n == CONTINUE) // XXX not used
  406. n = command("ACCT %s", getPasswd("Account:"));
  407.     if (n == COMPLETE)
  408. state |= FS_LOGGEDIN;
  409.     else
  410. state &= ~FS_LOGGEDIN;
  411.     if (isLoggedIn()) {
  412. if (state&FS_TZPEND) {
  413.     u_int tz = tzone;
  414.     tzone = 0;
  415.     (void) setTimeZone(tz);
  416.     state &= ~FS_TZPEND;
  417. }
  418. return (true);
  419.     } else {
  420. emsg = "Login failed: " | lastResponse;
  421. return (false);
  422.     }
  423. }
  425. /*
  426.  * Prompt for a password.
  427.  */
  428. const char*
  429. FaxClient::getPasswd(const char* prompt)
  430. {
  431.     return (getpass(prompt));
  432. }
  434. /*
  435.  * Do admin login procedure.
  436.  */
  437. bool
  438. FaxClient::admin(const char* pass, fxStr& emsg)
  439. {
  440.     if (command("ADMIN %s", pass ? pass : getpass("Password:")) != COMPLETE) {
  441. emsg = "Admin failed: " | lastResponse;
  442. return (false);
  443.     } else
  444. return (true);
  445. }
  447. bool
  448. FaxClient::setCommon(FaxParam& parm, u_int v)
  449. {
  450.     if (v != this->*parm.pv) {
  451. if (0 < v && v < parm.NparmNames) {
  452.     if (command("%s %s", parm.cmd, parm.parmNames[v]) != COMPLETE) {
  453. printError("%s", (const char*) lastResponse);
  454. return (false);
  455.     }
  456. } else {
  457.     printError("Bad %s parameter value %u.", parm.cmd, v);
  458.     return (false);
  459. }
  460. this->*parm.pv = v;
  461.     }
  462.     return (true);
  463. }
  465. static const char* typeNames[] = { "", "A", "E", "I", "L" };
  466. FaxClient::FaxParam FaxClient::typeParam =
  467.     { "TYPE", typeNames, N(typeNames), &FaxClient::type };
  468. bool FaxClient::setType(u_int v) { return setCommon(typeParam, v); }
  470. static const char* modeNames[] = { "", "S", "B", "C", "Z" };
  471. FaxClient::FaxParam FaxClient::modeParam =
  472.     { "MODE", modeNames, N(modeNames), &FaxClient::mode };
  473. bool FaxClient::setMode(u_int v) { return setCommon(modeParam, v); }
  475. static const char* struNames[] = { "", "F", "R", "P", "T" };
  476. FaxClient::FaxParam FaxClient::struParam =
  477.     { "STRU", struNames, N(struNames), &FaxClient::stru };
  478. bool FaxClient::setStruct(u_int v) { return setCommon(struParam, v); }
  480. static const char* formNames[] = { "", "PS", "PS2", "TIFF", "PCL", "PDF" };
  481. FaxClient::FaxParam FaxClient::formParam =
  482.     { "FORM", formNames, N(formNames), &FaxClient::format };
  483. bool FaxClient::setFormat(u_int v) { return setCommon(formParam, v); }
  485. static const char* tzoneNames[] = { "", "GMT", "LOCAL" };
  486. FaxClient::FaxParam FaxClient::tzoneParam =
  487.     { "TZONE", tzoneNames, N(tzoneNames), &FaxClient::tzone };
  488. bool
  489. FaxClient::setTimeZone(u_int v)
  490. {
  491.     if (!isLoggedIn()) { // set and mark pending accordingly
  492.         if (0 < v && v < N(tzoneNames)) {
  493.             tzone = v;
  494.             if (v == TZ_GMT) state &= ~FS_TZPEND;
  495.             else state |= FS_TZPEND;
  496.         } else {
  497.             printError("Bad time zone parameter value %u.", v);
  498.             return (false);
  499.         }
  500.         return (true);
  501.     } else { // pass directly to server
  502.         return setCommon(tzoneParam, v);
  503.     }
  504. }
  506. /*
  507.  * Data connection support.
  508.  *
  509.  * Separate connections are used for data transfers.
  510.  * The transport classes handle the work since it is
  511.  * inherently transport-specific.  Connections are 
  512.  * setup in a 2-step process because of the need (in
  513.  * the TCP world) to setup a listening socket prior to
  514.  * issuing a server command that causes the data connection
  515.  * to be established.  Thus the expected protocol is to
  516.  * initialize (initDataConn), issue a server command,
  517.  * then open (openDataConn); after which data can be
  518.  * transfered over the connection.  When completed the
  519.  * connection should be closed (closeDataConn).
  520.  *
  521.  * Outbound connections can be terminated simply by
  522.  * closing the data connection.  Inbound connections
  523.  * must be aborted with ABOR command that is sent in
  524.  * a transport-specific way (e.g. for TCP the message
  525.  * is sent as urgent data).  The abortDataConn interface
  526.  * is provided for this use.
  527.  */
  529. bool
  530. FaxClient::initDataConn(fxStr& emsg)
  531. {
  532.     closeDataConn();
  533.     if (transport) {
  534.         if (!transport->initDataConn(emsg)) {
  535.             if (emsg == "") {
  536.                 emsg = "Unable to initialize data connection to server";
  537.             }
  538.             return (false);
  539.         }
  540.     }
  541.     return (true);
  542. }
  544. bool
  545. FaxClient::openDataConn(fxStr& emsg)
  546. {
  547.     if (transport) {
  548.         if (!transport->openDataConn(emsg)) {
  549.             if (emsg == "") {
  550.              emsg = "Unable to open data connection to server";
  551.             }
  552.         return (false);
  553.         }
  554.     }
  555.     return (true);
  556. }
  558. void
  559. FaxClient::closeDataConn(void)
  560. {
  561.     if (fdData >= 0) {
  562.         transport->closeDataConn(fdData);
  563.         fdData = -1;
  564.     }
  565. }
  567. bool
  568. FaxClient::abortDataConn(fxStr& emsg)
  569. {
  570.     if (fdData >= 0 && transport) {
  571.         fflush(fdOut);
  572.         if (!transport->abortCmd(emsg)) {
  573.             if (emsg == "") {
  574.              emsg = "Unable to abort data connection to server";
  575.             }
  576.         return (false);
  577.         }
  578. #ifdef notdef
  579.         /*
  580.          * Flush data from data connection.
  581.          */
  582.         int flags = fcntl(fdData, F_GETFL, 0);
  583.         fcntl(fdData, F_SETFL, flags | FNONBLK);
  584.         while (Sys::read(fdData, buf, sizeof (buf)) > 0);
  585.         fcntl(fdData, F_SETFL, flags);
  586. #endif
  587.         /*
  588.          * Server should send a reply that acknowledges the
  589.          * existing operation is aborted followed by an ack
  590.          * of the ABOR command itself.
  591.          */
  592.         if (getReply(false) != TRANSIENT || // 4xx operation aborted
  593.                 getReply(false) != COMPLETE) { // 2xx abort successful
  594.             unexpectedResponse(emsg);
  595.             return (false);
  596.         }
  597.     }
  598.     return (true);
  599. }
  601. void
  602. FaxClient::lostServer(void)
  603. {
  604.     printError("Service not available, remote server closed connection");
  605.     hangupServer();
  606. }
  608. void
  609. FaxClient::unexpectedResponse(fxStr& emsg)
  610. {
  611.     emsg = "Unexpected server response: " | lastResponse;
  612. }
  614. void
  615. FaxClient::protocolBotch(fxStr& emsg, const char* fmt ...)
  616. {
  617.     va_list ap;
  618.     va_start(ap, fmt);
  619.     emsg = "Protocol botch" | fxStr::vformat(fmt, ap);
  620.     va_end(ap);
  621. }
  623. /*
  624.  * Send a command and wait for a response.
  625.  * The primary response code is returned.
  626.  */
  627. int
  628. FaxClient::command(const char* fmt ...)
  629. {
  630.     va_list ap1, ap2;
  631.     va_start(ap1, fmt);
  632.     va_start(ap2, fmt);
  633.     int r = vcommand(fmt, ap1, ap2);
  634.     va_end(ap1);
  635.     va_end(ap2);
  636.     return (r);
  637. }
  639. /*
  640.  * Send a command and wait for a response.
  641.  * The primary response code is returned.
  642.  */
  643. int
  644. FaxClient::vcommand(const char* fmt, va_list ap1, va_list ap2)
  645. {
  646.     if (getVerbose()) {
  647.         if (strncasecmp("PASS ", fmt, 5) == 0) {
  648.             traceServer("-> PASS XXXX");
  649.         } else if (strncasecmp("ADMIN ", fmt, 6) == 0) {
  650.             traceServer("-> ADMIN XXXX");
  651.         } else {
  652.     char* line = (char *)malloc(1024);
  653.     if (line == NULL)
  654. printError("Memory allocation failed");
  655.     else {
  656. vsnprintf(line, 1024, fmt, ap1);
  657. traceServer("-> %s", line);
  658.     }
  659.     free(line);
  660.         }
  661.     }
  662.     if (fdOut == NULL) {
  663.         printError("No control connection for command");
  664.         code = -1;
  665.         return (0);
  666.     }
  667.     vfprintf(fdOut, fmt, ap2);
  668.     fputs("rn", fdOut);
  669.     (void) fflush(fdOut);
  670.     return (getReply(strncmp(fmt, "QUIT", 4) == 0));
  671. }
  673. /*
  674.  * Extract a valid reply code from a string.
  675.  * The code must be 3 numeric digits followed
  676.  * by a space or ``-'' (the latter indicates
  677.  * the server reponse is to be continued with
  678.  * one or more lines).  If no valid reply code
  679.  * is recognized zero is returned--this is
  680.  * assumed to be an invalid reply code.
  681.  */
  682. static int
  683. getReplyCode(const char* cp)
  684. {
  685.     if (!isdigit(cp[0])) return (0);
  686.     int c = (cp[0] - '0');
  687.     if (!isdigit(cp[1])) return (0);
  688.     c = 10 * c + (cp[1] - '0');
  689.     if (!isdigit(cp[2])) return (0);
  690.     c = 10 * c + (cp[2] - '0');
  691.     return ((cp[3] == ' ' || cp[3] == '-') ? c : 0);
  692. }
  694. /*
  695.  * Read from the control channel until a valid reply is
  696.  * received or the connection is dropped.  The last line
  697.  * of the received response is left in FaxClient::lastResponse
  698.  * and the reply code is left in FaxClient::code.  The
  699.  * primary response (the first digit of the reply code)
  700.  * is returned to the caller.  Continuation lines are
  701.  * collected separately.
  702.  */
  703. int
  704. FaxClient::getReply(bool expecteof)
  705. {
  706.     int firstCode = 0;
  707.     bool continuation = false;
  708.     lastContinuation.resize(0);
  709.     do {
  710.         lastResponse.resize(0);
  711.         int c;
  712.         while ((c = getc(fdIn)) != 'n') {
  713.             if (c == IAC) {     // handle telnet commands
  714.              switch (c = getc(fdIn)) {
  715.              case WILL:
  716.                 case WONT:
  717.                  c = getc(fdIn);
  718.                  fprintf(fdOut, "%c%c%c", IAC, DONT, c);
  719.                     (void) fflush(fdOut);
  720.                     break;
  721.                 case DO:
  722.                 case DONT:
  723.                     c = getc(fdIn);
  724.                     fprintf(fdOut, "%c%c%c", IAC, WONT, c);
  725.                     (void) fflush(fdOut);
  726.                     break;
  727.                 default:
  728.                     break;
  729.                 }
  730.                 continue;
  731.             }
  732.             if (c == EOF) {
  733.              if (expecteof) {
  734.                     code = 221;
  735.                     return (0);
  736.                 } else {
  737.                     lostServer();
  738.                     code = 421;
  739.                     return (4);
  740.                 }
  741.             }
  742.             if (c != 'r') lastResponse.append(c);
  743.         }
  744.         if (getVerbose()) {
  745.             traceServer("%s", (const char*) lastResponse);
  746.         }
  747.         code = getReplyCode(lastResponse);
  748.         if (code != 0) { // found valid reply code
  749.             if (lastResponse[3] == '-') { // continuation line
  750.                 if (firstCode == 0) // first line of reponse
  751.                     firstCode = code;
  752.                 continuation = true;
  753.             } else if (code == firstCode) // end of continued reply
  754.                 continuation = false;
  755.         }
  756. if (continuation) {
  757.     lastContinuation.append(&lastResponse[4]);
  758.     lastContinuation.append("n");
  759. }
  761.     } while (continuation || code == 0);
  763.     if (code == 421) { // server closed connection
  764.         lostServer();
  765.     }
  766.     return code / 100;
  767. }
  769. /*
  770.  * Extract a string from a reply message.  The
  771.  * string that is extracted is expected to follow
  772.  * a pattern string.  The pattern is tried both
  773.  * in the initial case and then the inverse case
  774.  * (upper or lower depending on what the original
  775.  * case was).  The resulting string is checked to
  776.  * make sure that it is not null.
  777.  */
  778. bool
  779. FaxClient::extract(u_int& pos, const char* pattern, fxStr& result,
  780.     const char* cmd, fxStr& emsg)
  781. {
  782.     fxStr pat(pattern);
  783.     u_int l = lastResponse.find(pos, pat);
  784.     if (l == lastResponse.length()) { // try inverse-case version
  785.         if (isupper(pattern[0])) {
  786.             pat.lowercase();
  787.         } else {
  788.             pat.raisecase();
  789.         }
  790.         l = lastResponse.find(pos, pat);
  791.     }
  792.     if (l == lastResponse.length()) {
  793.         protocolBotch(emsg, ": No "%s" in %s response: %s",
  794.             pattern, cmd, (const char*) lastResponse);
  795.         return false;
  796.     }
  797.     l = lastResponse.skip(l+pat.length(), ' ');// skip white space
  798.     result = lastResponse.extract(l, lastResponse.next(l, ' ')-l);
  799.     if (result == "") {
  800.         protocolBotch(emsg, ": Null %s in %s response: %s",
  801.             pattern, cmd, (const char*) lastResponse);
  802.         return false;
  803.     }
  804.     pos = l; // update position
  805.     return true;
  806. }
  808. /*
  809.  * Create a new job and return its job-id
  810.  * and group-id, parsed from the reply.
  811.  */
  812. bool
  813. FaxClient::newJob(fxStr& jobid, fxStr& groupid, fxStr& emsg)
  814. {
  815.     if (command("JNEW") == COMPLETE) {
  816.         if (code == 200) {
  817.             /*
  818.              * The response should be of the form:
  819.              *
  820.              * 200 ... jobid: xxxx groupid: yyyy.
  821.              *
  822.              * where xxxx is the ID for the new job and yyyy is the
  823.              * ID of the new job's group.
  824.              */
  825.             u_int l = 0;
  826.             if (extract(l, "jobid:", jobid, "JNEW", emsg) &&
  827.                     extract(l, "groupid:", groupid, "JNEW", emsg)) {
  828.                 /*
  829.                  * Force job and groupd IDs to be numeric;
  830.                  * this deals with servers that want to append
  831.                  * punctuation such as ``,'' or ``.''.
  832.                  */
  833.                 jobid.resize(jobid.skip(0, "0123456789"));
  834.                 groupid.resize(groupid.skip(0, "0123456789"));
  835.                 curjob = jobid;
  836.                 return true;
  837.             }
  838.         } else {
  839.             unexpectedResponse(emsg);
  840.         }
  841.     } else {
  842.         emsg = lastResponse;
  843.     }
  844.     return false;
  845. }
  847. /*
  848.  * Set the current job on the server.
  849.  */
  850. bool
  851. FaxClient::setCurrentJob(const char* jobid)
  852. {
  853.     if (strcasecmp(jobid, curjob) != 0) {
  854.         if (command("JOB %s", jobid) != COMPLETE) {
  855.             return false;
  856.         }
  857.         curjob = jobid;
  858.     }
  859.     return true;
  860. }
  862. bool
  863. FaxClient::jobParm(const char* name, const fxStr& value)
  864. {
  865.     /*
  866.      * We need to quote any " marks in the string before
  867.      * we pass it on to the raw jobParm(... const char*)
  868.      */
  869.     if (value.next(0,'"'))
  870.     {
  871. fxStr tmp(value);
  872. int r = tmp.length();
  873. while (r > 0)
  874. {
  875.     if ( (r = tmp.nextR(r-1, '"') ) > 0 )
  876. tmp.insert('\', r-1);
  877. }
  878. return jobParm(name, (const char*)tmp);
  879.     }
  880.     return jobParm(name, (const char*) value);
  881. }
  883. bool
  884. FaxClient::jobParm(const char* name, const char* value)
  885. {
  886.     /*
  887.      * if they're passing us a wrong char*, we expect
  888.      * them to have handled any quoting requried.
  889.      */
  890.     return (command("JPARM %s "%s"", name, value) == COMPLETE);
  891. }
  893. bool
  894. FaxClient::jobParm(const char* name, bool b)
  895. {
  896.     return (command("JPARM %s %s", name, b ? "YES" : "NO") == COMPLETE);
  897. }
  899. bool
  900. FaxClient::jobParm(const char* name, u_int v)
  901. {
  902.     return (command("JPARM %s %u", name, v) == COMPLETE);
  903. }
  905. bool
  906. FaxClient::jobParm(const char* name, float v)
  907. {
  908.     return (command("JPARM %s %g", name, v) == COMPLETE);
  909. }
  911. bool
  912. FaxClient::jobSendTime(const struct tm tm)
  913. {
  914.     return (command("JPARM SENDTIME %d%02d%02d%02d%02d"
  915.         , tm.tm_year+1900
  916.         , tm.tm_mon+1
  917.         , tm.tm_mday
  918.         , tm.tm_hour
  919.         , tm.tm_min
  920.         ) == COMPLETE);
  921. }
  923. bool
  924. FaxClient::jobLastTime(u_long tv)
  925. {
  926.     return (command("JPARM LASTTIME %02d%02d%02d",
  927.         tv/(24*60*60), (tv/(60*60))%24, (tv/60)%60) == COMPLETE);
  928. }
  930. bool
  931. FaxClient::jobRetryTime(u_long tv)
  932. {
  933.     return (command("JPARM RETRYTIME %02d%02d", tv/60, tv%60) == COMPLETE);
  934. }
  936. bool
  937. FaxClient::jobCover(const char* docname)
  938. {
  939.     return (command("JPARM COVER %s", docname) == COMPLETE);
  940. }
  942. bool
  943. FaxClient::jobDocument(const char* docname)
  944. {
  945.     return (command("JPARM DOCUMENT %s", docname) == COMPLETE);
  946. }
  948. bool
  949. FaxClient::jobPollRequest(const char* sep, const char* pwd)
  950. {
  951.     return (command("JPARM POLL "%s" "%s"", sep, pwd) == COMPLETE);
  952. }
  954. bool
  955. FaxClient::jobOp(const char* op, const char* jobid)
  956. {
  957.     return (command(jobid == curjob ? "%s" : "%s %s", op, jobid) == COMPLETE);
  958. }
  959. bool FaxClient::jobSubmit(const char* jobid) { return jobOp("JSUBM",jobid); }
  960. bool FaxClient::jobSuspend(const char* jobid) { return jobOp("JSUSP",jobid); }
  961. bool FaxClient::jobKill(const char* jobid) { return jobOp("JKILL",jobid); }
  962. bool FaxClient::jobDelete(const char* jobid) { return jobOp("JDELE",jobid); }
  963. bool FaxClient::jobWait(const char* jobid) { return jobOp("JWAIT",jobid); }
  965. bool FaxClient::jgrpSubmit(const char* jgrpid)
  966.     { return (command("JGSUBM %s", jgrpid) == COMPLETE); }
  967. bool FaxClient::jgrpSuspend(const char* jgrpid)
  968.     { return (command("JGSUSP %s", jgrpid) == COMPLETE); }
  969. bool FaxClient::jgrpKill(const char* jgrpid)
  970.     { return (command("JGKILL %s", jgrpid) == COMPLETE); }
  971. bool FaxClient::jgrpWait(const char* jgrpid)
  972.     { return (command("JGWAIT %s", jgrpid) == COMPLETE); }
  974. bool
  975. FaxClient::runScript(const char* filename, fxStr& emsg)
  976. {
  977.     bool ok = false;
  978.     FILE* fd = fopen(filename, "r");
  979.     if (fd != NULL) {
  980. ok = runScript(fd, filename, emsg);
  981. fclose(fd);
  982.     } else
  983. emsg = fxStr::format("Unable to open script file "%s".", filename);
  984.     return (ok);
  985. }
  987. bool
  988. FaxClient::runScript(FILE* fp, const char* filename, fxStr& emsg)
  989. {
  990.     bool ok = false;
  991.     struct stat sb;
  992.     (void) Sys::fstat(fileno(fp), sb);
  993.     char* addr;
  994. #if HAS_MMAP
  995.     addr = (char*) mmap(NULL, (size_t) sb.st_size, PROT_READ, MAP_SHARED, fileno(fp), 0);
  996.     if (addr == (char*) -1) { // revert to file reads
  997. #endif
  998. addr = new char[sb.st_size];
  999. if (Sys::read(fileno(fp), addr, (u_int) sb.st_size) == sb.st_size)
  1000.     ok = runScript(addr, sb.st_size, filename, emsg);
  1001. else
  1002.     emsg = fxStr::format("%s: Read error: %s",
  1003. filename, strerror(errno));
  1004. delete [] addr;
  1005. #if HAS_MMAP
  1006.     } else { // send mmap'd file data
  1007. ok = runScript(addr, sb.st_size, filename, emsg);
  1008. munmap(addr, (size_t) sb.st_size);
  1009.     }
  1010. #endif
  1011.     return (ok);
  1012. }
  1014. bool
  1015. FaxClient::runScript(const char* script, u_long scriptLen,
  1016.     const char* filename, fxStr& emsg)
  1017. {
  1018.     u_int lineno = 0;
  1019.     while (scriptLen > 0) {
  1020. lineno++;
  1021. const char* ep = strchr(script, 'n');
  1022. if (!ep)
  1023.     ep = script+scriptLen;
  1024. u_int cmdLen = ep-script;
  1025. if (cmdLen > 1) {
  1026.     if (command("%.*s", cmdLen, script) != COMPLETE) {
  1027. emsg = fxStr::format("%s: line %u: %s",
  1028.     filename, lineno, (const char*) lastResponse);
  1029. return (false);
  1030.     }
  1031. }
  1032. if (*ep == 'n')
  1033.     ep++;
  1034. scriptLen -= ep - script;
  1035. script = ep;
  1036.     }
  1037.     return (true);
  1038. }
  1040. /*
  1041.  * Create a uniquely named document on the server
  1042.  * that is not removed when the server exits.
  1043.  */
  1044. bool
  1045. FaxClient::storeUnique(fxStr& docname, fxStr& emsg)
  1046. {
  1047.     return storeUnique("STOU", docname, emsg);
  1048. }
  1049. /*
  1050.  * Create a uniquely named document on the server
  1051.  * that is automatically removed when the server exits.
  1052.  */
  1053. bool
  1054. FaxClient::storeTemp(fxStr& docname, fxStr& emsg)
  1055. {
  1056.     return storeUnique("STOT", docname, emsg);
  1057. }
  1059. /*
  1060.  * Send a STOU/STOT command and parse the
  1061.  * response to get the resulting filename.
  1062.  */
  1063. bool
  1064. FaxClient::storeUnique(const char* cmd, fxStr& docname, fxStr& emsg)
  1065. {
  1066.     if (command(cmd) == PRELIM) {
  1067. if (code == 150) {
  1068.     /*
  1069.      * According to RFC 1123, the response must be of the form:
  1070.      *
  1071.      * 150 FILE: pppp[ anything]
  1072.      *
  1073.      * where pppp is the unique document name chosen by the server.
  1074.      */
  1075.     u_int l = 0;
  1076.     return (extract(l, "FILE:", docname, cmd, emsg));
  1077. } else
  1078.     unexpectedResponse(emsg);
  1079.     } else
  1080. emsg = lastResponse;
  1081.     return (false);
  1082. }
  1084. /*
  1085.  * Create/overwrite a file on the server.
  1086.  */
  1087. bool
  1088. FaxClient::storeFile(fxStr& docname, fxStr& emsg)
  1089. {
  1090.     if (command("STOR " | docname) != PRELIM) {
  1091. emsg = lastResponse;
  1092. return (false);
  1093.     }
  1094.     if (code != 150) {
  1095. unexpectedResponse(emsg);
  1096. return (false);
  1097.     }
  1098.     return (true);
  1099. }
  1101. /*
  1102.  * Send a block of raw data on the data
  1103.  * conenction, interpreting write errors.
  1104.  */
  1105. bool
  1106. FaxClient::sendRawData(void* buf, int cc, fxStr& emsg)
  1107. {
  1108. #ifdef __linux__
  1109.     /*
  1110.      * Linux kernel bug: can get short writes on
  1111.      * stream sockets when setup for blocking i/o.
  1112.      */
  1113.     u_char* bp = (u_char*) buf;
  1114.     for (int cnt, sent = 0; cc; sent += cnt, cc -= cnt) 
  1115. if ((cnt = write(fdData, bp + sent, cc)) <= 0) {
  1116.     protocolBotch(emsg, errno == EPIPE ?
  1117. " (server closed connection)" : " (server write error: %s).",
  1118. strerror(errno));
  1119.     return (false);
  1120. }
  1121. #else
  1122.     if (write(fdData, buf, cc) != cc) {
  1123. protocolBotch(emsg, errno == EPIPE ?
  1124.     " (server closed connection)" : " (server write error: %s).",
  1125.     strerror(errno));
  1126. return (false);
  1127.     }
  1128. #endif
  1129.     return (true);
  1130. }
  1132. /*
  1133.  * Send a document file using stream (uncompressed) mode
  1134.  * and the current transfer parameters.  The server-side
  1135.  * document name where data gets placed is returned.
  1136.  */
  1137. bool
  1138. FaxClient::sendData(int fd,
  1139.     bool (FaxClient::*store)(fxStr&, fxStr&), fxStr& docname, fxStr& emsg)
  1140. {
  1141.     char* addr = (char*) -1;
  1142.     struct stat sb;
  1143.     size_t cc;
  1144.     (void) Sys::fstat(fd, sb);
  1145.     if (getVerbose())
  1146. traceServer("SEND data, %lu bytes", (u_long) sb.st_size);
  1147.     if (!initDataConn(emsg))
  1148. goto bad;
  1149.     if (!setMode(MODE_S))
  1150. goto bad;
  1151.     if (!(this->*store)(docname, emsg))
  1152. goto bad;
  1153.     if (!openDataConn(emsg))
  1154. goto bad;
  1155. #if HAS_MMAP
  1156.     addr = (char*) mmap(NULL, (size_t) sb.st_size, PROT_READ, MAP_SHARED, fd, 0);
  1157.     if (addr == (char*) -1) { // revert to file reads
  1158. #endif
  1159. cc = (size_t) sb.st_size;
  1160. while (cc > 0) {
  1161.     char buf[32*1024]; // XXX better if page-aligned
  1162.     size_t n = fxmin(cc, sizeof (buf));
  1163.     if (read(fd, buf, n) != (ssize_t)n) {
  1164. protocolBotch(emsg, " (data read: %s).", strerror(errno));
  1165. goto bad;
  1166.     }
  1167.     if (!sendRawData(buf, n, emsg))
  1168. goto bad;
  1169.     cc -= n;
  1170. }
  1171. #if HAS_MMAP
  1172.     } else if (!sendRawData(addr, (int) sb.st_size, emsg)) // send mmap'd file data
  1173. goto bad;
  1174. #endif
  1175.     closeDataConn();
  1176. #if HAS_MMAP
  1177.     if (addr != (char*) -1)
  1178. munmap(addr, (size_t) sb.st_size);
  1179. #endif
  1180.     return (getReply(false) == 2);
  1181. bad:
  1182.     closeDataConn();
  1183. #if HAS_MMAP
  1184.     if (addr != (char*) -1)
  1185. munmap(addr, (size_t) sb.st_size);
  1186. #endif
  1187.     return (false);
  1188. }
  1190. /*
  1191.  * Send a document file using zip-compressed mode
  1192.  * and the current transfer parameters.  The server-side
  1193.  * document name where data gets placed is returned.
  1194.  */
  1195. bool
  1196. FaxClient::sendZData(int fd,
  1197.     bool (FaxClient::*store)(fxStr&, fxStr&), fxStr& docname, fxStr& emsg)
  1198. {
  1199.     z_stream zstream;
  1200.     zstream.zalloc = NULL;
  1201.     zstream.zfree = NULL;
  1202.     zstream.opaque = NULL;
  1203.     zstream.data_type = Z_BINARY;
  1204.     if (deflateInit(&zstream, Z_DEFAULT_COMPRESSION) == Z_OK) {
  1205. #if HAS_MMAP
  1206. char* addr = (char*) -1; // mmap'd file
  1207. #endif
  1208. char obuf[32*1024]; // XXX better if page-aligned
  1209. zstream.next_out = (Bytef*) obuf;
  1210. zstream.avail_out = sizeof (obuf);
  1211. struct stat sb;
  1212. size_t cc;
  1213. Sys::fstat(fd, sb);
  1214. if (getVerbose())
  1215.     traceServer("SEND compressed data, %lu bytes", (u_long) sb.st_size);
  1216. if (!initDataConn(emsg))
  1217.     goto bad;
  1218. if (!setMode(MODE_Z))
  1219.     goto bad;
  1220. if (!(this->*store)(docname, emsg))
  1221.     goto bad;
  1222. if (!openDataConn(emsg))
  1223.     goto bad;
  1224. #if HAS_MMAP
  1225. addr = (char*) mmap(NULL, (size_t) sb.st_size, PROT_READ, MAP_SHARED, fd, 0);
  1226. if (addr == (char*) -1) { // revert to file reads
  1227. #endif
  1228.     cc = (size_t) sb.st_size;
  1229.     while (cc > 0) {
  1230. char buf[32*1024];
  1231. int n = fxmin((size_t) cc, sizeof (buf));
  1232. if (read(fd, buf, n) != n) {
  1233.     protocolBotch(emsg, " (data read: %s)", strerror(errno));
  1234.     goto bad;
  1235. }
  1236. zstream.next_in = (Bytef*) buf;
  1237. zstream.avail_in = n;
  1238. do {
  1239.     if (deflate(&zstream, Z_NO_FLUSH) != Z_OK) {
  1240. emsg = fxStr::format("zlib compressor error: %s",
  1241.     zstream.msg);
  1242. goto bad;
  1243.     }
  1244.     if (zstream.avail_out == 0) {
  1245. if (!sendRawData(obuf, sizeof (obuf), emsg))
  1246.     goto bad2;
  1247. zstream.next_out = (Bytef*) obuf;
  1248. zstream.avail_out = sizeof (obuf);
  1249.     }
  1250. } while (zstream.avail_in > 0);
  1251. cc -= n;
  1252.     }
  1253.     zstream.avail_in = 0;
  1254. #if HAS_MMAP
  1255. } else {
  1256.     zstream.next_in = (Bytef*) addr;
  1257.     zstream.avail_in = (u_int) sb.st_size;
  1258.     do {
  1259. if (deflate(&zstream, Z_NO_FLUSH) != Z_OK) {
  1260.     emsg = fxStr::format("zlib compressor error: %s",
  1261. zstream.msg);
  1262.     goto bad;
  1263. }
  1264. if (zstream.avail_out == 0) {
  1265.     if (!sendRawData(obuf, sizeof (obuf), emsg))
  1266. goto bad2;
  1267.     zstream.next_out = (Bytef*) obuf;
  1268.     zstream.avail_out = sizeof (obuf);
  1269. }
  1270.     } while (zstream.avail_in > 0);
  1271. }
  1272. #endif
  1273. int dstate;
  1274. do {
  1275.     switch (dstate = deflate(&zstream, Z_FINISH)) {
  1276.     case Z_STREAM_END:
  1277.     case Z_OK:
  1278. if (zstream.avail_out != sizeof (obuf)) {
  1279.     if (!sendRawData(obuf, sizeof (obuf) - zstream.avail_out, emsg))
  1280. goto bad2;
  1281.     zstream.next_out = (Bytef*) obuf;
  1282.     zstream.avail_out = sizeof (obuf);
  1283. }
  1284. break;
  1285.     default:
  1286. emsg = fxStr::format("zlib compressor error: %s",
  1287.     zstream.msg);
  1288. goto bad;
  1289.     }
  1290. } while (dstate != Z_STREAM_END);
  1291. if (getVerbose())
  1292.     traceServer("SEND %lu bytes transmitted (%.1fx compression)",
  1293. #define NZ(x) ((x)?(x):1)
  1294. zstream.total_out, float(sb.st_size) / NZ(zstream.total_out));
  1295. closeDataConn();
  1296. #if HAS_MMAP
  1297. if (addr != (char*) -1)
  1298.     munmap(addr, (size_t) sb.st_size);
  1299. #endif
  1300. deflateEnd(&zstream);
  1301. return (getReply(false) == COMPLETE);
  1302. bad2:
  1303. (void) getReply(false);
  1304. /* fall thru... */
  1305. bad:
  1306. closeDataConn();
  1307. #if HAS_MMAP
  1308. if (addr != (char*) -1)
  1309.     munmap(addr, (size_t) sb.st_size);
  1310. #endif
  1311. deflateEnd(&zstream);
  1312.     } else
  1313. emsg = fxStr::format("Can not initialize compression library: %s",
  1314.     zstream.msg);
  1315.     return (false);
  1316. }
  1318. /*
  1319.  * Receive data using stream mode and the current
  1320.  * transfer parameters.  The supplied arguments are
  1321.  * passed to command to initiate the transfers once
  1322.  * a data connection has been setup.  These commands
  1323.  * can intiate a file retrieval (RETR), directory
  1324.  * listing (LIST), trigger event trace log (SITE TRIGGER)
  1325.  * or other data connection-based transfer.
  1326.  */
  1327. bool
  1328. FaxClient::recvData(bool (*f)(void*, const char*, int, fxStr&),
  1329.     void* arg, fxStr& emsg, u_long restart, const char* fmt, ...)
  1330. {
  1331.     if ((!setMode(MODE_S)) ||
  1332. (!initDataConn(emsg)) ||
  1333. (restart && command("REST %lu", restart) != CONTINUE)) {
  1334. // cannot "goto bad" because it is outside the scope of a va_arg
  1335. closeDataConn();
  1336. return (false);
  1337.     }
  1338.     va_list ap1, ap2;
  1339.     va_start(ap1, fmt);
  1340.     va_start(ap2, fmt);
  1341.     int r; r = vcommand(fmt, ap1, ap2);
  1342.     va_end(ap1);
  1343.     va_end(ap2);
  1344.     if (r != PRELIM)
  1345. goto bad;
  1346.     if (!openDataConn(emsg))
  1347. goto bad;
  1348.     u_long byte_count; byte_count = 0; // XXX for __GNUC__
  1349.     for (;;) {
  1350. char buf[16*1024];
  1351. int cc = read(fdData, buf, sizeof (buf));
  1352. if (cc == 0) {
  1353.     closeDataConn();
  1354.     return (getReply(false) == COMPLETE);
  1355. }
  1356. if (cc < 0) {
  1357.     emsg = fxStr::format("Data Connection: %s", strerror(errno));
  1358.     (void) getReply(false);
  1359.     break;
  1360. }
  1361. byte_count += cc;
  1362. if (!(*f)(arg, buf, cc, emsg))
  1363.     break;
  1364.     }
  1365. bad:
  1366.     closeDataConn();
  1367.     return (false);
  1368. }
  1370. /*
  1371.  * Receive data using zip-compressed mode and the current
  1372.  * transfer parameters.  The supplied arguments are
  1373.  * passed to command to initiate the transfers once
  1374.  * a data connection has been setup.  These commands
  1375.  * can intiate a file retrieval (RETR), directory
  1376.  * listing (LIST), trigger event trace log (SITE TRIGGER)
  1377.  * or other data connection-based transfer.
  1378.  */
  1379. bool
  1380. FaxClient::recvZData(bool (*f)(void*, const char*, int, fxStr&),
  1381.     void* arg, fxStr& emsg, u_long restart, const char* fmt, ...)
  1382. {
  1383.     z_stream zstream;
  1384.     zstream.zalloc = NULL;
  1385.     zstream.zfree = NULL;
  1386.     zstream.opaque = NULL;
  1387.     zstream.data_type = Z_BINARY;
  1388.     if (inflateInit(&zstream) == Z_OK) {
  1389. if ((!setMode(MODE_Z)) ||
  1390.     (!initDataConn(emsg)) ||
  1391.     (restart && command("REST %lu", restart) != CONTINUE)) {
  1392.     // cannot "goto bad" because it is outside the scope of a va_arg
  1393.     closeDataConn();
  1394.     inflateEnd(&zstream);
  1395.     return (false);
  1396. }
  1397. va_list ap1, ap2;
  1398. va_start(ap1, fmt);
  1399. va_start(ap2, fmt);
  1400. int r; r = vcommand(fmt, ap1, ap2); // XXX for __GNUC__
  1401. va_end(ap1);
  1402. va_end(ap2);
  1403. if (r != PRELIM)
  1404.     goto bad;
  1405. if (!openDataConn(emsg))
  1406.     goto bad;
  1407. char obuf[16*1024];
  1408. zstream.next_out = (Bytef*) obuf;
  1409. zstream.avail_out = sizeof (obuf);
  1410. for (;;) {
  1411.     char buf[16*1024];
  1412.     int cc = read(fdData, buf, sizeof (buf));
  1413.     if (cc == 0) {
  1414. size_t occ = sizeof (obuf) - zstream.avail_out;
  1415. if (occ > 0 && !(*f)(arg, obuf, occ, emsg))
  1416.     goto bad;
  1417. closeDataConn();
  1418. (void) inflateEnd(&zstream);
  1419. return (getReply(false) == COMPLETE);
  1420.     }
  1421.     if (cc < 0) {
  1422. emsg = fxStr::format("Data Connection: %s", strerror(errno));
  1423. (void) getReply(false);
  1424. goto bad;
  1425.     }
  1426.     zstream.next_in = (Bytef*) buf;
  1427.     zstream.avail_in = cc;
  1428.     do {
  1429. int dstate = inflate(&zstream, Z_PARTIAL_FLUSH);
  1430. if (dstate == Z_STREAM_END)
  1431.     break;
  1432. if (dstate != Z_OK) {
  1433.     emsg = fxStr::format("Decoding error: %s", zstream.msg);
  1434.     goto bad;
  1435. }
  1436. size_t occ = sizeof (obuf) - zstream.avail_out;
  1437. if (!(*f)(arg, obuf, occ, emsg))
  1438.     goto bad;
  1439. zstream.next_out = (Bytef*) obuf;
  1440. zstream.avail_out = sizeof (obuf);
  1441.     } while (zstream.avail_in > 0);
  1442. }
  1443. bad:
  1444. closeDataConn();
  1445. inflateEnd(&zstream);
  1446.     } else
  1447. emsg = fxStr::format("Can not initialize decoder: %s", zstream.msg);
  1448.     return (false);
  1449. }
  1451. /*
  1452.  * Return the current value for the specified
  1453.  * status format string.  If we have not set a
  1454.  * value locally, ask the server for the default
  1455.  * setting.
  1456.  */
  1457. const fxStr&
  1458. FaxClient::getStatusFormat(u_int flag, const char* cmd, fxStr& fmt)
  1459. {
  1460.     if (isLoggedIn()) {
  1461. if (state&flag) { // set pending; do it
  1462.     if (command("%s "%s"", cmd, (const char*) fmt) == COMPLETE)
  1463. state &= ~flag;
  1464.     else
  1465. printError("%s", (const char*) lastResponse);
  1466. } else if (fmt == "") { // must query server
  1467.     if (command(cmd) == COMPLETE)
  1468. fmt = lastResponse.tail(lastResponse.length()-4);
  1469.     else
  1470. printError("%s", (const char*) lastResponse);
  1471. }
  1472.     }
  1473.     return (fmt);
  1474. }
  1476. /*
  1477.  * Set the specified status format string
  1478.  *  in the client and the server.
  1479.  */
  1480. bool
  1481. FaxClient::setStatusFormat(const char* cmd, u_int flag,
  1482.     fxStr& fmt, const char* value)
  1483. {
  1484.     if (isLoggedIn()) {
  1485. if (command("%s "%s"", cmd, value) != COMPLETE) {
  1486.     printError("%s", (const char*) lastResponse);
  1487.     return (false);
  1488. }
  1489. state &= ~flag;
  1490.     } else
  1491. state |= flag;
  1492.     fmt = value;
  1493.     return (true);
  1494. }
  1496. /*
  1497.  * Set the job status format string in the
  1498.  * client and the server.
  1499.  */
  1500. bool
  1501. FaxClient::setJobStatusFormat(const char* cp)
  1502. {
  1503.     return setStatusFormat("JOBFMT", FS_JFMTPEND, jobFmt, cp);
  1504. }
  1506. /*
  1507.  * Return the current job status format string.
  1508.  * If we have not set a value locally, ask the
  1509.  * server for the default setting.
  1510.  */
  1511. const fxStr&
  1512. FaxClient::getJobStatusFormat(void)
  1513. {
  1514.     return getStatusFormat(FS_JFMTPEND, "JOBFMT", jobFmt);
  1515. }
  1517. /*
  1518.  * Set the receive queue status format
  1519.  * string in the client and the server.
  1520.  */
  1521. bool
  1522. FaxClient::setRecvStatusFormat(const char* cp)
  1523. {
  1524.     return setStatusFormat("RCVFMT", FS_RFMTPEND, recvFmt, cp);
  1525. }
  1527. /*
  1528.  * Return the current recv queue status format
  1529.  * string.  If we have not set a value locally,
  1530.  * ask the server for the default setting.
  1531.  */
  1532. const fxStr&
  1533. FaxClient::getRecvStatusFormat(void)
  1534. {
  1535.     return getStatusFormat(FS_RFMTPEND, "RCVFMT", recvFmt);
  1536. }
  1539. /*
  1540.  * Set the modem status format
  1541.  * string in the client and the server.
  1542.  */
  1543. bool
  1544. FaxClient::setModemStatusFormat(const char* cp)
  1545. {
  1546.     return setStatusFormat("MDMFMT", FS_MFMTPEND, modemFmt, cp);
  1547. }
  1549. /*
  1550.  * Return the current modem status format
  1551.  * string.  If we have not set a value locally,
  1552.  * ask the server for the default setting.
  1553.  */
  1554. const fxStr&
  1555. FaxClient::getModemStatusFormat(void)
  1556. {
  1557.     return getStatusFormat(FS_MFMTPEND, "MDMFMT", modemFmt);
  1558. }
  1560. /*
  1561.  * Set the file status format
  1562.  * string in the client and the server.
  1563.  */
  1564. bool
  1565. FaxClient::setFileStatusFormat(const char* cp)
  1566. {
  1567.     return setStatusFormat("FILEFMT", FS_FFMTPEND, fileFmt, cp);
  1568. }
  1570. /*
  1571.  * Return the current file status format
  1572.  * string.  If we have not set a value locally,
  1573.  * ask the server for the default setting.
  1574.  */
  1575. const fxStr&
  1576. FaxClient::getFileStatusFormat(void)
  1577. {
  1578.     return getStatusFormat(FS_FFMTPEND, "FILEFMT", fileFmt);
  1579. }
  1581. /*
  1582.  * Convert a format string to a header using a table
  1583.  * that maps format character to field header.
  1584.  */
  1585. void
  1586. FaxClient::makeHeader(const char* fmt, const FaxFmtHeader fmts[], fxStr& header)
  1587. {
  1588.     for (const char* cp = fmt; *cp; cp++) {
  1589. if (*cp == '%') {
  1590.     u_int width = 0; // field width
  1591.     u_int prec = 0; // field precision
  1592. #define MAXSPEC 20
  1593.     char fspec[MAXSPEC];
  1594.     char* fp = fspec;
  1595.     *fp++ = '%';
  1596.     char c = *++cp;
  1597.     if (c == '')
  1598. break;
  1599.     if (c == '-')
  1600. *fp++ = c, c = *++cp;
  1601.     if (isdigit(c)) {
  1602. do {
  1603.     *fp++ = c;
  1604.     width = 10*width + (c-'0');
  1605. } while (isdigit(c = *++cp) && fp < &fspec[MAXSPEC-3]);
  1606.     }
  1607.     if (c == '.') {
  1608. do {
  1609.     *fp++ = c;
  1610.     prec = 10*prec + (c-'0');
  1611. } while (isdigit(c = *++cp) && fp < &fspec[MAXSPEC-2]);
  1612.     }
  1613.     if (c == '%') { // %% -> %
  1614. header.append(c);
  1615. continue;
  1616.     }
  1617.     const FaxFmtHeader* hp;
  1618.     for (hp = fmts; hp->fmt != '' && hp->fmt != c; hp++)
  1619. ;
  1620.     if (hp->fmt == c) {
  1621. if (prec == 0) // constrain header to field width
  1622.     prec = width;
  1623. if (fspec[1] == '-') // left justify
  1624.     width = -width;
  1625. if (width == 0 && prec == 0)
  1626.     header.append(hp->title);
  1627. else
  1628.     header.append(fxStr::format("%*.*s", width, prec, hp->title));
  1629.     } else {
  1630. *fp++ = c;
  1631. header.append(fxStr(fspec, fp-fspec));
  1632.     }
  1633. } else
  1634.     header.append(*cp);
  1635.     }
  1636. }
  1638. /*
  1639.  * Table of known format strings for the job
  1640.  * queue status listings returned by the server.
  1641.  */
  1642. const FaxClient::FaxFmtHeader FaxClient::jobFormats[] = {
  1643.     { 'A', "SUB" }, // A (subaddr)
  1644.     { 'B', "PWD" }, // B (passwd)
  1645.     { 'C', "Company" }, // C (company)
  1646.     { 'D', "Dials" }, // D (totdials & maxdials)
  1647.     { 'E', "BR" }, // E (desiredbr)
  1648.     { 'F', "Tagline" }, // F (tagline)
  1649.     { 'G', "ST" }, // G (desiredst)
  1650.     { 'H', "DF" }, // H (desireddf)
  1651.     { 'I', "UsrPri" }, // I (usrpri)
  1652.     { 'J', "JobTag" }, // J (jobtag)
  1653.     { 'K', "EC" }, // K (desiredec as symbol)
  1654.     { 'L', "Location" }, // L (location)
  1655.     { 'M', "MailAddr" }, // M (mailaddr)
  1656.     { 'N', "DT" }, // N (desiredtl as symbol)
  1657.     { 'O', "CC" }, // O (useccover as symbol)
  1658.     { 'P', "Pages" }, // P (npages & totpages)
  1659.     { 'Q', "MinSP" }, // Q (minsp)
  1660.     { 'R', "Receiver" }, // R (receiver)
  1661.     { 'S', "Sender" }, // S (sender)
  1662.     { 'T', "Tries" }, // T (tottries & maxtries)
  1663.     { 'U', "ChopThreshold" },// U (chopthreshold)
  1664.     { 'V', "DoneOp" }, // V (doneop)
  1665.     { 'W', "CommID" }, // W (commid)
  1666.     { 'X', "JobType" }, // X (jobtype)
  1667.     { 'Y', "Date       Time" }, // Y (date & time)
  1668.     { 'Z', "UNIX Time" }, // Z (seconds since the UNIX epoch)
  1669.     { 'a', "State" }, // a (job state as symbol)
  1670.     { 'b', "NTries" }, // b (ntries)
  1671.     { 'c', "Client" }, // c (client)
  1672.     { 'd', "TotDials" }, // d (totdials)
  1673.     { 'e', "Number" }, // e (external)
  1674.     { 'f', "NDials" }, // f (ndials)
  1675.     { 'g', "GID" }, // g (groupid)
  1676.     { 'h', "Chop" }, // h (pagechop as symbol)
  1677.     { 'i', "Priority" }, // i (pri)
  1678.     { 'j', "JID" }, // j (jobid)
  1679.     { 'k', "LastTime" }, // k (killtime)
  1680.     { 'l', "PageLength" }, // l (pagelength)
  1681.     { 'm', "Modem" }, // m (modem)
  1682.     { 'n', "Notify" }, // n (notify as symbol)
  1683.     { 'o', "Owner" }, // o (owner)
  1684.     { 'p', "Pages" }, // p (npages)
  1685.     { 'q', "RetryTime" }, // q (retrytime as MM:SS)
  1686.     { 'r', "Resolution" }, // r (resolution)
  1687.     { 's', "Status" }, // s (notice a.k.a. status)
  1688.     { 't', "TotTries" }, // t (tottries)
  1689.     { 'u', "MaxTries" }, // u (maxtries)
  1690.     { 'v', "DialString" }, // v (number a.ka. dialstring)
  1691.     { 'w', "PageWidth" }, // w (pagewidth)
  1692.     { 'x', "MaxDials" }, // x (maxdials)
  1693.     { 'y', "TotPages" }, // y (totpages)
  1694.     { 'z', "TTS" }, // z (tts)
  1695.     { '0', "UseXVres" }, // 0 (usexvres as symbol)
  1696.     { '' },
  1697. };
  1698. void FaxClient::getJobStatusHeader(fxStr& header)
  1699.     { makeHeader(getJobStatusFormat(), jobFormats, header); }
  1701. /*
  1702.  * Table of known format strings for the receive
  1703.  * queue status listings returned by the server.
  1704.  */
  1705. const FaxClient::FaxFmtHeader FaxClient::recvFormats[] = {
  1706.     { 'X', "RI" }, // X (reception indicator)
  1707.     { 'Y', "Date       Time" }, // Y (date & time)
  1708.     { 'Z', "UNIX Time" }, // Z (seconds since the UNIX epoch)
  1709.     { 'a', "SUB" }, // a (subaddress)
  1710.     { 'b', "BR" }, // b (bitrate)
  1711.     { 'd', "DF" }, // d (data format)
  1712.     { 'e', "Error" }, // e (error description)
  1713.     { 'f', "Filename" }, // f (filename)
  1714.     { 'h', "Time" }, // h (time spent receiving)
  1715.     { 'i', "CIDName" }, // i (caller id name)
  1716.     { 'j', "CIDNumber" }, // j (caller id number)
  1717.     { 'l', "Length" }, // l (pagelength)
  1718.     { 'm', "Protect" }, // m (fax-style protection mode, no group bits)
  1719.     { 'n', "Size" }, // n (file size)
  1720.     { 'o', "Owner" }, // o (owner)
  1721.     { 'p', "Pages" }, // p (npages)
  1722.     { 'q', "Protect" }, // m (UNIX-style protection mode)
  1723.     { 'r', "Resolution" }, // r (resolution)
  1724.     { 's', "Sender/TSI" }, // s (sender TSI)
  1725.     { 't', "Recvd@" }, // t (time received)
  1726.     { 'w', "Width" }, // w (pagewidth)
  1727.     { 'z', " " }, // z (``*'' if being received)
  1728.     { '' },
  1729. };
  1730. void FaxClient::getRecvStatusHeader(fxStr& header)
  1731.     { makeHeader(getRecvStatusFormat(), recvFormats, header); }
  1733. /*
  1734.  * Table of known format strings for the modem
  1735.  * status listings returned by the server.
  1736.  */
  1737. const FaxClient::FaxFmtHeader FaxClient::modemFormats[] = {
  1738.     { 'h', "Host" }, // h (hostname)
  1739.     { 'l', "LocalID" }, // l (local identifier)
  1740.     { 'm', "Modem" }, // m (canonical modem name)
  1741.     { 'n', "Number" }, // n (fax phone number)
  1742.     { 'r', "MaxRecv" }, // r (max recv pages)
  1743.     { 's', "Status" }, // s (status information)
  1744.     { 't', "Tracing" }, // t (server:session tracing level)
  1745.     { 'v', "Speaker" }, // v (speaker volume as symbol)
  1746.     { 'z', " " }, // z (``*'' if faxgetty is running)
  1747.     { '' },
  1748. };
  1749. void FaxClient::getModemStatusHeader(fxStr& header)
  1750.     { makeHeader(getModemStatusFormat(), modemFormats, header); }
  1752. /*
  1753.  * Table of known format strings for the file
  1754.  * status listings returned by the server.
  1755.  */
  1756. const FaxClient::FaxFmtHeader FaxClient::fileFormats[] = {
  1757.     { 'a', "LastAcc" }, // a (last access time)
  1758.     { 'c', "Created" }, // c (create time)
  1759.     { 'd', "Device" }, // d (device)
  1760.     { 'f', "Filename" }, // f (filename)
  1761.     { 'g', "GID" }, // g (GID of file)
  1762.     { 'l', "Links" }, // l (link count)
  1763.     { 'm', "LastMod" }, // m (last modification time)
  1764.     { 'o', "Owner" }, // o (owner based on file GID)
  1765.     { 'p', "Protect" }, // p (fax-style protection flags, no group bits)
  1766.     { 'q', "Protect" }, // q (UNIX-style protection flags)
  1767.     { 'r', "RootDev" }, // r (root device)
  1768.     { 's', "Size" }, // s (file size in bytes)
  1769.     { 'u', "UID" }, // u (UID of file)
  1770.     { '' },
  1771. };
  1772. void FaxClient::getFileStatusHeader(fxStr& header)
  1773.     { makeHeader(getFileStatusFormat(), fileFormats, header); }