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

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

传真(Fax)编程

开发平台：

C/C++

SNPPClient.c++：源码内容
  1. /* $Id: SNPPClient.c++,v 1.6 2008/03/12 05:43:09 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.  */
  26. #include "config.h"
  27. #include "Sys.h"
  28. #include "SNPPClient.h"
  29. #include <pwd.h>
  30. #include <ctype.h>
  31. #include <sys/types.h>
  32. #include <errno.h>
  34. #define N(a) (sizeof (a) / sizeof (a[0]))
  36. SNPPClient::SNPPClient()
  37. {
  38.     init();
  39. }
  41. SNPPClient::SNPPClient(const fxStr& hostarg)
  42. {
  43.     init();
  44.     setupHostModem(hostarg);
  45. }
  47. SNPPClient::SNPPClient(const char* hostarg)
  48. {
  49.     init();
  50.     setupHostModem(hostarg);
  51. }
  53. void
  54. SNPPClient::init()
  55. {
  56.     jobs = new SNPPJobArray;
  57.     fdIn = NULL;
  58.     fdOut = NULL;
  59.     state = 0;
  60.     msg = NULL;
  61.     pasv = false;
  63.     setupConfig();
  64. }
  66. void
  67. SNPPClient::initServerState(void)
  68. {
  69. }
  71. SNPPClient::~SNPPClient()
  72. {
  73.     (void) hangupServer();
  74.     delete jobs;
  75.     delete msg;
  76. }
  78. void
  79. SNPPClient::printError(const char* fmt ...)
  80. {
  81.     va_list ap;
  82.     va_start(ap, fmt);
  83.     vprintError(fmt, ap);
  84.     va_end(ap);
  85. }
  86. void
  87. SNPPClient::vprintError(const char* fmt, va_list ap)
  88. {
  89.     vfprintf(stderr, fmt, ap);
  90.     fputs("n", stderr);
  91. }
  93. void
  94. SNPPClient::printWarning(const char* fmt ...)
  95. {
  96.     va_list ap;
  97.     va_start(ap, fmt);
  98.     vprintWarning(fmt, ap);
  99.     va_end(ap);
  100. }
  101. void
  102. SNPPClient::vprintWarning(const char* fmt, va_list ap)
  103. {
  104.     fprintf(stderr, "Warning, ");
  105.     vfprintf(stderr, fmt, ap);
  106.     fputs("n", stderr);
  107. }
  109. void
  110. SNPPClient::traceServer(const char* fmt ...)
  111. {
  112.     va_list ap;
  113.     va_start(ap, fmt);
  114.     vtraceServer(fmt, ap);
  115.     va_end(ap);
  116. }
  117. void
  118. SNPPClient::vtraceServer(const char* fmt, va_list ap)
  119. {
  120.     vfprintf(stdout, fmt, ap);
  121.     fputs("n", stdout);
  122. }
  124. /*
  125.  * Host, port, and modem can be specified using
  126.  *
  127.  *     modem@host:port
  128.  *
  129.  * e.g. ttyf2@flake.asd:9999.  Alternate forms
  130.  * are: modem@, modem@host, host, host:port.
  131.  */
  132. void
  133. SNPPClient::setupHostModem(const fxStr& s)
  134. {
  135.     u_int pos = s.next(0, '@');
  136.     if (pos != s.length()) {
  137. modem = s.head(pos);
  138. host = s.tail(s.length() - (pos+1));
  139.     } else
  140. host = s;
  141.     pos = host.next(0, ':');
  142.     if (pos != host.length()) {
  143. port = atoi(host.tail(host.length() - (pos+1)));
  144. host.resize(pos);
  145.     }
  146. }
  147. void SNPPClient::setupHostModem(const char* cp) { setupHostModem(fxStr(cp)); }
  149. void SNPPClient::setHost(const fxStr& hostarg) { setupHostModem(hostarg); }
  150. void SNPPClient::setHost(const char* hostarg) { setupHostModem(hostarg); }
  151. void SNPPClient::setPort(int p) { port = p; }
  152. void SNPPClient::setProtoName(const char* s) { proto = s; }
  154. void SNPPClient::setModem(const fxStr& modemarg){ modem = modemarg; }
  155. void SNPPClient::setModem(const char* modemarg) { modem = modemarg; }
  157. void
  158. SNPPClient::setVerbose(bool v)
  159. {
  160.     if (v)
  161. state |= SS_VERBOSE;
  162.     else
  163. state &= ~SS_VERBOSE;
  164. }
  166. /*
  167.  * Setup the sender's identity.
  168.  */
  169. bool
  170. SNPPClient::setupSenderIdentity(fxStr& emsg)
  171. {
  172.     setupUserIdentity(emsg); // client identity
  174.     if (from != "") {
  175. u_int l = from.next(0, '<');
  176. if (l == from.length()) {
  177.     l = from.next(0, '(');
  178.     if (l != from.length()) { // joe@foobar (Joe Schmo)
  179. setBlankMailboxes(from.head(l));
  180. l++, senderName = from.token(l, ')');
  181.     } else { // joe
  182. setBlankMailboxes(from);
  183. if (from != getUserName())
  184.     senderName = "";
  185.     }
  186. } else { // Joe Schmo <joe@foobar>
  187.     senderName = from.head(l);
  188.     l++, setBlankMailboxes(from.token(l, '>'));
  189. }
  190. if (senderName == "" && getNonBlankMailbox(senderName)) {
  191.     /*
  192.      * Mail address, but no "real name"; construct one from
  193.      * the account name.  Do this by first stripping anything
  194.      * to the right of an '@' and then stripping any leading
  195.      * uucp patch (host!host!...!user).
  196.      */
  197.     senderName.resize(senderName.next(0, '@'));
  198.     senderName.remove(0, senderName.nextR(senderName.length(), '!'));
  199. }
  201. // strip and leading&trailing white space
  202. senderName.remove(0, senderName.skip(0, " t"));
  203. senderName.resize(senderName.skipR(senderName.length(), " t"));
  204.     } else {
  205. setBlankMailboxes(getUserName());
  206.     }
  207.     fxStr mbox;
  208.     if (senderName == "" || !getNonBlankMailbox(mbox)) {
  209. emsg = "Malformed (null) sender name or mail address";
  210. return (false);
  211.     } else
  212. return (true);
  213. }
  214. void SNPPClient::setFromIdentity(const char* s) { from = s; }
  216. /*
  217.  * Assign the specified string to any unspecified email
  218.  * addresses used for notification mail.
  219.  */
  220. void
  221. SNPPClient::setBlankMailboxes(const fxStr& s)
  222. {
  223.     for (u_int i = 0, n = jobs->length(); i < n; i++) {
  224. SNPPJob& job = (*jobs)[i];
  225. if (job.getMailbox() == "")
  226.     job.setMailbox(s);
  227.     }
  228. }
  230. /*
  231.  * Return the first non-null mailbox string
  232.  * in the set of jobs.
  233.  */
  234. bool
  235. SNPPClient::getNonBlankMailbox(fxStr& s)
  236. {
  237.     for (u_int i = 0, n = jobs->length(); i < n; i++) {
  238. SNPPJob& job = (*jobs)[i];
  239. if (job.getMailbox() != "") {
  240.     s = job.getMailbox();
  241.     return (true);
  242. }
  243.     }
  244.     return (false);
  245. }
  247. bool
  248. SNPPClient::setupUserIdentity(fxStr& emsg)
  249. {
  250.     struct passwd* pwd;
  252.     pwd = getpwuid(getuid());
  253.     if (!pwd) {
  254. emsg = fxStr::format(
  255.     "Can not locate your password entry (uid %lu): %s.",
  256. (u_long) getuid(), strerror(errno));
  257. return (false);
  258.     }
  259.     userName = pwd->pw_name;
  260.     if (pwd->pw_gecos && pwd->pw_gecos[0] != '') {
  261. senderName = pwd->pw_gecos;
  262. senderName.resize(senderName.next(0, '(')); // strip SysV junk
  263. u_int l = senderName.next(0, '&');
  264. if (l < senderName.length()) {
  265.     /*
  266.      * Do the '&' substitution and raise the
  267.      * case of the first letter of the inserted
  268.      * string (the usual convention...)
  269.      */
  270.     senderName.remove(l);
  271.     senderName.insert(userName, l);
  272.     if (islower(senderName[l]))
  273. senderName[l] = toupper(senderName[l]);
  274. }
  275. senderName.resize(senderName.next(0,','));
  276.     } else
  277. senderName = userName;
  278.     if (senderName.length() == 0) {
  279. emsg = "Bad (null) user name; your password file entry"
  280.     " probably has bogus GECOS field information.";
  281. return (false);
  282.     } else
  283. return (true);
  284. }
  286. void
  287. SNPPClient::setPagerMsg(const char* v)
  288. {
  289.     delete msg;
  290.     msg = new fxStr(v);
  291.     msgFile ="";
  292. }
  294. void
  295. SNPPClient::setPagerMsgFile(const char* v)
  296. {
  297.     msgFile = v;
  298.     delete msg;
  299. }
  301. /*
  302.  * Configuration file support.
  303.  */
  305. SNPPClient::S_stringtag SNPPClient::strings[] = {
  306. { "protocol", &SNPPClient::proto, SNPP_PROTONAME },
  307. { "host", &SNPPClient::host, NULL },
  308. { "modem", &SNPPClient::modem, NULL },
  309. };
  310. SNPPClient::S_numbertag SNPPClient::numbers[] = {
  311. { "port", &SNPPClient::port, (u_int) -1 },
  312. };
  314. /*
  315.  * Configuration file support.
  316.  */
  317. #define N(a) (sizeof (a) / sizeof (a[0]))
  319. void
  320. SNPPClient::setupConfig()
  321. {
  322.     int i;
  324.     for (i = N(strings)-1; i >= 0; i--)
  325. (*this).*strings[i].p = (strings[i].def ? strings[i].def : "");
  326.     for (i = N(numbers)-1; i >= 0; i--)
  327. (*this).*numbers[i].p = numbers[i].def;
  328.     initServerState();
  330.     jproto.setQueued(SNPP_DEFQUEUE);
  331.     jproto.setNotification(SNPP_DEFNOTIFY);
  332.     jproto.setHoldTime(0); // immediate delivery
  333.     jproto.setRetryTime((u_int) -1);
  334.     jproto.setMaxTries(SNPP_DEFRETRIES);
  335.     jproto.setMaxDials(SNPP_DEFREDIALS);
  336.     jproto.setServiceLevel(SNPP_DEFLEVEL);
  337.     jproto.setMailbox("");
  338. }
  340. void
  341. SNPPClient::resetConfig()
  342. {
  343.     setupConfig();
  344. }
  346. void
  347. SNPPClient::configError(const char* fmt ...)
  348. {
  349.     va_list ap;
  350.     va_start(ap, fmt);
  351.     vprintError(fmt, ap);
  352.     va_end(ap);
  353. }
  355. void
  356. SNPPClient::configTrace(const char* fmt ...)
  357. {
  358.     if (getVerbose()) {
  359. va_list ap;
  360. va_start(ap, fmt);
  361. vprintWarning(fmt, ap);
  362. va_end(ap);
  363.     }
  364. }
  366. bool
  367. SNPPClient::setConfigItem(const char* tag, const char* value)
  368. {
  369.     u_int ix;
  370.     if (findTag(tag, (const tags*) strings, N(strings), ix)) {
  371. (*this).*strings[ix].p = value;
  372.     } else if (findTag(tag, (const tags*) numbers, N(numbers), ix)) {
  373. (*this).*numbers[ix].p = getNumber(value);
  374.     } else if (streq(tag, "verbose")) {
  375. if (getBoolean(value))
  376.     state |= SS_VERBOSE;
  377. else
  378.     state &= ~SS_VERBOSE;
  379.     } else if (streq(tag, "queuesend")) {
  380. jproto.setQueued(getBoolean(value));
  381.     } else if (streq(tag, "notify") || streq(tag, "notification")) {
  382. jproto.setNotification(value);
  383.     } else if (streq(tag, "holdtime")) {
  384. fxStr emsg;
  385. if (!jproto.setHoldTime(tag, emsg))
  386.     configError("Invalid hold time "%s": %s",
  387. value, (const char*) emsg);
  388.     } else if (streq(tag, "retrytime")) {
  389. jproto.setRetryTime(value);
  390.     } else if (streq(tag, "maxtries")) {
  391. jproto.setMaxTries(getNumber(value));
  392.     } else if (streq(tag, "maxdials")) {
  393. jproto.setMaxDials(getNumber(value));
  394.     } else if (streq(tag, "servicelevel")) {
  395. jproto.setServiceLevel(getNumber(value));
  396.     } else if (streq(tag, "mailaddr")) {
  397. jproto.setMailbox(value);
  398.     } else if (streq(tag, "passivemode")) {
  399. pasv = getBoolean(value);
  400.     } else
  401. return (false);
  402.     return (true);
  403. }
  405. bool
  406. SNPPClient::callServer(fxStr& emsg)
  407. {
  408.     if (host.length() == 0) { // if host not specified by -h
  409. const char* cp = getenv("SNPPSERVER");
  410. if (cp && *cp != '') {
  411.     if (modem != "") { // don't clobber specified modem
  412. fxStr m(modem);
  413. setupHostModem(cp);
  414. modem = m;
  415.     } else
  416. setupHostModem(cp);
  417. } else // use default host
  418.     host = SNPP_DEFHOST;
  419.     }
  420.     if (callInetServer(emsg)) {
  421. signal(SIGPIPE, fxSIGHANDLER(SIG_IGN));
  422. /*
  423.  * Transport code is expected to call back through
  424.  * setCtrlFds so fdIn should be properly setup...
  425.  */
  426. return (fdIn != NULL && getReply(false) == COMPLETE);
  427.     } else
  428. return (false);
  429. }
  431. #if CONFIG_INETTRANSPORT
  432. #include "Socket.h"
  434. extern "C" {
  435. #include <arpa/inet.h>
  436. #include <arpa/telnet.h>
  437. #include <netinet/in.h>
  438. #include <netinet/in_systm.h>
  439. #include <netinet/ip.h>
  440. #include <netdb.h>
  441. }
  443. bool
  444. SNPPClient::callInetServer(fxStr& emsg)
  445. {
  446.     fxStr proto(getProtoName());
  447.     char* cp;
  448.     if ((cp = getenv("SNPPSERVICE")) && *cp != '') {
  449. fxStr s(cp);
  450. u_int l = s.next(0,'/');
  451. port = (u_int) (int) s.head(l);
  452. if (l < s.length())
  453.     proto = s.tail(s.length()-(l+1));
  454.     }
  455.     struct hostent* hp = Socket::gethostbyname(getHost());
  456.     if (!hp) {
  457. emsg = getHost() | ": Unknown host";
  458. return (false);
  459.     }
  460.     int protocol;
  461.     const char* cproto = proto; // XXX for busted include files
  462.     struct protoent* pp = getprotobyname(cproto);
  463.     if (!pp) {
  464. printWarning("%s: No protocol definition, using default.", cproto);
  465. protocol = 0;
  466.     } else
  467. protocol = pp->p_proto;
  468.     int fd = socket(hp->h_addrtype, SOCK_STREAM, protocol);
  469.     if (fd < 0) {
  470. emsg = "Can not create socket to connect to server.";
  471. return (false);
  472.     }
  473.     struct sockaddr_in sin;
  474.     memset(&sin, 0, sizeof (sin));
  475.     sin.sin_family = hp->h_addrtype;
  476.     if (port == (u_int) -1) {
  477. struct servent* sp = getservbyname(SNPP_SERVICE, cproto);
  478. if (!sp) {
  479.     if (!isdigit(cproto[0])) {
  480. printWarning(
  481.     "No "%s" service definition, using default %u/%s.",
  482.     SNPP_SERVICE, SNPP_DEFPORT, cproto);
  483. sin.sin_port = htons(SNPP_DEFPORT);
  484.     } else
  485. sin.sin_port = htons(atoi(cproto));
  486. } else
  487.     sin.sin_port = sp->s_port;
  488.     } else
  489. sin.sin_port = htons(port);
  490.     for (char** cpp = hp->h_addr_list; *cpp; cpp++) {
  491. memcpy(&sin.sin_addr, *cpp, hp->h_length);
  492. if (getVerbose())
  493.     traceServer("Trying %s (%s) at port %u...",
  494. (const char*) getHost(),
  495. inet_ntoa(sin.sin_addr),
  496. ntohs(sin.sin_port));
  497. if (Socket::connect(fd, &sin, sizeof (sin)) >= 0) {
  498.     if (getVerbose())
  499. traceServer("Connected to %s.", hp->h_name);
  500. #if defined(IP_TOS) && defined(IPTOS_LOWDELAY)
  501.     int tos = IPTOS_LOWDELAY;
  502.     if (Socket::setsockopt(fd, IPPROTO_IP, IP_TOS, &tos, sizeof (tos)) < 0)
  503. printWarning("setsockopt(TOS): %s (ignored)",
  504.     strerror(errno));
  505. #endif
  506. #ifdef SO_OOBINLINE
  507.     int on = 1;
  508.     if (Socket::setsockopt(fd, SOL_SOCKET, SO_OOBINLINE, &on, sizeof (on)) < 0)
  509. printWarning("setsockopt(OOBLINE): %s (ignored)",
  510.     strerror(errno));
  511. #endif
  512.     setCtrlFds(fd, fd);
  513.     return (true);
  514. }
  515.     }
  516.     emsg = fxStr::format("Can not reach server at host "%s", port %u.",
  517. (const char*) getHost(), ntohs(sin.sin_port));
  518.     close(fd), fd = -1;
  519.     return (false);
  520. }
  521. #else
  522. bool
  523. SNPPServer::callInetServer(fxStr& emsg)
  524. {
  525.     emsg = "Sorry, no TCP/IP communication support was configured.";
  526.     return (false);
  527. }
  528. #endif
  530. bool
  531. SNPPClient::hangupServer(void)
  532. {
  533.     if (fdIn != NULL)
  534. fclose(fdIn), fdIn = NULL;
  535.     if (fdOut != NULL)
  536. fclose(fdOut), fdOut = NULL;
  537.     initServerState();
  538.     return (true);
  539. }
  541. void
  542. SNPPClient::setCtrlFds(int in, int out)
  543. {
  544.     if (fdIn != NULL)
  545. fclose(fdIn);
  546.     fdIn = fdopen(in, "r");
  547.     if (fdOut != NULL)
  548. fclose(fdOut);
  549.     fdOut = fdopen(out, "w");
  550. }
  552. /*
  553.  * Do login procedure.
  554.  */
  555. bool
  556. SNPPClient::login(const char* user, const char* pass, fxStr& emsg)
  557. {
  558.     if (user == NULL) {
  559. setupSenderIdentity(emsg); // invokes setupUserIdentity
  560. user = userName;
  561.     }
  562.     int n = command("LOGI %s", user);
  563.     if (code == 550)
  564. n = command("LOGI %s %s", user, pass ? pass : getPasswd("Password:"));
  565.     if (n == COMPLETE)
  566. state |= SS_LOGGEDIN;
  567.     else
  568. state &= ~SS_LOGGEDIN;
  569.     if (isLoggedIn()) {
  570. if (command("SITE HELP NOTIFY") == COMPLETE)
  571.     state |= SS_HASSITE;
  572. else
  573.     state &= ~SS_HASSITE;
  574. return (true);
  575.     } else {
  576. emsg = "Login failed: " | lastResponse;
  577. return (false);
  578.     }
  579. }
  581. /*
  582.  * Prompt for a password.
  583.  */
  584. const char*
  585. SNPPClient::getPasswd(const char* prompt)
  586. {
  587.     return (getpass(prompt));
  588. }
  590. void
  591. SNPPClient::lostServer(void)
  592. {
  593.     printError("Service not available, remote server closed connection");
  594.     hangupServer();
  595. }
  597. void
  598. SNPPClient::unexpectedResponse(fxStr& emsg)
  599. {
  600.     emsg = "Unexpected server response: " | lastResponse;
  601. }
  603. void
  604. SNPPClient::protocolBotch(fxStr& emsg, const char* fmt ...)
  605. {
  606.     va_list ap;
  607.     va_start(ap, fmt);
  608.     emsg = "Protocol botch" | fxStr::vformat(fmt, ap);
  609.     va_end(ap);
  610. }
  612. /*
  613.  * Send a command and wait for a response.
  614.  * The primary response code is returned.
  615.  */
  616. int
  617. SNPPClient::command(const char* fmt ...)
  618. {
  619.     va_list ap1, ap2;
  620.     va_start(ap1, fmt);
  621.     va_start(ap2, fmt);
  622.     int r = vcommand(fmt, ap1, ap2);
  623.     va_end(ap1);
  624.     va_end(ap2);
  625.     return (r);
  626. }
  628. /*
  629.  * Send a command and wait for a response.
  630.  * The primary response code is returned.
  631.  */
  632. int
  633. SNPPClient::vcommand(const char* fmt, va_list ap1, va_list ap2)
  634. {
  635.     if (getVerbose()) {
  636. if (strncasecmp("LOGI", fmt, 4) == 0)
  637.     traceServer("-> LOGI XXXX");
  638. else {
  639.         fxStr f("-> ");
  640.         f.append(fmt);
  641.     vtraceServer(f, ap1);
  642. }
  643.     }
  644.     if (fdOut == NULL) {
  645. printError("No control connection for command");
  646. code = -1;
  647. return (0);
  648.     }
  649.     vfprintf(fdOut, fmt, ap2);
  650.     fputs("rn", fdOut);
  651.     (void) fflush(fdOut);
  652.     int r = getReply(strncmp(fmt, "QUIT", 4) == 0);
  653.     return (r);
  654. }
  656. /*
  657.  * Extract a valid reply code from a string.
  658.  * The code must be 3 numeric digits followed
  659.  * by a space or ``-'' (the latter indicates
  660.  * the server reponse is to be continued with
  661.  * one or more lines).  If no valid reply code
  662.  * is recognized zero is returned--this is
  663.  * assumed to be an invalid reply code.
  664.  */
  665. static int
  666. getReplyCode(const char* cp)
  667. {
  668.     if (!isdigit(cp[0]))
  669. return (0);
  670.     int c = (cp[0] - '0');
  671.     if (!isdigit(cp[1]))
  672. return (0);
  673.     c = 10*c + (cp[1]-'0');
  674.     if (!isdigit(cp[2]))
  675. return (0);
  676.     c = 10*c + (cp[2]-'0');
  677.     return ((cp[3] == ' ' || cp[3] == '-') ? c : 0);
  678. }
  680. /*
  681.  * Read from the control channel until a valid reply is
  682.  * received or the connection is dropped.  The last line
  683.  * of the received response is left in SNPPClient::lastResponse
  684.  * and the reply code is left in SNPPClient::code.  The
  685.  * primary response (the first digit of the reply code)
  686.  * is returned to the caller.  Continuation lines are
  687.  * handled but not collected.
  688.  */
  689. int
  690. SNPPClient::getReply(bool expecteof)
  691. {
  692.     int firstCode = 0;
  693.     bool continuation = false;
  694.     do {
  695. lastResponse.resize(0);
  696. int c;
  697. while ((c = getc(fdIn)) != 'n') {
  698.     if (c == IAC) {     // handle telnet commands
  699. switch (c = getc(fdIn)) {
  700. case WILL:
  701. case WONT:
  702.     c = getc(fdIn);
  703.     fprintf(fdOut, "%c%c%c", IAC, DONT, c);
  704.     (void) fflush(fdOut);
  705.     break;
  706. case DO:
  707. case DONT:
  708.     c = getc(fdIn);
  709.     fprintf(fdOut, "%c%c%c", IAC, WONT, c);
  710.     (void) fflush(fdOut);
  711.     break;
  712. default:
  713.     break;
  714. }
  715. continue;
  716.     }
  717.     if (c == EOF) {
  718. if (expecteof) {
  719.     code = 221;
  720.     return (0);
  721. } else {
  722.     lostServer();
  723.     code = 421;
  724.     return (4);
  725. }
  726.     }
  727.     if (c != 'r')
  728. lastResponse.append(c);
  729. }
  730. if (getVerbose())
  731.     traceServer("%s", (const char*) lastResponse);
  732. code = getReplyCode(lastResponse);
  733. if (code != 0) { // found valid reply code
  734.     if (lastResponse[3] == '-') { // continuation line
  735. if (firstCode == 0) // first line of reponse
  736.     firstCode = code;
  737. continuation = true;
  738.     } else if (code == firstCode) // end of continued reply
  739. continuation = false;
  740. }
  741.     } while (continuation || code == 0);
  743.     if (code == 421) // server closed connection
  744. lostServer();
  745.     return (code/100);
  746. }
  748. /*
  749.  * Extract a string from a reply message.  The
  750.  * string that is extracted is expected to follow
  751.  * a pattern string.  The pattern is tried both
  752.  * in the initial case and then the inverse case
  753.  * (upper or lower depending on what the original
  754.  * case was).  The resulting string is checked to
  755.  * make sure that it is not null.
  756.  */
  757. bool
  758. SNPPClient::extract(u_int& pos, const char* pattern, fxStr& result)
  759. {
  760.     fxStr pat(pattern);
  761.     u_int l = lastResponse.find(pos, pat);
  762.     if (l == lastResponse.length()) { // try inverse-case version
  763. if (isupper(pattern[0]))
  764.     pat.lowercase();
  765. else
  766.     pat.raisecase();
  767. l = lastResponse.find(pos, pat);
  768.     }
  769.     if (l == lastResponse.length())
  770. return (false);
  771.     l = lastResponse.skip(l+pat.length(), ' ');// skip white space
  772.     result = lastResponse.extract(l, lastResponse.next(l, ' ')-l);
  773.     if (result == "")
  774. return (false);
  775.     pos = l; // update position
  776.     return (true);
  777. }
  779. /*
  780.  * Create a new job and return its job-id if
  781.  * parsed from the reply (this is for HylaFAX,
  782.  * RFC 1861 says nothing about this).
  783.  */
  784. bool
  785. SNPPClient::newPage(const fxStr& pin, const fxStr& passwd, fxStr& jobid, fxStr& emsg)
  786. {
  787.     int result;
  788.     if (passwd != "")
  789. result = command("PAGE %s %s", (const char*) pin, (const char*) passwd);
  790.     else
  791. result = command("PAGE %s", (const char*) pin);
  792.     if (result == COMPLETE) {
  793. if (code == 250) {
  794.     /*
  795.      * If the server is hfaxd, then the response should be
  796.      * of the form:
  797.      *
  798.      * 250 ... jobid: xxxx.
  799.      *
  800.      * where xxxx is the ID for the new job.
  801.      */
  802.     u_int l = 0;
  803.     if (extract(l, "jobid:", jobid)) {
  804. /*
  805.  * Force job IDs to be numeric;
  806.  * this deals with servers that want to append
  807.  * punctuation such as ``,'' or ``.''.
  808.  */
  809. jobid.resize(jobid.skip(0, "0123456789"));
  810.     } else
  811. jobid = "unknown";
  812.     return (true);
  813. } else
  814.     unexpectedResponse(emsg);
  815.     } else
  816. emsg = lastResponse;
  817.     return (false);
  818. }
  820. SNPPJob&
  821. SNPPClient::addJob(void)
  822. {
  823.     u_int ix = jobs->length();
  824.     jobs->resize(ix+1);
  825.     (*jobs)[ix] = jproto;
  826.     return ((*jobs)[ix]);
  827. }
  828. u_int SNPPClient::getNumberOfJobs() const { return jobs->length(); }
  830. SNPPJob*
  831. SNPPClient::findJob(const fxStr& pin)
  832. {
  833.     for (u_int i = 0, n = jobs->length(); i < n; i++) {
  834. SNPPJob& job = (*jobs)[i];
  835. if (job.getPIN() == pin)
  836.     return (&job);
  837.     }
  838.     return (NULL);
  839. }
  841. void
  842. SNPPClient::removeJob(const SNPPJob& job)
  843. {
  844.     u_int ix = jobs->find(job);
  845.     if (ix != fx_invalidArrayIndex)
  846. jobs->remove(ix);
  847. }
  849. bool
  850. SNPPClient::prepareForJobSubmissions(fxStr&)
  851. {
  852.     // XXX nothing to do right now
  853.     return (true);
  854. }
  856. bool
  857. SNPPClient::submitJobs(fxStr& emsg)
  858. {
  859.     if (!isLoggedIn()) {
  860. emsg = "Not logged in to server";
  861. return (false);
  862.     }
  863.     /*
  864.      * Construct jobs and submit them.
  865.      */
  866.     for (u_int i = 0, n = jobs->length(); i < n; i++) {
  867. SNPPJob& job = (*jobs)[i];
  868. if (!job.createJob(*this, emsg))
  869.     return (false);
  870. notifyNewJob(job); // notify client
  871.     }
  872.     if (msgFile != "") {
  873. if (!sendData(msgFile, emsg))
  874.     return (false);
  875.     } else if (msg) {
  876. if (!sendMsg(*msg, emsg))
  877.     return (false);
  878.     }
  879.     if (command("SEND") != COMPLETE) {
  880. emsg = lastResponse;
  881. return (false);
  882.     } else
  883. return (true);
  884. }
  886. /*
  887.  * Default notification handler for when a new job is created.
  888.  */
  889. void
  890. SNPPClient::notifyNewJob(const SNPPJob& job)
  891. {
  892.     printf("destination pin %s: request id is %s for host %sn"
  893. , (const char*) job.getPIN()
  894. , (const char*) job.getJobID()
  895. , (const char*) getHost()
  896.     );
  897. }
  899. /*
  900.  * Send a block of raw data on the data
  901.  * conenction, interpreting write errors.
  902.  */
  903. bool
  904. SNPPClient::sendRawData(void* buf, int cc, fxStr& emsg)
  905. {
  906. #ifdef __linux__
  907.     /*
  908.      * Linux kernel bug: can get short writes on
  909.      * stream sockets when setup for blocking i/o.
  910.      */
  911.     u_char* bp = (u_char*) buf;
  912.     for (int cnt, sent = 0; cc; sent += cnt, cc -= cnt) 
  913. if ((cnt = write(fileno(fdOut), bp + sent, cc)) <= 0) {
  914.     protocolBotch(emsg, errno == EPIPE ?
  915. " (server closed connection)" : " (server write error: %s).",
  916. strerror(errno));
  917.     return (false);
  918. }
  919. #else
  920.     if (write(fileno(fdOut), buf, cc) != cc) {
  921. protocolBotch(emsg, errno == EPIPE ?
  922.     " (server closed connection)" : " (server write error: %s).",
  923.     strerror(errno));
  924. return (false);
  925.     }
  926. #endif
  927.     return (true);
  928. }
  930. bool
  931. SNPPClient::sendData(int fd, fxStr& emsg)
  932. {
  933.     struct stat sb;
  934.     (void) Sys::fstat(fd, sb);
  935.     if (getVerbose())
  936. traceServer("SEND message data, %lu bytes", (u_long) sb.st_size);
  937.     if (command("DATA") == CONTINUE) {
  938. size_t cc = (size_t) sb.st_size;
  939. while (cc > 0) {
  940.     char buf[32*1024];
  941.     size_t n = fxmin(cc, sizeof (buf));
  942.     if (read(fd, buf, n) != (ssize_t) n) {
  943. protocolBotch(emsg, " (data read: %s).", strerror(errno));
  944. return (false);
  945.     }
  946.     if (!sendRawData(buf, n, emsg))
  947. return (false);
  948.     cc -= n;
  949. }
  950. if (command(".") == COMPLETE)
  951.     return (true);
  952.     }
  953.     emsg = getLastResponse();
  954.     return (false);
  955. }
  957. bool
  958. SNPPClient::sendData(const fxStr& filename, fxStr& emsg)
  959. {
  960.     bool ok = false;
  961.     int fd = Sys::open(filename, O_RDONLY);
  962.     if (fd >= 0) {
  963. ok = sendData(fd, emsg);
  964. Sys::close(fd);
  965.     } else
  966. emsg = fxStr::format("Unable to open message file "%s".",
  967.     (const char*) filename);
  968.     return (ok);
  969. }
  971. bool
  972. SNPPClient::sendMsg(const char* msg, fxStr& emsg)
  973. {
  974.     if (command("MESS %s", msg) != COMPLETE) {
  975. emsg = getLastResponse();
  976. return (false);
  977.     } else
  978. return (true);
  979. }
  981. bool
  982. SNPPClient::siteParm(const char* name, const fxStr& value)
  983. {
  984.     if (!hasSiteCmd()) {
  985. printWarning("no SITE %s support; ignoring set request.", name);
  986. return (true);
  987.     } else
  988. return (command("SITE %s %s", name, (const char*) value) == COMPLETE);
  989. }
  991. bool
  992. SNPPClient::siteParm(const char* name, u_int value)
  993. {
  994.     if (!hasSiteCmd()) {
  995. printWarning("no SITE %s support; ignoring set request.", name);
  996. return (true);
  997.     } else
  998. return (command("SITE %s %u", name, value) == COMPLETE);
  999. }
  1001. bool
  1002. SNPPClient::setHoldTime(u_int t)
  1003. {
  1004.     time_t tv = t;
  1005.     struct tm* tm = gmtime(&tv);
  1006.     return (command("HOLD %02d%02d%02d%02d%02d"
  1007. , (tm->tm_year) % 100
  1008. , tm->tm_mon+1
  1009. , tm->tm_mday
  1010. , tm->tm_hour
  1011. , tm->tm_min) == COMPLETE);
  1012. }
  1014. bool
  1015. SNPPClient::setRetryTime(u_int t)
  1016. {
  1017.     return siteParm("RETRYTIME", fxStr::format("%02d%02d", t/60, t%60));
  1018. }