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

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

传真(Fax)编程

开发平台：

C/C++

ClassModem.c++：源码内容
  1. /* $Id: ClassModem.c++,v 1.35 2009/02/17 01:42:42 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 <ctype.h>
  27. #include <stdlib.h>
  29. #include "ModemServer.h"
  30. #include "FaxTrace.h"
  31. #include "Sys.h"
  33. /*
  34.  * Call status description strings.
  35.  */
  36. const char* ClassModem::callStatus[10] = {
  37.     "Call successful {E000}", // OK
  38.     "Busy signal detected {E001}", // BUSY
  39.     "No carrier detected {E002}", // NOCARRIER
  40.     "No answer from remote {E003}", // NOANSWER
  41.     "No local dialtone {E004}", // NODIALTONE
  42.     "Invalid dialing command {E005}", // ERROR
  43.     "Unknown problem {E006}", // FAILURE
  44.     "Carrier established, but Phase A failure {E007}", // NOFCON
  45.     "Data connection established (wanted fax) {E008}", // DATACONN
  46.     "Glare - RING detected {E009}", // RING
  47. };
  48. /*
  49.  * Service class descriptions.  The first three
  50.  * correspond to the EIA/TIA definitions.  The
  51.  * voice class is for ZyXEL modems.
  52.  */
  53. const char* ClassModem::serviceNames[9] = {
  54.     ""Data"", // SERVICE_DATA
  55.     ""Class 1"", // SERVICE_CLASS1
  56.     ""Class 2"", // SERVICE_CLASS2
  57.     ""Class 2.0"", // SERVICE_CLASS20 (XXX 3)
  58.     ""Class 1.0"", // SERVICE_CLASS10 (XXX 4)
  59.     ""Class 2.1"", // SERVICE_CLASS21 (XXX 5)
  60.     "", // 6
  61.     "", // 7
  62.     ""Voice"", // SERVICE_VOICE
  63. };
  64. const char* ClassModem::ATresponses[19] = {
  65.     "Nothing", // AT_NOTHING
  66.     "OK", // AT_OK
  67.     "Connection established", // AT_CONNECT
  68.     "No answer or ring back", // AT_NOANSWER
  69.     "No carrier", // AT_NOCARRIER
  70.     "No dial tone", // AT_NODIALTONE
  71.     "Busy", // AT_BUSY
  72.     "Phone off-hook", // AT_OFFHOOK
  73.     "Ring", // AT_RING
  74.     "Command error", // AT_ERROR
  75.     "Hang up", // AT_FHNG
  76.     "<Empty line>", // AT_EMPTYLINE
  77.     "<Timeout>", // AT_TIMEOUT
  78.     "<dle+etx>", // AT_DLEETX
  79.     "End of transmission", // AT_DLEEOT
  80.     "<xon>", // AT_XON
  81.     "DTMF detection", // AT_DTMF
  82.     "Voice connection", // AT_VCON
  83.     "<Unknown response>" // AT_OTHER
  84. };
  85. const char* ClassModem::callTypes[6] = {
  86.     "unknown",
  87.     "data",
  88.     "fax",
  89.     "voice",
  90.     "error",
  91.     "done"
  92. };
  93. const char* ClassModem::answerTypes[6] = {
  94.     "any",
  95.     "data",
  96.     "fax",
  97.     "voice",
  98.     "dial",
  99.     "external"
  100. };
  102. ClassModem::ClassModem(ModemServer& s, const ModemConfig& c)
  103.     : server(s)
  104.     , conf(c)
  105.     , mfrQueryCmd(c.mfrQueryCmd)
  106.     , modelQueryCmd(c.modelQueryCmd)
  107.     , revQueryCmd(c.revQueryCmd)
  108. {
  109.     modemServices = 0;
  110.     rate = BR0;
  111.     flowControl = conf.flowControl;
  112.     iFlow = FLOW_NONE;
  113.     oFlow = FLOW_NONE;
  114.     setupDefault(mfrQueryCmd,   conf.mfrQueryCmd,       "ATI3");
  115.     setupDefault(modelQueryCmd, conf.modelQueryCmd,     "ATI0");
  116.     setupDefault(revQueryCmd,   conf.revQueryCmd,       ""); // No "standard" way? -- dbely
  117. }
  119. ClassModem::~ClassModem()
  120. {
  121. }
  123. /*
  124.  * Default methods for modem driver interface.
  125.  */
  127. bool
  128. ClassModem::dataService()
  129. {
  130.     return atCmd(conf.class0Cmd);
  131. }
  133. CallStatus
  134. ClassModem::dial(const char* number, const char* origin, fxStr& emsg)
  135. {
  136.     dialedNumber = fxStr(number);
  137.     protoTrace("DIAL %s", number);
  138.     fxStr dialcmd = conf.dialCmd;
  139.     u_int destpos = dialcmd.find(0, "%s");
  140.     u_int origpos = dialcmd.find(0, "%d");
  141.     if (destpos == dialcmd.length() && origpos == dialcmd.length()) {
  142. // neither %d nor %s appear in the cmd, use dialcmd as-is
  143.     } else if (origpos == dialcmd.length()) {
  144. // just %s appears in the cmd
  145. dialcmd = fxStr::format((const char*) dialcmd, number);
  146.     } else if (destpos == dialcmd.length()) {
  147. // just %d appears in the cmd
  148. dialcmd[origpos+1] = 's';  // change %d to %s
  149. dialcmd = fxStr::format((const char*) dialcmd, origin);
  150.     } else {
  151. // both %d and %s appear in the cmd
  152. dialcmd[origpos+1] = 's';  // change %d to %s
  153. if (origpos < destpos) {
  154.     // %d appears before %s
  155.     dialcmd = fxStr::format((const char*) dialcmd, origin, number);
  156. } else {
  157.     // %s appears before %d
  158.     dialcmd = fxStr::format((const char*) dialcmd, number, origin);
  159. }
  160.     }
  161.     emsg = "";
  162.     CallStatus cs = (atCmd(dialcmd, AT_NOTHING) ? dialResponse(emsg) : FAILURE);
  163.     if (cs != OK && emsg == "") {
  164.         emsg = callStatus[cs];
  165.     }
  166.     return (cs);
  167. }
  169. /*
  170.  * Status messages to ignore when dialing.
  171.  */
  172. bool
  173. ClassModem::isNoise(const char* s)
  174. {
  175.     static const char* noiseMsgs[] = {
  176. "CED", // RC32ACL-based modems send this before +FCON
  177. "DIALING",
  178. "RRING", // Telebit
  179. "RINGING", // ZyXEL
  180. "+FHR:", // Intel 144e
  181. "+A8", // Class 1.0 V.8 report
  182. "+F34:", // Class 1.0 V.34 report
  183. "+FDB:", // DCE debugging
  184. "MESSAGE-WAITING", // voice-mail waiting, Conexant
  185. "2003", // DLE+ETX ???
  186.     };
  187. #define NNOISE (sizeof (noiseMsgs) / sizeof (noiseMsgs[0]))
  189.     for (u_int i = 0; i < NNOISE; i++)
  190. if (strneq(s, noiseMsgs[i], strlen(noiseMsgs[i])))
  191.     return (true);
  192.     /*
  193.      * Some modems echoes the DTMF of the dialed number, and this should be
  194.      * ignored too.
  195.      * Instead of simply checking if "dialedNumber" is equal to "s" we must
  196.      * consider the possibility of having more numbers at "conf.dialCmd".
  197.      * Eg.: conf.dialCmd = atdt0%s (zero will be echoed)
  198.      * The easiest way is to find if "dialedNumber" is a sub-string of "s".
  199.      */
  200.     if (strstr(s, (const char *) dialedNumber) != NULL) return (true);
  201.     return (false);
  202. }
  203. #undef NNOISE
  205. /*
  206.  * Set of status codes we expect to receive
  207.  * from a modem in response to an A (answer
  208.  * the phone) command.
  209.  */
  210. static const AnswerMsg answerMsgs[] = {
  211. { "CONNECT FAX",11,
  212.    ClassModem::AT_NOTHING, ClassModem::OK,   ClassModem::CALLTYPE_FAX },
  213. { "CONNECT",     7,
  214.    ClassModem::AT_NOTHING, ClassModem::OK,   ClassModem::CALLTYPE_DATA },
  215. { "NO ANSWER",   9,
  216.    ClassModem::AT_NOTHING, ClassModem::NOANSWER,  ClassModem::CALLTYPE_ERROR },
  217. { "NO CARRIER", 10,
  218.    ClassModem::AT_NOTHING, ClassModem::NOCARRIER, ClassModem::CALLTYPE_ERROR },
  219. { "NO DIALTONE",11,
  220.    ClassModem::AT_NOTHING, ClassModem::NODIALTONE,ClassModem::CALLTYPE_ERROR },
  221. { "ERROR",       5,
  222.    ClassModem::AT_NOTHING, ClassModem::ERROR,     ClassModem::CALLTYPE_ERROR },
  223. { "+FHNG:", 6,
  224.    ClassModem::AT_NOTHING, ClassModem::NOCARRIER, ClassModem::CALLTYPE_ERROR },
  225. { "+FHS:", 5,
  226.    ClassModem::AT_NOTHING, ClassModem::NOCARRIER, ClassModem::CALLTYPE_ERROR },
  227. { "OK", 2,
  228.    ClassModem::AT_NOTHING, ClassModem::NOCARRIER, ClassModem::CALLTYPE_ERROR },
  229. { "BUSY", 4,
  230.    ClassModem::AT_NOTHING, ClassModem::NOCARRIER, ClassModem::CALLTYPE_ERROR },
  231. { "FAX",  3,
  232.    ClassModem::AT_CONNECT, ClassModem::OK,   ClassModem::CALLTYPE_FAX },
  233. { "DATA",  4,
  234.    ClassModem::AT_CONNECT, ClassModem::OK,   ClassModem::CALLTYPE_DATA },
  235. };
  236. #define NANSWERS (sizeof (answerMsgs) / sizeof (answerMsgs[0]))
  238. const AnswerMsg*
  239. ClassModem::findAnswer(const char* s)
  240. {
  241.     for (u_int i = 0; i < NANSWERS; i++)
  242. if (strneq(s, answerMsgs[i].msg, answerMsgs[i].len))
  243.     return (&answerMsgs[i]);
  244.     return (NULL);
  245. }
  246. #undef NANSWERS
  248. /*
  249.  * Deduce connection kind: fax, data, or voice.
  250.  */
  251. CallType
  252. ClassModem::answerResponse(fxStr answerCmd, fxStr& emsg)
  253. {
  254.     CallStatus cs = FAILURE;
  255.     ATResponse r;
  256.     time_t start = Sys::now();
  257.     u_short morerings = 0;
  259.     do {
  260. r = atResponse(rbuf, conf.answerResponseTimeout);
  261. again:
  262. if (r == AT_TIMEOUT || r == AT_DLEEOT || r == AT_NOCARRIER)
  263.     break;
  264. if (r == AT_RING && ++morerings > 1) {
  265.     /*
  266.      * We answered already.  If we see RING once it could
  267.      * be glare.  If we see it yet again, then the modem
  268.      * apparently did not see or respond to our first 
  269.      * answerCmd and we've got to try it again.
  270.      *
  271.      * In some cases this may happen because our ATA comes
  272.      * too soon following the RING for the modem's liking.
  273.      * This may have to do with the presence of Caller*ID
  274.      * reporting and in such cases is probably best-resolved
  275.      * by changing the RingsBeforeAnswer setting.  However,
  276.      * as a fail-safe we try to shake up the timing by
  277.      * using a small delay in our ATA here.
  278.      */
  279.     pause(500);
  280.     atCmd(answerCmd, AT_NOTHING);
  281.     morerings = 0;
  282. }
  283. const AnswerMsg* am = findAnswer(rbuf);
  284. if (am != NULL) {
  285.     if (am->expect != AT_NOTHING && conf.waitForConnect) {
  286. /*
  287.  * Response string is an intermediate result that
  288.  * is only meaningful if followed by AT response
  289.  * am->next.  Read the next response from the modem
  290.  * and if it's the expected one, use the message
  291.  * to intuit the call type.  Otherwise, discard
  292.  * the intermediate response string and process the
  293.  * call according to the newly read response.
  294.  * This is intended to deal with modems that send
  295.  *   <something>
  296.  *   CONNECT
  297.  * (such as the Boca 14.4).
  298.  */
  299. r = atResponse(rbuf, conf.answerResponseTimeout);
  300. if (r != am->expect)
  301.     goto again;
  302.     }
  303.     if (am->status == OK) // success
  304. return (am->type);
  305.     cs = am->status;
  306.     break;
  307. }
  308. if (r == AT_EMPTYLINE) {
  309.     emsg = callStatus[cs];
  310.     return (CALLTYPE_ERROR);
  311. }
  312.     } while ((unsigned) ((Sys::now()-start)*1000) < conf.answerResponseTimeout);
  313.     emsg = "Ring detected without successful handshake {E012}";
  314.     return (CALLTYPE_ERROR);
  315. }
  317. CallType
  318. ClassModem::answerCall(AnswerType atype, fxStr& emsg, const char* number)
  319. {
  320.     CallType ctype = CALLTYPE_ERROR;
  321.     /*
  322.      * If the request has no type-specific commands
  323.      * to use, then just use the normal commands
  324.      * intended for answering any type of call.
  325.      */
  326.     fxStr answerCmd;
  327.     switch (atype) {
  328.     case ANSTYPE_FAX: answerCmd = conf.answerFaxCmd; break;
  329.     case ANSTYPE_DATA: answerCmd = conf.answerDataCmd; break;
  330.     case ANSTYPE_VOICE: answerCmd = conf.answerVoiceCmd; break;
  331.     case ANSTYPE_DIAL:
  332. answerCmd = conf.answerDialCmd;
  333. dial(number, NULL, emsg); // no error-checking
  334. break;
  335.     }
  336.     if (answerCmd == "")
  337. answerCmd = conf.answerAnyCmd;
  338.     if (atCmd(answerCmd, AT_NOTHING)) {
  339. ctype = answerResponse(answerCmd, emsg);
  340. if (atype == ANSTYPE_DIAL) ctype = CALLTYPE_FAX; // force as fax
  341. if (ctype == CALLTYPE_UNKNOWN) {
  342.     /*
  343.      * The response does not uniquely identify the type
  344.      * of call; assume the type corresponds to the type
  345.      * of the answer request.
  346.      */
  347.     static CallType unknownCall[] = {
  348. CALLTYPE_FAX, // ANSTYPE_ANY (default)
  349. CALLTYPE_DATA, // ANSTYPE_DATA
  350. CALLTYPE_FAX, // ANSTYPE_FAX
  351. CALLTYPE_VOICE, // ANSTYPE_VOICE
  352. CALLTYPE_UNKNOWN, // ANSTYPE_EXTERN
  353.     };
  354.     ctype = unknownCall[atype];
  355. }
  356. answerCallCmd(ctype);
  357.     }
  358.     return (ctype);
  359. } 
  361. /*
  362.  * Send any configured commands to the modem once the
  363.  * type of the call has been established.  These commands
  364.  * normally configure flow control and buad rate for
  365.  * modems that, for example, require a fixed baud rate
  366.  * and flow control scheme when receiving fax.
  367.  */ 
  368. void
  369. ClassModem::answerCallCmd(CallType ctype)
  370. {
  371.     fxStr beginCmd;
  372.     switch (ctype) {
  373.     case CALLTYPE_FAX: beginCmd = conf.answerFaxBeginCmd; break;
  374.     case CALLTYPE_DATA: beginCmd = conf.answerDataBeginCmd; break;
  375.     case CALLTYPE_VOICE:beginCmd = conf.answerVoiceBeginCmd; break;
  376.     }
  377.     if (beginCmd != "")
  378. (void) atCmd(beginCmd);
  379. }
  381. /*
  382.  * Set data transfer timeout and adjust according
  383.  * to the negotiated bit rate.
  384.  */
  385. void
  386. ClassModem::setDataTimeout(long secs, u_int br)
  387. {
  388.     dataTimeout = secs*1000; // 9600 baud timeout/data write (ms)
  389.     switch (br) {
  390.     case BR_2400: dataTimeout *= 4; break;
  391.     case BR_4800: dataTimeout *= 2; break;
  392.     case BR_9600: dataTimeout = (4*dataTimeout)/3; break;
  393.     // could shrink timeout for br > 9600
  394.     }
  395. }
  397. fxStr
  398. ClassModem::getCapabilities() const
  399. {
  400.     return fxStr("");
  401. }
  403. /*
  404.  * Tracing support.
  405.  */
  407. /*
  408.  * Trace a MODEM-communication-related activity.
  409.  */
  410. void
  411. ClassModem::modemTrace(const char* fmt ...)
  412. {
  413.     va_list ap;
  414.     va_start(ap, fmt);
  415.     server.vtraceStatus(FAXTRACE_MODEMCOM, fmt, ap);
  416.     va_end(ap);
  417. }
  419. /*
  420.  * Trace a modem capability.
  421.  */
  422. void
  423. ClassModem::modemCapability(const char* fmt ...)
  424. {
  425.     va_list ap;
  426.     va_start(ap, fmt);
  427.     static const fxStr modem("MODEM: ");
  428.     server.vtraceStatus(FAXTRACE_MODEMCAP, modem | fmt, ap);
  429.     va_end(ap);
  430. }
  432. /*
  433.  * Indicate a modem supports some capability.
  434.  */
  435. void
  436. ClassModem::modemSupports(const char* fmt ...)
  437. {
  438.     va_list ap;
  439.     va_start(ap, fmt);
  440.     static const fxStr supports("MODEM Supports ");
  441.     server.vtraceStatus(FAXTRACE_MODEMCAP, supports | fmt, ap);
  442.     va_end(ap);
  443. }
  445. /*
  446.  * Trace a protocol-related activity.
  447.  */
  448. void
  449. ClassModem::protoTrace(const char* fmt ...)
  450. {
  451.     va_list ap;
  452.     va_start(ap, fmt);
  453.     server.vtraceStatus(FAXTRACE_PROTOCOL, fmt, ap);
  454.     va_end(ap);
  455. }
  457. /*
  458.  * Trace a server-level activity.
  459.  */
  460. void
  461. ClassModem::serverTrace(const char* fmt ...)
  462. {
  463.     va_list ap;
  464.     va_start(ap, fmt);
  465.     server.vtraceStatus(FAXTRACE_SERVER, fmt, ap);
  466.     va_end(ap);
  467. }
  469. /*
  470.  * Trace a modem capability bit mask.
  471.  */
  472. void
  473. ClassModem::traceBits(u_int bits, const char* bitNames[])
  474. {
  475.     for (u_int i = 0; bits; i++)
  476. if (BIT(i) & bits) {
  477.     modemSupports(bitNames[i]);
  478.     bits &= ~BIT(i);
  479. }
  480. }
  482. /*
  483.  * Trace a modem capability true bit mask (VR, BF, JP).
  484.  */
  485. void
  486. ClassModem::traceBitMask(u_int bits, const char* bitNames[])
  487. {
  488.     u_int i = 0;
  489.     do {
  490. if ((bits & i) == i) {
  491.     modemSupports(bitNames[i]);
  492.     bits -= i;
  493. }
  494. i++;
  495.     } while (bits);
  496. }
  498. /*
  499.  * Modem i/o support.
  500.  */
  502. int
  503. ClassModem::getModemLine(char buf[], u_int bufSize, long ms)
  504. {
  505.     int n = server.getModemLine(buf, bufSize, ms);
  506.     if (n > 0)
  507. trimModemLine(buf, n);
  508.     return (n);
  509. }
  510. int ClassModem::getModemBit(long ms)  { return server.getModemBit(ms); }
  511. int ClassModem::getModemChar(long ms, bool doquery) { return server.getModemChar(ms, doquery); }
  512. int ClassModem::getModemDataChar()    { return server.getModemChar(dataTimeout); }
  513. int ClassModem::getLastByte()         { return server.getLastByte(); }
  514. bool ClassModem::didBlockEnd()        { return server.didBlockEnd(); }
  515. void ClassModem::resetBlock()         { server.resetBlock(); }
  517. bool
  518. ClassModem::putModemDLEData(const u_char* data, u_int cc, const u_char* bitrev, long ms, bool doquery)
  519. {
  520.     u_char dlebuf[2*1024];
  521.     while (cc > 0) {
  522. if (wasTimeout() || abortRequested())
  523.     return (false);
  524. /*
  525.  * Copy to temp buffer, doubling DLE's.
  526.  */
  527. u_int i, j;
  528. u_int n = fxmin((size_t) cc, sizeof (dlebuf)/2);
  529. for (i = 0, j = 0; i < n; i++, j++) {
  530.     dlebuf[j] = bitrev[data[i]];
  531.     if (dlebuf[j] == DLE)
  532. dlebuf[++j] = DLE;
  533. }
  534. if (!putModem(dlebuf, j, ms))
  535.     return (false);
  536. data += n;
  537. cc -= n;
  538. /*
  539.  * Fax is half-duplex.  Thus, we shouldn't typically need to read
  540.  * data from the modem while we are transmitting.  However, Phase C
  541.  * can be long, and things can go wrong, and it will be nice to
  542.  * see the timing of any messages that will come from the modem,
  543.  * instead of letting them buffer.  Furthermore, advanced Class 2 
  544.  * debugging will send us messages during Phase C.  So in those
  545.  * cases when it will be useful, we query the modem during transmits.
  546.  *
  547.  * In the cases where things do go wrong, we'll need to begin
  548.  * building-in the intelligence to handle that here.  But we have
  549.  * to wait and see what turns up in order to do that.
  550.  */
  551. if (doquery) {
  552.     int c;
  553.     fxStr dbdata;
  554.     do {
  555.         c = getModemChar(0, true);
  556. if (c != EOF && c != '' && c != 'r' && c != 'n')
  557.     dbdata.append(c);
  558. else if (dbdata.length()) {
  559.     protoTrace("DCE DEBUG: %s", (const char*) dbdata);
  560.     dbdata = "";
  561. }
  562.     } while (c != EOF);
  563. }
  564.     }
  565.     return (true);
  566. }
  568. void ClassModem::flushModemInput()
  569.     { server.modemFlushInput(); }
  570. bool ClassModem::putModem(void* d, int n, long ms)
  571.     { return server.putModem(d, n, ms); }
  572. bool ClassModem::putModemData(void* d, int n, long ms)
  573.     { return server.putModem(d, n, (ms == -1) ? dataTimeout : ms); }
  575. bool
  576. ClassModem::putModemLine(const char* cp, long ms)
  577. {
  578.     u_int cc = strlen(cp);
  579.     server.traceStatus(FAXTRACE_MODEMCOM, "<-- [%u:%s\r]", cc+1, cp);
  580.     static const char CR = 'r';
  581.     return (server.putModem1(cp, cc, ms) && server.putModem1(&CR, 1, ms));
  582. }
  584. void ClassModem::startTimeout(long ms) { server.startTimeout(ms); }
  585. void ClassModem::stopTimeout(const char* w){ server.stopTimeout(w); }
  587. const u_int MSEC_PER_SEC = 1000;
  589. #include <sys/time.h>
  590. #if HAS_SELECT_H
  591. #include <sys/select.h>
  592. #endif
  594. void
  595. ClassModem::pause(u_int ms)
  596. {
  597.     if (ms == 0)
  598. return;
  599.     protoTrace("DELAY %u ms", ms);
  600.     struct timeval tv;
  601.     tv.tv_sec = ms / MSEC_PER_SEC;
  602.     tv.tv_usec = (ms % MSEC_PER_SEC) * 1000;
  603.     (void) select(0, 0, 0, 0, &tv);
  604. }
  606. void
  607. ClassModem::setupDefault(fxStr& s, const fxStr& configured, const char* def)
  608. {
  609.     if (configured == "")
  610. s = def;
  611.     else
  612. s = configured;
  613. }
  615. /*
  616.  * Reset the modem and set the DTE-DCE rate.
  617.  */
  618. bool
  619. ClassModem::selectBaudRate(BaudRate br, FlowControl i, FlowControl o)
  620. {
  621.     rate = br;
  622.     iFlow = i;
  623.     oFlow = o;
  624.     return (reset(5*1000) || reset(5*1000)); // NB: try at most twice
  625. }
  627. bool ClassModem::sendBreak(bool pause)
  628.     { return server.sendBreak(pause); }
  629. bool
  630. ClassModem::setBaudRate(BaudRate r)
  631. {
  632.     if (server.setBaudRate(r)) {
  633. if (conf.baudRateDelay)
  634.     pause(conf.baudRateDelay);
  635. return (true);
  636.     } else
  637. return (false);
  638. }
  639. bool
  640. ClassModem::setBaudRate(BaudRate r, FlowControl i, FlowControl o)
  641. {
  642.     iFlow = i;
  643.     oFlow = o;
  644.     rate = r;
  645.     if (server.setBaudRate(r,i,o)) {
  646. if (conf.baudRateDelay)
  647.     pause(conf.baudRateDelay);
  648. return (true);
  649.     } else
  650. return (false);
  651. }
  652. bool
  653. ClassModem::setXONXOFF(FlowControl i, FlowControl o, SetAction a)
  654. {
  655.     iFlow = i;
  656.     oFlow = o;
  657.     return server.setXONXOFF(i, o, a);
  658. }
  660. bool ClassModem::setDTR(bool onoff)
  661.     { return server.setDTR(onoff); }
  662. bool ClassModem::setInputBuffering(bool onoff)
  663.     { return server.setInputBuffering(onoff); }
  664. bool ClassModem::modemStopOutput()
  665.     { return server.modemStopOutput(); }
  667. /*
  668.  * Miscellaneous server interfaces hooks.
  669.  */
  671. bool ClassModem::abortRequested()
  672.     { return server.abortRequested(); }
  674. void ClassModem::beginTimedTransfer() { server.timeout = false; }
  675. void ClassModem::endTimedTransfer() {}
  676. bool ClassModem::wasTimeout() { return server.timeout; }
  677. void ClassModem::setTimeout(bool b) { server.timeout = b; }
  679. /*
  680.  * Parsing support routines.
  681.  */
  683. /*
  684.  * Cleanup a response line from the modem.  This removes
  685.  * leading white space and any prefixing "+F<mumble>=" crap
  686.  * that some Class 2 modems put at the front, as well as
  687.  * any trailing white space.
  688.  */
  689. void
  690. ClassModem::trimModemLine(char buf[], int& cc)
  691. {
  692.     // trim trailing white space
  693.     if (cc > 0 && isspace(buf[cc-1])) {
  694. do {
  695.     cc--;
  696. } while (cc > 0 && isspace(buf[cc-1]));
  697. buf[cc] = '';
  698.     }
  699.     if (cc > 0) {
  700. int i = 0;
  701. // leading white space
  702. while (i < cc && isspace(buf[i]))
  703.     i++;
  704. // check for a leading +F<mumble>=
  705. if (i+1 < cc && buf[i] == '+' && buf[i+1] == 'F') {
  706.     u_int j = i;
  707.     for (i += 2; i < cc && buf[i] != '='; i++)
  708.  ;
  709.     if (i < cc) { // trim more white space
  710. for (i++; i < cc && isspace(buf[i]); i++)
  711.     ;
  712.     } else // no '=', back out
  713. i = j;
  714. }
  715. cc -= i;
  716. memmove(buf, buf+i, cc+1);
  717.     }
  718. }
  720.     /*
  721.      * The modem drivers and main server code require:
  722.      *
  723.      * echoOff command echo disabled
  724.      * verboseResults verbose command result strings
  725.      * resultCodes result codes enabled
  726.      * onHook modem initially on hook (hung up)
  727.      * noAutoAnswe no auto-answer (we do it manually)
  728.      *
  729.      * In addition the following configuration is included
  730.      * in the reset command set:
  731.      *
  732.      * flowControl DCE-DTE flow control method
  733.      * setupDTR DTR management technique
  734.      * setupDCD DCD management technique
  735.      * pauseTime time to pause for "," when dialing
  736.      * waitTime time to wait for carrier when dialing
  737.      *
  738.      * Any other modem-specific configuration that needs to
  739.      * be done at reset time should be implemented by overriding
  740.      * the ClassModem::reset method.
  741.      */
  742. bool
  743. ClassModem::reset(long ms)
  744. {
  745.     if (conf.dtrDropDelay) {
  746. setDTR(false);
  747. pause(conf.dtrDropDelay); // required DTR OFF-to-ON delay
  748. setDTR(true);
  749. pause(conf.resetDelay); // pause so modem can do reset
  750.     }
  751. #ifndef CONFIG_NOREOPEN
  752.     /*
  753.      * On some systems lowering and raising DTR is not done
  754.      * properly (DTR is not raised when requested); thus we
  755.      * reopen the device to insure that DTR is reasserted.
  756.      */
  757.     server.reopenDevice();
  758. #endif
  759.     if (!setBaudRate(rate, iFlow, oFlow)) {
  760.         return (false);
  761.     }
  762.     flushModemInput();
  763.     /*
  764.      * Perform a soft reset as well to ensure the modem
  765.      * is in a stable state before sending the additional
  766.      * reset commands.  Depending on the modem and its
  767.      * state, we may wait 30 sec for OK repsonse.
  768.      */
  769.     if ( true != atCmd(conf.softResetCmd, AT_OK, 30*1000) ) {
  770.         return false;
  771.     }
  773.     /*
  774.      * Some modems require a pause after ATZ before they can
  775.      * accept any more commands although they have already
  776.      * replied OK to the ATZ command.
  777.      */
  778.     pause(conf.softResetCmdDelay);
  780.     // some modems result with OK *twice* after ATZ, so flush it
  781.     flushModemInput();
  783.     if ( true != atCmd(conf.resetCmds, AT_OK, ms) ) {
  784.         return false;
  785.     }
  786.     if ( true != atCmd(conf.noAutoAnswerCmd, AT_OK, ms) ) {
  787.         return false;
  788.     }
  789.     if (conf.noAutoAnswerCmdDelay) {
  790. /* Some modems do funny things after ATS0=0. */
  791. pause(conf.noAutoAnswerCmdDelay);
  792. flushModemInput();
  793.     }
  794.     if ( true != atCmd(conf.echoOffCmd, AT_OK, ms) ) {
  795.         return false;
  796.     }
  797.     if ( true != atCmd(conf.verboseResultsCmd, AT_OK, ms) ) {
  798.         return false;
  799.     }
  800.     if ( true != atCmd(conf.resultCodesCmd, AT_OK, ms) ) {
  801.         return false;
  802.     }
  803.     // some modems do not accept standard onHookCmd (ATH0) when
  804.     // they are allready on hook
  805. //    if ( true != atCmd(conf.onHookCmd, AT_OK, ms) ) {
  806. //        return false;
  807. //    }
  808.     if ( true != atCmd(conf.pauseTimeCmd, AT_OK, ms) ) {
  809.         return false;
  810.     }
  811.     if ( true != atCmd(conf.waitTimeCmd, AT_OK, ms) ) {
  812.         return false;
  813.     }
  814.     if ( true != atCmd(conf.getFlowCmd(conf.flowControl), AT_OK, ms) ) {
  815.         return false;
  816.     }
  817.     if ( true != atCmd(conf.setupDTRCmd, AT_OK, ms) ) {
  818.         return false;
  819.     }
  820.     if ( true != atCmd(conf.setupDCDCmd, AT_OK, ms) ) {
  821.         return false;
  822.     }
  824.     return true;
  825. }
  827. /*
  828.  * Some scenarios require a "ready" command sequence to occur
  829.  * to, for example, un-busy a line (DID) or otherwise ready
  830.  * the modem for incoming calls after the rest of the
  831.  * initialization has already occurred.
  832.  */
  833. bool
  834. ClassModem::ready(long ms)
  835. {
  836.     return atCmd(conf.readyCmds, AT_OK, ms);
  837. }
  839. bool
  840. ClassModem::sync(long ms)
  841. {
  842.     return waitFor(AT_OK, ms);
  843. }
  845. ATResponse
  846. ClassModem::atResponse(char* buf, long ms)
  847. {
  848.     bool prevTimeout = wasTimeout();
  849.     int n = getModemLine(buf, sizeof (rbuf), ms);
  850.     if (!prevTimeout && wasTimeout())
  851. lastResponse = AT_TIMEOUT;
  852.     else if (n <= 0)
  853. lastResponse = AT_EMPTYLINE;
  854.     else {
  855. lastResponse = AT_OTHER;
  856. switch (buf[0]) {
  857. case 'B':
  858.     if (strneq(buf, "BUSY", 4))
  859. lastResponse = AT_BUSY;
  860.     break;
  861. case 'C':
  862.     if (strneq(buf, "CONNECT", 7))
  863. lastResponse = AT_CONNECT;
  864.     break;
  865. case 'D':
  866.     if (strneq(buf, "DTMF", 4))
  867. lastResponse = AT_DTMF;
  868.     break;
  869. case 'E':
  870.     if (strneq(buf, "ERROR", 5))
  871. lastResponse = AT_ERROR;
  872.     break;
  873. case 'N':
  874.     if (strneq(buf, "NO CARRIER", 10))
  875. lastResponse = AT_NOCARRIER;
  876.     else if (strneq(buf, "NO DIAL", 7)) // NO DIALTONE or NO DIAL TONE
  877. lastResponse = AT_NODIALTONE;
  878.     else if (strneq(buf, "NO ANSWER", 9))
  879. lastResponse = AT_NOANSWER;
  880.     break;
  881. case 'O':
  882.     if (strneq(buf, "OK", 2))
  883. lastResponse = AT_OK;
  884.     break;
  885. case 'P':
  886.     if (strneq(buf, "PHONE OFF-HOOK", 14))
  887. lastResponse = AT_OFFHOOK;
  888.     break;
  889. case 'R':
  890.     if (streq(buf, "RING")) // NB: avoid match of RINGING
  891. lastResponse = AT_RING;
  892.     break;
  893. case 'V':
  894.     if (streq(buf, "VCON"))
  895. lastResponse = AT_VCON;
  896.     break;
  897. case '20':
  898.     if (streq(buf, "2003")) // DLE/ETX
  899. lastResponse = AT_DLEETX;
  900.     if (streq(buf, "2004"))
  901. lastResponse = AT_DLEEOT; // DLE+EOT
  902.     break;
  903. case '21':
  904.     if (streq(buf, "21")) // DC1 (XON)
  905. lastResponse = AT_XON;
  906.     break;
  907. }
  908.     }
  909.     return lastResponse;
  910. }
  912. #define isLineBreak(c) ((c) == 'n' || (c) == 'r')
  913. #define isEscape(c) ((c) & 0x80)
  914. /*
  915.  * Send an AT command string to the modem and, optionally
  916.  * wait for status responses.  This routine breaks multi-line
  917.  * strings (demarcated by embedded n's) and waits for each
  918.  * intermediate response.  Embedded escape sequences for
  919.  * changing the DCE-DTE communication rate and/or host-modem
  920.  * flow control scheme are also recognized and handled.
  921.  */
  922. bool
  923. ClassModem::atCmd(const fxStr& cmd, ATResponse r, long ms)
  924. {
  925.     u_int cmdlen;
  926.     u_int pos;
  927.     bool respPending;
  928.     if (lastResponse == AT_RING) lastResponse = AT_NOTHING;
  929.     do {
  930. cmdlen = cmd.length();
  931. pos = 0;
  932. respPending = false;
  934. /*
  935.  * Scan string for line breaks and escape codes (byte w/ 0x80 set).
  936.  * A line break causes the current string to be sent to the modem
  937.  * and a return status string parsed (and possibly compared to an
  938.  * expected response).  An escape code terminates scanning,
  939.  * with any pending string flushed to the modem before the
  940.  * associated commands are carried out.  All commands are sent in
  941.  * uppercase.
  942.  */
  943. u_int i = 0;
  944. while (i < cmdlen) {
  945.     if (isLineBreak(cmd[i]) && !(i+1 < cmdlen && isEscape(cmd[i+1]))) {
  946. /*
  947.  * No escape code follows, send partial string
  948.  * to modem and await status string if necessary.
  949.  */
  950. if (conf.atCmdDelay)
  951.     pause(conf.atCmdDelay);
  952. fxStr command = cmd.extract(pos, i-pos);
  953. if (conf.raiseATCmd) command.raiseatcmd();
  954. if (!putModemLine(command, ms))
  955.     return (false);
  956. pos = ++i; // next segment starts after line break
  957. if (r != AT_NOTHING) {
  958.     if (!waitFor(r, ms))
  959. return (false);
  960. } else {
  961.     if (!waitFor(AT_OK, ms))
  962. return (false);
  963. }
  964. respPending = false;
  965.     } else if (isEscape(cmd[i])) {
  966. /*
  967.  * Escape code; flush any partial line, process
  968.  * escape codes and carry out their actions.
  969.  */
  970. ATResponse resp = AT_NOTHING;
  971. if (i > pos) {
  972.     if (conf.atCmdDelay)
  973. pause(conf.atCmdDelay);
  974.     if (isLineBreak(cmd[i-1])) {
  975. /*
  976.  * Send data with a line break and arrange to
  977.  * collect the expected response (possibly
  978.  * specified through a <waitfor> escape processed
  979.  * below).  Note that we use putModemLine, as
  980.  * above, so that the same line break is sent
  981.  * to the modem for all segments (i.e. n is
  982.  * translated to r).
  983.  */
  984. fxStr command = cmd.extract(pos, i-1-pos);
  985. if (conf.raiseATCmd) command.raiseatcmd();
  986. if (!putModemLine(command, ms))
  987.     return (false);
  988. // setup for expected response
  989. resp = (r != AT_NOTHING ? r : AT_OK);
  990.     } else {
  991. /*
  992.  * Flush any data as-is, w/o adding a line
  993.  * break or expecting a response.  This is
  994.  * important for sending, for example, a
  995.  * command escape sequence such as "+++".
  996.  */
  997. u_int cc = i-pos;
  998. const char* cp = &cmd[pos];
  999. server.traceStatus(FAXTRACE_MODEMCOM, "<-- [%u:%s]", cc,cp);
  1000. if (!server.putModem1(cp, cc))
  1001.     return (false);
  1002.     }
  1003.     respPending = true;
  1004. }
  1005. /*
  1006.  * Process escape codes.
  1007.  */
  1008. BaudRate br = rate;
  1009. FlowControl flow = flowControl;
  1010. u_int delay = 0;
  1011. do {
  1012.     switch (cmd[i] & 0xff) {
  1013.     case ESC_SETBR: // set host baud rate
  1014. br = (u_char) cmd[++i];
  1015. if (br != rate) {
  1016.     setBaudRate(br);
  1017.     rate = br;
  1018. }
  1019. break;
  1020.     case ESC_SETFLOW: // set host flow control
  1021. flow = (u_char) cmd[++i];
  1022. if (flow != flowControl) {
  1023.     setBaudRate(br, flow, flow);
  1024.     flowControl = flow;
  1025. }
  1026. break;
  1027.     case ESC_DELAY: // host delay
  1028. delay = (u_char) cmd[++i];
  1029. if (delay != 0)
  1030.     pause(delay*10); // 10 ms granularity
  1031. break;
  1032.     case ESC_WAITFOR: // wait for response
  1033. resp = (u_char) cmd[++i];
  1034.         if (resp != AT_NOTHING) {
  1035.     // XXX check return?
  1036.     // The timeout setting here (60*1000) used to be "ms" (which
  1037.     // defaults to 30 s), but we find that's too short, especially 
  1038.     // for long-running escape sequences.  It really needs to be
  1039.     // escape-configurable, but for now we just make it 60 s.
  1040.     (void) waitFor(resp, 60*1000);
  1041.     respPending = false;
  1042. }
  1043. break;
  1044.     case ESC_FLUSH: // flush input
  1045. flushModemInput();
  1046. break;
  1047.     case ESC_PLAY:
  1048. {
  1049.     fxStr filename = fxStr("etc/play");
  1050.     filename.append(cmd[++i]);
  1051.     filename.append(".raw");
  1052.     protoTrace("Playing file "%s".", (const char*) filename);
  1053.     int fd = open((const char*) filename, O_RDONLY);
  1054.     if (fd > 0) {
  1055. u_char buf[1024];
  1056. int len, pos;
  1057. do {
  1058.     pos = 0;
  1059.     do {
  1060. len = read(fd, &buf[pos], 1);
  1061. if (buf[pos] == 0x10) buf[++pos] = 0x10;
  1062. pos++;
  1063.     } while (len > 0 &&  (u_int) pos < sizeof(buf) - 1);
  1064.     putModem(&buf[0], pos, getDataTimeout());
  1065. } while (len > 0);
  1066. close(fd);
  1067.     } else {
  1068. protoTrace("Unable to open file "%s" for reading.", (const char*) filename);
  1069.     }
  1070.     u_char buf[2];
  1071.     buf[0] = DLE; buf[1] = ETX;
  1072.     putModem(buf, 2, getDataTimeout());
  1073. }
  1074. break;
  1075.     }
  1076. } while (++i < cmdlen && isEscape(cmd[i]));
  1077. pos = i; // next segment starts here
  1078. if (respPending) {
  1079.     /*
  1080.      * If a segment with a line break was flushed
  1081.      * but no explicit <waitfor> escape followed
  1082.      * then collect the response here so that it
  1083.      * does not get lost.
  1084.      */
  1085.     if (resp != AT_NOTHING && !waitFor(resp, ms))
  1086. return (false);
  1087.     respPending = false;
  1088. }
  1089.     } else
  1090. i++;
  1091. }
  1092. /*
  1093.  * Flush any pending string to modem.
  1094.  */
  1095. if (i > pos) {
  1096.     if (conf.atCmdDelay)
  1097. pause(conf.atCmdDelay);
  1098.     fxStr command = cmd.extract(pos, i-pos);
  1099.     if (conf.raiseATCmd) command.raiseatcmd();
  1100.     if (!putModemLine(command, ms))
  1101. return (false);
  1102.     respPending = true;
  1103. }
  1104. /*
  1105.  * Wait for any pending response.
  1106.  */
  1107. if (respPending) {
  1108.     if (r != AT_NOTHING && !waitFor(r, ms)) {
  1109. if (lastResponse != AT_RING) {
  1110.     return (false);
  1111. } else {
  1112.     // wait for result, but some modem's don't result after glare
  1113.     if (r != AT_NOTHING && !waitFor(r, ms)) {
  1114. lastResponse = AT_RING;
  1115.     }
  1116. }
  1117.     }
  1118. }
  1119.     } while (lastResponse == AT_RING);
  1120.     return (true);
  1121. }
  1122. #undef isEscape
  1123. #undef isLineBreak
  1125. /*
  1126.  * Wait (carefully) for some response from the modem.
  1127.  */
  1128. bool
  1129. ClassModem::waitFor(ATResponse wanted, long ms)
  1130. {
  1131.     for (;;) {
  1132. ATResponse response = atResponse(rbuf, ms);
  1133. if (response == wanted)
  1134.     return (true);
  1136. // we need to translate AT responses from faxd/Class2.h
  1137. if (response == 100) response = AT_FHNG;
  1139. switch (response) {
  1140. case AT_TIMEOUT:
  1141. case AT_EMPTYLINE:
  1142. case AT_ERROR:
  1143. case AT_NOCARRIER:
  1144. case AT_NODIALTONE:
  1145. case AT_NOANSWER:
  1146. case AT_BUSY:
  1147. case AT_OFFHOOK:
  1148. case AT_RING:
  1149. case AT_FHNG:
  1150.     modemTrace("MODEM %s", ATresponses[response]);
  1151. case AT_OK:
  1152.     /*
  1153.      * If we get OK and aren't expecting it then we're back in command-mode
  1154.      * and our previous command failed to acheive the desired result.
  1155.      */
  1156.     return (false);
  1157. }
  1158.     }
  1159. }
  1161. /*
  1162.  * Process a manufacturer/model/revision query.
  1163.  */
  1164. bool
  1165. ClassModem::doQuery(const fxStr& queryCmd, fxStr& result, long ms)
  1166. {
  1167.     if (queryCmd == "")
  1168. return (true);
  1169.     if (queryCmd[0] == '!') {
  1170. /*
  1171.  * ``!mumble'' is interpreted as "return mumble";
  1172.  * this means that you can't send ! to the modem.
  1173.  */
  1174. result = queryCmd.tail(queryCmd.length()-1);
  1175. return (true);
  1176.     }
  1177.     return (atQuery(queryCmd, result, ms));
  1178. }
  1180. /*
  1181.  * Return modem manufacturer.
  1182.  */
  1183. bool
  1184. ClassModem::setupManufacturer(fxStr& mfr)
  1185. {
  1186.     return doQuery(mfrQueryCmd, mfr);
  1187. }
  1189. /*
  1190.  * Return modem model identification.
  1191.  */
  1192. bool
  1193. ClassModem::setupModel(fxStr& model)
  1194. {
  1195.     return doQuery(modelQueryCmd, model);
  1196. }
  1198. /*
  1199.  * Return modem firmware revision.
  1200.  */
  1201. bool
  1202. ClassModem::setupRevision(fxStr& rev)
  1203. {
  1204.     return doQuery(revQueryCmd, rev);
  1205. }
  1207. /*
  1208.  * Send AT<what>? and get a string response.
  1209.  */
  1210. bool
  1211. ClassModem::atQuery(const char* what, fxStr& v, long ms)
  1212. {
  1213.     ATResponse r = AT_ERROR;
  1214.     if (atCmd(what, AT_NOTHING)) {
  1215. v.resize(0);
  1216. while ((r = atResponse(rbuf, ms)) != AT_OK) {
  1217.     if (r == AT_ERROR || r == AT_TIMEOUT || r == AT_EMPTYLINE)
  1218. break;
  1219.     if (v.length())
  1220. v.append('n');
  1221.     v.append(rbuf);
  1222. }
  1223.     }
  1224.     return (r == AT_OK);
  1225. }
  1227. /*
  1228.  * Send AT<what>? and get a range response.
  1229.  */
  1230. bool
  1231. ClassModem::atQuery(const char* what, u_int& v, long ms)
  1232. {
  1233.     char response[1024];
  1234.     if (atCmd(what, AT_NOTHING) && atResponse(response) == AT_OTHER) {
  1235. sync(ms);
  1236. return parseRange(response, v);
  1237.     }
  1238.     return (false);
  1239. }
  1241. /*
  1242.  * Parsing support routines.
  1243.  */
  1245. const char OPAREN = '(';
  1246. const char CPAREN = ')';
  1247. const char COMMA = ',';
  1248. const char SPACE = ' ';
  1250. /*
  1251.  * Parse a Class 2 parameter range string.  This is very
  1252.  * forgiving because modem vendors do not exactly follow
  1253.  * the syntax specified in the "standard".  Try looking
  1254.  * at some of the responses given by rev ~4.04 of the
  1255.  * ZyXEL firmware (for example)!
  1256.  *
  1257.  * This can also get complicated in that the parameters may
  1258.  * be in hexadecimal or decimal notation.  If in the future
  1259.  * a standard way to "detect" the presence of future hex values
  1260.  * (i.e. the <low> value is "00" instead of "0") may be found.
  1261.  * For now we just use Class2UseHex.
  1262.  *
  1263.  * NB: We accept alphanumeric items but don't return them
  1264.  *     in the parsed range so that modems like the ZyXEL 2864
  1265.  *     that indicate they support ``Class Z'' are handled.
  1266.  */
  1267. bool
  1268. ClassModem::vparseRange(const char* cp, int masked, int nargs ... )
  1269. {
  1270.     bool b = true;
  1271.     va_list ap;
  1272.     va_start(ap, nargs);
  1273.     while (nargs-- > 0) {
  1274. while (cp[0] == SPACE)
  1275.     cp++;
  1276. char matchc;
  1277. bool acceptList;
  1278. if (cp[0] == OPAREN) { // (<items>)
  1279.     matchc = CPAREN;
  1280.     acceptList = true;
  1281.     cp++;
  1282. } else if (isalnum(cp[0])) { // <item>
  1283.     matchc = COMMA;
  1284.     acceptList = (nargs == 0);
  1285. } else { // skip to comma
  1286.     b = false;
  1287.     break;
  1288. }
  1289. int mask = 0;
  1290. while (cp[0] && cp[0] != matchc) {
  1291.     if (cp[0] == SPACE) { // ignore white space
  1292. cp++;
  1293. continue;
  1294.     }
  1295.     if (!isalnum(cp[0])) {
  1296. b = false;
  1297. goto done;
  1298.     }
  1299.     int v;
  1300.     if (conf.class2UseHex) { // read as hex
  1301. if (isxdigit(cp[0])) {
  1302.     char *endp;
  1303.     v = (int) strtol(cp, &endp, 16);
  1304.     cp = endp;
  1305. } else {
  1306.     v = -1; // XXX skip item below
  1307.     while (isalnum((++cp)[0]));
  1308. }
  1309.     } else { // assume decimal
  1310. if (isdigit(cp[0])) {
  1311.     v = 0;
  1312.     do {
  1313. v = v*10 + (cp[0] - '0');
  1314.     } while (isdigit((++cp)[0]));
  1315. } else {
  1316.     v = -1; // XXX skip item below
  1317.     while (isalnum((++cp)[0]));
  1318. }
  1319.     }
  1320.     int r = v;
  1321.     if (cp[0] == '-') { // <low>-<high>
  1322. cp++;
  1323. if (conf.class2UseHex) { // read as hex
  1324.     if (!isxdigit(cp[0])) {
  1325. b = false;
  1326. goto done;
  1327.     }
  1328.     char *endp;
  1329.     r = (int) strtol(cp, &endp, 16);
  1330.     cp = endp;
  1331. } else { // assume decimal
  1332.     if (!isdigit(cp[0])) {
  1333. b = false;
  1334. goto done;
  1335.     }
  1336.     r = 0;
  1337.     do {
  1338. r = r*10 + (cp[0] - '0');
  1339.     } while (isdigit((++cp)[0]));
  1340. }
  1341.     } else if (cp[0] == '.') { // <d.b>
  1342. cp++;
  1343. if (v == 2) {
  1344.     if (cp[0] == '1') { // 2.1 -> 5
  1345. v = 5;
  1346. r = 5;
  1347.     } else { // 2.0 -> 3
  1348. v = 3;
  1349. r = 3;
  1350.     }
  1351. } else { // 1.0 -> 4
  1352. v = 4;
  1353. r = 4;
  1354. }
  1355. while (isdigit(cp[0])) // XXX
  1356.     cp++;
  1357.     }
  1358.     if (v != -1) { // expand range or list
  1359. if ((BIT(nargs) & masked) == BIT(nargs)) {
  1360.     /*
  1361.      * These are pre-masked values. T.32 Table 21 gives valid
  1362.      * values as: 00, 01, 02, 04, 08, 10, 20, 40 (hex).
  1363.      *
  1364.      * Some modems may say "(00-7F)" when what's meant is
  1365.      * "(00-40)" or simply "(7F)".
  1366.      */
  1367.     if (v == 00 && r == 127)
  1368. v = r = 127;
  1369.     if (v == r)
  1370. mask = v;
  1371.     else {
  1372. r = fxmin(r, 64); // clamp to valid range
  1373. mask = 0;
  1374. for (; v <= r; v++)
  1375.     if (v == 0 || v == 1 || v == 2 || v == 4 || v == 8 || v == 16 || v == 32 || v == 64)
  1376. mask += v;
  1377.     }
  1378. } else {
  1379.     r = fxmin(r, 31); // clamp to valid range
  1380.     for (; v <= r; v++)
  1381. mask |= 1<<v;
  1382. }
  1383.     }
  1384.     if (acceptList && cp[0] == COMMA) // (<item>,<item>...)
  1385. cp++;
  1386. }
  1387. *va_arg(ap, int*) = mask;
  1388. if (cp[0] == matchc)
  1389.     cp++;
  1390. if (matchc == CPAREN && cp[0] == COMMA)
  1391.     cp++;
  1392.     }
  1393. done:
  1394.     va_end(ap);
  1395.     return (b);
  1396. }
  1398. /*
  1399.  * Parse a single Class X range specification
  1400.  * and return the resulting bit mask.
  1401.  */
  1402. bool
  1403. ClassModem::parseRange(const char* cp, u_int& a0)
  1404. {
  1405.     return vparseRange(cp, 0, 1, &a0);
  1406. }
  1408. void
  1409. ClassModem::setSpeakerVolume(SpeakerVolume l)
  1410. {
  1411.     atCmd(conf.setVolumeCmd[l], AT_OK, 5000);
  1412. }
  1414. void
  1415. ClassModem::hangup()
  1416. {
  1417.     atCmd(conf.onHookCmd, AT_OK, 5000);
  1418. }
  1420. bool
  1421. ClassModem::poke()
  1422. {
  1423.     return atCmd("AT", AT_OK, 5000);
  1424. }
  1426. bool
  1427. ClassModem::waitForRings(u_short rings, CallType& type, CallID& callid)
  1428. {
  1429.     bool gotring = false;
  1430.     u_int i = 0, count = 0;
  1431.     int incadence[5] = { 0, 0, 0, 0, 0 };
  1432.     time_t timeout = conf.ringTimeout/1000; // 6 second/ring
  1433.     time_t start = Sys::now();
  1434.     do {
  1435. switch (atResponse(rbuf, conf.ringTimeout)) {
  1436. case AT_DTMF:
  1437. case AT_OTHER: // check distinctive ring
  1438.     if (streq(conf.ringData, rbuf))
  1439. type = CALLTYPE_DATA;
  1440.     else if (streq(conf.ringFax, rbuf))
  1441. type = CALLTYPE_FAX;
  1442.     else if (streq(conf.ringVoice, rbuf))
  1443. type = CALLTYPE_VOICE;
  1444.     else if (conf.dringOff.length() && strneq(conf.dringOff, rbuf, conf.dringOff.length())) {
  1445.         if (count++ == 0) break;         //discard initial DROFF code if present
  1446.         incadence[i++] = -atoi(rbuf + conf.dringOff.length());
  1447.         break;
  1448.     } else if (conf.dringOn.length() && strneq(conf.dringOn, rbuf, conf.dringOn.length())) {
  1449.         ++count;
  1450.         incadence[i++] = atoi(rbuf + conf.dringOn.length());
  1451.         break;
  1452.     } else {
  1453. if (conf.ringExtended.length() && strneq(rbuf, conf.ringExtended, conf.ringExtended.length())) // extended RING
  1454.     gotring = true;
  1455. conf.parseCallID(rbuf, callid);
  1456. /* DID modems may send DID data in lieu of RING */
  1457. for (u_int i = 0; i < conf.idConfig.length(); i++) {
  1458.     if (conf.idConfig[i].answerlength && callid.length(i) >= conf.idConfig[i].answerlength)
  1459. gotring = true;
  1460. }
  1461. break;
  1462.     }
  1463.     /* fall thru... */
  1464. case AT_RING: // normal ring
  1465.     if (conf.ringResponse != "" && rings+1U >= conf.ringsBeforeResponse) {
  1466. // With the MT1932ZDX we must respond ATH1>DT1 in order
  1467. // to hear DTMF tones which are DID data, and we configure
  1468. // RingExtended to be FAXCNG to then trigger ATA.
  1469. atCmd(conf.ringResponse, AT_NOTHING);
  1470. ATResponse r;
  1471. time_t ringstart = Sys::now();
  1472. bool callidwasempty = true, cmddone = false;
  1473. for (u_int i = 0; callidwasempty && i < callid.size(); i++)
  1474.     if (callid.length(i) )
  1475. callidwasempty = false;
  1476. do {
  1477.     r = atResponse(rbuf, 3000);
  1478.     if (r == AT_OTHER && callidwasempty) {
  1479. /*
  1480.  * Perhaps a modem will repeat CID/DID info for us
  1481.  * with AT+VRID if we missed it before.
  1482.  */
  1483. conf.parseCallID(rbuf, callid);
  1484.     }
  1485.     if (r == AT_OK) cmddone = true;
  1486.     else if (r == AT_VCON) cmddone = true; // VCON for modems that require ATA
  1487. } while (!cmddone && (Sys::now()-ringstart < 3));
  1488. for (u_int j = 0 ; j < conf.idConfig.length(); j++) {
  1489.     if (conf.idConfig[j].pattern == "SHIELDED_DTMF") { // retrieve DID, e.g. via voice DTMF
  1490. ringstart = Sys::now();
  1491. bool marked = false, gotdigit = false;
  1492. do {
  1493.     int c = server.getModemChar(10000);
  1494.     if (c == 0x10) c = server.getModemChar(10000);
  1495.     if (c == 0x23 || c == 0x2A || (c >= 0x30 && c <= 0x39)) {
  1496. // a DTMF digit was received...
  1497. if (!marked || (marked && !gotdigit)) {
  1498.     protoTrace("MODEM HEARD DTMF: %c", c);
  1499.     callid[j].append(fxStr::format("%c", c));
  1500.     gotdigit = true;
  1501. }
  1502.     } else if (c == 0x2F) {
  1503. // got IS-101 DTMF lead marker
  1504. marked = true;
  1505. gotdigit = false;
  1506.     } else if (c == 0x7E) {
  1507. // got IS-101 DTMF end marker
  1508. marked = false;
  1509. gotdigit = false;
  1510.     } else if (c == 0x73) {
  1511. // got silence, keep waiting
  1512. protoTrace("MODEM HEARD SILENCE");
  1513.     } else if (c == 0x62) {
  1514. // got busy tone, fail
  1515. protoTrace("MODEM HEARD BUSY");
  1516. return (false);
  1517.     } else if (c == 0x63) {
  1518. // got CNG tone, we're not going to get more DTMF, trigger answering
  1519. protoTrace("MODEM HEARD CNG");
  1520. break;
  1521.     }
  1522. } while (callid.length(j) < conf.idConfig[j].answerlength && (Sys::now()-ringstart < 10));
  1523. /*
  1524.  * If the sender doesn't send enough DTMF then we want to answer anyway.
  1525.  */
  1526. while (callid.length(j) < conf.idConfig[j].answerlength) callid[j].append(" ");
  1527.     }
  1528. }
  1529.     }
  1530.     if (conf.dringOn.length()) {              // Compare with all distinctive ring cadences
  1531. modemTrace("WFR: received cadence = %d, %d, %d, %d, %d", incadence[0], incadence[1], incadence[2], incadence[3], incadence[4]);
  1532. type = findCallType(incadence);
  1533.     }
  1534.     gotring = true;
  1535.     break;
  1536. case AT_NOANSWER:
  1537. case AT_NOCARRIER:
  1538. case AT_NODIALTONE:
  1539. case AT_ERROR:
  1540.     return (false);
  1541. }
  1542.     } while (!gotring && Sys::now()-start < timeout);
  1543.     return (gotring);
  1544. }
  1546. CallType ClassModem::findCallType(int vec[])
  1547. {
  1548. // compare x^2 than x to avoid use of math functions
  1550.     double limit = 0.33*0.33;
  1551.     double dif, sum;
  1552.     u_int n, k;
  1553.     for (n=0; n < conf.NoDRings; ++n) {
  1554. for (k=0, sum=0; k < 5; ++k) {
  1555.             dif = vec[k] - conf.distinctiveRings[n].cadence[k];
  1556.             sum += dif*dif;
  1557.         }
  1558. if (sum/conf.distinctiveRings[n].magsqrd < limit)  
  1559.     return conf.distinctiveRings[n].type;
  1560.     }
  1561.     return CALLTYPE_UNKNOWN;
  1562. }
  1564. bool ClassModem::doCallIDDisplay(int i) const { return conf.idConfig[i].display; }
  1565. bool ClassModem::doCallIDRecord(int i) const { return conf.idConfig[i].record; }
  1566. const fxStr& ClassModem::getCallIDLabel(int i) const { return conf.idConfig[i].label; }
  1567. const fxStr& ClassModem::getCallIDType(int i) const { return conf.idConfig[i].type; }