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

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

传真(Fax)编程

开发平台：

C/C++

pageSendApp.c++：源码内容
  1. /* $Id: pageSendApp.c++,v 1.10 2009/07/13 04:50:41 faxguy Exp $ */
  2. /*
  3.  * Copyright (c) 1994-1996 Sam Leffler
  4.  * Copyright (c) 1994-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 <sys/types.h>
  27. #include <unistd.h>
  28. #include <errno.h>
  29. #include <fcntl.h>
  30. #include <stdlib.h>
  31. #include <sys/file.h>
  32. #include <signal.h>
  33. #include <ctype.h>
  35. #include "FaxMachineInfo.h"
  36. #include "FaxAcctInfo.h"
  37. #include "UUCPLock.h"
  38. #include "pageSendApp.h"
  39. #include "FaxRequest.h"
  40. #include "Dispatcher.h"
  41. #include "StackBuffer.h"
  42. #include "Sys.h"
  43. #include "ixo.h"
  45. #include "config.h"
  47. /*
  48.  * Send messages with IXO/TAP protocol.
  49.  */
  51. pageSendApp* pageSendApp::_instance = NULL;
  53. pageSendApp::pageSendApp(const fxStr& devName, const fxStr& devID)
  54.     : ModemServer(devName, devID)
  55. {
  56.     ready = false;
  57.     modemLock = NULL;
  58.     setupConfig();
  60.     fxAssert(_instance == NULL, "Cannot create multiple pageSendApp instances");
  61.     _instance = this;
  62. }
  64. pageSendApp::~pageSendApp()
  65. {
  66.     delete modemLock;
  67. }
  69. pageSendApp& pageSendApp::instance() { return *_instance; }
  71. void
  72. pageSendApp::initialize(int argc, char** argv)
  73. {
  74.     ModemServer::initialize(argc, argv);
  75.     faxApp::initialize(argc, argv);
  77.     // NB: must do last to override config file information
  78.     for (GetoptIter iter(argc, argv, getOpts()); iter.notDone(); iter++)
  79. switch (iter.option()) {
  80. case 'l': // do uucp locking
  81.     modemLock = getUUCPLock(getModemDevice());
  82.     break;
  83. case 'c': // set configuration parameter
  84.     readConfigItem(iter.optArg());
  85.     break;
  86. }
  87. }
  89. void
  90. pageSendApp::open()
  91. {
  92.     ModemServer::open();
  93.     faxApp::open();
  94. }
  96. void
  97. pageSendApp::close()
  98. {
  99.     if (isRunning()) {
  100. if (state == ModemServer::SENDING) {
  101.     /*
  102.      * Terminate the active job and let the send
  103.      * operation complete so that the transfer is
  104.      * logged and the appropriate exit status is
  105.      * returned to the caller.
  106.      */
  107.     ModemServer::abortSession();
  108. } else {
  109.     ModemServer::close();
  110.     faxApp::close();
  111. }
  112.     }
  113. }
  115. # define BATCH_FIRST 1
  116. # define BATCH_LAST  2
  118. FaxSendStatus
  119. pageSendApp::send(const char** filenames, int num)
  120. {
  121.     u_int batched = BATCH_FIRST;
  122.     FaxSendStatus status = send_done;
  123.     fxStr batchcommid, notice, errorcode;
  124.     time_t retrybatchtts = 0;
  126.     for (int i = 0; i < num; i++) {
  127. if (i+1 == num)
  128.     batched |= BATCH_LAST;
  129.     
  130. int fd = Sys::open(filenames[i], O_RDWR);
  131. if (fd >= 0) {
  132.     if (flock(fd, LOCK_EX) >= 0) {
  133. FaxRequest* req = new FaxRequest(filenames[i], fd);
  134. bool reject;
  135. if (req->readQFile(reject) && !reject) {
  136.     if (status == send_done) {
  138. if (req->findItem(FaxRequest::send_page) != fx_invalidArrayIndex) {
  139.     FaxMachineInfo info;
  140.     info.updateConfig(canonicalizePhoneNumber(req->number));
  141.     FaxAcctInfo ai;
  143.     ai.start = Sys::now();
  145.     req->commid = batchcommid; // pass commid on...
  147.     sendPage(*req, info, batched);
  149.     batchcommid = req->commid; // ... to all batched jobs
  151.     ai.jobid = req->jobid;
  152.     ai.jobtag = req->jobtag;
  153.     ai.user = req->mailaddr;
  154.     ai.duration = Sys::now() - ai.start;
  155.     ai.conntime = getConnectTime();
  156.     ai.commid = req->commid;
  157.     ai.device = getModemDeviceID();
  158.     ai.dest = req->external;
  159.     ai.csi = "";
  160.     ai.params = 0;
  161.     ai.npages = 0;
  162.     CallID empty_callid;
  163.     ai.callid = empty_callid;
  164.     ai.owner = req->owner;
  165.     if (req->status == send_done)
  166. ai.status = "";
  167.     else {
  168. errorcode = req->errorcode;
  169. notice = req->notice;
  170. ai.status = req->notice;
  171. retrybatchtts = req->tts;
  172.     }
  173.     ai.jobinfo = fxStr::format("%u/%u/%u/%u/%u/%u/%u", 
  174. req->totpages, req->ntries, req->ndials, req->totdials, req->maxdials, req->tottries, req->maxtries);
  175.     if (!ai.record("PAGE"))
  176. logError("Error writing %s accounting record, dest=%s",
  177.     "PAGE", (const char*) ai.dest);
  178. } else
  179.     sendFailed(*req, send_failed, "Job has no PIN to send to");
  181. status = req->status;
  182.     } else {
  183. /*
  184.  * This job cannot get sent right now due to an error in a previous
  185.  * job in the batch.
  186.  *
  187.  * In the event that the previous error was not an in-job error (e.g.
  188.  * a busy signal) then we treat that error as if it applies to all jobs.
  189.  * We "keep the batch together" by synchronizing their tts.
  190.  *
  191.  * In the event that the previous error was an in-job error, then the
  192.  * previous job processing is essentially blocking this job from
  193.  * processing, and so we set the notice accordingly and don't increase
  194.  * the dial-count.  In case batching itself triggered the problem, we
  195.  * don't set the tts, allowing faxq to reschedule the job, expecting that
  196.  * to disassemble and "shuffle" the entire batch.
  197.  */
  198. if (errorcode == "E001" ||
  199.     errorcode == "E002" ||
  200.     errorcode == "E003") {
  201.     /* busy, no carrier, no answer */
  202.     req->notice = notice;
  203.     req->status = send_retry;
  204.     req->tts = retrybatchtts;
  205.     req->totdials++;
  206. } else {
  207.     req->notice = "Blocked by another job";
  208.     req->status = send_retry;
  209. }
  210.     }
  211.     req->writeQFile(); // update on-disk copy
  212.     delete req;
  213. } else {
  214.     delete req;
  215.     logError("Could not read request file");
  216.     status = send_failed;
  217. }
  218.     } else {
  219. logError("Could not lock request file: %m");
  220. Sys::close(fd);
  221. status = send_failed;
  222.     }
  223. } else {
  224.     logError("Could not open request file "%s": %m", filenames[i]);
  225.     status = send_failed;
  226. }
  227. batched = 0; // disable BATCH_FIRST and BATCH_LAST routines
  228.     }
  229.     return (status); // return status for exit
  230. }
  232. void
  233. pageSendApp::sendPage(FaxRequest& req, FaxMachineInfo& info, u_int& batched)
  234. {
  235.     if (!(batched & BATCH_FIRST) || lockModem()) {
  236.         if (batched & BATCH_FIRST) {
  237.             beginSession(req.number);
  238.             batchid = getCommID();
  239.         }
  241.         req.commid = getCommID();        // set by beginSession
  242.         traceServer("SEND PAGE (possibly batched): JOB %s DEST %s COMMID %s DEVICE '%s'"
  243.                     , (const char*) req.jobid
  244.                     , (const char*) req.external
  245.                     , (const char*) req.commid
  246.                     , (const char*) getModemDevice()
  247.                    );
  248. /*
  249.  * Setup tty parity; per-destination information takes
  250.  * precedence over command-line arguments/config params;
  251.  * otherwise the IXO/TAP spec is used (set below).
  252.  */
  253. if (info.getPagerTTYParity() != "")
  254.     pagerTTYParity = info.getPagerTTYParity();
  255. // NB: may need to set tty baud rate here XXX
  256.         if (!(batched & BATCH_FIRST) || setupModem(true)) {
  257.     changeState(SENDING);
  258.     setServerStatus("Sending page " | req.jobid);
  259.     /*
  260.      * Construct the phone number to dial by applying the
  261.      * dialing rules to the user-specified dialing string.
  262.      */
  263.     fxStr msg;
  264.     if (prepareMsg(req, info, msg))
  265. sendPage(req, info, prepareDialString(req.number), msg, batched);
  266.         } else
  267.        sendFailed(req, send_retry, "Can not setup modem", 4*pollModemWait);
  269.         if ((batched & BATCH_LAST) || (req.status != send_done)) {
  270.             discardModem(true);
  271.             changeState(MODEMWAIT, 5);
  272.             unlockModem();
  273.             endSession();
  274.         } 
  275.     } else {
  276. sendFailed(req, send_retry, "Can not lock modem device",2*pollLockWait);
  277.     }
  278. }
  280. bool
  281. pageSendApp::prepareMsg(FaxRequest& req, FaxMachineInfo& info, fxStr& msg)
  282. {
  283.     u_int i = req.findItem(FaxRequest::send_data);
  284.     if (i == fx_invalidArrayIndex) // page w/o text
  285. return (true);
  286.     int fd = Sys::open(req.items[i].item, O_RDONLY);
  287.     if (fd < 0) {
  288. sendFailed(req, send_failed,
  289.     "Internal error: unable to open text message file");
  290. return (false);
  291.     }
  292.     struct stat sb;
  293.     (void) Sys::fstat(fd, sb);
  294.     msg.resize((u_int) sb.st_size);
  295.     if (Sys::read(fd, &msg[0], (u_int) sb.st_size) != sb.st_size) {
  296. sendFailed(req, send_failed,
  297.     "Internal error: unable to read text message file");
  298. return (false);
  299.     }
  300.     Sys::close(fd);
  302.     u_int maxMsgLen = info.getPagerMaxMsgLength();
  303.     if (maxMsgLen == (u_int) -1) // not set, use default
  304. maxMsgLen = pagerMaxMsgLength;
  305.     if (msg.length() > maxMsgLen) {
  306. traceServer("Pager message length %u too large; truncated to %u",
  307.     msg.length(), maxMsgLen);
  308. msg.resize(maxMsgLen);
  309.     }
  310.     return (true);
  311. }
  313. void
  314. pageSendApp::sendFailed(FaxRequest& req, FaxSendStatus stat, const char* notice, u_int tts)
  315. {
  316.     req.status = stat;
  317.     req.notice = notice;
  318.     /*
  319.      * When requeued for the default interval (called with 3 args),
  320.      * don't adjust the time-to-send field so that the spooler
  321.      * will set it according to the default algorithm that 
  322.      * uses the command-line parameter or requeueOther and a random jitter.
  323.      */
  324.     if (tts != 0)
  325. req.tts = Sys::now() + tts;
  326.     traceServer("PAGE FAILED: %s", notice);
  327. }
  329. void
  330. pageSendApp::sendPage(FaxRequest& req, FaxMachineInfo& info, const fxStr& number, const fxStr& msg, u_int& batched)
  331. {
  332.     connTime = 0; // indicate no connection
  333.     if ((batched & BATCH_FIRST) && !getModem()->dataService()) {
  334. sendFailed(req, send_failed, "Unable to configure modem for data use");
  335. return;
  336.     }
  337.     req.notice = "";
  338.     fxStr notice;
  339.     time_t pageStart = Sys::now();
  340.     if (batched & BATCH_FIRST) {
  341.         if (info.getPagerSetupCmds() != "")        // use values from info file
  342.             pagerSetupCmds = info.getPagerSetupCmds();
  344.         if (pagerSetupCmds != "")            // configure line speed, etc.
  345.             (void) getModem()->atCmd(pagerSetupCmds);
  346.     }
  348.     CallStatus callstat;
  350.     if (batched & BATCH_FIRST)
  351.         callstat = getModem()->dial(number, req.faxnumber, notice);
  352.     else
  353.         callstat = ClassModem::OK;
  354.     if (callstat == ClassModem::OK)
  355. connTime = Sys::now(); // connection start time
  356.     (void) abortRequested(); // check for user abort
  357.     if (callstat == ClassModem::OK && !abortCall) {
  358. req.ndials = 0; // consec. failed dial attempts
  359. req.tottries++; // total answered calls
  360. req.totdials++; // total attempted calls
  361. info.setCalledBefore(true);
  362. info.setDialFailures(0);
  364. req.status = send_ok; // be optimistic
  366. // from this point on, the treatment of the two protocols differs
  367. if (streq(info.getPagingProtocol(), "ixo")) {
  368.     sendIxoPage(req, info, msg, notice, batched);
  369. } else if (streq(info.getPagingProtocol(), "ucp")) {
  370.     sendUcpPage(req, info, msg, notice);
  371. } else {
  372.     notice = req.notice | "; paging protocol unknown ";
  373.     sendFailed(req, send_failed, notice);
  374.     req.status = send_failed;
  375. }
  377. // here again, we have identical code
  378. if (req.status == send_ok) {
  379.     time_t now = Sys::now();
  380.     traceServer("SEND PAGE: FROM " | req.mailaddr
  381. | " TO " | req.external | " (sent in %s)",
  382. fmtTime(now - pageStart));
  383.     info.setSendFailures(0);
  384. } else {
  385.     info.setSendFailures(info.getSendFailures()+1);
  386.     info.setLastSendFailure(req.notice);
  387. }
  388.     } else if (!abortCall) {
  389. /*
  390.  * Analyze the call status codes and selectively decide if the
  391.  * job should be retried.  We try to avoid the situations where
  392.  * we might be calling the wrong number so that we don't end up
  393.  * harrassing someone w/ repeated calls.
  394.  */
  395. req.ndials++;
  396. req.totdials++; // total attempted calls
  397. switch (callstat) {
  398. case ClassModem::NOCARRIER: // no carrier detected on remote side
  399.     /*
  400.      * Since some modems can not distinguish between ``No Carrier''
  401.      * and ``No Answer'' we offer this configurable hack whereby
  402.      * we'll retry the job <n> times in the face of ``No Carrier''
  403.      * dialing errors; if we've never previously reached a modem
  404.      * at that number.  This should not be used except if
  405.      * the modem is incapable of distinguishing between
  406.      * ``No Carrier'' and ``No Answer''.
  407.      */
  408.     if (!info.getCalledBefore() && req.ndials > retryMAX[callstat]) {
  409. sendFailed(req, send_failed, notice);
  410. break;
  411.     }
  412.     /* fall thru... */
  413. case ClassModem::NODIALTONE: // no local dialtone, possibly unplugged
  414. case ClassModem::ERROR: // modem might just need to be reset
  415. case ClassModem::FAILURE: // modem returned something unexpected
  416. case ClassModem::BUSY: // busy signal
  417. case ClassModem::NOANSWER: // no answer or ring back
  418.     sendFailed(req, send_retry, notice, requeueTTS[callstat]);
  419.     /* fall thru... */
  420. case ClassModem::OK: // call was aborted by user
  421.     break;
  422. }
  423. if (callstat != ClassModem::OK) {
  424.     info.setDialFailures(info.getDialFailures()+1);
  425.     info.setLastDialFailure(req.notice);
  426. }
  427.     }
  428.     if (abortCall)
  429. sendFailed(req, send_retry, "Call aborted by user");
  430.     else if (req.status == send_retry) {
  431. if (req.totdials == req.maxdials) {
  432.     notice = req.notice | "; too many attempts to dial";
  433.     sendFailed(req, send_failed, notice);
  434. } else if (req.tottries == req.maxtries) {
  435.     notice = req.notice | "; too many attempts to send";
  436.     sendFailed(req, send_failed, notice);
  437. }
  438.     }
  440.    if ((batched & BATCH_LAST) || (req.status != send_done))
  441.     {
  442.     /*
  443.      * Cleanup after the call.  If we have new information on
  444.      * the client's remote capabilities, the machine info
  445.      * database will be updated when the instance is destroyed.
  446.      */
  447.     getModem()->hangup();
  448.     }
  450.     /*
  451.      * This may not be exact--the line may already have been
  452.      * dropped--but it should be close enough unless the modem
  453.      * gets wedged and the hangup work times out.  Also be
  454.      * sure to register a non-zero amount of connect time so
  455.      * that folks doing accounting can adjust charge-back costs
  456.      * to reflect any minimum connect time tarrifs imposted by
  457.      * their PTT (e.g. calls < 1 minute are rounded up to 1 min.)
  458.      */
  459.     if (connTime) {
  460. connTime = Sys::now() - connTime;
  461. if (connTime == 0)
  462.     connTime++;
  463.     }
  464. }
  465. /*
  466.  * here comes the IXO specific code for sendPage, search for the
  467.  * string 'BEGIN UCP Support' for UCP specific code
  468.  */
  469. void
  470. pageSendApp::sendIxoPage(FaxRequest& req, FaxMachineInfo& info, const fxStr& msg,
  471.     fxStr& notice, u_int& batched)
  472. {
  473. if (batched & BATCH_FIRST) {
  474. if(!pagePrologue(req, info, notice)) {
  475. sendFailed(req, req.status, notice, requeueProto);
  476. return;
  477. }
  478. }
  480. while (req.items.length() > 0) {    // messages
  481.     u_int i = req.findItem(FaxRequest::send_page);
  482.     if (i == fx_invalidArrayIndex)
  483. break;
  484.     if (req.items[i].item.length() == 0) {
  485. sendFailed(req, send_failed, "No PIN specified");
  486. break;
  487.     }
  488.     if (!sendPagerMsg(req, req.items[i], msg, req.notice)) {
  489. /*
  490.  * On protocol errors retry more quickly
  491.  * (there's no reason to wait is there?).
  492.  */
  493. if (req.status == send_retry) {
  494.     req.tts = time(0) + requeueProto;
  495.     break;
  496. }
  497.     }
  498.     req.items.remove(i);
  499.     }
  501.     if ((batched & BATCH_LAST)
  502.             && req.status == send_ok) {
  503.         (void) pageEpilogue(req, info, notice);
  504.     }
  505. }
  507. u_int
  508. pageSendApp::getResponse(fxStackBuffer& buf, long secs)
  509. {
  510.     buf.reset();
  511.     if (secs) startTimeout(secs*1000);
  512.     for (;;) {
  513. int c = getModemChar(0);
  514. if (c == EOF)
  515.     break;
  516. if (c == 'r' || c == '03') {
  517.     if (buf.getLength() > 0) // discard leading r's or ETX
  518. break;
  519. } else if (c != 'n') // discard all n's
  520.     buf.put(c);
  521.     }
  522.     if (secs) stopTimeout("reading line from modem");
  523.     if (buf.getLength() > 0)
  524. traceIXOCom("-->", (u_char*) (const char*) buf, buf.getLength());
  525.     return (buf.getLength());
  526. }
  528. /*
  529.  * Scan through a buffer looking for a potential
  530.  * code byte return in a protocol response.
  531.  * This is needed because some pager services such
  532.  * as PageNet intersperse protocol messages and
  533.  * verbose text messages.
  534.  */
  535. static bool
  536. scanForCode(const u_char*& cp, u_int& len)
  537. {
  538.     if (len > 0) {
  539. do {
  540.     cp++, len--;
  541. } while (len > 0 &&
  542.     *cp != ACK && *cp != NAK && *cp != ESC && *cp != RS);
  543.     }
  544.     return (len > 0);
  545. }
  547. bool
  548. pageSendApp::pagePrologue(FaxRequest& req, const FaxMachineInfo& info, fxStr& emsg)
  549. {
  550.     fxStackBuffer buf;
  551.     time_t start;
  553.     /*
  554.      * Send r and wait for ``ID='' response.
  555.      * Repeat at 2 second intervals until a
  556.      * response is received or ntries have
  557.      * been done.
  558.      */
  559.     traceIXO("EXPECT ID (paging central identification)");
  560.     start = Sys::now();
  561.     bool gotID = false;
  562.     do {
  563. putModem("r", 1);
  564. if (getResponse(buf, ixoIDProbe) >= 3) {
  565.     // skip leading white space
  566.     const char* cp;
  567.     for (cp = buf; *cp && isspace(*cp); cp++)
  568. ;
  569.     gotID = strneq(cp, "ID=", 3);
  570. }
  571. if (gotID) {
  572.     traceIXO("RECV ID ("%.*s")",
  573. buf.getLength(), (const char*) buf);
  574. } else
  575.     traceResponse(buf);
  576.     } while (!gotID && (unsigned) Sys::now() - start < ixoIDTimeout);
  577.     if (!gotID) {
  578. emsg = "No initial ID response from paging central {E500}";
  579. req.status = send_retry;
  580. return (false);
  581.     }
  582.     flushModemInput(); // paging central may send multiple ID=
  583.     /*
  584.      * Identify use of automatic protocol (as opposed
  585.      * to manual) and proceed with login procedure:
  586.      *
  587.      *    ESC SST<pwd>.
  588.      *
  589.      * ESC means ``automatic dump mode'' protocol.
  590.      * SS  identifies service:
  591.      *    P = Pager ID
  592.      *    G = Message (?)
  593.      * T identifies type of terminal or device sending:
  594.      *    1 = ``category of entry devices using the same protocol''
  595.      *       (PETs and IXO)
  596.      *    7,8,9 = ``wild card terminals or devices which may 
  597.      *         relate to a specific users' system''.
  598.      * <pwd> is a 6-character alpha-numeric password
  599.      *    string (optional)
  600.      */
  601.     const fxStr& pass = info.getPagerPassword();
  602.     fxStr prolog("33" | ixoService | ixoDeviceID);
  603.     if (pass != "")
  604. prolog.append(pass);
  605.     prolog.append('r');
  607.     traceIXO("SEND device identification/login request");
  608.     putModem((const char*) prolog, prolog.length());
  610.     int ntries = ixoLoginRetries; // retry login up to 3 times
  611.     int unknown = ixoMaxUnknown; // accept up to 3 unknown messages
  612.     start = Sys::now();
  613.     do {
  614. u_int len = getResponse(buf, ixoLoginTimeout);
  615. const u_char* cp = buf;
  616. while (len > 0) {
  617.     switch (cp[0]) {
  618.     case ACK: // login successful, wait for go-ahead
  619. traceIXO("RECV ACK (login successful)");
  620. return (pageGoAhead(req, info, emsg));
  621.     case NAK: // login failed, retry
  622. traceIXO("RECV NAK (login unsuccessful)");
  623. if (--ntries == 0) {
  624.     emsg = "Login failed multiple times {E501}";
  625.     req.status = send_retry;
  626.     return (false);
  627. }
  628. /*
  629.  * Resend the login request.
  630.  */
  631. traceIXO("SEND device identification/login request");
  632. putModem((const char*) prolog, prolog.length());
  633. start = Sys::now(); // restart timer
  634. /*
  635.  * NB: we should just goto the top of the loop,
  636.  *     but old cfront-based compilers aren't
  637.  *     smart enough to handle goto's that might
  638.  *     bypass destructors.
  639.  */
  640. unknown++; // counteract loop iteration
  641. len = 0; // don't scan forward in buffer
  642. break;
  643.     case ESC:
  644. if (len > 1) {
  645.     if (cp[1] == EOT) {
  646. traceIXO("RECV EOT (forced disconnect)");
  647. emsg =
  648.     "Paging central responded with forced disconnect";
  649. req.status = send_failed;
  650. return (false);
  651.     }
  652.     // check for go-ahead message
  653.     if (len > 2 && cp[1] == '[' && cp[2] == 'p') {
  654. traceIXO("RECV ACK (login successful & got go-ahead)");
  655. return (true);
  656.     }
  657. }
  658. break;
  659.     }
  660.     if (!scanForCode(cp, len))
  661. traceResponse(buf);
  662. }
  663.     } while ((unsigned)Sys::now()-start < ixoLoginTimeout && --unknown != 0);
  664.     emsg = fxStr::format("Protocol failure: %s from paging central {E502}",
  665. (unknown ?
  666.     "timeout waiting for response" : "too many unknown responses"));
  667.     req.status = send_retry;
  668.     return (false);
  669. }
  671. bool
  672. pageSendApp::pageGoAhead(FaxRequest& req, const FaxMachineInfo&, fxStr& emsg)
  673. {
  674.     fxStackBuffer buf;
  675.     time_t start = Sys::now();
  676.     u_int unknown = ixoMaxUnknown;
  677.     do {
  678. u_int len = getResponse(buf, ixoGATimeout);
  679. const u_char* cp = buf;
  680. while (len > 0) {
  681.     if (len > 2 && cp[0] == ESC && cp[1] == '[' && cp[2] == 'p') {
  682. traceIXO("RECV go-ahead (prologue done)");
  683. return (true);
  684.     }
  685.     (void) scanForCode(cp, len);
  686. }
  687. traceResponse(buf);
  688.     } while ((unsigned) Sys::now()-start < ixoGATimeout && --unknown != 0);
  689.     emsg = fxStr::format("Protocol failure: %s waiting for go-ahead message {E503}",
  690. unknown ? "timeout" : "too many unknown responses");
  691.     req.status = send_retry;
  692.     return (false);
  693. }
  695. /*
  696.  * Calculate packet checksum and append to buffer.
  697.  */
  698. static void
  699. addChecksum(fxStackBuffer& buf)
  700. {
  701.     int sum = 0;
  702.     for (u_int i = 0; i < buf.getLength(); i++)
  703. sum += buf[i];
  705.     char check[3];
  706.     check[2] = '0' + (sum & 15); sum = sum >> 4;
  707.     check[1] = '0' + (sum & 15); sum = sum >> 4;
  708.     check[0] = '0' + (sum & 15);
  709.     buf.put(check, 3);
  710. }
  712. bool
  713. pageSendApp::sendPagerMsg(FaxRequest& req, FaxItem& preq, const fxStr& msg, fxStr& emsg)
  714. {
  715.     /*
  716.      * Build page packet:
  717.      *
  718.      *    STX pin CR line1 CR ... linen CR EEE checksum CR
  719.      *
  720.      * where pin is the destination Pager ID and line<n>
  721.      * are the lines of the message to send.  The trailing
  722.      * EEE depends on whether or not the message is continued
  723.      * on into the next block and/or whether this is the last
  724.      * block in the transaction.
  725.      */
  726.     fxStackBuffer buf;
  727.     buf.put(STX);
  728.     buf.put(preq.item); // copy PIN to packet
  729.     buf.put('r');
  730.     buf.put(msg); // copy text message
  731.     buf.put('r');
  732.     buf.put(ETX); // XXX
  733.     addChecksum(buf); // append packet checksum
  734.     buf.put('r');
  736.     /*
  737.      * Send the packet to paging central.
  738.      */
  739.     traceIXO("SEND message block");
  740.     putModem((const char*) buf, buf.getLength());
  742.     /*
  743.      * Process replies, possibly retransmitting the packet.
  744.      */
  745.     fxStackBuffer resp; // paging central response
  746.     u_int ntries = ixoXmitRetries; // up to 3 xmits of message
  747.     u_int unknown = 0; // count of unknown responses
  748.     time_t start = Sys::now();
  749.     do {
  750. u_int len = getResponse(resp, ixoXmitTimeout);
  751. const u_char* cp = resp;
  752. while (len > 0) {
  753.     switch (cp[0]) {
  754.     case ACK:
  755. traceIXO("RECV ACK (message block accepted)");
  756. return (true);
  757.     case NAK:
  758. traceIXO("RECV NAK (message block rejected)");
  759. if (--ntries == 0) {
  760.     req.status = send_retry;
  761.     emsg = "Message block not acknowledged by paging central "
  762. "after multiple tries {E504}";
  763.     return (false);
  764. }
  765. /*
  766.  * Retransmit the packet to paging central.
  767.  */
  768. traceIXO("SEND message block (retransmit)");
  769. putModem((const char*) buf, buf.getLength());
  770. start = Sys::now(); // restart timer
  771. unknown = 0; // reset unknown response count
  772. /*
  773.  * NB: we should just goto the top of the loop,
  774.  *     but old cfront-based compilers aren't
  775.  *     smart enough to handle goto's that might
  776.  *     bypass destructors.
  777.  */
  778. len = 0; // flush response buffer
  779. flushModemInput(); // flush pending data
  780. break;
  781.     case RS:
  782. traceIXO("RECV RS (message block rejected; skip to next)");
  783. /*
  784.  * This actually means to abandon the current transaction
  785.  * and proceed to the next.  However we treat it as a
  786.  * total failure since it's not clear within the present
  787.  * design whether proceeding to the next transaction is
  788.  * the right thing to do.
  789.  */
  790. req.status = send_failed;
  791. emsg = "Message block transmit failed; "
  792.     "paging central rejected it {E505}";
  793. return (false);
  794.     case ESC:
  795. if (len > 1 && cp[1] == EOT) {
  796.     traceIXO("RECV EOT (forced disconnect)");
  797.     req.status = send_failed;
  798.     emsg = "Protocol failure: paging central responded to "
  799. "message block transmit with forced disconnect {E506}";
  800.     return (false);
  801. }
  802. /* fall thru... */
  803.     default: // unrecognized response
  804. unknown++;
  805. break;
  806.     }
  807.     if (!scanForCode(cp, len))
  808. traceResponse(resp);
  809. }
  810.     } while ((unsigned)Sys::now()-start < ixoXmitTimeout && unknown < ixoMaxUnknown);
  811.     emsg = fxStr::format("Protocol failure: %s to message block transmit {E507}",
  812. (unknown ?
  813.     "timeout waiting for response" : "too many unknown responses"));
  814.     req.status = send_retry;
  815.     return (false);
  816. }
  818. bool
  819. pageSendApp::pageEpilogue(FaxRequest& req, const FaxMachineInfo&, fxStr& emsg)
  820. {
  821.     putModem("4r", 2); // EOT then <CR>
  823.     fxStackBuffer buf;
  824.     time_t start = Sys::now();
  825.     do {
  826. u_int len = getResponse(buf, ixoAckTimeout);
  827. const u_char* cp = buf;
  828. while (len > 0) {
  829.     switch (cp[0]) {
  830.     case ESC:
  831. if (len > 1 && cp[1] == EOT) {
  832.     traceIXO("RECV EOT (disconnect)");
  833.     return (true);
  834. }
  835. break;
  836.     case RS:
  837. traceIXO("RECV RS (message content rejected)");
  838. emsg = "Paging central rejected content; check PIN {E508}";
  839. req.status = send_failed;
  840. return (false);
  841.     }
  842.     (void) scanForCode(cp, len);
  843. }
  844. traceResponse(buf);
  845. // NB: ignore unknown responses
  846.     } while ((unsigned)Sys::now() - start < ixoAckTimeout);
  847.     req.status = send_retry;
  848.     emsg = "Protocol failure: timeout waiting for transaction ACK/NAK "
  849. "from paging central {E509}";
  850.     return (false);
  851. }
  853. void
  854. pageSendApp::traceResponse(const fxStackBuffer& buf)
  855. {
  856.     const char* extra = "";
  857.     u_int len = buf.getLength();
  858.     if (len > 0) {
  859. const char* cp = buf;
  860. do {
  861.     if (!isprint(*cp++)) {
  862. extra = "unknown paging central response";
  863. break;
  864.     }
  865. } while (--len);
  866. /*
  867.  * No unprintable characters, just log the string w/o
  868.  * the alarming "Unknown paging central response".
  869.  */
  870. traceIXO("RECV%s: %.*s", extra, buf.getLength(), (const char*) buf);
  871.     }
  872. }
  874. void
  875. pageSendApp::traceIXOCom(const char* dir, const u_char* data, u_int cc)
  876. {
  877.     if (log) {
  878. if ((logTracingLevel& FAXTRACE_IXO) == 0)
  879.     return;
  880.     } else if ((tracingLevel & FAXTRACE_IXO) == 0)
  881. return;
  883.     fxStackBuffer buf;
  884.     for (u_int i = 0; i < cc; i++) {
  885. u_char b = data[i];
  886. if (!isprint(b)) {
  887.     const char* octdigits = "01234567";
  888.     char s[4];
  889.     s[0] = '\';
  890.     s[1] = octdigits[b>>6];
  891.     s[2] = octdigits[(b>>3)&07];
  892.     s[3] = octdigits[b&07];
  893.     buf.put(s, 4);
  894. } else
  895.     buf.put(b);
  896.     }
  897.     traceStatus(FAXTRACE_IXO, "%s <%u:%.*s>",
  898. dir, cc, buf.getLength(), (const char*) buf);
  899. }
  901. void
  902. pageSendApp::traceIXO(const char* fmt ...)
  903. {
  904.     va_list ap;
  905.     va_start(ap, fmt);
  906.     vtraceStatus(FAXTRACE_PROTOCOL, fmt, ap);
  907.     va_end(ap);
  908. }
  910. /*
  911.  * BEGIN UCP Support
  912.  */
  913. void
  914. pageSendApp::sendUcpPage(FaxRequest& req, FaxMachineInfo& info,
  915.     const fxStr& msg, fxStr& notice)
  916. {
  918.     while (req.items.length() > 0) { // messages
  919.         u_int i = req.findItem(FaxRequest::send_page);
  920. if (i == fx_invalidArrayIndex)
  921.     break;
  922. if (req.items[i].item.length() == 0) {
  923.     sendFailed(req, send_failed, "No PIN specified");
  924.     break;
  925. }
  926. if (!sendUcpMsg(req, req.items[i], msg, req.notice, info)) {
  927.     /*
  928.      * On protocol errors retry more quickly
  929.      * (there's no reason to wait is there?).
  930.      */
  931.     if (req.status == send_retry) {
  932.         req.tts = time(0) + requeueProto;
  933. break;
  934.     }
  935. }
  936. req.items.remove(i);
  937.     }
  938. //    if (req.status == send_ok) 
  939. //        (void) pageEpilogue(req, info, notice);
  940. }
  941. // the (simplistic) UCP checksum algorithm
  942. static void
  943. addUcpChecksum(fxStackBuffer& buf)
  944. {
  945.     int sum = 0;
  946.     for (u_int i = 1; i < buf.getLength(); i++)
  947. sum += buf[i];
  948.     sum&=0xff;
  950.     buf.put(fxStr::format("%2.2X",sum&0xff));
  951. }
  953. // Encode the message text in HEX, and perform the character set
  954. // translation while doing so.
  955. // Note that SMS uses a very strange character encoding. The switch
  956. // statement below translates the ISO 8859-1 characters that can
  957. // be mapped to there SMS counterpart, the others to something
  958. // recognizable. The characterset RFC was used as a guideline.
  959. static void
  960. addUcpCodedMsg(fxStackBuffer& buf, const fxStr& msg)
  961. {
  962.     u_int c;
  963.     for (u_int i = 0; i < msg.length(); i++) {
  964. c = msg[i];
  965. switch (c) {
  966. case 0:
  967. case 1:
  968. case 2:
  969. case 3:
  970. case 4:
  971. case 5:
  972. case 6:
  973. case 7:
  974. case 8:
  975. case 9:
  976. case 11:
  977. case 13:
  978. case 14:
  979. case 15:
  980. case 16:
  981. case 17:
  982. case 18:
  983. case 19:
  984. case 20:
  985. case 21:
  986. case 22:
  987. case 23:
  988. case 24:
  989. case 25:
  990. case 26:
  991. case 27:
  992. case 28:
  993. case 29:
  994. case 30:
  995. case 31: break;
  997. case 10: buf.put("0A"); break;
  998. case 12: buf.put("0D"); break;
  999. case 36: buf.put("02"); break;
  1000. case 64: buf.put("00"); break;
  1001. case 91: buf.put("3C28"); break;
  1002. case 92: buf.put("2F2F"); break;
  1003. case 93: buf.put("293E"); break;
  1004. case 94: buf.put("3E"); break;
  1005. case 95: buf.put("11"); break;
  1006. case 96: buf.put("2C21"); break;
  1007. case 123: buf.put("2821"); break;
  1008. case 124: buf.put("2121"); break;
  1009. case 125: buf.put("2129"); break;
  1010. case 126: buf.put("213F"); break;
  1011. case 160: buf.put("20"); break;
  1012. case 161: buf.put("40"); break;
  1013. case 162: buf.put("4374"); break;
  1014. case 163: buf.put("01"); break;
  1015. case 164: buf.put("24"); break;
  1016. case 165: buf.put("03"); break;
  1017. case 166: buf.put("4242"); break;
  1018. case 167: buf.put("5F"); break;
  1019. case 168: buf.put("22"); break;
  1020. case 169: buf.put("436F"); break;
  1021. case 170: buf.put("61"); break;
  1022. case 171: buf.put("3C"); break;
  1023. case 172: buf.put("2D"); break;
  1024. case 173: buf.put("2D"); break;
  1025. case 174: buf.put("52"); break;
  1026. case 175: buf.put("2D"); break;
  1028. case 176: buf.put("4447"); break;
  1029. case 177: buf.put("2B2D"); break;
  1030. case 178: buf.put("2A2A32"); break;
  1031. case 179: buf.put("2A2A33"); break;
  1032. case 180: buf.put("2C"); break;
  1033. case 181: buf.put("6D75"); break;
  1034. case 182: buf.put("5049"); break;
  1035. case 183: buf.put("2E"); break;
  1036. case 184: buf.put("2C"); break;
  1037. case 185: buf.put("2A2A31"); break;
  1038. case 186: buf.put("6F"); break;
  1039. case 187: buf.put("3E"); break;
  1040. case 188: buf.put("312F34"); break;
  1041. case 189: buf.put("312F32"); break;
  1042. case 190: buf.put("332F34"); break;
  1043. case 191: buf.put("60"); break;
  1045. case 192: buf.put("41"); break;
  1046. case 193: buf.put("41"); break;
  1047. case 194: buf.put("41"); break;
  1048. case 195: buf.put("41"); break;
  1049. case 196: buf.put("5B"); break;
  1050. case 197: buf.put("0E"); break;
  1051. case 198: buf.put("1C"); break;
  1052. case 199: buf.put("09"); break;
  1053. case 200: buf.put("45"); break;
  1054. case 201: buf.put("1F"); break;
  1055. case 202: buf.put("45"); break;
  1056. case 203: buf.put("45"); break;
  1057. case 204: buf.put("49"); break;
  1058. case 205: buf.put("49"); break;
  1059. case 206: buf.put("49"); break;
  1060. case 207: buf.put("49"); break;
  1062. case 208: buf.put("442D"); break;
  1063. case 209: buf.put("5D"); break;
  1064. case 210: buf.put("4F"); break;
  1065. case 211: buf.put("4F"); break;
  1066. case 212: buf.put("4F"); break;
  1067. case 213: buf.put("4F"); break;
  1068. case 214: buf.put("4F"); break;
  1069. case 215: buf.put("78"); break;
  1070. case 216: buf.put("0B"); break;
  1071. case 217: buf.put("55"); break;
  1072. case 218: buf.put("55"); break;
  1073. case 219: buf.put("55"); break;
  1074. case 220: buf.put("55"); break;
  1075. case 221: buf.put("59"); break;
  1076. case 222: buf.put("5448"); break;
  1077. case 223: buf.put("1E"); break;
  1079. case 224: buf.put("7F"); break;
  1080. case 225: buf.put("61"); break;
  1081. case 226: buf.put("61"); break;
  1082. case 227: buf.put("61"); break;
  1083. case 228: buf.put("7B"); break;
  1084. case 229: buf.put("0F"); break;
  1085. case 230: buf.put("6165"); break;
  1086. case 231: buf.put("09"); break;
  1087. case 232: buf.put("04"); break;
  1088. case 233: buf.put("05"); break;
  1089. case 234: buf.put("65"); break;
  1090. case 235: buf.put("65"); break;
  1091. case 236: buf.put("07"); break;
  1092. case 237: buf.put("69"); break;
  1093. case 238: buf.put("69"); break;
  1094. case 239: buf.put("69"); break;
  1096. case 240: buf.put("642D"); break;
  1097. case 241: buf.put("7D"); break;
  1098. case 242: buf.put("08"); break;
  1099. case 243: buf.put("6F"); break;
  1100. case 244: buf.put("6F"); break;
  1101. case 245: buf.put("6F"); break;
  1102. case 246: buf.put("7C"); break;
  1103. case 247: buf.put("2F"); break;
  1104. case 248: buf.put("0C"); break;
  1105. case 249: buf.put("06"); break;
  1106. case 250: buf.put("75"); break;
  1107. case 251: buf.put("75"); break;
  1108. case 252: buf.put("7E"); break;
  1109. case 253: buf.put("79"); break;
  1110. case 254: buf.put("7468"); break;
  1111. case 255: buf.put("79"); break;
  1112. default:
  1113. buf.put(fxStr::format("%2.2X",msg[i]&0xff));
  1114. break;
  1115. }
  1116.     }
  1117.     if (msg.length() > 160) {
  1118. msg[320] = '';
  1119.     }
  1120. }
  1122. bool
  1123. pageSendApp::sendUcpMsg(FaxRequest& req, FaxItem& preq, const fxStr& msg, fxStr& emsg, FaxMachineInfo& info)
  1124. {
  1125.     /*
  1126.      * Build page packet:
  1127.      *
  1128.      *    STX trn '/' len '/O/30/' recipient '/' originator '/' password 
  1129.      * '///////' message '/' checksum ETX
  1130.      *
  1131.      * trn a transaction number
  1132.      * len computed at the end, when the character set
  1133.      * translation is complete
  1134.      * recipient who is to receive the message
  1135.      * originator who sent the message, may be different from the
  1136.      * the number of the modem sending the message
  1137.      * password a number, untested
  1138.      * message the hex encoded message (see addUcpCodedMsg)
  1139.      * checksum the UCP checksum
  1140.      *
  1141.      */
  1142.     fxStackBuffer tmp;
  1144.     // first compose the things we know before hand
  1145.     fxStackBuffer buf;
  1147.     buf.put("/O/30/");
  1148.     buf.put(preq.item); // recipient
  1149.     buf.put("/");
  1150.     buf.put(info.getPageSource()); // originator
  1151.     buf.put("/");
  1152.     buf.put(info.getPagerPassword()); // authenticator
  1153.     buf.put("///////");
  1154.     addUcpCodedMsg(buf,msg);
  1155.     buf.put("/");
  1157.     // now we know the length, and we can compute the first field
  1158.     int len = buf.getLength() + 2 /* trn */ + 1 /* slash */ + 5 /* length */
  1159. + 2 /* check sum */;
  1160.     tmp.put(STX);
  1161.     tmp.put("01/");
  1162.     tmp.put(fxStr::format("%5.5d", len));
  1163.     tmp.put(buf, buf.getLength());
  1165.     // know we still have to add the check sum and the trailer
  1166.     addUcpChecksum(tmp);     // append packet checksum
  1167.     tmp.put("x03");
  1169.     buf = tmp;
  1171.     /*
  1172.      * Send the packet to paging central.
  1173.      */
  1174.     traceIXO("SEND message block: [%.*s]", buf.getLength(), (const char*) buf);
  1175.     putModem((const char*) buf, buf.getLength());
  1177.     /*
  1178.      * Process replies, possibly retransmitting the packet.
  1179.      */
  1180.     fxStackBuffer resp; // paging central response
  1181.     u_int ntries = ixoXmitRetries; // up to 3 xmits of message
  1182.     u_int unknown = 0; // count of unknown responses
  1183.     time_t start = Sys::now();
  1184.     do {
  1185. (void) getResponse(resp, ixoXmitTimeout);
  1186. const fxStr str = (const char*)resp;
  1187. //readUcpResponse(str);
  1188. fxStr tmp;
  1189. u_int pos=1,pos2;
  1190. while(pos<str.length()) {
  1191.     tmp=str.token(pos,"03");
  1193.     // Verify checksum
  1194.     int sum = 0;
  1195.     for (u_int i = 0; i < tmp.length()-2; i++)
  1196.           sum += tmp[i];
  1197.     sum&=0xff;
  1198.     pos2=tmp.length();
  1199.     fxStr CSum=tmp.tokenR(pos2,"/");
  1201.     pos2=0;
  1202.     fxStr TRN=tmp.token(pos2,"/");
  1203.     fxStr LEN=tmp.token(pos2,"/");
  1204.     fxStr OR=tmp.token(pos2,"/");
  1205.     fxStr OT=tmp.token(pos2,"/");
  1206.     if(OR=="R") {  // Response
  1207.         if(OT=="30") { 
  1208.     fxStr  N_ACK=tmp.token(pos2,"/");
  1209.     switch( N_ACK[0]) { 
  1210.     case 'A':  // positive result (ACK)
  1211.         traceIXO("RECV ACK (message block accepted)");
  1212. return(true);
  1213.     case 'N': // Negative result (NACK)
  1214.         traceIXO("RECV NACK (message block rejected)");
  1215.         if(--ntries==0) {
  1216.     req.status = send_retry;
  1217.     emsg="Message block not acknowledged by paging central"
  1218.       "after multiple tries";
  1219.     return(false);
  1220. }
  1221. traceIXO("SEND message block (retransmit)");
  1222. putModem((const char*) buf, buf.getLength());
  1223. start = Sys::now(); // restart timer
  1224. unknown = 0; // reset unknown response count
  1225.     }
  1226. }
  1227.     }
  1228. }
  1229.     } while ((unsigned)Sys::now()-start < ixoXmitTimeout && unknown < ixoMaxUnknown);
  1230.     return false;
  1231. }
  1233. /*
  1234.  * END UCP Support
  1235.  */
  1237. bool
  1238. pageSendApp::putModem(const void* data, int n, long ms)
  1239. {
  1240.     traceIXOCom("<--",  (const u_char*) data, n);
  1241.     return (putModem1(data, n, ms));
  1242. }
  1244. time_t pageSendApp::getConnectTime() const { return (connTime); }
  1246. /*
  1247.  * Configuration support.
  1248.  */
  1250. void
  1251. pageSendApp::resetConfig()
  1252. {
  1253.     ModemServer::resetConfig();
  1254.     setupConfig();
  1255. }
  1257. #define N(a) (sizeof (a) / sizeof (a[0]))
  1259. pageSendApp::stringtag pageSendApp::strings[] = {
  1260. { "ixoservice", &pageSendApp::ixoService, IXO_SERVICE },
  1261. { "ixodeviceid", &pageSendApp::ixoDeviceID, IXO_DEVICEID },
  1262. { "pagerttyparity", &pageSendApp::pagerTTYParity, "even" },
  1263. };
  1264. pageSendApp::stringtag pageSendApp::atcmds[] = {
  1265. { "pagersetupcmds", &pageSendApp::pagerSetupCmds },
  1266. };
  1267. pageSendApp::numbertag pageSendApp::numbers[] = {
  1268. { "pagermaxmsglength", &pageSendApp::pagerMaxMsgLength,128 },
  1269. { "ixomaxunknown", &pageSendApp::ixoMaxUnknown, IXO_MAXUNKNOWN },
  1270. { "ixoidprobe", &pageSendApp::ixoIDProbe, IXO_IDPROBE },
  1271. { "ixoidtimeout", &pageSendApp::ixoIDTimeout, IXO_IDTIMEOUT },
  1272. { "ixologinretries", &pageSendApp::ixoLoginRetries, IXO_LOGINRETRIES },
  1273. { "ixologintimeout", &pageSendApp::ixoLoginTimeout, IXO_LOGINTIMEOUT },
  1274. { "ixogatimeout", &pageSendApp::ixoGATimeout, IXO_GATIMEOUT },
  1275. { "ixoxmitretries", &pageSendApp::ixoXmitRetries, IXO_XMITRETRIES },
  1276. { "ixoxmittimeout", &pageSendApp::ixoXmitTimeout, IXO_XMITTIMEOUT },
  1277. { "ixoacktimeout", &pageSendApp::ixoAckTimeout, IXO_ACKTIMEOUT },
  1278. };
  1280. void
  1281. pageSendApp::setupConfig()
  1282. {
  1283.     int i;
  1284.     for (i = N(strings)-1; i >= 0; i--)
  1285. (*this).*strings[i].p = (strings[i].def ? strings[i].def : "");
  1286.     for (i = N(atcmds)-1; i >= 0; i--)
  1287. (*this).*atcmds[i].p = (atcmds[i].def ? atcmds[i].def : "");
  1288.     for (i = N(numbers)-1; i >= 0; i--)
  1289. (*this).*numbers[i].p = numbers[i].def;
  1290. }
  1292. bool
  1293. pageSendApp::setConfigItem(const char* tag, const char* value)
  1294. {
  1295.     u_int ix;
  1296.     if (findTag(tag, (const tags*)atcmds, N(atcmds), ix)) {
  1297. (*this).*atcmds[ix].p = parseATCmd(value);
  1298.     } else if (findTag(tag, (const tags*) strings, N(strings), ix)) {
  1299. (*this).*strings[ix].p = value;
  1300.     } else if (findTag(tag, (const tags*)numbers, N(numbers), ix)) {
  1301. (*this).*numbers[ix].p = getNumber(value);
  1302.     } else
  1303. return (ModemServer::setConfigItem(tag, value));
  1304.     return (true);
  1305. }
  1306. #undef N
  1308. u_int
  1309. pageSendApp::getConfigParity(const char* value) const
  1310. {
  1311.     if (streq(value, "even"))
  1312. return (EVEN);
  1313.     else if (streq(value, "odd"))
  1314. return (ODD);
  1315.     else if (streq(value, "none"))
  1316. return (NONE);
  1317.     else {
  1318. logError("Unknown pager tty parity %s ignored; using EVEN", value);
  1319. return (EVEN); // per IXO/TAP spec
  1320.     }
  1321. }
  1323. /*
  1324.  * Modem and TTY setup
  1325.  */
  1326. bool 
  1327. pageSendApp::setupModem(bool isSend)
  1328. {
  1329.     return (ModemServer::setupModem(isSend) &&
  1330. setParity((Parity) getConfigParity(pagerTTYParity)));
  1331. }
  1333. /*
  1334.  * Modem locking support.
  1335.  */
  1337. bool
  1338. pageSendApp::canLockModem()
  1339. {
  1340.     return (modemLock ? modemLock->check() : true);
  1341. }
  1343. bool
  1344. pageSendApp::lockModem()
  1345. {
  1346.     return (modemLock ? modemLock->lock() : true);
  1347. }
  1349. void
  1350. pageSendApp::unlockModem()
  1351. {
  1352.     if (modemLock)
  1353. modemLock->unlock();
  1354. }
  1356. /*
  1357.  * Notification handlers.
  1358.  */
  1360. /*
  1361.  * Handle notification that the modem device has become
  1362.  * available again after a period of being unavailable.
  1363.  */
  1364. void
  1365. pageSendApp::notifyModemReady()
  1366. {
  1367.     ready = true;
  1368. }
  1370. /*
  1371.  * Handle notification that the modem device looks to
  1372.  * be in a state that requires operator intervention.
  1373.  */
  1374. void
  1375. pageSendApp::notifyModemWedged()
  1376. {
  1377.     if (!sendModemStatus(getModemDeviceID(), "W"))
  1378. logError("MODEM %s appears to be wedged",
  1379.     (const char*) getModemDevice());
  1380.     close();
  1381. }
  1383. /*
  1384.  * Miscellaneous stuff.
  1385.  */
  1387. static void
  1388. usage(const char* appName)
  1389. {
  1390.     faxApp::fatal("usage: %s -m deviceID [-t tracelevel] [-l] qfile ...",
  1391. appName);
  1392. }
  1394. static void
  1395. sigCleanup(int s)
  1396. {
  1397.     int old_errno = errno;
  1398.     signal(s, fxSIGHANDLER(sigCleanup));
  1399.     logError("CAUGHT SIGNAL %d", s);
  1400.     pageSendApp::instance().close();
  1401.     if (!pageSendApp::instance().isRunning())
  1402. _exit(send_failed);
  1403.     errno = old_errno;
  1404. }
  1406. int
  1407. main(int argc, char** argv)
  1408. {
  1409.     faxApp::setupLogging("PageSend");
  1411.     fxStr appName = argv[0];
  1412.     u_int l = appName.length();
  1413.     appName = appName.tokenR(l, '/');
  1415.     faxApp::setOpts("c:m:l");
  1417.     fxStr devID;
  1418.     for (GetoptIter iter(argc, argv, faxApp::getOpts()); iter.notDone(); iter++)
  1419. switch (iter.option()) {
  1420. case 'm': devID = iter.optArg(); break;
  1421. case '?': usage(appName);
  1422. }
  1423.     if (devID == "")
  1424. usage(appName);
  1426.     pageSendApp* app = new pageSendApp(faxApp::idToDev(devID), devID);
  1428.     signal(SIGTERM, fxSIGHANDLER(sigCleanup));
  1429.     signal(SIGINT, fxSIGHANDLER(sigCleanup));
  1431.     app->initialize(argc, argv);
  1432.     app->open();
  1433.     while (app->isRunning() && !app->isReady())
  1434. Dispatcher::instance().dispatch();
  1435.     FaxSendStatus status;
  1436.     if (app->isReady())
  1437. status = app->send((const char**)&argv[optind], argc - optind);
  1438.     else
  1439. status = send_retry;
  1440.     app->close();
  1441.     return (status);
  1442. }