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

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

传真(Fax)编程

开发平台：

C/C++

ModemServer.c++：源码内容
  1. /* $Id: ModemServer.c++,v 1.13 2008/07/26 17:57:09 faxguy Exp $ */
  2. /*
  3.  * Copyright (c) 1990-1996 Sam Leffler
  4.  * Copyright (c) 1991-1996 Silicon Graphics, Inc.
  5.  * HylaFAX is a trademark of Silicon Graphics
  6.  *
  7.  * Permission to use, copy, modify, distribute, and sell this software and 
  8.  * its documentation for any purpose is hereby granted without fee, provided
  9.  * that (i) the above copyright notices and this permission notice appear in
  10.  * all copies of the software and related documentation, and (ii) the names of
  11.  * Sam Leffler and Silicon Graphics may not be used in any advertising or
  12.  * publicity relating to the software without the specific, prior written
  13.  * permission of Sam Leffler and Silicon Graphics.
  14.  * 
  15.  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
  16.  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
  17.  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
  18.  * 
  19.  * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
  20.  * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
  21.  * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  22.  * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
  23.  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
  24.  * OF THIS SOFTWARE.
  25.  */
  26. #include "Sys.h"
  28. #include <ctype.h>
  29. #include <termios.h>
  30. #include <errno.h>
  31. #include <sys/param.h>
  32. #include <sys/time.h>
  33. #if HAS_MODEM_H
  34. #include <sys/modem.h>
  35. #else
  36. #include <sys/ioctl.h>
  37. #endif
  38. #if HAS_TERMIOX
  39. #include <sys/termiox.h>
  40. #endif
  41. #include <sys/file.h>
  43. #include "Dispatcher.h"
  44. #include "FaxTrace.h"
  45. #include "FaxMachineLog.h"
  46. #include "ModemServer.h"
  47. #include "UUCPLock.h"
  48. #include "Class0.h"
  50. #include "config.h"
  52. #ifndef O_NOCTTY
  53. #define O_NOCTTY 0 // no POSIX O_NOCTTY support
  54. #endif
  56. /*
  57.  * HylaFAX Modem Server.
  58.  */
  60. // map ClassModem::BaudRate to numeric value
  61. static const u_int baudRates[] = {
  62.     0, // BR0
  63.     300, // BR300
  64.     1200, // BR1200
  65.     2400, // BR2400
  66.     4800, // BR4800
  67.     9600, // BR9600
  68.     19200, // BR19200
  69.     38400, // BR38400
  70.     57600, // BR57600
  71.     76800, // BR76800
  72.     115200, // BR115200
  73. };
  75. ModemServer::ModemServer(const fxStr& devName, const fxStr& devID)
  76.     : modemDevice(devName)
  77.     , modemDevID(devID)
  78.     , configFile(fxStr(FAX_CONFIG) | "." | devID)
  79. {
  80.     state = BASE;
  81.     statusFile = NULL;
  82.     abortCall = false;
  83.     deduceComplain = true; // first failure causes complaint
  84.     changePriority = true;
  85.     delayConfig = false;
  86.     inputBuffered = true; // OSes buffer by default
  88.     modemFd = -1;
  89.     modem = NULL;
  90.     curRate = ClassModem::BR0; // unspecified baud rate
  91.     curParity = NONE; // default is 8-bit/no parity
  92.     curVMin = 127; // buffer input by default
  93.     curVTime = 1; // ditto
  94.     setupAttempts = 0;
  96.     rcvCC = rcvNext = rcvBit = gotByte = 0;
  97.     sawBlockEnd = false;
  98.     timeout = false;
  99.     log = NULL;
  100.     readyStateMsg = NULL;
  101. }
  103. ModemServer::~ModemServer()
  104. {
  105.     delete log;
  106.     delete modem;
  107.     if (statusFile)
  108. fclose(statusFile);
  109. }
  111. #include "faxApp.h"
  112. /*
  113.  * Initialize the server from command line arguments.
  114.  */
  115. void
  116. ModemServer::initialize(int argc, char** argv)
  117. {
  118.     for (GetoptIter iter(argc, argv, faxApp::getOpts()); iter.notDone(); iter++)
  119. switch (iter.option()) {
  120. case 'p':
  121.     changePriority = false;
  122.     break;
  123. case 'x':
  124.     tracingMask &= ~(FAXTRACE_MODEMIO|FAXTRACE_TIMEOUTS);
  125.     break;
  126. }
  127.     TIFFSetErrorHandler(NULL);
  128.     TIFFSetWarningHandler(NULL);
  129.     // setup server's status file
  130.     statusFile = Sys::fopen(FAX_STATUSDIR "/" | modemDevID, "w");
  131.     if (statusFile != NULL) {
  132. #if HAS_FCHMOD
  133. fchmod(fileno(statusFile), 0644);
  134. #else
  135. Sys::chmod(FAX_STATUSDIR "/" | modemDevID, 0644);
  136. #endif
  137. setServerStatus("Initializing server");
  138.     }
  139.     umask(077); // keep all temp files private
  141.     updateConfig(configFile); // read config file
  142. }
  144. /*
  145.  * Startup the server for the first time.
  146.  */
  147. void
  148. ModemServer::open()
  149. {
  150.     if (lockModem()) {
  151. bool modemReady = setupModem();
  152. unlockModem();
  153. if (!modemReady)
  154.     changeState(MODEMWAIT, pollModemWait);
  155. else
  156.     changeState(RUNNING, pollLockWait);
  157.     } else {
  158. traceServer("%s: Can not lock device.", (const char*) modemDevice);
  159. changeState(LOCKWAIT, pollLockWait);
  160.     }
  161. }
  163. /*
  164.  * Close down the server.
  165.  */
  166. void
  167. ModemServer::close()
  168. {
  169.     if (lockModem()) {
  170. if (modem)
  171.     modem->hangup();
  172. discardModem(true);
  173. unlockModem();
  174.     }
  175. }
  177. const char* ModemServer::stateNames[9] = {
  178.     "BASE",
  179.     "RUNNING",
  180.     "MODEMWAIT",
  181.     "LOCKWAIT",
  182.     "GETTYWAIT",
  183.     "SENDING",
  184.     "ANSWERING",
  185.     "RECEIVING",
  186.     "LISTENING"
  187. };
  188. const char* ModemServer::stateStatus[9] = {
  189.     "Initializing server and modem", // BASE
  190.     "Running and idle", // RUNNING
  191.     "Waiting for modem to come ready", // MODEMWAIT
  192.     "Waiting for modem to come free", // LOCKWAIT
  193.     "Waiting for login session to terminate", // GETTYWAIT
  194.     "Sending facsimile", // SENDING
  195.     "Answering the phone", // ANSWERING
  196.     "Receiving facsimile", // RECEIVING
  197.     "Listening to rings from modem", // LISTENING
  198. };
  200. /*
  201.  * Change the server's state and, optionally,
  202.  * start a timer running for timeout seconds.
  203.  */
  204. void
  205. ModemServer::changeState(ModemServerState s, long timeout, const char* msg)
  206. {
  207.     if (s != state) {
  208. if (timeout)
  209.     traceStatus(FAXTRACE_STATETRANS,
  210. "STATE CHANGE: %s -> %s (timeout %ld)",
  211. stateNames[state], stateNames[s], timeout);
  212. else
  213.     traceStatus(FAXTRACE_STATETRANS, "STATE CHANGE: %s -> %s",
  214. stateNames[state], stateNames[s]);
  215. state = s;
  216. if (changePriority)
  217.     setProcessPriority(state);
  218. if (modemFd >= 0)
  219.     setInputBuffering(state != RUNNING && state != SENDING &&
  220. state != ANSWERING && state != RECEIVING && state != LISTENING);
  221. if (state == RUNNING) {
  222.     fxStr statusmsg = msg ? fxStr(msg) : fxStr(stateStatus[state]);
  223.     if (readyStateMsg) statusmsg.append(readyStateMsg);
  224.     setServerStatus(statusmsg);
  225. } else {
  226.     setServerStatus(msg ? msg : stateStatus[state]);
  227. }
  228. switch (state) {
  229. case RUNNING:
  230.     notifyModemReady(); // notify surrogate
  231.     break;
  232. case MODEMWAIT:
  233.     setupAttempts = 0;
  234.     break;
  235. default:
  236.     break;
  237. }
  238.     } else if (s == MODEMWAIT && ++setupAttempts >= maxSetupAttempts) {
  239. traceStatus(FAXTRACE_SERVER,
  240.     "Unable to setup modem on %s; giving up after %d attempts",
  241.     (const char*) modemDevice, setupAttempts);
  242. notifyModemWedged();
  243.     }
  244.     /*
  245.      * Before we start any timer, make sure we stop the current one
  246.      */
  247.     Dispatcher::instance().stopTimer(this);
  249.     if (timeout)
  250. Dispatcher::instance().startTimer(timeout, 0, this);
  251. }
  253. #if HAS_SCHEDCTL
  254. #include <sys/schedctl.h>
  255. /*
  256.  * When low latency is required, use a nondegrading process
  257.  * priority; otherwise just remove any nondegrading priority.
  258.  * Note that we assign a high nondegrading priority when sending,
  259.  * answering the telephone, or receiving.  We assume that if the
  260.  * incoming call spawns a getty process that the priority will
  261.  * be reset in the child before the getty is exec'd.
  262.  */
  263. static const int schedCtlParams[9][2] = {
  264.     { NDPRI, 0 }, // BASE
  265.     { NDPRI, 0 }, // RUNNING
  266.     { NDPRI, 0 }, // MODEMWAIT
  267.     { NDPRI, 0 }, // LOCKWAIT
  268.     { NDPRI, 0 }, // GETTYWAIT
  269.     { NDPRI, NDPHIMIN }, // SENDING
  270.     { NDPRI, NDPHIMIN }, // ANSWERING
  271.     { NDPRI, NDPHIMIN }, // RECEIVING
  272.     { NDPRI, 0 }, // LISTENING
  273. };
  274. #elif HAS_PRIOCNTL
  275. extern "C" {
  276. #include <sys/priocntl.h>
  277. #ifdef HAS_FPPRIOCNTL
  278. #include <sys/fppriocntl.h>
  279. #else
  280. #include <sys/rtpriocntl.h>
  281. #endif
  282. #include <sys/tspriocntl.h>
  283. }
  284. static struct SchedInfo {
  285.     const char* clname; // scheduling class name
  286.     int params[3]; // scheduling class parameters
  287. } schedInfo[9] = {
  288.     { "TS", { TS_NOCHANGE, TS_NOCHANGE } }, // BASE
  289.     { "TS", { TS_NOCHANGE, TS_NOCHANGE } }, // RUNNING
  290.     { "TS", { TS_NOCHANGE, TS_NOCHANGE } }, // MODEMWAIT
  291.     { "TS", { TS_NOCHANGE, TS_NOCHANGE } }, // LOCKWAIT
  292.     { "TS", { TS_NOCHANGE, TS_NOCHANGE } }, // GETTYWAIT
  293. #ifdef HAS_FPPRIOCNTL // if still fails, set prio to 0
  294.     { "FP", { FP_NOCHANGE, FP_NOCHANGE, FP_TQDEF } },// SENDING
  295.     { "FP", { FP_NOCHANGE, FP_NOCHANGE, FP_TQDEF } },// ANSWERING
  296.     { "FP", { FP_NOCHANGE, FP_NOCHANGE, FP_TQDEF } },// RECEIVING
  297. #else
  298.     { "RT", { RT_NOCHANGE, RT_NOCHANGE, RT_NOCHANGE } },// SENDING
  299.     { "RT", { RT_NOCHANGE, RT_NOCHANGE, RT_NOCHANGE } },// ANSWERING
  300.     { "RT", { RT_NOCHANGE, RT_NOCHANGE, RT_NOCHANGE } },// RECEIVING
  301. #endif
  302.     { "TS", { TS_NOCHANGE, TS_NOCHANGE } }, // LISTENING
  303. };
  304. #elif HAS_RTPRIO
  305. /*
  306.  * On HP-UX, a real-time priority is between 0 (high)
  307.  * and 127 (low);  for now we use 120.
  308.  */
  309. #include <sys/rtprio.h>
  310. #ifndef RTPRIO_HIGH
  311. #define RTPRIO_HIGH 120
  312. #endif
  314. static const int rtprioParams[9] = {
  315.     RTPRIO_RTOFF, // BASE
  316.     RTPRIO_RTOFF, // RUNNING
  317.     RTPRIO_RTOFF, // MODEMWAIT
  318.     RTPRIO_RTOFF, // LOCKWAIT
  319.     RTPRIO_RTOFF, // GETTYWAIT
  320.     RTPRIO_HIGH, // SENDING
  321.     RTPRIO_HIGH, // ANSWERING
  322.     RTPRIO_HIGH, // RECEIVING
  323.     RTPRIO_RTOFF, // LISTENING
  324. };
  325. #elif HAS_POSIXSCHED
  326. /*
  327.  * In POSIX (i.e. Linux), a real time priority is
  328.  * between 1 (low) and 99 (high);
  329.  * for now we conservatively use 1.  Priority of 0 
  330.  * is without real-time application.
  331.  */
  332. #include <sched.h>
  333. static const struct SchedInfo {
  334.     int policy;
  335.     int priority;
  336. } sched_setschedulerParams[9] = {
  337.     {SCHED_OTHER, 0}, // BASE
  338.     {SCHED_OTHER, 0}, // RUNNING
  339.     {SCHED_OTHER, 0}, // MODEMWAIT
  340.     {SCHED_OTHER, 0}, // LOCKWAIT
  341.     {SCHED_OTHER, 0}, // GETTYWAIT
  342.     {SCHED_FIFO, RT_PRIORITY}, // SENDING
  343.     {SCHED_FIFO, RT_PRIORITY}, // ANSWERING
  344.     {SCHED_FIFO, RT_PRIORITY}, // RECEIVING
  345.     {SCHED_OTHER, 0}, // LISTENING
  346. };
  348. #endif
  350. void
  351. ModemServer::setProcessPriority(ModemServerState s)
  352. {
  353.     if (priorityScheduling) {
  354. #if HAS_SCHEDCTL
  355.     uid_t euid = geteuid();
  356.     if (seteuid(0) >= 0) { // must be done as root
  357. if (schedctl(schedCtlParams[s][0], 0, schedCtlParams[s][1]) < 0)
  358.     traceServer("schedctl: %m");
  359. if (seteuid(euid) < 0) // restore previous effective uid
  360.     traceServer("seteuid(%d): %m", euid);
  361.     } else
  362. traceServer("seteuid(root): %m");
  363. #elif HAS_PRIOCNTL
  364.     uid_t euid = geteuid();
  365.     if (seteuid(0) >= 0) { // must be done as root
  366. const SchedInfo& si = schedInfo[s];
  367. pcinfo_t pcinfo;
  368. strcpy(pcinfo.pc_clname, si.clname);
  369. if (priocntl((idtype_t)0, 0, PC_GETCID, (caddr_t)&pcinfo) >= 0) {
  370.     pcparms_t pcparms;
  371.     pcparms.pc_cid = pcinfo.pc_cid;
  372. #ifdef HAS_FPPRIOCNTL
  373.     if (streq(si.clname, "FP")) {
  374. fpparms_t* fpp = (fpparms_t*) pcparms.pc_clparms;
  375. fpp->fp_pri = si.params[0];
  376. fpp->fp_tqsecs = (ulong) si.params[1];
  377. fpp->fp_tqnsecs = si.params[2];
  378. #else
  379.     if (streq(si.clname, "RT")) {
  380. rtparms_t* rtp = (rtparms_t*) pcparms.pc_clparms;
  381. rtp->rt_pri = si.params[0];
  382. rtp->rt_tqsecs = (ulong) si.params[1];
  383. rtp->rt_tqnsecs = si.params[2];
  384. #endif
  385.     } else {
  386. tsparms_t* tsp = (tsparms_t*) pcparms.pc_clparms;
  387. tsp->ts_uprilim = si.params[0];
  388. tsp->ts_upri = si.params[1];
  389.     }
  390.     if (priocntl(P_PID, P_MYID, PC_SETPARMS, (caddr_t)&pcparms) < 0)
  391. traceServer("Unable to set %s scheduling parameters: %m",
  392.     si.clname);
  393. } else
  394.     traceServer("priocntl(%s): %m", si.clname);
  395. if (seteuid(euid) < 0) // restore previous effective uid
  396.     traceServer("setreuid(%d): %m", euid);
  397.     } else
  398. traceServer("setreuid(root): %m");
  399. #elif HAS_RTPRIO
  400.     uid_t euid = geteuid();
  401.     if (seteuid(0) >= 0) { // must be done as root
  402.         if(rtprio((pid_t) 0, rtprioParams[s]) < 0)
  403.            traceServer("rtprio: %m");
  404. if (seteuid(euid) < 0) // restore previous effective uid
  405.     traceServer("seteuid(%d): %m", euid);
  406.     } else
  407. traceServer("seteuid(root): %m");
  408. #elif HAS_POSIXSCHED
  409.     uid_t euid = geteuid();
  410.     if (seteuid(0) >= 0) { // must be done as root
  411. struct sched_param sp;
  412. sp.sched_priority = sched_setschedulerParams[s].priority;
  413. if (sched_setscheduler(0, sched_setschedulerParams[s].policy, &sp))
  414.     traceServer("sched_setscheduler: %m");
  415. if (sched_getparam(0, &sp))
  416.     traceServer("sched_getparam: %m");
  417. traceServer("sched policy=%d, priority=%d", sched_getscheduler(0), sp.sched_priority);
  418. if (seteuid(euid) < 0) // restore previous effective uid
  419.     traceServer("seteuid(%d): %m", euid);
  420.     } else
  421. traceServer("seteuid(root): %m");
  422. #endif
  423.     }
  424. }
  426. /*
  427.  * Record the server status in the status file.
  428.  */
  429. void
  430. ModemServer::setServerStatus(const char* fmt, ...)
  431. {
  432.     if (statusFile == NULL)
  433. return;
  434.     flock(fileno(statusFile), LOCK_EX);
  435.     rewind(statusFile);
  436.     va_list ap;
  437.     va_start(ap, fmt);
  438.     vfprintf(statusFile, fmt, ap);
  439.     va_end(ap);
  440.     fprintf(statusFile, "n");
  441.     fflush(statusFile);
  442.     int ignore = ftruncate(fileno(statusFile), ftell(statusFile));
  443.     flock(fileno(statusFile), LOCK_UN);
  444. }
  446. void
  447. ModemServer::resetConfig()
  448. {
  449.     if (modem)
  450. discardModem(true);
  451.     ServerConfig::resetConfig();
  452. }
  454. const fxStr& ModemServer::getConfigFile() const { return configFile; }
  456. /*
  457.  * Setup the modem; if needed.
  458.  */
  459. bool
  460. ModemServer::setupModem(bool isSend)
  461. {
  462.     if (!modem) {
  463. const char* dev = modemDevice;
  464. if (!openDevice(dev))
  465.     return (false);
  466. /*
  467.  * Deduce modem type and setup configuration info.
  468.  * The deduceComplain cruft is just to reduce the
  469.  * noise in the log file when probing for a modem.
  470.  */
  471. modem = deduceModem(isSend);
  472. if (!modem) {
  473.     discardModem(true);
  474.     if (deduceComplain) {
  475. traceServer("%s: Can not initialize modem.", dev);
  476. deduceComplain = false;
  477.     }
  478.     return (false);
  479. } else {
  480.     deduceComplain = true;
  481.     traceServer("MODEM "
  482. | modem->getManufacturer() | " "
  483. | modem->getModel() | "/"
  484. | modem->getRevision());
  485. }
  486.     } else {
  487. /*
  488.  * Reset the modem in case some other program
  489.  * went in and messed with the configuration.
  490.  *
  491.  * Sometimes a modem may get interrupted while in a
  492.  * "transmit" state such as AT+VTX (voice mode) or
  493.  * AT+FTM=146 (fax mode) or similar.  Now, the modem
  494.  * should be smart enough to return to command-mode
  495.  * after a short period of inactivity, but it's
  496.  * conceivable that some don't (and we've seen some
  497.  * that are this way).  Furthermore, it is likely
  498.  * possible to configure a modem in such a way so as
  499.  * to never provide for that short period of inactivity.
  500.  * Further complicating matters, some modems are not
  501.  * sensitive to DTR.
  502.  *
  503.  * So if our first reset attempt fails we send DLE+ETX 
  504.  * to the modem just in case we happen to have a modem 
  505.  * in this kind of state, waiting for DLE+ETX before 
  506.  * returning to command mode.  Then we retry the reset.
  507.  */
  508.         if (!(modem->reset())) {
  509.     sendDLEETX();
  510.     if (!(modem->reset()))
  511. return (false);
  512. }
  513.     }
  514.     /*
  515.      * Most modem-related parameters are dealt with
  516.      * in the modem driver.  The speaker volume is
  517.      * kept in the fax server because it often gets
  518.      * changed on the fly.  The phone number has no
  519.      * business in the modem class.
  520.      */
  521.     modem->setSpeakerVolume(speakerVolume);
  522.     return (true);
  523. }
  525. /*
  526.  * Ready the modem; if needed.
  527.  */
  528. bool
  529. ModemServer::readyModem()
  530. {
  531.     return (modem->ready());
  532. }
  534. /*
  535.  * Deduce the type of modem supplied to the server
  536.  * and return an instance of the appropriate modem
  537.  * driver class.
  538.  */
  539. ClassModem*
  540. ModemServer::deduceModem(bool isSend)
  541. {
  542.     ClassModem* modem = new Class0Modem(*this, *this);
  543.     if (modem) {
  544. if (modem->setupModem(isSend))
  545.     return modem;
  546. delete modem;
  547.     }
  548.     return (NULL);
  549. }
  551. fxStr
  552. ModemServer::getModemCapabilities() const
  553. {
  554.     return modem->getCapabilities();
  555. }
  557. /*
  558.  * Open the tty device associated with the modem
  559.  * and change the device file to be owned by us
  560.  * and with a protected file mode.
  561.  */
  562. bool
  563. ModemServer::openDevice(const char* dev)
  564. {
  565.     /*
  566.      * Temporarily become root to open the device.
  567.      * Routines that call setupModem *must* first
  568.      * lock the device with the usual effective uid.
  569.      */
  570.     uid_t euid = geteuid();
  571.     if (seteuid(0) < 0) {
  572.  traceServer("%s: seteuid root failed (%m)", dev);
  573.  return (false);
  574.     }
  575. #ifdef O_NDELAY
  576.     /*
  577.      * Open device w/ O_NDELAY to bypass modem
  578.      * control signals, then turn off the flag bit.
  579.      */
  580.     modemFd = Sys::open(dev, O_RDWR|O_NDELAY|O_NOCTTY);
  581.     if (modemFd < 0) {
  582. seteuid(euid);
  583. traceServer("%s: Can not open modem (%m)", dev);
  584. return (false);
  585.     }
  587.     /*
  588.      * Wait a second for "slower" modems
  589.      * such as the Nokia 6210 mobile.
  590.      */
  591.     (void) sleep(1);
  593.     int flags = fcntl(modemFd, F_GETFL, 0);
  594.     if (fcntl(modemFd, F_SETFL, flags &~ O_NDELAY) < 0) {
  595.  traceServer("%s: fcntl: %m", dev);
  596.  Sys::close(modemFd), modemFd = -1;
  597.  return (false);
  598.     }
  599. #else
  600.     startTimeout(3*1000);
  601.     modemFd = Sys::open(dev, O_RDWR);
  602.     stopTimeout("opening modem");
  603.     if (modemFd < 0) {
  604. seteuid(euid);
  605. traceServer((timeout ?
  606. "%s: Can not open modem (timed out)." :
  607. "%s: Can not open modem (%m)."),
  608.     dev, errno);
  609. return (false);
  610.     }
  611. #endif
  612.     /*
  613.      * NB: we stat and use the gid because passing -1
  614.      *     through the gid_t parameter in the prototype
  615.      *    causes it to get truncated to 65535.
  616.      */
  617.     struct stat sb;
  618.     (void) Sys::fstat(modemFd, sb);
  619. #if HAS_FCHOWN
  620.     if (fchown(modemFd, UUCPLock::getUUCPUid(), sb.st_gid) < 0)
  621. #else
  622.     if (Sys::chown(dev, UUCPLock::getUUCPUid(), sb.st_gid) < 0)
  623. #endif
  624. traceServer("%s: chown: %m", dev);
  625. #if HAS_FCHMOD
  626.     if (fchmod(modemFd, deviceMode) < 0)
  627. #else
  628.     if (Sys::chmod(dev, deviceMode) < 0)
  629. #endif
  630. traceServer("%s: chmod: %m", dev);
  631.     seteuid(euid);
  632.     return (true);
  633. }
  635. bool
  636. ModemServer::reopenDevice()
  637. {
  638.     if (modemFd >= 0)
  639. Sys::close(modemFd), modemFd = -1;
  640.     return openDevice(modemDevice);
  641. }
  643. /*
  644.  * Discard any handle on the modem.
  645.  */
  646. void
  647. ModemServer::discardModem(bool dropDTR)
  648. {
  649.     if (modemFd >= 0) {
  650. if (dropDTR)
  651.     (void) setDTR(false); // force hangup
  652. Sys::close(modemFd), modemFd = -1; // discard open file
  653. #ifdef sco5
  654. // do it again so DTR is really off (SCO Open Server 5 wierdness)
  655. modemFd = Sys::open(modemDevice, O_RDWR|O_NDELAY|O_NOCTTY);
  656. Sys::close(modemFd), modemFd = -1;
  657. #endif
  658.     }
  659.     delete modem, modem = NULL;
  660. }
  662. /*
  663.  * Start a session: a period of time during which
  664.  * carrier is raised and a peer is engaged.
  665.  */
  666. void
  667. ModemServer::beginSession(const fxStr& number)
  668. {
  669.     /*
  670.      * Obtain the next communication identifier by reading
  671.      * and updating the sequence number file.  If a problem
  672.      * occurs then session logging will not be done.
  673.      */
  674.     fxStr emsg;
  675.     u_long seqnum = Sequence::getNext(FAX_LOGDIR "/" FAX_SEQF, emsg);
  677.     if (seqnum == (u_long)-1)
  678.     {
  679. logError("Couldn't get next seqnum for session log: %s",
  680.  (const char*)emsg);
  681. return;
  682.     }
  683.     commid = fxStr::format(Sequence::format, seqnum);
  684.     fxStr file = FAX_LOGDIR "/c" | commid;
  686.     mode_t omask = umask(022);
  687.     int ftmp = Sys::open(file, O_RDWR|O_CREAT|O_EXCL, logMode);
  688.     umask(omask);
  690.     if (ftmp < 0)
  691.     {
  692. logError("Failed to open free sessionlog (seqnum=%u)", seqnum);
  693.     } else
  694.     {
  695. log =
  696.     new FaxMachineLog(ftmp, canonicalizePhoneNumber(number), commid);
  697.     }
  698. }
  700. /*
  701.  * Terminate a session.
  702.  */
  703. void
  704. ModemServer::endSession()
  705. {
  706.     delete log, log = NULL;
  707. }
  709. /*
  710.  * Return true if a request has been made to abort
  711.  * the current session.  This is true if a previous
  712.  * abort request was made or if an external abort
  713.  * message is dispatched during our processing.
  714.  */
  715. bool
  716. ModemServer::abortRequested()
  717. {
  718. #ifndef SERVERABORTBUG
  719.     if (!abortCall) {
  720. // poll for input so abort commands get processed
  721. long sec = 0;
  722. long usec = 0;
  723. while (Dispatcher::instance().dispatch(sec,usec) && !abortCall)
  724.     ;
  725.     }
  726. #endif
  727.     return (abortCall);
  728. }
  730. /*
  731.  * Request that a current session be aborted.
  732.  */
  733. void
  734. ModemServer::abortSession()
  735. {
  736.     abortCall = true;
  737.     traceServer("ABORT: job abort requested");
  738. }
  740. /*
  741.  * Dispatcher timer expired routine.  Perform the action
  742.  * associated with the server's state and, possible, transition
  743.  * to a new state.
  744.  */
  745. void
  746. ModemServer::timerExpired(long, long)
  747. {
  748.     switch (state) {
  749.     case RUNNING:
  750. /*
  751.  * Poll the lock file, see if it's lockable.
  752.  * If it's lockable, then no lock file exists.  Rinse. Repeat.
  753.  * If a lockfile exists, go to LOCKWAIT
  754.  */
  755. if (canLockModem()) {
  756.     bool ok = true;
  757.     if (pollLockPokeModem) {
  758. /*
  759.  * Poke the modem to make sure it's still there.
  760.  * If not, then mark it to be reset.
  761.  */
  762. lockModem();
  763. ok = modem->poke();
  764. unlockModem();
  765.     }
  766.     if (ok)
  767. Dispatcher::instance().startTimer(pollLockWait, 0, this);
  768.     else
  769. changeState(MODEMWAIT, pollModemWait);
  770. } else {
  771.     changeState(LOCKWAIT, pollLockWait);
  772. }
  773. break;
  774.     case MODEMWAIT:
  775.     case LOCKWAIT:
  776. /*
  777.  * Waiting for modem to start working.  Retry setup
  778.  * and either change state or restart the timer.
  779.  * Note that we unlock the modem before we change
  780.  * our state to RUNNING after a modem setup so that
  781.  * any callback doesn't find the modem locked (and
  782.  * so cause jobs to be requeued).
  783.  */
  784. if (lockModem()) {
  785.     bool modemReady = setupModem();
  786.     unlockModem();
  787.     if (modemReady)
  788. changeState(RUNNING, pollLockWait);
  789.     else
  790. changeState(MODEMWAIT, pollModemWait);
  791. } else
  792.     changeState(LOCKWAIT, pollLockWait);
  793. break;
  794.     default:
  795. traceServer("ModemServer::timerExpired() in an unexpected "
  796.     "state %d", state);
  797. break;
  798.     }
  799. }
  801. /*
  802.  * Modem support interfaces.  Note that the values
  803.  * returned when we don't have a handle on the modem
  804.  * are selected so that any imaged facsimile should
  805.  * still be sendable.
  806.  */
  807. bool ModemServer::modemReady() const
  808.     { return modem != NULL; }
  810. bool ModemServer::serverBusy() const
  811.     { return state != RUNNING; }
  813. bool ModemServer::modemWaitForRings(u_short rings, CallType& type, CallID& callid)
  814.     { return modem->waitForRings(rings, type, callid); }
  815. CallType ModemServer::modemAnswerCall(AnswerType atype, fxStr& emsg, const char* dialnumber)
  816.     { return modem->answerCall(atype, emsg, dialnumber); }
  817. void ModemServer::modemAnswerCallCmd(CallType ctype)
  818.     { modem->answerCallCmd(ctype); }
  819. void ModemServer::modemHangup() { modem->hangup(); }
  821. BaudRate ModemServer::getModemRate() const { return baudRates[curRate]; }
  823. /*
  824.  * Server configuration support.
  825.  */
  827. /*
  828.  * Read a configuration file.  Note that we suppress
  829.  * dial string rules setup while reading so that the
  830.  * order of related parameters is not important.  We
  831.  * also setup the local identifier from the fax number
  832.  * if nothing is specified in the config file (for
  833.  * backwards compatibility).
  834.  */
  835. void
  836. ModemServer::readConfig(const fxStr& filename)
  837. {
  838.     if (delayConfig)
  839.     {
  840.         /*
  841.         * We're recursively in here, likely from an Include statement.
  842.         * We don't want to do any of our delayConfig stuff...
  843.         */
  844.        ServerConfig::readConfig(filename);
  845.        return;
  846.     }
  847.     dialRulesFile = "";
  848.     delayConfig = true;
  849.     ServerConfig::readConfig(filename);
  850.     delayConfig = false;
  851.     if (dialRulesFile != "")
  852. setDialRules(dialRulesFile);
  853.     if (localIdentifier == "")
  854. setLocalIdentifier(canonicalizePhoneNumber(FAXNumber));
  855. }
  857. void ModemServer::vconfigError(const char* fmt, va_list ap)
  858.     { vtraceStatus(FAXTRACE_SERVER, fmt, ap); }
  859. void ModemServer::vconfigTrace(const char* fmt, va_list ap)
  860.     { vtraceStatus(FAXTRACE_CONFIG, fmt, ap); }
  861. void ModemServer::vdialrulesTrace(const char* fmt, va_list ap)
  862.     { vtraceStatus(FAXTRACE_DIALRULES, fmt, ap); }
  864. /*
  865.  * Setup the dial string rules.  Note that if we're
  866.  * reading the configuration file (as opposed to
  867.  * reconfiguring based on a FIFO message), then we
  868.  * suppress the actual setup so that other parameters
  869.  * such as the area code can be specified out of
  870.  * order in the configuration file.
  871.  */
  872. void
  873. ModemServer::setDialRules(const char* name)
  874. {
  875.     if (delayConfig) // delay during config setup
  876. dialRulesFile = name;
  877.     else
  878. ServerConfig::setDialRules(name);
  879. }
  881. /*
  882.  * Set the modem speaker volume and if a modem
  883.  * is setup, pass it into the modem driver to
  884.  * pass to the modem.
  885.  */
  886. void
  887. ModemServer::setModemSpeakerVolume(SpeakerVolume level)
  888. {
  889.     ServerConfig::setModemSpeakerVolume(level);
  890.     if (modem)
  891. modem->setSpeakerVolume(level);
  892. }
  894. /*
  895.  * Tracing support.
  896.  */
  898. void
  899. ModemServer::traceServer(const char* fmt ...)
  900. {
  901.     va_list ap;
  902.     va_start(ap, fmt);
  903.     vtraceStatus(FAXTRACE_SERVER, fmt, ap);
  904.     va_end(ap);
  905. }
  907. void
  908. ModemServer::traceProtocol(const char* fmt ...)
  909. {
  910.     va_list ap;
  911.     va_start(ap, fmt);
  912.     vtraceStatus(FAXTRACE_PROTOCOL, fmt, ap);
  913.     va_end(ap);
  914. }
  916. void
  917. ModemServer::traceModemOp(const char* fmt0 ...)
  918. {
  919.     va_list ap;
  920.     va_start(ap, fmt0);
  921.     fxStr fmt = fxStr::format("MODEM %s", fmt0);
  922.     vtraceStatus(FAXTRACE_MODEMOPS, fmt, ap);
  923.     va_end(ap);
  924. }
  926. void
  927. ModemServer::traceStatus(int kind, const char* fmt ...)
  928. {
  929.     va_list ap;
  930.     va_start(ap, fmt);
  931.     vtraceStatus(kind, fmt, ap);
  932.     va_end(ap);
  933. }
  935. extern void vlogInfo(const char* fmt, va_list ap);
  937. void
  938. ModemServer::vtraceStatus(int kind, const char* fmt, va_list ap)
  939. {
  940.     if (log) {
  941.         fxStr s = fxStr::vformat(fmt, ap);
  942.         if (kind == FAXTRACE_SERVER) { // always log server stuff
  943.             logInfo("%s", (const char*)s);
  944.         }
  945.         if (logTracingLevel & kind) {
  946.         log->log("%s", (const char*)s);
  947.         }
  948.     } else if (tracingLevel & kind) {
  949.     logInfo("%s", (const char*)fxStr::vformat(fmt, ap));
  950.     }
  951. }
  953. #include "StackBuffer.h"
  955. void
  956. ModemServer::traceModemIO(const char* dir, const u_char* data, u_int cc)
  957. {
  958.     if (log) {
  959. if ((logTracingLevel& FAXTRACE_MODEMIO) == 0)
  960.     return;
  961.     } else if ((tracingLevel & FAXTRACE_MODEMIO) == 0)
  962. return;
  964.     const char* hexdigits = "0123456789ABCDEF";
  965.     fxStackBuffer buf;
  966.     for (u_int i = 0; i < cc; i++) {
  967. u_char b = data[i];
  968. if (i > 0)
  969.     buf.put(' ');
  970. buf.put(hexdigits[b>>4]);
  971. buf.put(hexdigits[b&0xf]);
  972.     }
  973.     traceStatus(FAXTRACE_MODEMIO, "%s <%u:%.*s>",
  974. dir, cc, buf.getLength(), (const char*) buf);
  975. }
  977. /*
  978.  * Device manipulation.
  979.  */
  981. #ifndef B38400
  982. #define B38400 B19200
  983. #endif
  984. #ifndef B57600
  985. #define B57600 B38400
  986. #endif
  987. #ifndef B76800
  988. #define B76800 B57600
  989. #endif
  990. #ifndef B115200
  991. #define B115200 B76800
  992. #endif
  993. static speed_t termioBaud[] = {
  994.     B0, // BR0
  995.     B300, // BR300
  996.     B1200, // BR1200
  997.     B2400, // BR2400
  998.     B4800, // BR4800
  999.     B9600, // BR9600
  1000.     B19200, // BR19200
  1001.     B38400, // BR38400
  1002.     B57600, // BR57600
  1003.     B76800, // BR76800
  1004.     B115200, // BR115200
  1005. };
  1006. #define NBAUDS (sizeof (termioBaud) / sizeof (termioBaud[0]))
  1007. static const char* flowNames[] = { "NONE", "XON/XOFF", "RTS/CTS", };
  1008. static const char* parityNames[] = {
  1009.     "8 bits, no parity", // NONE
  1010.     "7 bits, even parity", // EVEN
  1011.     "7 bits, odd parity", // ODD
  1012. };
  1014. #if defined(CCTS_OFLOW) && defined(CRTS_IFLOW) && !defined(__NetBSD__) && !defined(__OpenBSD__)
  1015. #undef CRTSCTS /* BSDi */
  1016. #define CRTSCTS (CCTS_OFLOW|CRTS_IFLOW)
  1017. #endif
  1018. #if defined(CTSFLOW) && defined(RTSFLOW)
  1019. #define CRTSCTS (CTSFLOW|RTSFLOW) /* SCO */
  1020. #endif
  1021. #if defined(CNEW_RTSCTS)
  1022. #define CRTSCTS CNEW_RTSCTS /* IRIX 5.x */
  1023. #endif
  1024. #ifndef CRTSCTS
  1025. #define CRTSCTS 0
  1026. #endif
  1028. void
  1029. ModemServer::setFlow(termios& term, FlowControl iflow, FlowControl oflow)
  1030. {
  1031.     switch (iflow) {
  1032.     case ClassModem::FLOW_NONE:
  1033. term.c_iflag &= ~IXON;
  1034. term.c_cflag &= ~CRTSCTS;
  1035. break;
  1036.     case ClassModem::FLOW_XONXOFF:
  1037. term.c_iflag |= IXON;
  1038. term.c_cflag &= ~CRTSCTS;
  1039. break;
  1040.     case ClassModem::FLOW_RTSCTS:
  1041. term.c_iflag &= ~IXON;
  1042. term.c_cflag |= CRTSCTS;
  1043. break;
  1044.     }
  1045.     switch (oflow) {
  1046.     case ClassModem::FLOW_NONE:
  1047. term.c_iflag &= ~IXOFF;
  1048. term.c_cflag &= ~CRTSCTS;
  1049. break;
  1050.     case ClassModem::FLOW_XONXOFF:
  1051. term.c_iflag |= IXOFF;
  1052. term.c_cflag &= ~CRTSCTS;
  1053. break;
  1054.     case ClassModem::FLOW_RTSCTS:
  1055. term.c_iflag &= ~IXOFF;
  1056. term.c_cflag |= CRTSCTS;
  1057. break;
  1058.     }
  1059. }
  1061. void
  1062. ModemServer::setParity(termios& term, Parity parity)
  1063. {
  1064.     switch (parity) {
  1065.     case NONE: 
  1066. term.c_cflag &= ~(CSIZE | PARENB);
  1067. term.c_cflag |= CS8;
  1068. term.c_iflag &= ~(IGNPAR | ISTRIP);
  1069. break;
  1070.     case EVEN:
  1071. term.c_cflag &= ~(CSIZE | PARODD);
  1072. term.c_cflag |= CS7 | PARENB;
  1073. term.c_iflag |= IGNPAR | ISTRIP;
  1074. break;
  1075.     case ODD:
  1076. term.c_cflag &= ~CSIZE;
  1077. term.c_cflag |= CS7 | PARENB | PARODD;
  1078. term.c_iflag |= IGNPAR | ISTRIP;
  1079. break;
  1080.     }
  1081. }
  1083. bool
  1084. ModemServer::tcsetattr(int op, struct termios& term)
  1085. {
  1086.     bool ok;
  1087.     if (clocalAsRoot) {
  1088. /*
  1089.  * Gag, IRIX 5.2 and beyond permit only the super-user to
  1090.  * change the CLOCAL bit on a tty device with modem control.
  1091.  * However, since some versions have a bug in the UART driver
  1092.  * that causes RTS/CTS flow control to be silently turned off
  1093.  * when CLOCAL is set, for now we enable this from the
  1094.  * configuration file so that IRIX users can still disable it.
  1095.  */
  1096. uid_t euid = geteuid();
  1097. (void) seteuid(0);
  1098. ok = (::tcsetattr(modemFd, op, &term) == 0);
  1099. seteuid(euid);
  1100.     } else
  1101. ok = (::tcsetattr(modemFd, op, &term) == 0);
  1102.     if (!ok)
  1103. traceModemOp("tcsetattr: %m");
  1104.     return ok;
  1105. }
  1107. bool
  1108. ModemServer::tcgetattr(const char* method, struct termios& term)
  1109. {
  1110.     if (::tcgetattr(modemFd, &term) != 0) {
  1111. traceModemOp("%s::tcgetattr: %m", method);
  1112. return (false);
  1113.     } else
  1114. return (true);
  1115. }
  1117. /*
  1118.  * Set tty port baud rate and flow control.
  1119.  */
  1120. bool
  1121. ModemServer::setBaudRate(BaudRate rate, FlowControl iFlow, FlowControl oFlow)
  1122. {
  1123.     if (rate >= NBAUDS)
  1124. rate = NBAUDS-1;
  1125.     traceModemOp("set baud rate: %d baud, input flow %s, output flow %s",
  1126. baudRates[rate], flowNames[iFlow], flowNames[oFlow]);
  1127.     struct termios term;
  1128.     if (!tcgetattr("setBaudRate", term))
  1129. return (false);
  1130.     curRate = rate; // NB: for use elsewhere
  1131.     term.c_oflag = 0;
  1132.     term.c_lflag = 0;
  1133.     term.c_iflag &= IXON|IXOFF; // keep these bits
  1134.     term.c_cflag &= CRTSCTS; // and these bits
  1135.     setParity(term, curParity);
  1136.     term.c_cflag |= CLOCAL | CREAD;
  1137.     setFlow(term, iFlow, oFlow);
  1138.     cfsetospeed(&term, termioBaud[rate]);
  1139.     cfsetispeed(&term, termioBaud[rate]);
  1140.     term.c_cc[VMIN] = (cc_t) curVMin;
  1141.     term.c_cc[VTIME] = (cc_t) curVTime;
  1142.     flushModemInput();
  1143. #if HAS_TXCD
  1144.     /* 
  1145.      * From: Steve Williams <steve@geniers.cuug.ab.ca>
  1146.      *
  1147.      * Under AIX there is no easy way to determine if hardware
  1148.      * handshaking is already on the terminal Control Discipline
  1149.      * stack.  This is necessary to properly condition the tty
  1150.      * device for RTS/CTS flow control.  Rather than determine
  1151.      * the state of the device we just add/remove the Control
  1152.      * Discipline and ignore any errors.  Note that this is the
  1153.      * only place this must be done because it is the only
  1154.      * method through which the modem drivers enable/disable
  1155.      * RTS/CTS flow control.
  1156.      */
  1157.     if (iFlow == FaxModem::FLOW_RTSCTS) {
  1158. traceModemOp("add rts control discipline");
  1159. (void) ioctl(modemFd, TXADDCD, "rts"); // XXX check return
  1160.     } else {
  1161. traceModemOp("remove rts control discipline");
  1162. (void) ioctl(modemFd, TXDELCD, "rts"); // XXX check return
  1163.     }
  1164. #endif
  1165. #if HAS_TERMIOX
  1166.     /*
  1167.      * Some SVR4.2 systems require use of termiox
  1168.      * to setup hardware handshaking on a port.
  1169.      */
  1170.     struct termiox termx;
  1171.     if (ioctl(modemFd, TCGETX, &termx) >= 0) {
  1172. if (iFlow == FaxModem::FLOW_RTSCTS)
  1173.     termx.x_hflag |= RTSXOFF|CTSXON;
  1174. else
  1175.     termx.x_hflag &= ~(RTSXOFF|CTSXON);
  1176. if (ioctl(modemFd, TCSETX, &termx) < 0)
  1177.     traceModemOp("ioctl(TCSETX): %m");
  1178.     }
  1179. #endif
  1180.     return (tcsetattr(TCSANOW, term));
  1181. }
  1183. /*
  1184.  * Set tty port baud rate and leave flow control state unchanged.
  1185.  */
  1186. bool
  1187. ModemServer::setBaudRate(BaudRate rate)
  1188. {
  1189.     if (rate >= NBAUDS)
  1190. rate = NBAUDS-1;
  1191.     traceModemOp("set baud rate: %d baud (flow control unchanged)",
  1192. baudRates[rate]);
  1193.     struct termios term;
  1194.     if (!tcgetattr("setBaudRate", term))
  1195. return (false);
  1196.     curRate = rate; // NB: for use elsewhere
  1197.     term.c_oflag = 0;
  1198.     term.c_lflag = 0;
  1199.     term.c_iflag &= IXON|IXOFF; // keep these bits
  1200.     term.c_cflag &= CRTSCTS; // and these bits
  1201.     setParity(term, curParity);
  1202.     term.c_cflag |= CLOCAL | CREAD;
  1203.     cfsetospeed(&term, termioBaud[rate]);
  1204.     cfsetispeed(&term, termioBaud[rate]);
  1205.     term.c_cc[VMIN] = (cc_t) curVMin;
  1206.     term.c_cc[VTIME] = (cc_t) curVTime;
  1207.     flushModemInput();
  1208.     return (tcsetattr(TCSANOW, term));
  1209. }
  1211. /*
  1212.  * Set tty port parity and number of data bits
  1213.  */
  1214. bool
  1215. ModemServer::setParity(Parity parity)
  1216. {
  1217.     traceModemOp("set parity: %s", parityNames[parity]);
  1218.     struct termios term;
  1219.     if (!tcgetattr("setParity", term))
  1220. return (false);
  1221.     setParity(term, parity);
  1222.     flushModemInput();
  1223.     if (!tcsetattr(TCSANOW, term))
  1224. return (false);
  1225.     curParity = parity; // used above
  1226.     return (true);
  1227. }
  1229. /*
  1230.  * Manipulate DTR on tty port.
  1231.  *
  1232.  * On systems that support explicit DTR control this is done
  1233.  * with an ioctl.  Otherwise we assume that setting the baud
  1234.  * rate to zero causes DTR to be dropped (asserting DTR is
  1235.  * assumed to be implicit in setting a non-zero baud rate).
  1236.  *
  1237.  * NB: we use the explicit DTR manipulation ioctls because
  1238.  *     setting the baud rate to zero on some systems can cause
  1239.  *     strange side effects.
  1240.  */
  1241. bool
  1242. ModemServer::setDTR(bool onoff)
  1243. {
  1244.     traceModemOp("set DTR %s", onoff ? "ON" : "OFF");
  1245. #if defined(MCGETA) && defined(MCSETAF) && defined(MDTR)
  1246.     /*
  1247.      * HP-UX has a special way to manipulate DTR.
  1248.      */
  1249.     int mstat;
  1250.     if (ioctl(modemFd, MCGETA, &mstat) >= 0) {
  1251. if (onoff)
  1252.     mstat |= MDTR;
  1253. else
  1254.     mstat &= ~MDTR;
  1255. if (ioctl(modemFd, MCSETAF, &mstat) >= 0)
  1256.     return (true);
  1257.     }
  1258. #elif defined(TIOCMBIS)
  1259.     int mctl = TIOCM_DTR;
  1260.     /*
  1261.      * Happy days! Some systems passes the arg by value, while
  1262.      * others passes it by reference; is this progress?
  1263.      */
  1264. #ifdef CONFIG_TIOCMBISBYREF
  1265.     if (ioctl(modemFd, onoff ? TIOCMBIS : TIOCMBIC, (char *)&mctl) >= 0)
  1266. #else
  1267.     if (ioctl(modemFd, onoff ? TIOCMBIS : TIOCMBIC, (char *)mctl) >= 0)
  1268. #endif
  1269. return (true);
  1270.     /*
  1271.      * Sigh, Sun seems to support this ioctl only on *some*
  1272.      * devices (e.g. on-board duarts, but not the ALM-2 card);
  1273.      * so if the ioctl that should work fails, we fallback
  1274.      * on the usual way of doing things...
  1275.      */
  1276. #endif /* TIOCMBIS */
  1277.     return (onoff ? true : setBaudRate(ClassModem::BR0));
  1278. }
  1280. static const char* actNames[] = { "NOW", "DRAIN", "FLUSH" };
  1281. static u_int actCode[] = { TCSANOW, TCSADRAIN, TCSAFLUSH };
  1283. /*
  1284.  * Set tty modes so that the specified handling
  1285.  * is done on data being sent and received.  When
  1286.  * transmitting binary data, oFlow is FLOW_NONE to
  1287.  * disable the transmission of XON/XOFF by the host
  1288.  * to the modem.  When receiving binary data, iFlow
  1289.  * is FLOW_NONE to cause XON/XOFF from the modem
  1290.  * to not be interpreted.  In each case the opposite
  1291.  * XON/XOFF handling should be enabled so that any
  1292.  * XON/XOFF from/to the modem will be interpreted.
  1293.  */
  1294. bool
  1295. ModemServer::setXONXOFF(FlowControl iFlow, FlowControl oFlow, SetAction act)
  1296. {
  1297.     traceModemOp("set XON/XOFF/%s: input %s, output %s",
  1298. actNames[act],
  1299. iFlow == ClassModem::FLOW_NONE ? "ignored" : "interpreted",
  1300. oFlow == ClassModem::FLOW_NONE ? "disabled" : "generated"
  1301.     );
  1302.     struct termios term;
  1303.     if (!tcgetattr("setXONXOFF", term))
  1304. return (false);
  1305.     setFlow(term, iFlow, oFlow);
  1306.     if (act == ClassModem::ACT_FLUSH)
  1307. flushModemInput();
  1308.     return (tcsetattr(actCode[act], term));
  1309. }
  1311. #ifdef sgi
  1312. #include <sys/stropts.h>
  1313. #include <sys/z8530.h>
  1314. #endif
  1315. #ifdef sun
  1316. #include <sys/stropts.h>
  1317. #endif
  1319. /*
  1320.  * Setup process state either for minimum latency (no buffering)
  1321.  * or reduced latency (input may be buffered).  We fiddle with
  1322.  * the termio structure and, if required, the streams timer
  1323.  * that delays the delivery of input data from the UART module
  1324.  * upstream to the tty module.
  1325.  */
  1326. bool
  1327. ModemServer::setInputBuffering(bool on)
  1328. {
  1329.     if (on != inputBuffered) traceModemOp("input buffering %s", on ? "enabled" : "disabled");
  1330.     inputBuffered = on;
  1331. #ifdef SIOC_ITIMER
  1332.     /*
  1333.      * Silicon Graphics systems have a settable timer
  1334.      * that causes the UART driver to delay passing
  1335.      * data upstream to the tty module.  This can cause
  1336.      * anywhere from 20-30ms delay between input characters.
  1337.      * We set it to zero when input latency is critical.
  1338.      */
  1339.     strioctl str;
  1340.     str.ic_cmd = SIOC_ITIMER;
  1341.     str.ic_timout = (on ? 2 : 0); // 2 ticks = 20ms (usually)
  1342.     str.ic_len = 4;
  1343.     int arg = 0;
  1344.     str.ic_dp = (char*)&arg;
  1345.     if (ioctl(modemFd, I_STR, &str) < 0)
  1346. traceModemOp("setInputBuffer::ioctl(SIOC_ITIMER): %m");
  1347. #endif
  1348. #ifdef sun
  1349.     /*
  1350.      * SunOS has a timer similar to the SIOC_ITIMER described
  1351.      * above for input on the on-board serial ports, but it is
  1352.      * not generally accessible because it is controlled by a
  1353.      * stream control message (M_CTL w/ either MC_SERVICEDEF or
  1354.      * MC_SERVICEIMM) and you can not do a putmsg directly to
  1355.      * the UART module and the tty driver does not provide an
  1356.      * interface.  Also, the ALM-2 driver apparently also has
  1357.      * a timer, but does not provide the M_CTL interface that's
  1358.      * provided for the on-board ports.  All in all this means
  1359.      * that the only way to defeat the timer for the on-board
  1360.      * serial ports (and thereby provide enough control for the
  1361.      * fax server to work with Class 1 modems) is to implement
  1362.      * a streams module in the kernel that provides an interface
  1363.      * to the timer--which is what has been done.  In the case of
  1364.      * the ALM-2, however, you are just plain out of luck unless
  1365.      * you have source code.
  1366.      */
  1367.     static bool zsunbuf_push_tried = false;
  1368.     static bool zsunbuf_push_ok = false;
  1369.     if (on) { // pop zsunbuf if present to turn on buffering
  1370. char topmodule[FMNAMESZ+1];
  1371.         if (zsunbuf_push_ok && ioctl(modemFd, I_LOOK, topmodule) >= 0 &&
  1372.   streq(topmodule, "zsunbuf")) {
  1373.     if (ioctl(modemFd, I_POP, 0) < 0)
  1374. traceModemOp("pop zsunbuf failed: %m");
  1375. }
  1376.     } else { // push zsunbuf to turn off buffering
  1377.         if (!zsunbuf_push_tried) {
  1378.             zsunbuf_push_ok = (ioctl(modemFd, I_PUSH, "zsunbuf") >= 0);
  1379.             traceModemOp("initial push zsunbuf %s",
  1380.                 zsunbuf_push_ok ? "succeeded" : "failed");
  1381.             zsunbuf_push_tried = true;
  1382.         } else if (zsunbuf_push_ok) {
  1383.             if (ioctl(modemFd, I_PUSH, "zsunbuf") < 0)
  1384.                 traceModemOp("push zsunbuf failed: %m");
  1385.         }
  1386.     }
  1387. #endif
  1388.     struct termios term;
  1389.     (void) tcgetattr("setInputBuffering", term);
  1390.     if (on) {
  1391. curVMin = 127;
  1392. curVTime = 1;
  1393.     } else {
  1394. curVMin = 1;
  1395. curVTime = 0;
  1396.     }
  1397.     term.c_cc[VMIN] = (cc_t) curVMin;
  1398.     term.c_cc[VTIME] = (cc_t) curVTime;
  1399.     return (tcsetattr(TCSANOW, term));
  1400. }
  1402. bool
  1403. ModemServer::sendBreak(bool pause)
  1404. {
  1405.     traceModemOp("send break%s", pause ? " (pause)" : "");
  1406.     flushModemInput();
  1407.     if (pause) {
  1408. /*
  1409.  * NB: TCSBRK is supposed to wait for output to drain,
  1410.  * but some modems appear to lose data if we don't do this.
  1411.  */
  1412. (void) tcdrain(modemFd);
  1413.     }
  1414.     if (tcsendbreak(modemFd, 0) != 0) {
  1415. traceModemOp("tcsendbreak: %m");
  1416. return (false);
  1417.     } else
  1418. return (true);
  1419. }
  1421. void
  1422. ModemServer::startTimeout(long ms)
  1423. {
  1424.     timer.startTimeout(ms);
  1425.     timeout = false;
  1426. }
  1428. void
  1429. ModemServer::stopTimeout(const char* whichdir)
  1430. {
  1431.     timer.stopTimeout();
  1432.     timeout = timer.wasTimeout();
  1433.     if (timeout)
  1434. traceModemOp("TIMEOUT: %s", whichdir);
  1435. }
  1437. void
  1438. ModemServer::sendDLEETX()
  1439. {
  1440.     u_char buf[2];
  1441.     buf[0] = DLE;
  1442.     buf[1] = ETX;
  1443.     (void) putModem(buf, 2);
  1444. }
  1446. int
  1447. ModemServer::getModemLine(char rbuf[], u_int bufSize, long ms)
  1448. {
  1449.     int c;
  1450.     u_int cc = 0;
  1451.     if (ms) startTimeout(ms);
  1452.     do {
  1453. while ((c = getModemChar(0)) != EOF && c != 'n' && !timer.wasTimeout())
  1454.     if (c != '' && c != 'r' && cc < bufSize)
  1455. rbuf[cc++] = c;
  1456.     } while (!timer.wasTimeout() && cc == 0 && c != EOF);
  1457.     rbuf[cc] = '';
  1458.     if (ms) stopTimeout("reading line from modem");
  1459.     if (!timeout)
  1460. traceStatus(FAXTRACE_MODEMCOM, "--> [%d:%s]", cc, rbuf);
  1461.     return (cc);
  1462. }
  1464. int
  1465. ModemServer::getModemChar(long ms, bool isquery)
  1466. {
  1467.     if (rcvNext >= rcvCC) {
  1468. int n = 0;
  1469. if (isquery) {
  1470.     if (fcntl(modemFd, F_SETFL, fcntl(modemFd, F_GETFL, 0) | O_NONBLOCK)) {
  1471. traceStatus(FAXTRACE_MODEMCOM, "Can not set O_NONBLOCK: errno %u", errno);
  1472. return (EOF);
  1473.     }
  1474.     n = 5; // only read once
  1475. }
  1476. if (ms) startTimeout(ms);
  1477. do
  1478.     rcvCC = Sys::read(modemFd, (char*) rcvBuf, sizeof (rcvBuf));
  1479. while (n++ < 5 && rcvCC == 0);
  1480. if (ms) stopTimeout("reading from modem");
  1481. if (isquery) {
  1482.     if (fcntl(modemFd, F_SETFL, fcntl(modemFd, F_GETFL, 0) &~ O_NONBLOCK))
  1483. traceStatus(FAXTRACE_MODEMCOM, "Can not reset O_NONBLOCK: errno %u", errno);
  1484. }
  1485. if (rcvCC <= 0) {
  1486.     if (rcvCC < 0) {
  1487. if (errno != EINTR)
  1488.     if (!isquery || errno != EAGAIN)
  1489. traceStatus(FAXTRACE_MODEMCOM,
  1490.     "MODEM READ ERROR: errno %u", errno);
  1491.     }
  1492.     return (EOF);
  1493. } else
  1494.     traceModemIO("-->", rcvBuf, rcvCC);
  1495. rcvNext = 0;
  1496.     }
  1497.     return (rcvBuf[rcvNext++]);
  1498. }
  1500. int
  1501. ModemServer::getModemBit(long ms)
  1502. {
  1503.     /*
  1504.      * Return bytes bit-by-bit in MSB2LSB order.
  1505.      * getModemChar() returns them in LSB2MSB.
  1506.      */
  1507.     if (rcvBit < 1) {
  1508. rcvBit = 8;
  1509. gotByte = getModemChar(ms);
  1510. if (gotByte == 0x10) { // strip stuffed DLE
  1511.     gotByte = getModemChar(ms);
  1512.     if (gotByte == 0x03) sawBlockEnd = true; // DLE+ETX
  1513. }
  1514.     }
  1515.     // enable this to simulate a VERY noisy connection
  1516.     // if (((int) Sys::now() & 1) && ((random() % 10000)/10000.0) > 0.95) return (1);
  1517.     if (gotByte == EOF) return (EOF);
  1518.     else if (gotByte & (0x80 >> --rcvBit)) return (1);
  1519.     else return (0);
  1520. }
  1522. int
  1523. ModemServer::getLastByte()
  1524. {
  1525.     return gotByte;
  1526. }
  1528. bool
  1529. ModemServer::didBlockEnd()
  1530. {
  1531.     return sawBlockEnd;
  1532. }
  1534. void
  1535. ModemServer::resetBlock()
  1536. {
  1537.     sawBlockEnd = false;
  1538. }
  1540. void
  1541. ModemServer::modemFlushInput()
  1542. {
  1543.     traceModemOp("flush i/o");
  1544.     flushModemInput();
  1545.     if (tcflush(modemFd, TCIFLUSH) != 0)
  1546. traceModemOp("tcflush: %m");
  1547. }
  1549. bool
  1550. ModemServer::modemStopOutput()
  1551. {
  1552.     if (tcflow(modemFd, TCOOFF) != 0) {
  1553. traceModemOp("tcflow: %m");
  1554. return (false);
  1555.     } else
  1556. return (true);
  1557. }
  1559. void
  1560. ModemServer::flushModemInput()
  1561. {
  1562.     rcvCC = rcvNext = rcvBit = gotByte = 0;
  1563.     sawBlockEnd = false;
  1564. }
  1566. bool
  1567. ModemServer::putModem(const void* data, int n, long ms)
  1568. {
  1569.     traceStatus(FAXTRACE_MODEMCOM, "<-- data [%d]", n);
  1570.     return (putModem1(data, n, ms));
  1571. }
  1573. bool
  1574. ModemServer::putModem1(const void* data, int n, long ms)
  1575. {
  1576.     if (ms)
  1577. startTimeout(ms);
  1578.     else
  1579. timeout = false;
  1580.     int cc = Sys::write(modemFd, (const char*) data, n);
  1581.     if (ms)
  1582. stopTimeout("writing to modem");
  1583.     if (cc > 0) {
  1584. traceModemIO("<--", (const u_char*) data, cc);
  1585. n -= cc;
  1586.     }
  1587.     if (cc == -1) {
  1588. if (errno != EINTR)
  1589.     traceStatus(FAXTRACE_MODEMCOM, "MODEM WRITE ERROR: errno %u",
  1590. errno);
  1591.     } else if (n != 0)
  1592. traceStatus(FAXTRACE_MODEMCOM, "MODEM WRITE SHORT: sent %u, wrote %u",
  1593.     cc+n, cc);
  1594.     return (!timeout && n == 0);
  1595. }