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

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

传真(Fax)编程

开发平台：

C/C++

SNPPServer.c++：源码内容
  1. /* $Id: SNPPServer.c++,v 1.8 2008/04/26 22:34:29 faxguy Exp $ */
  2. /*
  3.  * Copyright (c) 1995-1996 Sam Leffler
  4.  * Copyright (c) 1995-1996 Silicon Graphics, Inc.
  5.  * HylaFAX is a trademark of Silicon Graphics
  6.  *
  7.  * Permission to use, copy, modify, distribute, and sell this software and 
  8.  * its documentation for any purpose is hereby granted without fee, provided
  9.  * that (i) the above copyright notices and this permission notice appear in
  10.  * all copies of the software and related documentation, and (ii) the names of
  11.  * Sam Leffler and Silicon Graphics may not be used in any advertising or
  12.  * publicity relating to the software without the specific, prior written
  13.  * permission of Sam Leffler and Silicon Graphics.
  14.  * 
  15.  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
  16.  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
  17.  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
  18.  * 
  19.  * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
  20.  * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
  21.  * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  22.  * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
  23.  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
  24.  * OF THIS SOFTWARE.
  25.  */
  27. #ifdef SNPP_SUPPORT
  28. /*
  29.  * Simple Network Paging Protocol (SNPP) Support.
  30.  */
  31. #include "config.h"
  32. #include "Sys.h"
  33. #include "Socket.h"
  34. #include "SNPPServer.h"
  35. #include "Dispatcher.h"
  36. #include "RE.h"
  38. #include <ctype.h>
  39. #if HAS_CRYPT_H
  40. #include <crypt.h>
  41. #endif
  43. extern "C" {
  44. #include <netdb.h>
  45. #include <arpa/inet.h>
  47. #include <netinet/in_systm.h>
  48. #include <netinet/ip.h>
  49. }
  51. SNPPSuperServer::SNPPSuperServer(const char* p, int bl)
  52.     : SuperServer("SNPP", bl)
  53.     , port(p)
  54. {}
  55. SNPPSuperServer::~SNPPSuperServer() {}
  57. bool
  58. SNPPSuperServer::startServer(void)
  59. {
  60.     /*
  61.      * Switch to super-user to do the bind in case
  62.      * we are to use a port in the privileged region
  63.      * on a BSD system (ports <=1024 are reserved
  64.      * and the default SNPP port is 444).
  65.      *
  66.      * NB: We do it for both the socket+bind calls
  67.      *     to workaround a bug in Solaris 2.5.
  68.      */
  69.     uid_t ouid = geteuid();
  70.     (void) seteuid(0);
  71.     int s = socket(AF_INET, SOCK_STREAM, 0);
  72.     if (s >= 0) {
  73. struct sockaddr_in sin;
  74. memset(&sin, 0, sizeof (sin));
  75. sin.sin_family = AF_INET;
  76. const char* cp = port;
  77. struct servent* sp = getservbyname(cp, SNPP_PROTONAME);
  78. if (!sp) {
  79.     if (isdigit(cp[0]))
  80. sin.sin_port = htons(atoi(cp));
  81.     else
  82. sin.sin_port = htons(SNPP_DEFPORT);
  83. } else
  84.     sin.sin_port = sp->s_port;
  85. if (Socket::bind(s, &sin, sizeof (sin)) >= 0) {
  86.     (void) listen(s, getBacklog());
  87.     (void) seteuid(ouid);
  88.     Dispatcher::instance().link(s, Dispatcher::ReadMask, this);
  89.     return (true); // success
  90. }
  91. Sys::close(s);
  92. logError("HylaFAX %s: bind (port %u): %m",
  93.     getKind(), ntohs(sin.sin_port));
  94.     } else
  95. logError("HylaFAX %s: socket: %m", getKind());
  96.     (void) seteuid(ouid);
  97.     return (false);
  98. }
  99. HylaFAXServer* SNPPSuperServer::newChild(void) { return new SNPPServer; }
  101. SNPPServer::SNPPServer() {}
  102. SNPPServer::~SNPPServer() {}
  104. void
  105. SNPPServer::open(void)
  106. {
  107.     setupNetwork(STDIN_FILENO);
  108.     initServer(); // complete state initialization
  109.     fxStr emsg;
  110.     if (!initClientFIFO(emsg)) {
  111.         logInfo("connection refused (%s) from %s [%s]",
  112.     (const char*) emsg,
  113.     (const char*) remotehost, (const char*) remoteaddr);
  114. reply(420, "%s server cannot initialize: %s",
  115.     (const char*) hostname, (const char*) emsg);
  116. dologout(-1);
  117.     }
  118.     ctrlFlags = fcntl(STDIN_FILENO, F_GETFL); // for parser
  119.     if (isShutdown(true)) {
  120. reply(421, "%s SNPP server unavailable; try again later.",
  121.     (const char*) hostname);
  122. dologout(-1);
  123.     }
  124.     reply(220, "%s SNPP server (%s) ready.", (const char*) hostname, version);
  125.     if (TRACE(CONNECT))
  126.         logInfo("SNPP connection from %s [%s]",
  127.     (const char*) remotehost, (const char*) remoteaddr);
  128. }
  130. void
  131. SNPPServer::initServer(void)
  132. {
  133.     InetFaxServer::initServer();
  134.     state &= ~S_USEGMT; // SNPP uses local times
  135.     resetState();
  136. }
  138. void
  139. SNPPServer::initDefaultJob(void)
  140. {
  141.     InetFaxServer::initDefaultJob();
  143.     defJob.jobtype = "pager";
  144.     initSNPPJob();
  145. }
  147. void
  148. SNPPServer::initSNPPJob(void)
  149. {
  150.     defJob.queued = false; // jobs not queued--per protocol
  151.     defJob.maxdials = SNPP_DEFREDIALS; // configuration defaults...
  152.     defJob.maxtries = SNPP_DEFRETRIES;
  153.     defJob.killtime = 60*killMap[SNPP_DEFLEVEL];
  154.     defJob.retrytime = retryMap[SNPP_DEFLEVEL];
  155.     defJob.usrpri = priMap[SNPP_DEFLEVEL];
  156.     // XXX default notification
  157. }
  159. void
  160. SNPPServer::resetState(void)
  161. {
  162.     initDefaultJob(); // default job state
  163.     msgFile = "";
  164.     haveText = false; // no message text yet
  165.     msgs.resize(0); // purge any message refs
  166. }
  168. void
  169. SNPPServer::dologout(int status)
  170. {
  171.     /*
  172.      * Purge any partially constructed jobs.  If we were
  173.      * doing a SEND when the connection was dropped then
  174.      * we do not purge jobs but instead just let them run
  175.      * detached.  This may not be the best thing; we might
  176.      * instead want to kill the jobs--we'll need to think
  177.      * about this some more before changing this behaviour.
  178.      */
  179.     if (msgs.length() > 0 && !IS(SENDWAIT)) {
  180. fxStr emsg;
  181. for (u_int i = 0, n = msgs.length(); i < n; i++) {
  182.     Job* job = findJob(msgs[i], emsg);
  183.     if (job) {
  184. for (u_int j = 0, m = job->items.length(); j < m; j++)
  185.     if (job->items[j].op == FaxRequest::send_data)
  186. (void) Sys::unlink(job->items[j].item);
  187. (void) Sys::unlink(job->qfile);
  188. delete job;
  189.     }
  190. }
  191.     }
  192.     InetFaxServer::dologout(status);
  193. }
  195. static inline bool
  196. isMagic(char c)
  197. {
  198.     return (c == '[' || c == ']' || c == '*' || c == '.' || c == '^' ||
  199. c == '$' || c == '-' || c == '+' || c == '{' || c == '}' ||
  200. c == '(' || c == ')');
  201. }
  203. /*
  204.  * Handle escapes for a pager ID replacement string.
  205.  */
  206. static void
  207. subRHS(fxStr& result, const RE& re, const fxStr& match)
  208. {
  209.     /*
  210.      * Do ``&'' and ``n'' interpolations in the replacement.
  211.      */
  212.     for (u_int i = 0, n = result.length(); i < n; i++) {
  213. if (result[i] == '\') { // process <char> escapes
  214.     result.remove(i), n--;
  215.     if (isdigit(result[i])) {
  216. int mn = result[i] - '0';
  217. int ms = re.StartOfMatch(mn);
  218. int mlen = re.EndOfMatch(mn) - ms;
  219. result.remove(i); // delete n
  220. if (ms >= 0)
  221.     result.insert(match.extract(ms, mlen), i);
  222. else
  223.     logError("Invalid backreference in pagermap: \%d", mn);
  224. n = result.length(); // adjust string length ...
  225. i += mlen - 1; // ... and scan index
  226.     }
  227. } else if (result[i] == '&') { // process & replacement
  228.     int ms = re.StartOfMatch(0);
  229.     int mlen = re.EndOfMatch(0) - ms;
  230.     result.remove(i); // delete &
  231.     result.insert(match.extract(ms, mlen), i);
  232.     n = result.length(); // adjust string length ...
  233.     i += mlen - 1; // ... and scan index
  234. }
  235.     }
  236. }
  238. /*
  239.  * Given a client-supplied pager ID return the phone number
  240.  * to dial of the service provider and the PIN to supply
  241.  * to the provider when talking IXO/TAP (for aliases).
  242.  */
  243. bool
  244. SNPPServer::mapPagerID(const char* pagerID, fxStr& number, fxStr& pin, fxStr& emsg)
  245. {
  246.     if (pagerIDMapFile != "") {
  247. FILE* fd = fopen(fixPathname(pagerIDMapFile), "r");
  248. if (fd != NULL) {
  249.     char buf[1024];
  250.     while (fgets(buf, sizeof (buf), fd)) {
  251. char* cp;
  252. for (cp = buf; isspace(*cp); cp++) // leading whitespace
  253.     ;
  254. if (*cp == '#' || *cp == '')
  255.     continue;
  256. /*
  257.  * Syntax is:
  258.  *
  259.  * <pattern> <dialstring>[/<PIN>]
  260.  *
  261.  * where <pattern> can be a simple string of alpha
  262.  * numerics or a regular expression.  The first line
  263.  * that matches the client-specified pager ID is used.
  264.  * If no <PIN> is specified then the client-specified
  265.  * string is sent to the provider.  If <dialstring>
  266.  * is "reject" (verbatim) then matches are rejected.
  267.  * <PIN> is treated as the RHS of an RE-style substitution:
  268.  * n and & escapes are replaced according to the RE
  269.  * matching work.
  270.  *
  271.  * Leading white space on a line is ignored.  Lines
  272.  * that begin with '#' are ignored (i.e. comments).
  273.  */
  274. const char* pattern = cp;
  275. bool isRE = false;
  276. for (; *cp != '' && !isspace(*cp); cp++)
  277.     if (isMagic(*cp))
  278. isRE = true;
  279. if (*cp != '') // -term. <pattern>
  280.     *cp++ = '';
  281. bool match;
  282. RE* re;
  283. if (isRE) {
  284.     re = new RE(pattern);
  285.     match = re->Find(pagerID, strlen(pagerID));
  286. } else {
  287.     match = streq(pattern, pagerID);
  288.     re = NULL;
  289. }
  290. if (match) {
  291.     while (isspace(*cp)) // leading whitespace
  292. cp++;
  293.     if (*cp != 'n' && *cp != '') { // got <dialstring>
  294. char* np = strchr(cp, 'n'); // remove trailing n
  295. if (np)
  296.     *np = '';
  297. np = cp;
  298. for (; *cp && *cp != '/'; cp++)
  299.     ;
  300. if (*cp == '/') { // <dialstring>/<PIN>
  301.     *cp++ = '';
  302.     number = np;
  303.     pin = cp;
  304.     if (re) { // do substitutions
  305.     subRHS(pin, *re, pagerID);
  306.                     subRHS(number, *re, pagerID);
  307.                 }
  308. } else { // <dialstring>
  309.     number = np;
  310.     pin = pagerID;
  311. }
  312. delete re;
  313. (void) fclose(fd);
  314. fxStr s(number);
  315. s.raisecase();
  316. if (s == "REJECT") {
  317.     emsg = fxStr::format("Invalid pager ID %s",pagerID);
  318.     return (false);
  319. } else
  320.     return (true);
  321.     }
  322. }
  323. delete re;
  324.     }
  325.     (void) fclose(fd);
  326.     emsg = fxStr::format("Unknown or illegal pager ID %s", pagerID);
  327. } else {
  328.     emsg = fxStr::format("Cannot open pager ID mapping file %s (%s)", 
  329. (const char*) pagerIDMapFile, strerror(errno));
  330.     logError("%s", (const char*) emsg);
  331. }
  332.     } else {
  333. emsg = "No pager ID mapping file found";
  334. logError("%s", (const char*) emsg);
  335.     }
  336.     return (false);
  337. }
  339. /*
  340.  * SNPP Parser.
  341.  */
  343. #define N(a) (sizeof (a) / sizeof (a[0]))
  345. /*
  346.  * Standard protocol commands.
  347.  */
  348. static const tab cmdtab[] = {
  349. { "2WAY", T_2WAY,  true,false, "(preface 2-way transaction)" },
  350. { "ABOR", T_ABOR, false, true, "(abort operation)" },
  351. { "ACKR", T_ACKREAD,  true,false, "0|1" },
  352. { "ALER", T_ALERT,  true,false, "alert-level" },
  353. { "CALL", T_CALLERID,    true,false, "caller-ID" },
  354. { "COVE", T_COVERAGE,    true,false, "alternate-area" },
  355. { "DATA", T_DATA,  true, true, "(specify multi-line message)" },
  356. { "EXPT", T_EXPTAG,  true,false, "hours" },
  357. { "HELP", T_HELP, false, true, "[<string>]" },
  358. { "HOLD", T_HOLDUNTIL,   true, true, "YYYYMMDDHHMMSS [+/-GMT-diff]" },
  359. { "KTAG", T_KTAG,  true,false, "message-tag pass-code" },
  360. { "LEVE", T_LEVEL,  true, true, "service-level" },
  361. { "LOGI", T_LOGIN, false, true, "username [password]" },
  362. { "MCRE", T_MCRESPONSE,  true,false, "2-byte-code response-text" },
  363. { "MESS", T_MESSAGE,  true, true, "message" },
  364. { "MSTA", T_MSTATUS,  true,false, "message-tag pass-code" },
  365. { "NOQU", T_NOQUEUEING,  true,false, "(disable message queueing)" },
  366. { "PAGE", T_PAGER,  true, true, "pager-ID|alias [PIN]" },
  367. { "PING", T_PING,  true, true, "pager-ID|alias" },
  368. { "QUIT", T_QUIT, false, true, "(terminate service)" },
  369. { "RESE", T_REST,  true, true, "(reset state)" },
  370. { "RTYP", T_RTYPE,  true,false, "reply-type-code" },
  371. { "SEND", T_SEND,  true, true, "(send message)" },
  372. { "SITE", T_SITE,  true, true, "site-cmd [arguments]" },
  373. { "STAT", T_STAT, false, true, "(return server status)" },
  374. { "SUBJ", T_SUBJECT,  true, true, "message-subject" },
  375. };
  377. /*
  378.  * Site-specific commands.
  379.  */
  380. static const tab sitetab[] = {
  381. { "FROMUSER",   T_FROM_USER,  true, true, "[<string>]" },
  382. { "HELP",       T_HELP,      false, true, "[<string>]" },
  383. { "IDLE",       T_IDLE,       true, true, "[max-idle-timeout]" },
  384. { "JPARM",      T_JPARM,      true, true, "(print job parameter status)" },
  385. { "JQUEUE", T_JQUEUE,     true, true, "[on|off]" },
  386. { "LASTTIME",   T_LASTTIME,  false, true, "[DDHHSS]" },
  387. { "MAXDIALS",   T_MAXDIALS,   true, true, "[<number>]" },
  388. { "MAXTRIES",   T_MAXTRIES,   true, true, "[<number>]" },
  389. { "MODEM",      T_MODEM,      true, true, "[device|class]" },
  390. { "NOTIFY",     T_NOTIFY,     true, true, "[NONE|DONE|REQUEUE|DONE+REQUEUE]"},
  391. { "MAILADDR",   T_NOTIFYADDR, true, true, "[email-address]" },
  392. { "RETRYTIME",  T_RETRYTIME,  true, true, "[HHSS]" },
  393. { "SCHEDPRI",   T_SCHEDPRI,   true, true, "[<number>]" },
  394. };
  396. static const tab*
  397. lookup(const tab* p, u_int n, const char* cmd)
  398. {
  399.     while (n != 0) {
  400.         if (strneq(cmd, p->name, 4)) // NB: match on first 4 chars
  401.     return (p);
  402. p++, n--;
  403.     }
  404.     return (NULL);
  405. }
  406. static const char*
  407. tokenName(const tab* p, u_int n, Token t)
  408. {
  409.     while (n != 0) {
  410. if (p->token == t)
  411.     return (p->name);
  412. p++, n--;
  413.     }
  414.     return ("???");
  415. }
  416. const char*
  417. SNPPServer::cmdToken(Token t)
  418. {
  419.     return tokenName(cmdtab, N(cmdtab), t);
  420. }
  421. const char*
  422. SNPPServer::siteToken(Token t)
  423. {
  424.     return tokenName(sitetab, N(sitetab), t);
  425. }
  427. bool
  428. SNPPServer::checklogin(Token t)
  429. {
  430.     if (!IS(LOGGEDIN)) {
  431. cmdFailure(t, "not logged in");
  432. reply(530, "Please login with LOGIN.");
  433. return (false);
  434.     } else
  435. return (true);
  436. }
  438. /*
  439.  * Parse and process command input received on the
  440.  * control channel.  This method is invoked whenever
  441.  * data is present on the control channel.  We read
  442.  * everything and parse (and execute) as much as possible
  443.  * but do not block waiting for more data except when
  444.  * a partial line of input is received.  This is done
  445.  * to ensure other processing will be handled in a
  446.  * timely fashion (e.g. processing of messages from
  447.  * the scheduler received via the FIFO).
  448.  */
  449. int
  450. SNPPServer::parse()
  451. {
  452.     if (IS(WAITDATA)) { // recursive invocation
  453. state &= ~S_WAITDATA;
  454. return (0);
  455.     }
  456.     if (IS(SENDWAIT)) { // waiting in SEND, discard data
  457. while (getCmdLine(cbuf, sizeof (cbuf)))
  458.     ;
  459. return (0);
  460.     }
  461. // stop control channel idle timeout
  462.     Dispatcher::instance().stopTimer(this);
  463.     pushToken(T_NIL); // reset state
  464.     for (;;) {
  465. /*
  466.  * Fetch the next complete line of input received on the
  467.  * control channel.  This call will fail when no more data
  468.  * is *currently* waiting on the control channel.  Note
  469.  * that this does not mean the connection has dropped; just
  470.  * that data is not available at this instant.  Note also
  471.  * that if a partial line of input is received a complete
  472.  * line will be waited for (see below).
  473.  */
  474. if (!getCmdLine(cbuf, sizeof (cbuf)))
  475.     break;
  476. /*
  477.  * Parse the line of input read above.
  478.  */
  479. if (getToken(T_STRING, "command token")) {
  480.     tokenBody.raisecase();
  481.     const tab* p = lookup(cmdtab, N(cmdtab), tokenBody);
  482.     if (p == NULL)
  483. reply(500, "%s: Command not recognized.",
  484.     (const char*) tokenBody);
  485.     else if (!p->implemented)
  486. reply(500, "%s: Command not implemented.", p->name);
  487.     else if (isShutdown(!IS(LOGGEDIN))) {
  488. reply(421, "Server shutting down.  Goodbye.");
  489. dologout(0); // XXX
  490.     /*
  491.      * If command requires client to be logged in check
  492.      * for this.  Note that some commands have variants
  493.      * that do not require the client be logged in--these
  494.      * cannot check here and must do it specially below.
  495.      */
  496.     } else if (p->checklogin && !checklogin(p->token))
  497. ;
  498.     /*
  499.      * Command is valid, implemented, and the server
  500.      * is available to service it.  If the syntax is
  501.      * correct then reset the number of consecutive
  502.      * bad commands.  Note that since part of the syntax
  503.      * checking is login validation this logic will also
  504.      * catch people typing syntacitcally valid but
  505.      * unacceptable commands just to remain connected.
  506.      */
  507.     else if (cmd(p->token)) {
  508. consecutiveBadCmds = 0;
  509. continue;
  510.     }
  511. }
  512. /*
  513.  * If too many consecutive bad commands have been
  514.  * received disconnect.  This is to safeguard against
  515.  * a client that spews trash down the control connection.
  516.  */
  517. if (++consecutiveBadCmds >= maxConsecutiveBadCmds) {
  518.     /*
  519.      * Check for shutdown so that any shutdown message
  520.      * will get prepended to client reply.
  521.      */
  522.     (void) isShutdown(!IS(LOGGEDIN));
  523.     reply(421, "Too many errors, server shutting down.  Goodbye.");
  524.     dologout(0);
  525. }
  526.     }
  527.     Dispatcher::instance().startTimer(idleTimeout, 0, this);
  528.     return (0);
  529. }
  531. /*
  532.  * Protocol command (one line).
  533.  */
  534. bool
  535. SNPPServer::cmd(Token t)
  536. {
  537.     fxStr s;
  538.     long n;
  539.     time_t tv;
  541.     switch (t) {
  542.     case T_ABOR: // abort active command (e.g. SEND)
  543. if (CRLF()) {
  544.     logcmd(t);
  545.     ack(250, cmdToken(t));
  546.     return (true);
  547. }
  548. break;
  549.     case T_DATA: // submit multi-line message data
  550. if (CRLF()) {
  551.     logcmd(t);
  552.     dataCmd();
  553.     return (true);
  554. }
  555. break;
  556.     case T_HELP: // return help
  557. if (opt_CRLF()) {
  558.     logcmd(t);
  559.     helpCmd(cmdtab, (char*) NULL);
  560.     return (true);
  561. } else if (string_param(s, "command name")) {
  562.     logcmd(t, "%s", (const char*) s);
  563.     s.raisecase();
  564.     if (s == "SITE")
  565. helpCmd(sitetab, NULL);
  566.     else
  567. helpCmd(cmdtab, s);
  568.     return (true);
  569. }
  570. break;
  571.     case T_HOLDUNTIL: // set time to send
  572. if (SPACE() && SNPPTime(tv)) {
  573.     if (opt_CRLF()) {
  574. holdCmd(tv);
  575. return (true);
  576.     } else if (string_param(s, "GMT-difference")) {
  577. // conver GMT offset to numeric value
  578. int sign = 1;
  579. const char* cp = s;
  580. if (*cp == '-')
  581.     cp++, sign = -1;
  582. else if (*cp == '+')
  583.     cp++;
  584. time_t off = (time_t) (strtoul(cp, 0, 10)*60 / 100);
  585. holdCmd(tv + sign*off);
  586. return (true);
  587.     }
  588. }
  589. break;
  590.     case T_LEVEL: // set level of operation
  591. if (number_param(n)) {
  592.     logcmd(t, "%lu", n);
  593.     serviceLevel((u_int) n);
  594.     return (true);
  595. }
  596. break;
  597.     case T_LOGIN: // login as user
  598. if (SPACE() && STRING(s, "login-ID")) {
  599.     fxStr pwd;
  600.     if (opt_CRLF()) {
  601. logcmd(t, (const char*) s);
  602. loginCmd(s);
  603. return (true);
  604.     } else if (string_param(pwd, "password")) {
  605. logcmd(t, "%s <passwd>", (const char*) s);
  606. loginCmd(s, pwd);
  607. return (true);
  608.     }
  609. }
  610. break;
  611.     case T_MESSAGE: // specify 1-line message data
  612. if (SPACE() && multi_STRING(s) && CRLF()) {
  613.     logcmd(t, "%s", (const char*) s);
  614.     messageCmd(s);
  615.     return (true);
  616. }
  617. break;
  618.     case T_PAGER: // specify destination pager ID
  619. if (SPACE() && STRING(s, "pager-ID")) {
  620.     fxStr pwd;
  621.     if (opt_CRLF()) {
  622. logcmd(t, "%s", (const char*) s);
  623. pagerCmd(s);
  624. return (true);
  625.     } else if (string_param(pwd, "password/PIN")) {
  626. logcmd(t, "%s <passwd/PIN>", (const char*) s);
  627. pagerCmd(s, pwd);
  628. return (true);
  629.     }
  630. }
  631. break;
  632.     case T_PING: // localize/verify pager ID
  633. if (string_param(s, "pager-ID")) {
  634.     logcmd(t, "%s", (const char*) s);
  635.     pingCmd(s);
  636.     return (true);
  637. }
  638. break;
  639.     case T_QUIT: // terminate session
  640. if (CRLF()) {
  641.     logcmd(t);
  642.     reply(221, "Goodbye.");
  643.     dologout(0);
  644.     return (true);
  645. }
  646. break;
  647.     case T_REST: // reset server state
  648. logcmd(t);
  649. initServer();
  650. reply(220, "%s server (%s) ready.", (const char*) hostname, version);
  651. break;
  652.     case T_SEND: // initiate send operation
  653. if (CRLF()) {
  654.     logcmd(t);
  655.     sendCmd();
  656.     return (true);
  657. }
  658. break;
  659.     case T_SITE: // site-specific command
  660. if (SPACE() && getToken(T_STRING, "site command")) {
  661.     tokenBody.raisecase();
  662.     const tab* p = lookup(sitetab, N(sitetab), tokenBody);
  663.     if (p == NULL) {
  664. reply(500, "SITE %s: Command not recognized.",
  665.     (const char*) tokenBody);
  666.     } else if (!p->implemented)
  667. reply(500, "SITE %s: Command not implemented.", p->name);
  668.     else
  669. return (site_cmd(p->token));
  670. }
  671. break;
  672.     case T_STAT: // server status
  673. if (CRLF()) {
  674.     logcmd(t);
  675.     statusCmd();
  676.     return (true);
  677. }
  678. break;
  679.     case T_SUBJECT: // message subject
  680. if (SPACE() && multi_STRING(s) && CRLF()) {
  681.     logcmd(t, "%s", (const char*) s);
  682.     subjectCmd(s);
  683.     return (true);
  684. }
  685. break;
  686.     default:
  687. break;
  688.     }
  689.     return (false);
  690. }
  692. /*
  693.  * Site-specific protocol commands (one line).
  694.  */
  695. bool
  696. SNPPServer::site_cmd(Token t)
  697. {
  698.     fxStr s;
  699.     long n;
  700.     time_t tv;
  701.     bool b;
  703.     switch (t) {
  704.     case T_IDLE: // set/query idle timeout
  705. if (opt_CRLF()) {
  706.     logcmd(t);
  707.     reply(250, "%u seconds.", idleTimeout);
  708.     return (true);
  709. } else if (number_param(n)) {
  710.     logcmd(t, "%lu", n);
  711.     if ((unsigned)n > maxIdleTimeout && !IS(PRIVILEGED)) {
  712. idleTimeout = maxIdleTimeout;
  713. reply(250, "%lu: Idle timeout too large, set to %u.",
  714.     n, maxIdleTimeout);
  715.     } else {
  716. idleTimeout = (int) n;
  717. reply(250, "Idle timeout set to %u.", idleTimeout);
  718.     }
  719.     return (true);
  720. }
  721. break;
  722.     case T_HELP: // return help
  723. if (opt_CRLF()) {
  724.     helpCmd(sitetab, (char*) NULL);
  725.     return (true);
  726. } else if (string_param(s, "command name")) {
  727.     logcmd(T_SITE, "HELP %s", (const char*) s);
  728.     s.raisecase();
  729.     helpCmd(sitetab, s);
  730.     return (true);
  731. }
  732. break;
  733.     case T_JQUEUE:
  734. if (boolean_param(b)) {
  735.     logcmd(t, "%s", b ? "YES" : "NO");
  736.     defJob.queued = b;
  737.     reply(250, "Job will%s be queued.", b ? "" : " not");
  738.     return (true);
  739. }
  740. break;
  741.     case T_FROM_USER:
  742.     case T_MODEM:
  743.     case T_NOTIFY:
  744.     case T_NOTIFYADDR:
  745. if (SPACE() && multi_STRING(s) && CRLF() && setJobParameter(defJob, t, s)) {
  746.     logcmd(t, "%s", (const char*) s);
  747.     reply(250, "%s set to "%s".", parmToken(t), (const char*) s);
  748.     return (true);
  749. }
  750. break;
  751.     case T_MAXDIALS:
  752.     case T_MAXTRIES:
  753.     case T_SCHEDPRI:
  754. if (number_param(n) && setJobParameter(defJob, t, (u_short) n)) {
  755.     logcmd(t, "%lu", n);
  756.     reply(250, "%s set to %u.", parmToken(t), n);
  757.     return (true);
  758. }
  759. break;
  760.     case T_LASTTIME: // time to kill job
  761. if (timespec_param(6, tv) && setJobParameter(defJob, t, tv)) {
  762.     logcmd(t, "%02d%02d%02d"
  763. , tv/(24*60*60) , (tv/(60*60))%24 , (tv/60)%60);
  764.     reply(250, "%s set to %02d%02d%02d."
  765. , parmToken(t)
  766. , tv/(24*60*60) , (tv/(60*60))%24 , (tv/60)%60);
  767.     return (true);
  768. }
  769. break;
  770.     case T_RETRYTIME: // retry interval for job
  771. if (timespec_param(4, tv) && setJobParameter(defJob, t, tv)) {
  772.     logcmd(t, "%02d%02d" , tv/60, tv%60);
  773.     reply(250, "%s set to %02d%02d.", parmToken(t), tv/60, tv%60);
  774.     return (true);
  775. }
  776. break;
  777.     case T_JPARM: // query job parameters
  778. if (CRLF()) {
  779.     logcmd(t);
  780.     jstatCmd(defJob);
  781.     return (true);
  782. }
  783. break;
  784.     default:
  785. break;
  786.     }
  787.     return (false);
  788. }
  790. /*
  791.  * Parse an SNPP time specification.
  792.  */
  793. bool
  794. SNPPServer::SNPPTime(time_t& result)
  795. {
  796.     if (getToken(T_STRING, "time specification") && checkNUMBER(tokenBody)) {
  797. u_int tlen = tokenBody.length();
  798. const char* cp = tokenBody;
  799. // YYMMDDHHMM[SS]
  800. if (tlen == 12 || tlen == 10) {
  801.     struct tm tm;
  802.     tm.tm_sec  = (tlen == 12 ? twodigits(cp+10, 60) : 0);
  803.     tm.tm_min  = twodigits(cp+8, 60);
  804.     tm.tm_hour = twodigits(cp+6, 24);
  805.     tm.tm_mday = twodigits(cp+4, 32);
  806.     tm.tm_mon  = twodigits(cp+2, 13) - 1;
  807.     tm.tm_year = twodigits(cp+0, 100);
  808.     /*
  809.      * SNPP botched time specifications by not using 4 digits
  810.      * to specify a year.  This means that we have to guess at
  811.      * the intended year when the value is far in the future
  812.      * (as opposed to a year in the past that was given by
  813.      * mistake).  We arbitrarily assume years prior to 1990
  814.      * are in the next century and adjust them accordingly.
  815.      */
  816.     if (tm.tm_year < 90)
  817. tm.tm_year += 100;
  818.     tm.tm_isdst= 0; // GMT/UTC never has DST
  819.     /*
  820.      * The above time is assumed to be relative to
  821.      * GMT and mktime returns locally adjusted time
  822.      * so we need to adjust the result to get things
  823.      * in the right timezone.  Note that any additional
  824.      * timezone correction factor specified by the
  825.      * client will then be applied to this result.
  826.      */
  827.     result = mktime(&tm) - gmtoff;
  828.     return (true);
  829. }
  830. syntaxError(fxStr::format(
  831.     "bad time specification (expecting 10/12 digits, got %u)", tlen));
  832.     }
  833.     return (false);
  834. }
  836. void
  837. SNPPServer::syntaxError(const char* msg)
  838. {
  839.     const char* cp = strchr(cbuf, '');
  840.     if (cp[-1] == 'n')
  841. cp--;
  842.     reply(500, "'%.*s': Syntax error, %s.", cp-cbuf, cbuf, msg);
  843. }
  845. /*
  846.  * Command support methods.
  847.  */
  849. /*
  850.  * Process a multi-line text message.
  851.  */
  852. void
  853. SNPPServer::dataCmd(void)
  854. {
  855.     if (!haveText) {
  856. fxStr emsg;
  857. u_int seqnum = getDocumentNumber(emsg);
  858. if (seqnum == (u_int) -1) {
  859.     reply(554, "%s", (const char*)emsg);
  860.     return;
  861. }
  862. msgFile = fxStr::format("/%s/doc%u.page", FAX_TMPDIR, seqnum);
  863. FILE* fout = Sys::fopen(msgFile, "w");
  864. if (fout != NULL) {
  865.     setFileOwner(msgFile);
  866.     FileCache::chmod(msgFile, 0660); // sync cache
  867.     tempFiles.append(msgFile);
  868.     reply(354, "Begin message input; end with <CRLF>'.'<CRLF>.");
  869.     char buf[1024];
  870.     u_int len = 0;
  871.     int ignore;
  872.     for (;;) {
  873. if (getCmdLine(buf, sizeof (buf), true)) {
  874.     const char* bp = buf;
  875.     if (bp[0] == '.') {
  876. if ((bp[1] == 'n' && bp[2] == '') || bp[1] == '')
  877.     break;
  878. if (bp[1] == '.' && bp[2] == '') // .. -> .
  879.     bp++;
  880.     }
  881.     u_int blen = strlen(bp);
  882.     if ((len += blen) > maxMsgLength) {
  883. reply(550,
  884.     "Error, message too long; max %u characters.",
  885.     maxMsgLength);
  886. (void) fclose(fout);
  887. Sys::unlink(msgFile);
  888. return;
  889.     }
  890.     // if buf only contains .., we skipped the first .
  891.     // hence we must write bp, not buf. also blen is
  892.     // the length of bp, not buf.
  893.     ignore = fwrite((const char*) bp, blen, 1, fout);
  894. }
  895.     }
  896.     if (fclose(fout)) {
  897. perror_reply(554, msgFile, errno);
  898. Sys::unlink(msgFile);
  899.     } else {
  900. haveText = true;
  901. reply(250, "Message text OK.");
  902.     }
  903. } else
  904.     perror_reply(554, msgFile, errno);
  905.     } else
  906. reply(503, "Error, message already entered.");
  907. }
  909. /*
  910.  * Provide help.  We cannot share the base class
  911.  * implementation of this command because SNPP
  912.  * defines a different style for responses (sigh).
  913.  */
  914. void
  915. SNPPServer::helpCmd(const tab* ctab, const char* s)
  916. {
  917.     const char* type;
  918.     u_int NCMDS;
  919.     if (ctab == sitetab) {
  920.         type = "SITE ";
  921. NCMDS = N(sitetab);
  922.     } else {
  923.         type = "";
  924. NCMDS = N(cmdtab);
  925.     }
  926.     int width = 0;
  927.     const tab* c = ctab;
  928.     for (u_int n = NCMDS; n != 0; c++, n--) {
  929.         int len = strlen(c->name);
  930.         if (len > width)
  931.             width = len;
  932.     }
  933.     width = (width + 8) &~ 7;
  934.     if (s == NULL) {
  935.         reply(214, "The following %scommands are recognized %s.",
  936.             type, "(* =>'s unimplemented)");
  937.         int columns = 76 / width;
  938.         if (columns == 0)
  939.             columns = 1;
  940.         int lines = (NCMDS + columns - 1) / columns;
  941.         for (int i = 0; i < lines; i++) {
  942.             printf("214 ");
  943.             for (int j = 0; j < columns; j++) {
  944.                 c = &ctab[j*lines + i];
  945.                 printf("%s%c", c->name, !c->implemented ? '*' : ' ');
  946.                 if (c + lines >= &ctab[NCMDS])
  947.                     break;
  948.                 int w = strlen(c->name) + 1;
  949.                 while (w < width) {
  950.                     putchar(' ');
  951.                     w++;
  952.                 }
  953.             }
  954.             printf("rn");
  955.         }
  956.         (void) fflush(stdout);
  957.         reply(250, "Direct comments to %s.", (const char*) faxContact);
  958.     } else {
  959. c = lookup(ctab, NCMDS, s);
  960. if (c == NULL)
  961.     reply(550, "Unknown command %s.", s);
  962. else if (c->implemented)
  963.     reply(218, "Syntax: %s%s %s", type, c->name, c->help);
  964. else
  965.     reply(218, "%s%-*st%s; unimplemented.",
  966. type, width, c->name, c->help);
  967.     }
  968. }
  970. /*
  971.  * Specify the hold time (time to send) for a request.
  972.  */
  973. void
  974. SNPPServer::holdCmd(time_t when)
  975. {
  976.     time_t now = Sys::now();
  977.     if (when > now) {
  978. defJob.tts = when;
  979. const struct tm* tm = cvtTime(defJob.tts);
  980. reply(250, "Message will be processed at %02d%02d%02d%02d%02d."
  981.     , tm->tm_year
  982.     , tm->tm_mon+1
  983.     , tm->tm_mday
  984.     , tm->tm_hour
  985.     , tm->tm_min
  986. );
  987.     } else
  988. reply(550, "Invalid delivery date/time; time in the past.");
  989. }
  991. /*
  992.  * Login as the specified user.
  993.  */
  994. void
  995. SNPPServer::loginCmd(const char* loginID, const char* pass)
  996. {
  997.     if (IS(LOGGEDIN))
  998.         end_login();
  999.     the_user = loginID;
  1000.     state &= ~S_PRIVILEGED;
  1001.     adminWd = "*"; // make sure no admin privileges
  1002.     passWd = "*"; // just in case...
  1004.     if (checkUser(loginID)) {
  1005. if (passWd != "") {
  1006.     if (pass[0] == '' || !(streq(crypt(pass, passWd), passWd) || pamCheck(the_user, pass))) {
  1007. if (++loginAttempts >= maxLoginAttempts) {
  1008.     reply(421, "Login incorrect (closing connection).");
  1009.     logNotice("Repeated SNPP login failures for user %s from %s [%s]"
  1010. , (const char*) the_user
  1011. , (const char*) remotehost
  1012. , (const char*) remoteaddr
  1013.     );
  1014.     dologout(0);
  1015. }
  1016. reply(550, "Login incorrect.");
  1017. logInfo("SNPP login failed from %s [%s], %s"
  1018.     , (const char*) remotehost
  1019.     , (const char*) remoteaddr
  1020.     , (const char*) the_user
  1021. );
  1022. return;
  1023.     }
  1024. }
  1025. login(250);
  1026.     } else {
  1027. if (++loginAttempts >= maxLoginAttempts) {
  1028.     reply(421, "Login incorrect (closing connection).");
  1029.     logNotice("Repeated SNPP login failures for user %s from %s [%s]"
  1030. , (const char*) the_user
  1031. , (const char*) remotehost
  1032. , (const char*) remoteaddr
  1033.     );
  1034.     dologout(0);
  1035. } else {
  1036.     reply(421, "User %s access denied.", (const char*) the_user);
  1037.     logNotice("SNPP LOGIN REFUSED (%s) FROM %s [%s], %s"
  1038. , "user denied"
  1039. , (const char*) remotehost
  1040. , (const char*) remoteaddr
  1041. , (const char*) the_user
  1042.     );
  1043. }
  1044.     }
  1045. }
  1047. /*
  1048.  * Specify a one-line message text.
  1049.  */
  1050. void
  1051. SNPPServer::messageCmd(const char* msg)
  1052. {
  1053.     if (!haveText) {
  1054. u_int len = strlen(msg);
  1055. if (len > maxMsgLength) {
  1056.     reply(550,
  1057. "Error, message too long; no more than %u characters accepted.",
  1058. maxMsgLength);
  1059.     return;
  1060. }
  1061. fxStr emsg;
  1062. u_int seqnum = getDocumentNumber(emsg);
  1063. if (seqnum == (u_int) -1) {
  1064.     reply(554, "%s", (const char*)emsg);
  1065.     return;
  1066. }
  1067. msgFile = fxStr::format("/%s/doc%u.page", FAX_TMPDIR, seqnum);
  1068. FILE* fout = Sys::fopen(msgFile, "w");
  1069. if (fout != NULL) {
  1070.     setFileOwner(msgFile);
  1071.     FileCache::chmod(msgFile, 0660); // sync cache
  1072.     tempFiles.append(msgFile);
  1073.     int ignore = fwrite(msg, len, 1, fout);
  1074.     if (fclose(fout)) {
  1075. perror_reply(554, msgFile, errno);
  1076. Sys::unlink(msgFile);
  1077.     } else {
  1078. haveText = true;
  1079. reply(250, "Message text OK.");
  1080.     }
  1081. } else
  1082.     perror_reply(554, msgFile, errno);
  1083.     } else
  1084. reply(503, "Error, message already entered.");
  1085. }
  1087. /*
  1088.  * Process a PAGE command.  Map the client-specified pager
  1089.  * identification string to a service provider phone number
  1090.  * and destination PIN and create a new job for this request.
  1091.  */
  1092. void
  1093. SNPPServer::pagerCmd(const char* pagerID, const char* pin)
  1094. {
  1095.     /*
  1096.      * Lookup pager ID and map to a service provider
  1097.      * and, optionally, PIN.
  1098.      */
  1099.     fxStr provider;
  1100.     fxStr PIN;
  1101.     fxStr emsg;
  1102.     if (!mapPagerID(pagerID, provider, PIN, emsg)) {
  1103. reply(550, "%s.", (const char*) emsg);
  1104. return;
  1105.     }
  1106.     /*
  1107.      * RFC 1861 says we should lock the Level, Coverage,
  1108.      * Holdtime, and Alert values for the request at this point.
  1109.      * To do this we create a job (inheriting the current state
  1110.      * from the default job) and fill in any other information.
  1111.      * However we do not submit it until later (when a SEND
  1112.      * request is made).
  1113.      */
  1114.     curJob = &defJob; // inherit from default job
  1115.     // XXX merge items to same provider (maybe?)
  1116.     if (newJob(emsg) && updateJobOnDisk(*curJob, emsg)) {
  1117. fxStr file("/" | curJob->qfile);
  1118. setFileOwner(file); // force ownership
  1119. FileCache::chmod(file, 0660); // sync cache
  1120. curJob->lastmod = Sys::now(); // noone else should update
  1122. curJob->number = provider; // destination phone number
  1123. if (!pin) // use mapped value
  1124.     pin = PIN;
  1125. curJob->items.append(FaxItem(FaxRequest::send_page, 0, "", pin));
  1126. curJob->items.append(
  1127.     FaxItem(FaxRequest::send_page_saved, 0, "", pin));
  1128. reply(250, "Pager ID accepted; provider: %s pin: %s jobid: %s."
  1129.     , (const char*) provider
  1130.     , pin
  1131.     , (const char*) curJob->jobid
  1132. );
  1133. msgs.append(curJob->jobid);
  1134. updateJobOnDisk(*curJob, emsg);
  1135.     } else
  1136. reply(554, "%s.", (const char*) emsg);
  1137.     initSNPPJob(); // reset job-related state
  1138. }
  1140. /*
  1141.  * Validate a client-specified pager ID string.
  1142.  * This is only sort of like the intended usage
  1143.  * but is the only thing that makes sense in
  1144.  * our environment (where the provider is not
  1145.  * directly accessible).
  1146.  */
  1147. void
  1148. SNPPServer::pingCmd(const char* pagerID)
  1149. {
  1150.     /*
  1151.      * Lookup pager ID and map to a service provider
  1152.      * and, optionally, PIN.
  1153.      */
  1154.     fxStr provider;
  1155.     fxStr PIN;
  1156.     fxStr emsg;
  1157.     if (mapPagerID(pagerID, provider, PIN, emsg))
  1158. reply(821, "Valid pager ID, no location information available.");
  1159.     else
  1160. reply(550, "%s.", (const char*) emsg);
  1161. }
  1163. static bool
  1164. notPresent(FaxItemArray& a, const char* name)
  1165. {
  1166.     for (u_int i = 0, n = a.length(); i < n; i++)
  1167. if (a[i].op == FaxRequest::send_data && a[i].item == name)
  1168.     return (false);
  1169.     return (true);
  1170. }
  1172. /*
  1173.  * Send (submit) a pager request.  We complete the
  1174.  * formulation of the job and submit it to the
  1175.  * scheduler.  If this job is marked for no queueing
  1176.  * then we also wait around for the job to complete.
  1177.  */
  1178. void
  1179. SNPPServer::sendCmd(void)
  1180. {
  1181.     if (msgs.length() == 0) {
  1182. reply(503, "Error, no pager ID specified with PAGE.");
  1183. return;
  1184.     }
  1185.     /*
  1186.      * If we need to wait for jobs to complete, construct
  1187.      * and register a trigger now before we submit the jobs.
  1188.      */
  1189.     fxStr emsg;
  1190.     u_int i, n = msgs.length();
  1191.     bool waitForJobs = false;
  1192.     for (i = 0; i < n; i++) {
  1193. Job* job = findJob(msgs[i], emsg);
  1194. if (!job)
  1195.     msgs.remove(i), n--;
  1196. else if (!job->queued)
  1197.     waitForJobs = true;
  1198.     }
  1199.     if (waitForJobs) {
  1200. state &= ~S_LOGTRIG; // just process events
  1201. if (!newTrigger(emsg, "J%04x", 1<<Trigger::JOB_DEAD)) {
  1202.     reply(550,
  1203. "Cannot register trigger to wait for job completion: %s.",
  1204. (const char*) emsg);
  1205.     return;
  1206. }
  1207.     }
  1208.     const char* docname = msgFile;
  1209.     const char* cp = strrchr(docname, '/');
  1210.     if (!cp) // relative name, e.g. doc123
  1211. cp = docname;
  1212.     for (i = 0; i < n; i++) {
  1213. Job* job = findJob(msgs[i], emsg);
  1214. if (!job) {
  1215.     msgs.remove(i), n--;
  1216.     continue;
  1217. }
  1218. if (*cp != '') {
  1219.     /*
  1220.      * Add a reference to the message text for
  1221.      * the current job, if not already present.
  1222.      */
  1223.     fxStr document =
  1224. fxStr::format("/" FAX_DOCDIR "%s.", cp) | job->jobid;
  1225.     if (notPresent(job->items, &document[1])) {
  1226. if (Sys::link(docname, document) < 0) {
  1227.     reply(554, "Unable to link document %s to %s: %s.",
  1228. docname, (const char*) document, strerror(errno));
  1229.     return;
  1230. }
  1231. job->items.append(
  1232.     FaxItem(FaxRequest::send_data, 0, "", &document[1]));
  1233.     }
  1234. }
  1235. /*
  1236.  * Submit the job for scheduling.
  1237.  */
  1238. if (job->mailaddr == "")
  1239.     replyBadJob(*job, T_NOTIFYADDR);
  1240. else if (job->sender == "")
  1241.     replyBadJob(*job, T_FROM_USER);
  1242. else if (job->modem == "")
  1243.     replyBadJob(*job, T_MODEM);
  1244. else if (job->client == "")
  1245.     replyBadJob(*job, T_CLIENT);
  1246. else {
  1247.     if (job->external == "")
  1248. job->external = job->number;
  1249.     if (job->tts == 0)
  1250. job->tts = Sys::now();
  1251.     job->killtime += job->tts; // adjust based on any hold time
  1252.     if (updateJobOnDisk(*job, emsg)) {
  1253. const char* jobid = job->jobid;
  1254. /*
  1255.  * NB: we don't mark the lastmod time for the
  1256.  * job since the scheduler should re-write the
  1257.  * queue file to reflect what it did with it
  1258.  * (e.g. what state it placed the job in).
  1259.  */
  1260. if (sendQueuerACK(emsg, "S%s", jobid))
  1261.     continue;
  1262. reply(554, "Failed to submit message %s: %s.",
  1263.     jobid, (const char*) emsg);
  1264.     } else
  1265. reply(554, "%s.", (const char*) emsg);
  1266. }
  1267. if (waitForJobs) { // cleanup trigger on error
  1268.     cancelTrigger(emsg);
  1269.     /*
  1270.      * Not sure what to do here.  If some jobs got
  1271.      * submitted then we want to remove them so the
  1272.      * client can just reissue SEND if the error was
  1273.      * transient (e.g. faxq was temporarily stopped).
  1274.      * However we don't track which jobs got started
  1275.      * and which did not so for now we'll just leave
  1276.      * everything so the client can resubmit things
  1277.      * with a subsequent SEND.  Unfortunately this
  1278.      * can result in duplicate pages being sent.
  1279.      */
  1280. }
  1281. return; // failure
  1282.     }
  1283.     if (waitForJobs) { // no queueing, wait for submitted jobs
  1284. if (setjmp(urgcatch) == 0) {
  1285.     Dispatcher& disp = Dispatcher::instance();
  1286.     state |= S_WAITTRIG|S_SENDWAIT;
  1287.     bool jobsPending;
  1288.     do {
  1289. disp.dispatch();
  1290. /*
  1291.  * The trigger event handlers update our notion
  1292.  * of the job state asynchronously so we can just
  1293.  * monitor the job state(s) after each event we
  1294.  * receive.
  1295.  */
  1296. jobsPending = false;
  1297. for (i = 0; i < n; i++) {
  1298.     Job* job = findJob(msgs[i], emsg);
  1299.     if (!job)
  1300. msgs.remove(i), n--;
  1301.     else if (!job->queued && 
  1302.       job->state != FaxRequest::state_done &&
  1303.       job->state != FaxRequest::state_failed)
  1304. jobsPending = true;
  1305. }
  1306.     } while (IS(WAITTRIG) && jobsPending);
  1307.     reply(250, "Message processing completed.");
  1308. }
  1309. state &= ~(S_WAITTRIG|S_SENDWAIT);
  1310. (void) cancelTrigger(emsg);
  1311.     } else // jobs queued, just acknowledge
  1312. reply(250, "Message%s succesfully queued.",
  1313.     msgs.length() > 1 ? "s" : "");
  1314.     resetState(); // reset SEND-related state
  1315. }
  1317. /*
  1318.  * Set the message service level.  We currently use
  1319.  * this just to select a scheduling priority and
  1320.  * job expiration time.
  1321.  */
  1322. void
  1323. SNPPServer::serviceLevel(u_int level)
  1324. {
  1325.     if (level <= 11) {
  1326. defJob.usrpri = priMap[level];
  1327. defJob.killtime = 60*killMap[level];
  1328. defJob.retrytime = retryMap[level];
  1329. reply(250, "OK, service level %u accepted.", level);
  1330.     } else
  1331. reply(550, "Invalid service level %u; we only handle 0-11.", level);
  1332. }
  1334. /*
  1335.  * Return server status.
  1336.  */
  1337. void
  1338. SNPPServer::statusCmd(void)
  1339. {
  1340.     reply(214, "%s SNPP server status:", (const char*) hostname);
  1341.     reply(214, "    %s", version);
  1342.     if (!isdigit(remotehost[0]))
  1343. reply(214, "    Connected to %s (%s).",
  1344.     (const char*) remotehost, (const char*) remoteaddr);
  1345.     else
  1346. reply(214, "    Connected to %s.", (const char*) remotehost);
  1347.     if (IS(LOGGEDIN)) {
  1348. reply(214, "    Logged in as user %s (uid %u)."
  1349.     , (const char*) the_user
  1350.     , uid
  1351. );
  1352.     } else
  1353. reply(214, "    Waiting for login.");
  1354.     reply(214, "    Idle timeout set to %d seconds.", idleTimeout);
  1355.     if (discTime > 0)
  1356. reply(214, "    Server scheduled to be unavailable at %.24s.",
  1357.     asctime(cvtTime(discTime)));
  1358.     else
  1359. reply(214, "    No server down time currently scheduled.");
  1360.     reply(214, "    HylaFAX scheduler reached at %s (%sconnected)."
  1361. , (const char*) faxqFIFOName
  1362. , faxqFd == -1 ? "not " : ""
  1363.     );
  1364.     if (clientFd != -1)
  1365. reply(214, "    Server FIFO is /%s (%sopen)."
  1366.     , (const char*) clientFIFOName
  1367.     , clientFd == -1 ? "not " : ""
  1368. );
  1369.     if (IS(WAITFIFO))
  1370. reply(214, "    Waiting for response from HylaFAX scheduler.");
  1371.     if (msgs.length() > 0) {
  1372. reply(214, "    %u message%s prepared for transmission.",
  1373.     msgs.length(), msgs.length() > 1 ? "s" : "");
  1374. // XXX dump status of msgs
  1375.     } else
  1376. reply(214, "    No messages prepared for transmission.");
  1377.     reply(214, "    %s message text.", haveText ? "Received" : "No received");
  1379.     reply(250, "End of status");
  1380. }
  1382. /*
  1383.  * Set the subject for outgoing messages.
  1384.  * For now we just use it to tag the jobs.
  1385.  */
  1386. void
  1387. SNPPServer::subjectCmd(const char* subj)
  1388. {
  1389.     defJob.jobtag = subj; // XXX
  1390.     reply(250, "Message subject OK.");
  1391. }
  1393. /*
  1394.  * Configuration support.
  1395.  */
  1397. void
  1398. SNPPServer::resetConfig()
  1399. {
  1400.     InetFaxServer::resetConfig();
  1401.     setupConfig();
  1402. }
  1404. void
  1405. SNPPServer::setupConfig()
  1406. {
  1407.     setConfigItem("maxmsglength",  "128");
  1408.     setConfigItem("pageridmapfile","/etc/pagermap");
  1409.     setConfigItem("prioritymap",
  1410. "63 127 127 127 127 127 127  127  127  127  127  127");
  1411.     setConfigItem("killtimemap",
  1412. " 5   5   5  15  60 240 720 1440 1440 1440 1440 1440");
  1413.     setConfigItem("retrytimemap",
  1414. "30  60  60 180   0   0   0    0    0    0    0    0");
  1415. }
  1417. static void
  1418. setShortMap(u_short map[12], const char* value)
  1419. {
  1420.     char* cp;
  1421.     for (int i = 0; i < 12; i++) {
  1422. map[i] = (u_short) strtoul(value, &cp, 0);
  1423. if (!cp && *cp == '')
  1424.     break;
  1425. value = cp;
  1426.     }
  1427. }
  1429. static void
  1430. setTimeMap(time_t map[12], const char* value)
  1431. {
  1432.     char* cp;
  1433.     for (int i = 0; i < 12; i++) {
  1434. map[i] = (time_t) strtoul(value, &cp, 0);
  1435. if (!cp && *cp == '')
  1436.     break;
  1437. value = cp;
  1438.     }
  1439. }
  1441. bool
  1442. SNPPServer::setConfigItem(const char* tag, const char* value)
  1443. {
  1444.     if (streq(tag, "maxmsglength")) {
  1445. maxMsgLength = getNumber(value);
  1446.     } else if (streq(tag, "pageridmapfile")) {
  1447. pagerIDMapFile = value;
  1448.     } else if (streq(tag, "prioritymap")) {
  1449. setShortMap(priMap, value);
  1450.     } else if (streq(tag, "killtimemap")) {
  1451. setTimeMap(killMap, value);
  1452.     } else if (streq(tag, "retrytimemap")) {
  1453. setTimeMap(retryMap, value);
  1454.     } else if (!InetFaxServer::setConfigItem(tag, value))
  1455. return (false);
  1456.     return (true);
  1457. }
  1458. #endif /* SNPP_SUPPORT */