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

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

传真(Fax)编程

开发平台：

C/C++

Class1.c++：源码内容
  1. /* $Id: Class1.c++,v 1.51 2008/07/16 16:17:39 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.  */
  27. /*
  28.  * EIA/TIA-578 (Class 1) Modem Driver.
  29.  */
  30. #include "Sys.h"
  31. #include "Class1.h"
  32. #include "ModemConfig.h"
  33. #include "HDLCFrame.h"
  34. #include "t.30.h"
  35. #include "tiffio.h"
  37. #include <stdlib.h>
  38. #include <ctype.h>
  40. const char* Class1Modem::modulationNames[6] = {
  41.     "v.21, chan 2",
  42.     "v.27ter fallback mode",
  43.     "v.27ter",
  44.     "v.29",
  45.     "v.17",
  46.     "v.33",
  47. };
  48. /*
  49.  * Modem capabilities are queried at startup and a
  50.  * table based on this is created for each modem.
  51.  * This information is used to negotiate T.30 session
  52.  * parameters (e.g. signalling rate).
  53.  *
  54.  * NB: v.17 w/ long training is the same as v.33, at
  55.  *     least at 12000 and 14400.
  56.  */
  57. const Class1Cap Class1Modem::basicCaps[15] = {
  58.     {  3,  0,   0,      V21,   false, 0 },  // v.21
  59.     {  24, BR_2400, DCSSIGRATE_2400V27,  V27FB, false, 1 },  // v.27 ter
  60.     {  48, BR_4800, DCSSIGRATE_4800V27,  V27,   false, 2 },  // v.27 ter
  61.     {  72, BR_7200, DCSSIGRATE_7200V29,  V29,   false, 3 },  // v.29
  62.     {  73, BR_7200, DCSSIGRATE_7200V17,  V17,   false, 4 },  // v.17
  63.     {  74, BR_7200, DCSSIGRATE_7200V17,  V17,   false, 5 },  // v.17 w/st
  64.     {  96, BR_9600, DCSSIGRATE_9600V29,  V29,   false, 6 },  // v.29
  65.     {  97, BR_9600, DCSSIGRATE_9600V17,  V17,   false, 7 },  // v.17
  66.     {  98, BR_9600, DCSSIGRATE_9600V17,  V17,   false, 8 },  // v.17 w/st
  67.     { 121, BR_12000, DCSSIGRATE_12000V33, V33,   false, 9 },  // v.33
  68.     { 121, BR_12000, DCSSIGRATE_12000V17, V17,   false, 10 }, // v.17
  69.     { 122, BR_12000, DCSSIGRATE_12000V17, V17,   false, 11 }, // v.17 w/st
  70.     { 145, BR_14400, DCSSIGRATE_14400V33, V33,   false, 12 }, // v.33
  71.     { 145, BR_14400, DCSSIGRATE_14400V17, V17,   false, 13 }, // v.17
  72.     { 146, BR_14400, DCSSIGRATE_14400V17, V17,   false, 14 }, // v.17 w/st
  73. };
  74. #define NCAPS (sizeof (basicCaps) / sizeof (basicCaps[0]))
  76. const char* Class1Modem::tmCmdFmt = "AT+FTM=%u";
  77. const char* Class1Modem::rmCmdFmt = "AT+FRM=%u";
  79. Class1Modem::Class1Modem(FaxServer& s, const ModemConfig& c)
  80.     : FaxModem(s,c)
  81.     , thCmd("AT+FTH=3")
  82.     , rhCmd("AT+FRH=3")
  83. {
  84.     messageReceived = false;
  85.     memcpy(xmitCaps, basicCaps, sizeof (basicCaps));
  86.     memcpy(recvCaps, basicCaps, sizeof (basicCaps));
  88.     /*
  89.      * Because the sending routines deliver data to the transmit functions
  90.      * in segments, these must be globally available to spool outgoing data
  91.      * until a complete ECM block can be assembled.
  92.      *
  93.      * Besides the contents of ecmBlock, ecmStuffedBlock must be able to
  94.      * hold all sync flag bytes, stuffed bits, and RCP frames.
  95.      */
  96.     u_int fs = 256;
  97.     if (conf.class1ECMFrameSize == 64) fs = 64;
  98.     ecmFrame = (u_char*) malloc(fs + 4);
  99.     fxAssert(ecmFrame != NULL, "ECM procedure error (frame).");
  100.     ecmBlock = (u_char*) malloc((fs + 4) * 256);
  101.     fxAssert(ecmBlock != NULL, "ECM procedure error (block).");
  102.     ecmStuffedBlock = (u_char*) malloc(fs == 256 ? 83000 : 33000);
  103.     fxAssert(ecmStuffedBlock != NULL, "ECM procedure error (stuffed block).");
  104.     gotCTRL = false;
  105.     repeatPhaseB = false;
  106.     silenceHeard = false;
  107.     imagefd = 0;
  108. }
  110. Class1Modem::~Class1Modem()
  111. {
  112.     free(ecmFrame);
  113.     free(ecmBlock);
  114.     free(ecmStuffedBlock);
  115. }
  117. bool
  118. Class1Modem::atCmd(const fxStr& cmd, ATResponse r, long ms)
  119. {
  120.     silenceHeard = false;
  121.     return (ClassModem::atCmd(cmd, r, ms));
  122. }
  124. /*
  125.  * Check if the modem is a Class 1 modem and,
  126.  * if so, configure it for use.
  127.  */
  128. bool
  129. Class1Modem::setupModem(bool isSend)
  130. {
  131.     if (!selectBaudRate(conf.maxRate, conf.flowControl, conf.flowControl))
  132. return (false);
  133.     // Query service support information
  134.     fxStr s;
  135.     if (doQuery(conf.classQueryCmd, s, 5000) && FaxModem::parseRange(s, modemServices))
  136. traceBits(modemServices & SERVICE_ALL, serviceNames);
  137.     if ((modemServices & serviceType) == 0)
  138. return (false);
  139.     atCmd(classCmd);
  141.     /*
  142.      * Query manufacturer, model, and firmware revision.
  143.      * We use the manufacturer especially as a key to
  144.      * working around firmware bugs (yech!).
  145.      */
  146.     if (setupManufacturer(modemMfr)) {
  147. modemCapability("Mfr " | modemMfr);
  148. modemMfr.raisecase();
  149.     }
  150.     (void) setupModel(modemModel);
  151.     (void) setupRevision(modemRevision);
  152.     if (modemModel != "")
  153. modemCapability("Model " | modemModel);
  154.     if (modemRevision != "")
  155. modemCapability("Revision " | modemRevision);
  157.     /*
  158.      * Get modem capabilities and calculate best signalling
  159.      * rate, data formatting capabilities, etc. for use in
  160.      * T.30 negotiations.
  161.      */
  162.     if (!class1Query(conf.class1TMQueryCmd, xmitCaps)) {
  163. serverTrace("Error parsing "+FTM" query response: "%s"", rbuf);
  164. return (false);
  165.     }
  166.     modemParams.br = 0;
  167.     u_int i;
  168.     for (i = 1; i < NCAPS; i++)
  169. if (xmitCaps[i].ok)
  170.     modemParams.br |= BIT(xmitCaps[i].br);
  171.     nonV34br = modemParams.br;
  172.     if (conf.class1EnableV34Cmd != "" && conf.class1ECMSupport) {
  173. // This is cosmetic, mostly, to state the modem supports V.34.
  174. // We could query the modem but that would require another
  175. // config option, so we just trust the enable command.
  176. primaryV34Rate = 0;
  177. u_short pos = conf.class1EnableV34Cmd.findR(conf.class1EnableV34Cmd.length(), "+F34=", 5) + 4;
  178. if (pos == 4) // Unknown class1EnableV34Cmd
  179.     modemCapability("Unable to determinate V.34 speed from class1EnableV34Cmd, V.34 faxing will be disabled!");
  180. else
  181.     primaryV34Rate = atoi(conf.class1EnableV34Cmd.extract(pos, conf.class1EnableV34Cmd.next(pos, ',') - pos));
  182. modemParams.br |= BIT(primaryV34Rate) - 1;
  183.     }
  184.     modemParams.wd = conf.class1PageWidthSupport;
  185.     modemParams.ln = conf.class1PageLengthSupport;
  186.     modemParams.df = BIT(DF_1DMH) | (conf.class1MRSupport ? BIT(DF_2DMR) : 0);
  187.     modemParams.bf = BF_DISABLE;
  188.     modemParams.st = ST_ALL;
  189.     modemParams.jp = 0;
  190.     pokeConfig(isSend);
  191.     traceModemParams();
  192.     /*
  193.      * Receive capabilities are maintained separately from
  194.      * transmit capabilities because we need to know more
  195.      * than the signalling rate to formulate the DIS.
  196.      */ 
  197.     if (!class1Query(conf.class1RMQueryCmd, recvCaps)) {
  198. serverTrace("Error parsing "+FRM" query response: "%s"", rbuf);
  199. return (false);
  200.     }
  201.     u_int mods = 0;
  202.     for (i = 1; i < NCAPS; i++)
  203. if (recvCaps[i].ok)
  204.     mods |= BIT(recvCaps[i].mod);
  205.     switch (mods) {
  206.     case BIT(V27FB):
  207. discap = DISSIGRATE_V27FB;
  208. break;
  209.     case BIT(V27FB)|BIT(V27):
  210. discap = DISSIGRATE_V27;
  211. break;
  212.     case BIT(V29):
  213. discap = DISSIGRATE_V29;
  214. break;
  215.     case BIT(V27FB)|BIT(V27)|BIT(V29):
  216. discap = DISSIGRATE_V2729;
  217. break;
  218.     case BIT(V27FB)|BIT(V27)|BIT(V29)|BIT(V33):
  219. discap = DISSIGRATE_V33;
  220. break;
  221.     case BIT(V27FB)|BIT(V27)|BIT(V29)|BIT(V17):
  222.     case BIT(V27FB)|BIT(V27)|BIT(V29)|BIT(V33)|BIT(V17):
  223. discap = DISSIGRATE_V17;
  224. break;
  225.     }
  226.     /*
  227.      * T.30 specifies that HDLC frame data are in MSB bit
  228.      * order except for CIG/TSI data which have LSB bit order.
  229.      * We compose and interpret frame data in MSB bit order
  230.      * and pass the frames through frameRev immediately before
  231.      * transmitting and upon receiving to handle modem characteristics.
  232.      *
  233.      * Class1Modem::encodeTSI and Class1Modem::decodeTSI (below)
  234.      * assume this work and process CIG/TSI data accordingly.
  235.      */
  236.     frameRev = TIFFGetBitRevTable(conf.frameFillOrder == FILLORDER_LSB2MSB);
  238.     setupClass1Parameters();
  239.     return (true);
  240. }
  242. /*
  243.  * These are potentially dynamic modem settings that can be altered on-the-fly.
  244.  */
  245. void
  246. Class1Modem::pokeConfig(bool isSend)
  247. {
  248.     modemParams.vr = conf.class1Resolutions; // bitmapped by configuration
  249.     if (conf.class1ECMSupport) {
  250. modemParams.ec = BIT(EC_DISABLE) | BIT(EC_ENABLE64) | BIT(EC_ENABLE256);
  251.   modemParams.df |= (conf.class1MMRSupport ? BIT(DF_2DMMR) : 0);
  252. switch (conf.class1JBIGSupport) {
  253.     case FaxModem::JBIG_FULL:
  254. jbigSupported = true; 
  255. break;
  256.     case FaxModem::JBIG_SEND:
  257. jbigSupported = isSend;
  258. break;
  259.     case FaxModem::JBIG_RECV:
  260. jbigSupported = !isSend;
  261. break;
  262.     default:
  263. jbigSupported = false;
  264. break;
  265. }
  266. if (jbigSupported) modemParams.df |= BIT(DF_JBIG);
  267. if (conf.class1GreyJPEGSupport || conf.class1ColorJPEGSupport)
  268.     modemParams.jp |= BIT(JP_GREY);
  269. if (conf.class1ColorJPEGSupport)
  270.     modemParams.jp |= BIT(JP_COLOR);
  271.     } else
  272. modemParams.ec = BIT(EC_DISABLE);
  273. }
  275. /*
  276.  * Send the modem the Class 1 configuration commands.
  277.  */
  278. bool
  279. Class1Modem::setupClass1Parameters()
  280. {
  281.     if (modemServices & serviceType) {
  282. setupFlowControl(flowControl);
  283. atCmd(conf.setupAACmd);
  284.     }
  285.     return (true);
  286. }
  288. void
  289. Class1Modem::hangup()
  290. {
  291.     if (useV34) {
  292. // terminate V.34 channel
  293. u_char buf[2];
  294. buf[0] = DLE; buf[1] = EOT; // <DLE><EOT>
  295. putModemData(buf, 2);
  296. // T.31-A1 samples indicate an OK response, but anything is acceptable
  297. (void) atResponse(rbuf, 60000);
  298.     }
  299.     atCmd(conf.onHookCmd, AT_OK, 5000);
  300. }
  302. /*
  303.  * Setup receive-specific parameters.
  304.  */
  305. bool
  306. Class1Modem::setupReceive()
  307. {
  308.     return (true); // nothing to do
  309. }
  311. /*
  312.  * Send the modem any commands needed to force use of
  313.  * the specified flow control scheme.
  314.  */
  315. bool
  316. Class1Modem::setupFlowControl(FlowControl fc)
  317. {
  318.     switch (fc) {
  319.     case FLOW_NONE: return atCmd(conf.class1NFLOCmd);
  320.     case FLOW_XONXOFF: return atCmd(conf.class1SFLOCmd);
  321.     case FLOW_RTSCTS: return atCmd(conf.class1HFLOCmd);
  322.     }
  323.     return (true);
  324. }
  326. /*
  327.  * Place the modem into the appropriate state
  328.  * for sending facsimile.
  329.  */
  330. bool
  331. Class1Modem::faxService(bool enableV34, bool enableV17)
  332. {
  333.     if (!atCmd(classCmd)) return (false);
  334.     if (conf.class1EnableV34Cmd != "" && enableV34)
  335. atCmd(conf.class1EnableV34Cmd);
  336.     useV34 = false; // only when V.8 handshaking is used
  337.     gotEOT = false;
  338.     return (setupFlowControl(flowControl));
  339. }
  341. /*
  342.  * The modem is initialized. Now set it to ready for answer.
  343.  */
  344. bool
  345. Class1Modem::ready(long ms)
  346. {
  347.     gotEOT = false;
  348.     useV34 = false;     // only when V.8 handshaking is used
  349.     if (conf.class1EnableV34Cmd != "" && conf.class1ECMSupport)   
  350.         if (!atCmd(conf.class1EnableV34Cmd))
  351.     return (false);
  352.     if (conf.class1AdaptRecvCmd != "")
  353. if (!atCmd(conf.class1AdaptRecvCmd))
  354.     return (false);
  355.     return (FaxModem::ready(ms));
  356. }
  359. /*
  360.  * Set the local subscriber identification.
  361.  */
  362. void
  363. Class1Modem::setLID(const fxStr& number)
  364. {
  365.     encodeTSI(lid, number);
  366. }
  368. bool
  369. Class1Modem::supportsPolling() const
  370. {
  371.     return (true);
  372. }
  374. /*
  375.  * Construct a binary TSI/CIG string for transmission.  Note
  376.  * that we do not enforce the specification that restricts
  377.  * the alphabet to that of Table 3/T.30 (numeric digits,
  378.  * hyphen, period, and space), but instead permit any
  379.  * printable ASCII string of at most 20 characters to be
  380.  * used.  Note also that the bit reversal is done with the
  381.  * understanding that the encoded string is processed again
  382.  * using frameRev (see above) when forming the transmitted
  383.  * HDLC frame.
  384.  */
  385. void
  386. Class1Modem::encodeTSI(fxStr& binary, const fxStr& ascii)
  387. {
  388.     u_int i, j;
  389.     u_char buf[20];
  390.     u_int n = fxmin(ascii.length(),(u_int) 20);
  391.     for (i = 0, j = 0; i < n; i++) {
  392. int c = ascii[i];
  393. if (isprint(c) || c == ' ')
  394.     buf[j++] = frameRev[c];
  395.     }
  396.     /*
  397.      * Now ``reverse copy'' the string.
  398.      */
  399.     binary.resize(20);
  400.     for (i = 0; j > 0; i++, j--)
  401. binary[i] = buf[j-1];
  402.     for (; i < 20; i++)
  403. binary[i] = frameRev[' ']; // blank pad remainder
  404. }
  406. /*
  407.  * Encode an NSF string for transmission.
  408.  */
  409. void
  410. Class1Modem::encodeNSF(fxStr& binary, const fxStr& ascii)
  411. {
  412.     u_int i, j;
  413.     u_int n = ascii.length();
  414.     binary.resize(n);
  415.     for (i = 0, j = 0; i < n; i++) {
  416. int c = ascii[i];
  417. if (isprint(c) || c == ' ')
  418.     binary[j++] = frameRev[c];
  419.     }
  420. }
  422. /*
  423.  * Do the inverse of encodeTSI; i.e. convert a binary
  424.  * string of encoded digits into the equivalent ascii.
  425.  * Note that as above (and per the spec) bytes are
  426.  * presumed to be transmitted in LSB2MSB bit order and
  427.  * then reversed on receipt according to the host bit
  428.  * order.
  429.  */
  430. const fxStr&
  431. Class1Modem::decodeTSI(fxStr& ascii, const HDLCFrame& binary)
  432. {
  433.     int n = binary.getFrameDataLength();
  434.     if (n > 20) // spec says no more than 20 digits
  435. n = 20;
  436.     else n--; // trim FCF
  437.     ascii.resize(n);
  438.     u_int d = 0;
  439.     bool seenDigit = false;
  440.     for (const u_char* cp = binary.getFrameData() + n-1; n > 0; cp--, n--) {
  441. /*
  442.  * Accept any printable ascii.
  443.  */
  444. u_char c = frameRev[*cp];
  445.         if (isprint(c) || c == ' ') {
  446.     if (c != ' ')
  447. seenDigit = true;
  448.     if (seenDigit)
  449. ascii[d++] = c;
  450. }
  451.     }
  452.     ascii.resize(d);
  453.     return ascii;
  454. }
  456. /*
  457.  * Construct a binary PWD/SUB/SEP string for transmission.
  458.  */
  459. void
  460. Class1Modem::encodePWD(fxStr& binary, const fxStr& ascii)
  461. {
  462.     encodeTSI(binary, ascii);
  463. }
  465. /*
  466.  * Do the inverse of encodePWD; i.e. convert a binary
  467.  * string of encoded digits into the equivalent ascii.
  468.  */
  469. const fxStr&
  470. Class1Modem::decodePWD(fxStr& ascii, const HDLCFrame& binary)
  471. {
  472.     return decodeTSI(ascii, binary);
  473. }
  475. bool
  476. Class1Modem::switchingPause(fxStr& emsg, u_int times)
  477. {
  478.     /*
  479.      * If class1SwitchingCmd is of the AT+FRS=n form we honor
  480.      * the caller's indicattion for a multiplication of the 
  481.      * configured silence detection.  This is primarily used
  482.      * to avoid sending CRP as a receiver during a sender's TCF,
  483.      * but it could also be used in places where we find a 
  484.      * longer wait often necessary.
  485.      */
  486.     fxStr scmd = fxStr(conf.class1SwitchingCmd);
  487.     if (times != 1) {
  488. fxStr ncmd = fxStr(scmd);
  489. ncmd.raiseatcmd();
  490. if (ncmd.length() > 7 && ncmd.head(7) == "AT+FRS=") {
  491.     int dur = atoi(ncmd.tail(ncmd.length()-7)) * times;
  492.     scmd = scmd.head(7) | fxStr(dur, "%d");
  493. }
  494.     }
  495.     if (!silenceHeard && !atCmd(scmd, AT_OK)) {
  496. emsg = "Failure to receive silence (synchronization failure). {E100}";
  497. protoTrace(emsg);
  498. if (wasTimeout()) abortReceive();
  499. return (false);
  500.     }
  501.     /*
  502.      * We necessarily use class1SwitchingCmd rather frequently... 
  503.      * sometimes this is programmed to be immediately before our signalling,
  504.      * and sometimes this is programmed to be immediately after the remote
  505.      * signalling.  That doesn't therefore give us very good control on 
  506.      * ensuring that class1SwitchingCmd is not issued in duplicate in some
  507.      * kinds of program flow.
  508.      *
  509.      * Ideally we'd be able to standardize on issuing class1SwitchingCmd
  510.      * only in one case or another (but not both), but that's not particularly
  511.      * an easy ideal to realize given the number of exceptions to that rule
  512.      * that would neccesarily be required.
  513.      *
  514.      * So for now we just set this flag here, and we unset it in atCmd, and 
  515.      * if the flag is set when we come back here, then we can avoid duplication.
  516.      */
  517.     silenceHeard = true;
  518.     return (true);
  519. }
  521. /*
  522.  * Pass data to modem, filtering DLE's and
  523.  * optionally including the end-of-data
  524.  * marker <DLE><ETX>.
  525.  *
  526.  * If the data transfer is aborted by the user
  527.  * then we must take care to send <DLE><ETX>
  528.  * in order to exit gracefully.
  529.  */
  530. bool
  531. Class1Modem::sendClass1Data(const u_char* data, u_int cc,
  532.     const u_char* bitrev, bool eod, long ms)
  533. {
  534.     bool ok = putModemDLEData(data, cc, bitrev, ms, conf.doPhaseCDebug);
  535.     if (eod || abortRequested()) {
  536. u_char buf[2];
  537. buf[0] = DLE;
  538. buf[1] = ETX;
  539. ok = putModemData(buf, 2, ms);
  540. return (ok && !abortRequested());
  541.     } else
  542. return (ok);
  543. }
  545. /*
  546.  * Receive timed out, abort the operation
  547.  * and resynchronize before returning.
  548.  */
  549. void
  550. Class1Modem::abortReceive()
  551. {
  552.     if (useV34) return; // nothing to do in V.34
  553.     bool b = wasTimeout();
  554.     char c = CAN; // anything other than DC1/DC3
  555.     putModem(&c, 1, 1);
  556.     /*
  557.      * If the modem handles abort properly, then just
  558.      * wait for an OK result.  Otherwise, wait a short
  559.      * period of time, flush any input, and then send
  560.      * "AT" and wait for the return "OK".
  561.      */
  562.     if (conf.class1RecvAbortOK == 0) { // modem doesn't send OK response
  563. pause(200);
  564. flushModemInput();
  565. (void) atCmd("AT", AT_OK, 100);
  566.     } else
  567. while (!waitFor(AT_OK, conf.class1RecvAbortOK) && lastResponse == AT_OTHER && !wasTimeout());
  568.     setTimeout(b); // XXX putModem clobbers timeout state
  569. }
  571. /*
  572.  * Request a primary rate renegotiation.
  573.  */
  574. bool
  575. Class1Modem::renegotiatePrimary(bool constrain)
  576. {
  577.     u_char buf[4];
  578.     u_short size = 0;
  579.     buf[size++] = DLE;
  580.     if (constrain) {
  581. // don't neotiate a faster rate
  582. if (primaryV34Rate == 1) buf[size++] = 0x70; // 2400 bit/s
  583. else if (primaryV34Rate == 2 || primaryV34Rate == 3) {
  584.     /*
  585.      * V.34 bitspeed 2400 is only possible with symbolrate 2400, and
  586.      * as we have no way of determining the symbolrate, we cannot
  587.      * wisely instruct the modem to use 2400 bps unless the modem
  588.      * negotiates it independently.
  589.      */
  590.     buf[size++] = 0x71; // 4800 bit/s
  591. } else buf[size++] = primaryV34Rate + 0x6D; // drop 4800 bit/s
  592. buf[size++] = DLE;
  593.     }
  594.     buf[size++] = 0x6C; // <DLE><pph>
  595.     if (!putModemData(buf, size)) return (false);
  596.     if (constrain)
  597. protoTrace("Request primary rate renegotiation (limit %u bit/s).", 
  598.     primaryV34Rate == 1 ? 2400 : primaryV34Rate > 3 ? (primaryV34Rate-2)*2400 : 4800);
  599.     else
  600. protoTrace("Request primary rate renegotiation.");
  601.     return (true);
  602. }
  604. /*
  605.  * Wait for a <DLE><ctrl> response per T.31-A1 B.8.4.
  606.  */
  607. bool
  608. Class1Modem::waitForDCEChannel(bool awaitctrl)
  609. {
  610.     time_t start = Sys::now();
  611.     int c;
  612.     fxStr garbage;
  613.     bool gotresponse = false;
  614.     gotRTNC = false;
  615.     ctrlFrameRcvd = fxStr::null;
  616.     do {
  617. c = getModemChar(60000);
  618. if (c == DLE) {
  619.     /*
  620.      * With V.34-faxing we expect <DLE><command>
  621.      * Refer to T.31-A1 Table B.1.  Except for EOT
  622.      * these are merely indicators and do not require
  623.      * action.
  624.      */
  625.     c = getModemChar(60000);
  626.     switch (c) {
  627. case EOT:
  628.     protoTrace("EOT received (end of transmission)");
  629.     gotEOT = true;
  630.     recvdDCN = true;
  631.     return (false);
  632. case 0x69:
  633.     protoTrace("Control channel retrain");
  634.     // wait for the control channel to reappear
  635.     // should we reset the timeout setting?
  636.     gotresponse = waitForDCEChannel(true);
  637.     gotRTNC = true;
  638.     return ((awaitctrl ? gotresponse : false));
  639. case 0x6B:
  640.     protoTrace("Primary channel selected");
  641.     gotCTRL = false;
  642.     continue;
  643. case 0x6D:
  644.     protoTrace("Control channel selected");
  645.     gotCTRL = true;
  646.     continue;
  647. case 0x6E: // 1200 bit/s
  648. case 0x6F: // 2400 bit/s
  649.     // control rate indication
  650.     if (controlV34Rate != (c - 0x6D)) {
  651. controlV34Rate = (c - 0x6D);
  652. protoTrace("Control channel rate now %u bit/s", controlV34Rate*1200);
  653.     }
  654.     if (awaitctrl) gotresponse = true;
  655.     continue;
  656. case 0x70: //  2400 bit/s
  657. case 0x71: //  4800 bit/s
  658. case 0x72: //  7200 bit/s
  659. case 0x73: //  9600 bit/s
  660. case 0x74: // 12000 bit/s
  661. case 0x75: // 14400 bit/s
  662. case 0x76: // 16800 bit/s
  663. case 0x77: // 19200 bit/s
  664. case 0x78: // 21600 bit/s
  665. case 0x79: // 24000 bit/s
  666. case 0x7A: // 26400 bit/s
  667. case 0x7B: // 28800 bit/s
  668. case 0x7C: // 31200 bit/s
  669. case 0x7D: // 33600 bit/s
  670.     // primary rate indication
  671.     if (primaryV34Rate != (c - 0x6F)) {
  672. primaryV34Rate = (c - 0x6F);
  673. protoTrace("Primary channel rate now %u bit/s", primaryV34Rate*2400);
  674.     }
  675.     if (!awaitctrl) gotresponse = true;
  676.     continue;
  677. default:
  678.     // unexpected <DLE><command>, deem as garbage
  679.     garbage.append(DLE);
  680.     garbage.append(c);
  681.     break;
  682.     }
  683. } else garbage.append(c);
  684. if (gotCTRL && garbage.length() > 2 && (garbage[0] & 0xFF) == 0xFF && 
  685.     (garbage[garbage.length()-2] & 0xFF) == 0x10 &&
  686.     (garbage[garbage.length()-1] & 0xFF) == 0x03) {
  687.     // We got a control frame and won't get the channel change...
  688.     for (u_int i = 0; i < garbage.length()-2; i++) {
  689. if ((garbage[i] & 0xFF) == DLE && ++i < garbage.length()) {
  690.     /*
  691.      * We've got a frame and must apply T.31-A1 Table B.1.
  692.      */
  693.     if ((garbage[i] & 0xFF) == 0x07) { // end of HDLC frame w/FCS error
  694. // what to do? send CRP? discard frame?
  695. continue;
  696.     }
  697.     switch (garbage[i] & 0xFF) {
  698. case DLE: // <DLE><DLE> => <DLE>
  699.     ctrlFrameRcvd.append(DLE);
  700.     break;
  701. case SUB: // <DLE><SUB> => <DLE><DLE>
  702.     ctrlFrameRcvd.append(DLE);
  703.     ctrlFrameRcvd.append(DLE);
  704.     break;
  705. case 0x51: // <DLE><0x51> => <DC1>
  706.     ctrlFrameRcvd.append(DC1);
  707.     break;
  708. case 0x53: // <DLE><0x53> => <DC3>
  709.     ctrlFrameRcvd.append(0x13);
  710.     break;
  711.     }
  712. } else
  713.     ctrlFrameRcvd.append(garbage[i] & 0xFF);
  714.     }
  715.     return (false);
  716. }
  717. fxStr rcpsignal;
  718. rcpsignal.append(0xFF); rcpsignal.append(0x03); rcpsignal.append(0x86); rcpsignal.append(0x69);
  719. rcpsignal.append(0xCB); rcpsignal.append(0x10); rcpsignal.append(0x03);
  720. if (!gotCTRL && garbage == rcpsignal) {
  721.     // We anticipate getting "extra" RCP frames since we
  722.     // only look for one but usually we will see three.
  723.     garbage.cut(0, 7);
  724. }
  725.     } while (!gotresponse && Sys::now()-start < 60);
  726.     if (getHDLCTracing() && garbage.length()) {
  727. fxStr buf;
  728. u_int j = 0;
  729. for (u_int i = 0; i < garbage.length(); i++) {
  730.     if (j > 0)
  731. buf.append(' ');
  732.     buf.append(fxStr(garbage[i] & 0xFF, "%2.2X"));
  733.     j++;
  734.     if (j > 19) {
  735. protoTrace("--> [%u:%.*s]",
  736.     j, buf.length(), (const char*) buf);
  737. buf = "";
  738. j = 0;
  739.     }
  740. }
  741. if (j)
  742.     protoTrace("--> [%u:%.*s]",
  743. j, buf.length(), (const char*) buf);
  744.     }
  745.     return (gotresponse);
  746. }
  748. /*
  749.  * Receive an HDLC frame. The frame itself must
  750.  * be received within 3 seconds (per the spec).
  751.  * If a carrier is received, but the complete frame
  752.  * is not received before the timeout, the receive
  753.  * is aborted.
  754.  */
  755. bool
  756. Class1Modem::recvRawFrame(HDLCFrame& frame)
  757. {
  758.     /*
  759.      * We need to be generous here ... given that
  760.      * some frames can be long and some devices
  761.      * can add lots of flags to the signalling.
  762.      * Adhering to the spec too closely, 5 sec,
  763.      * appears to be too conservative; if the modem
  764.      * has said CONNECT, then it should be
  765.      * responsible enough to carry-through with
  766.      * things.  A timeout here is only needed to
  767.      * reign-in modems that don't carry-through.
  768.      */
  769.     startTimeout(10000);
  770.     /*
  771.      * Strip HDLC frame flags. This is not needed,
  772.      * (according to the standard DCE does the job),
  773.      * be we leave this legacy code unchanged
  774.      * for sure - D.B.
  775.      */
  776.     int c;
  777.     fxStr garbage;
  779.     for (;;) {
  780. c = getModemChar(0);
  781. if (c == 0xff || c == EOF)
  782.     break;
  783. if (useV34 && c == DLE) {
  784.     c = getModemChar(0);
  785.     switch (c) {
  786. case EOT:
  787.     protoTrace("EOT received (end of transmission)");
  788.     gotEOT = true;
  789.     recvdDCN = true;
  790.     return (false);
  791. case 0x69:
  792.     protoTrace("Control channel retrain");
  793.     // wait for the control channel to reappear
  794.     // should we reset the timeout setting?
  795.     waitForDCEChannel(true);
  796.     gotRTNC = true;
  797.     return (false);
  798. default:
  799.     // unexpected <DLE><command>, deem as garbage
  800.     garbage.append(DLE);
  801.     break;
  802.     }
  803. }
  804. garbage.append(c);
  805. if ( garbage.length() >= 2 && garbage.tail(2) == "rn") {
  806.     /*
  807.      * CR+LF received before address field.
  808.      * We expect result code (though it's possible
  809.      * that CR+LF is a part of garbage frame)
  810.      */
  811.     garbage = garbage.head(garbage.length() - 2);
  812.     break;
  813. }
  814.     }
  816.     if (getHDLCTracing() && garbage.length()) {
  817. fxStr buf;
  818. u_int j = 0;
  819. for (u_int i = 0; i < garbage.length(); i++) {
  820.     if (j > 0)
  821. buf.append(' ');
  822.     buf.append(fxStr(garbage[i] & 0xFF, "%2.2X"));
  823.     j++;
  824.     if (j > 19) {
  825. protoTrace("--> [%u:%.*s]",
  826.     j, buf.length(), (const char*) buf);
  827. buf = "";
  828. j = 0;
  829.     }
  830. }
  831. if (j)
  832.     protoTrace("--> [%u:%.*s]",
  833. j, buf.length(), (const char*) buf);
  834.     }
  836.     if (c == 0xff) { // address field received
  837. do {
  838.     if (c == DLE) {
  839. c = getModemChar(0);
  840. if (c == ETX || c == EOF)
  841.     break;
  842. if (useV34) {
  843.     /*
  844.      * T.31-A1 Table B.1
  845.      * These indicate transparancy, shielding, or delimiting.
  846.      */
  847.     if (c == 0x07) { // end of HDLC frame w/FCS error
  848. break;
  849.     }
  850.     switch (c) {
  851. case EOT:
  852.     protoTrace("EOT received (end of transmission)");
  853.     gotEOT = true;
  854.     recvdDCN = true;
  855.     return (false);
  856. case DLE: // <DLE><DLE> => <DLE>
  857.     break;
  858. case SUB: // <DLE><SUB> => <DLE><DLE>
  859.     frame.put(frameRev[DLE]);
  860.     break;
  861. case 0x51: // <DLE><0x51> => <DC1>
  862.     c = DC1;
  863.     break;
  864. case 0x53: // <DLE><0x53> => <DC3>
  865.     c = 0x13;
  866.     break;
  867.     }
  868. } else {
  869.     /*
  870.      * Some modems may not double-up the in-data DLEs like they should.
  871.      */
  872.     if (conf.class1ModemHasDLEBug) frame.put(frameRev[DLE]);
  873.     else if (c != DLE) {
  874. protoTrace("Odd.  Modem reported meaningless <DLE><0x%X>.  Possible DLE bug indication.", c);
  875.     }
  876. }
  877.     }
  878.     frame.put(frameRev[c]);
  879. } while ((c = getModemChar(0)) != EOF);
  880.     }
  881.     stopTimeout("receiving HDLC frame data");
  882.     if (frame.getLength() > 0)
  883. traceHDLCFrame("-->", frame);
  884.     if (wasTimeout()) {
  885. abortReceive();
  886. return (false);
  887.     }
  888.     /*
  889.      * Now collect the "OK", "ERROR", or "FCERROR"
  890.      * response telling whether or not the FCS was
  891.      * legitimate.
  892.      */
  893.     if (!useV34 && !waitFor(AT_OK)) {
  894. if (lastResponse == AT_ERROR)
  895.     protoTrace("FCS error");
  896. return (false);
  897.     }
  898.     if (useV34 && c == 0x07) {
  899. protoTrace("FCS error");
  900. return (false);
  901.     }
  902.     if (frame.getFrameDataLength() < 1) {
  903. protoTrace("HDLC frame too short (%u bytes)", frame.getLength());
  904. return (false);
  905.     }
  906.     if ((frame[1]&0xf7) != 0xc0) {
  907. protoTrace("HDLC frame with bad control field %#x", frame[1]);
  908. return (false);
  909.     }
  910.     if (conf.class1ValidateV21Frames && !frame.checkCRC()) {
  911. protoTrace("FCS error (calculated)");
  912. return (false);
  913.     }
  914.     frameRcvd = "";
  915.     for (u_int i = 0; i < frame.getLength(); i++) frameRcvd.append(frame[i]);
  916.     frame.setOK(true);
  917.     return (true);
  918. }
  920. bool
  921. Class1Modem::syncECMFrame()
  922. {
  923.     /*
  924.      * We explicitly look for the first sync flag so as to
  925.      * not get confused by any initial garbage or training.
  926.      */
  927.     int bit = 0;
  928.     u_short ones = 0;
  930.     // look for the first sync flag
  932.     time_t start = Sys::now();
  933.     startTimeout(60000); // despite indications by T.4 A.3.1
  934.     do {
  935. if ((unsigned) Sys::now()-start >= 60) {
  936.     protoTrace("Timeout awaiting synchronization sequence");
  937.     setTimeout(true);
  938.     return (false);
  939. }
  940. bit = getModemBit(0);
  941.     } while (bit != 0 && !didBlockEnd());
  942.     do {
  943. if ((unsigned) Sys::now()-start >= 60) {
  944.     protoTrace("Timeout awaiting synchronization sequence");
  945.     setTimeout(true);
  946.     return (false);
  947. }
  948. if (bit == 0 || ones > 0xFF) ones = 0;
  949. bit = getModemBit(0);
  950. if (bit == 1) ones++;
  951.     } while (!(ones == 6 && bit == 0 && bit != EOF) && !didBlockEnd());
  952.     stopTimeout("awaiting synchronization sequence");
  953.     if (wasTimeout()) {
  954. return (false);
  955.     }
  956.     return (true);
  957. }
  959. /*
  960.  * Receive an HDLC frame with ECM.  We must always be cautious
  961.  * of "stuffed" zero-bits after five sequential one-bits between
  962.  * flag sequences.  We assume this is called only after a
  963.  * successfuly received complete flag sequence.
  964.  *
  965.  * Things are significantly more simple with V.34-fax ECM since
  966.  * there is no synchronization or RCP frames.  In this case we
  967.  * simply have to handle byte transparancy and shielding, looking
  968.  * for byte-aligned frame delimiters.
  969.  */
  970. bool
  971. Class1Modem::recvECMFrame(HDLCFrame& frame)
  972. {
  973.     if (useV34) {
  974. int c;
  975. for (;;) {
  976.     c = getModemChar(60000);
  977.     if (wasTimeout()) {
  978. return (false);
  979.     }
  980.     if (c == DLE) {
  981. c = getModemChar(60000);
  982. if (wasTimeout()) {
  983.     return (false);
  984. }
  985. switch (c) {
  986.     case DLE:
  987. break;
  988.     case SUB:
  989. frame.put(frameRev[DLE]);
  990. break;
  991.     case 0x51:
  992. c = 0x11;
  993. break;
  994.     case 0x53:
  995. c = 0x13;
  996. break;
  997.     case ETX:
  998. if (frame.getLength() > 0)
  999.     traceHDLCFrame("-->", frame, true);
  1000. if (frame.getLength() < 5) { // RCP frame size
  1001.     protoTrace("HDLC frame too short (%u bytes)", frame.getLength());
  1002.     return (false);
  1003. }
  1004. if (frame[0] != 0xff) {
  1005.     protoTrace("HDLC frame with bad address field %#x", frame[0]);
  1006.     return (false);
  1007. }
  1008. if ((frame[1]&0xf7) != 0xc0) {
  1009.     protoTrace("HDLC frame with bad control field %#x", frame[1]);
  1010.     return (false);
  1011. }
  1012. return (true);
  1013.     case 0x07:
  1014. protoTrace("FCS error");
  1015. return (false);
  1016.     case 0x04:
  1017. protoTrace("EOT received (end of transmission)");
  1018. gotEOT = true;
  1019. recvdDCN = true;
  1020. return (false);
  1021.     case 0x6D:
  1022. protoTrace("Control channel selected");
  1023. gotCTRL = true;
  1024. return (false);
  1025.     default:
  1026. protoTrace("got <DLE><%X>", c);
  1027. break;
  1028. }
  1029.     }
  1030.     frame.put(frameRev[c]);
  1031. }
  1032.     }
  1034.     int bit = getModemBit(60000);
  1035.     u_short ones = 0;
  1037.     // look for the last sync flag (possibly the previous one)
  1039.     // some senders use this as the time to do framing so we must wait longer than T.4 A.3.1 implies
  1040.     time_t start = Sys::now();
  1041.     while (bit != 1 && bit != EOF && !didBlockEnd()) { // flag begins with zero, address begins with one
  1042. do {
  1043.     if ((unsigned) Sys::now()-start >= 300) { // 5 minutes of synchronization is too much
  1044. protoTrace("Timeout waiting for the last synchronization flag");
  1045. return false;
  1046.     }
  1047.     if (bit == 0 || ones > 6) ones = 0;
  1048.     bit = getModemBit(60000);
  1049.     if (bit == 1) ones++;
  1050. } while (!(ones == 6 && bit == 0 && bit != EOF) && !didBlockEnd());
  1051. ones = 0;
  1052. bit = getModemBit(60000);
  1053.     }
  1055.     // receive the frame, strip stuffed zero-bits, and look for end flag
  1057.     ones = 1;
  1058.     u_short bitpos = 7;
  1059.     u_int byte = (bit << bitpos);
  1060.     bool rcpframe = false;
  1061.     start = Sys::now();
  1062.     do {
  1063. if ((unsigned) Sys::now()-start >= 3) {
  1064.     protoTrace("Timeout receiving HDLC frame");
  1065.     return (false);
  1066. }
  1067. bit = getModemBit(60000);
  1068. if (bit == 1) {
  1069.     ones++;
  1070. }
  1071. if (!(ones == 5 && bit == 0 && bit != EOF)) { // not transparent stuffed zero-bits
  1072.     bitpos--;
  1073.     byte |= (bit << bitpos);
  1074.     if (bitpos == 0) { // fully populated byte
  1075. frame.put(byte);
  1076. bitpos = 8;
  1077. byte = 0;
  1078.     }
  1079. }
  1080. if (bit == 0) ones = 0;
  1081. // don't wait for the terminating flag on an RCP frame
  1082. if (frame[0] == 0xff && frame[1] == 0xc0 && frame[2] == 0x61 && frame.getLength() == 5 && frame.checkCRC()) {
  1083.     protoTrace("RECV received RCP frame");
  1084.     rcpframe = true;
  1085. } else if (didBlockEnd()) {
  1086.     // sometimes RCP frames are truncated by or are missing due to premature DLE+ETX characters, sadly
  1087.     protoTrace("RECV assumed RCP frame with block end");
  1088.     // force-feed a valid RCP frame with FCS
  1089.     frame.reset();
  1090.     frame.put(0xff); frame.put(0xc0); frame.put(0x61); frame.put(0x96); frame.put(0xd3);
  1091.     rcpframe = true;
  1092. }
  1093.     } while (ones != 6 && bit != EOF && !rcpframe && frame.getLength() < frameSize+6);
  1094.     if (ones == 6) bit = getModemBit(60000); // trailing bit on flag
  1095.     if (!rcpframe && frame.getLength() < frameSize+6) {
  1096. /*
  1097.  * The HDLC frame was terminated early by a flag.  T.30 A.3.5 states that
  1098.  * frame size cannot change during one page, and T.4 A.3.6.2 seems to provide
  1099.  * for padding in order to get that last frame on a block to always line up
  1100.  * on a byte and frame boundary.  However, the NOTE 2 there seemse to give
  1101.  * leniency to that requirement, and in fact many senders will send short
  1102.  * frames on the last frame of a block.  So we run a couple of additional
  1103.  * checks here (in addition to FCS checking) to limit the remote chance
  1104.  * of FCS actually checking out on corrupt data (although that may be very
  1105.  * remote indeed).  We don't do these "trailing flag" tests on normal-sized
  1106.  * frames because we deliberately don't look for a trailing flag when we
  1107.  * get enough data.
  1108.  */
  1109. if (bit) { // should have been zero
  1110.     protoTrace("Bad HDLC terminating flag received.");
  1111.     return (false);
  1112. }
  1113. if (byte != 0x7e) { // trailing byte should be flag
  1114.     protoTrace("HDLC frame not byte-oriented.  Trailing byte: %#x", byte);
  1115.     return (false);
  1116. }
  1117.     }
  1118.     traceHDLCFrame("-->", frame, true);
  1119.     if (bit == EOF) {
  1120. protoTrace("EOF received.");
  1121. return (false);
  1122.     }
  1123.     if (frame.getLength() < 5) { // RCP frame size
  1124. protoTrace("HDLC frame too short (%u bytes)", frame.getLength());
  1125. return (false);
  1126.     }
  1127.     if (frame[0] != 0xff) {
  1128. protoTrace("HDLC frame with bad address field %#x", frame[0]);
  1129. return (false);
  1130.     }
  1131.     if ((frame[1]&0xf7) != 0xc0) {
  1132. protoTrace("HDLC frame with bad control field %#x", frame[1]);
  1133. return (false);
  1134.     }
  1135.     return (true);
  1136. }
  1138. bool
  1139. Class1Modem::endECMBlock()
  1140. {
  1141.     if (didBlockEnd()) return (true); // some erroniously re-use bytes
  1143.     int c = getLastByte(); // some erroniously re-use bits
  1144.     time_t start = Sys::now();
  1145.     setTimeout(false);
  1146.     do {
  1147. if ((unsigned) Sys::now()-start >= 60) { // 60 seconds of garbage after RCP is too much
  1148.     protoTrace("Timeout waiting for DLE+ETX");
  1149.     setTimeout(true);
  1150.     return false;
  1151. }
  1152. if (c == DLE) {
  1153.     c = getModemChar(30*1000);
  1154.     if (c == ETX || c == EOF)
  1155. break;
  1156. }
  1157.     } while ((c = getModemChar(30*1000)) != EOF);
  1158.     if (c == EOF) return (false);
  1159.     else return (true);
  1160. }
  1162. #include "StackBuffer.h"
  1164. /*
  1165.  * Log an HLDC frame along with a time stamp (secs.10ms).
  1166.  */
  1167. void
  1168. Class1Modem::traceHDLCFrame(const char* direction, const HDLCFrame& frame, bool isecm)
  1169. {
  1170.     if (!isecm) {
  1171. if (!getHDLCTracing()) return;
  1172.     } else {
  1173. if (!getECMTracing()) return;
  1174.     }
  1175.     const char* hexdigits = "0123456789ABCDEF";
  1176.     fxStackBuffer buf;
  1177.     for (u_int i = 0; i < frame.getLength(); i++) {
  1178. u_char b = frame[i];
  1179. if (i > 0)
  1180.     buf.put(' ');
  1181. buf.put(hexdigits[b>>4]);
  1182. buf.put(hexdigits[b&0xf]);
  1183.     }
  1184.     protoTrace("%s HDLC<%u:%.*s>", direction,
  1185. frame.getLength(), buf.getLength(), (const char*) buf);
  1186. }
  1188. /*
  1189.  * Send a raw HDLC frame and wait for the modem response.
  1190.  * The modem is expected to be an HDLC frame sending mode
  1191.  * (i.e. +FTH=3 or similar has already be sent to the modem).
  1192.  * The T.30 max frame length is enforced with a 3 second
  1193.  * timeout on the send.
  1194.  */
  1195. bool
  1196. Class1Modem::sendRawFrame(HDLCFrame& frame)
  1197. {
  1198.     traceHDLCFrame("<--", frame);
  1199.     if (frame.getLength() < 3) {
  1200. protoTrace("HDLC frame too short (%u bytes)", frame.getLength());
  1201. return (false);
  1202.     }
  1203.     if (frame[0] != 0xff) {
  1204. protoTrace("HDLC frame with bad address field %#x", frame[0]);
  1205. return (false);
  1206.     }
  1207.     if ((frame[1]&0xf7) != 0xc0) {
  1208. protoTrace("HDLC frame with bad control field %#x", frame[1]);
  1209. return (false);
  1210.     }
  1211.     signalSent = "";
  1212.     for (u_int i = 0; i < frame.getLength(); i++) signalSent.append(frame[i]);
  1213.     /*
  1214.      * sendFrame() is always called with a timeout set.
  1215.      * Let's keep it that way
  1216.      */
  1217.     return (sendClass1Data(frame, frame.getLength(), frameRev, true, 0) &&
  1218. (useV34 ? true : waitFor(frame.moreFrames() ? AT_CONNECT : AT_OK, 0)));
  1219. }
  1221. /*
  1222.  * Send a single byte frame.
  1223.  */
  1224. bool
  1225. Class1Modem::sendFrame(u_char fcf, bool lastFrame)
  1226. {
  1227.     HDLCFrame frame(conf.class1FrameOverhead);
  1228.     frame.put(0xff);
  1229.     frame.put(lastFrame ? 0xc8 : 0xc0);
  1230.     frame.put(fcf);
  1231.     return (sendRawFrame(frame));
  1232. }
  1234. /*
  1235.  * Send a frame with DCS/DIS.
  1236.  */
  1237. bool
  1238. Class1Modem::sendFrame(u_char fcf, FaxParams& dcs_caps, bool lastFrame)
  1239. {
  1240.     HDLCFrame frame(conf.class1FrameOverhead);
  1241.     frame.put(0xff);
  1242.     frame.put(lastFrame ? 0xc8 : 0xc0);
  1243.     frame.put(fcf);
  1245.     int curByte = 0;
  1246.     //add dcs bytes an any optional bytes
  1247.     frame.put(dcs_caps.getByte(curByte));
  1248.     while (dcs_caps.hasNextByte(curByte)) {
  1249.         curByte += 1;
  1250.         frame.put(dcs_caps.getByte(curByte));
  1251.     }
  1253.     return (sendRawFrame(frame));
  1254. }
  1256. /*
  1257.  * Send a frame with TSI/CSI/PWD/SUB/SEP/PPR.
  1258.  */
  1259. bool
  1260. Class1Modem::sendFrame(u_char fcf, const fxStr& tsi, bool lastFrame)
  1261. {
  1262.     HDLCFrame frame(conf.class1FrameOverhead);
  1263.     frame.put(0xff);
  1264.     frame.put(lastFrame ? 0xc8 : 0xc0);
  1265.     frame.put(fcf);
  1266.     frame.put((const u_char*)(const char*)tsi, tsi.length());
  1267.     return (sendRawFrame(frame));
  1268. }
  1270. /*
  1271.  * Send a frame with NSF.
  1272.  */
  1273. bool
  1274. Class1Modem::sendFrame(u_char fcf, const u_char* code, const fxStr& nsf, bool lastFrame)
  1275. {
  1276.     HDLCFrame frame(conf.class1FrameOverhead);
  1277.     frame.put(0xff);
  1278.     frame.put(lastFrame ? 0xc8 : 0xc0);
  1279.     frame.put(fcf);
  1280.     frame.put(code, 3); // should be in LSBMSB already
  1281.     frame.put((const u_char*)(const char*)nsf, nsf.length());
  1282.     return (sendRawFrame(frame));
  1283. }
  1285. bool
  1286. Class1Modem::transmitFrame(fxStr& signal)
  1287. {
  1288.     HDLCFrame frame(conf.class1FrameOverhead);
  1289.     for (u_int i = 0; i < signal.length(); i++) frame.put(signal[i]);
  1290.     startTimeout(7550);
  1291.     bool frameSent = useV34 ? true : atCmd(thCmd, AT_NOTHING, 0);
  1292.     if (frameSent) frameSent = useV34 ? true : atResponse(rbuf, 0) == AT_CONNECT;
  1293.     if (frameSent) frameSent = sendRawFrame(frame);
  1294.     else if (lastResponse == AT_ERROR) gotEOT = true; // on hook
  1295.     stopTimeout("sending HDLC frame");
  1296.     return (frameSent);
  1297. }
  1299. bool
  1300. Class1Modem::transmitFrame(u_char fcf, bool lastFrame)
  1301. {
  1302.     startTimeout(7550);
  1303.     bool frameSent = useV34 ? true : atCmd(thCmd, AT_NOTHING, 0);
  1304.     if (frameSent) frameSent = useV34 ? true : atResponse(rbuf, 0) == AT_CONNECT;
  1305.     if (frameSent) frameSent = sendFrame(fcf, lastFrame);
  1306.     else if (lastResponse == AT_ERROR) gotEOT = true; // on hook
  1307.     stopTimeout("sending HDLC frame");
  1308.     return (frameSent);
  1309. }
  1311. bool
  1312. Class1Modem::transmitFrame(u_char fcf, FaxParams& dcs_caps, bool lastFrame)
  1313. {
  1314.     /*
  1315.      * The T.30 spec says no frame can take more than 3 seconds
  1316.      * (+/- 15%) to transmit.  But the DCE can take as much as 5
  1317.      * seconds to respond CONNECT or result OK, per T.31.
  1318.      */
  1319.     startTimeout(7550);
  1320.     bool frameSent = useV34 ? true : atCmd(thCmd, AT_NOTHING, 0);
  1321.     if (frameSent) frameSent = useV34 ? true : atResponse(rbuf, 0) == AT_CONNECT;
  1322.     if (frameSent) frameSent = sendFrame(fcf, dcs_caps, lastFrame);
  1323.     else if (lastResponse == AT_ERROR) gotEOT = true; // on hook
  1324.     stopTimeout("sending HDLC frame");
  1325.     return (frameSent);
  1326. }
  1328. bool
  1329. Class1Modem::transmitFrame(u_char fcf, const fxStr& tsi, bool lastFrame)
  1330. {
  1331.     startTimeout(7550);
  1332.     bool frameSent = useV34 ? true : atCmd(thCmd, AT_NOTHING, 0);
  1333.     if (frameSent) frameSent = useV34 ? true : atResponse(rbuf, 0) == AT_CONNECT;
  1334.     if (frameSent) frameSent = sendFrame(fcf, tsi, lastFrame);
  1335.     else if (lastResponse == AT_ERROR) gotEOT = true; // on hook
  1336.     stopTimeout("sending HDLC frame");
  1337.     return (frameSent);
  1338. }
  1340. bool
  1341. Class1Modem::transmitFrame(u_char fcf, const u_char* code, const fxStr& nsf, bool lastFrame)
  1342. {
  1343.     startTimeout(7550);
  1344.     bool frameSent = useV34 ? true : atCmd(thCmd, AT_NOTHING, 0);
  1345.     if (frameSent) frameSent = useV34 ? true : atResponse(rbuf, 0) == AT_CONNECT;
  1346.     if (frameSent) frameSent = sendFrame(fcf, code, nsf, lastFrame);
  1347.     else if (lastResponse == AT_ERROR) gotEOT = true; // on hook
  1348.     stopTimeout("sending HDLC frame");
  1349.     return (frameSent);
  1350. }
  1352. /*
  1353.  * Send data using the specified signalling rate.
  1354.  */
  1355. bool
  1356. Class1Modem::transmitData(int br, u_char* data, u_int cc,
  1357.     const u_char* bitrev, bool eod)
  1358. {
  1359.     if (flowControl == FLOW_XONXOFF)
  1360. setXONXOFF(FLOW_XONXOFF, FLOW_NONE, ACT_FLUSH);
  1361.     fxStr tmCmd(br, tmCmdFmt);
  1362.     bool ok = atCmd(tmCmd, AT_CONNECT);
  1363.     if (ok) {
  1365. // T.31 8.3.3 requires the DCE to report CONNECT at the beginning
  1366. // of transmission of the training pattern rather than at the end.
  1367. // We pause here to allow the remote's +FRM to result in CONNECT.
  1368. // This delay will vary depending on the modem's adherence to T.31.
  1369. pause(conf.class1TMConnectDelay);
  1371. ok = sendClass1Data(data, cc, bitrev, eod, getDataTimeout());
  1372. if (ok && eod) {
  1373.     ok = false;
  1374.     u_short attempts = 0;
  1375.     lastResponse = AT_NOTHING;
  1376.     while (!ok && lastResponse != AT_NOCARRIER && attempts++ < 3) {
  1377. ok = waitFor(AT_OK, 60*1000); // wait up to 60 seconds for "OK"
  1378.     }
  1379. }
  1380.     } else if (lastResponse == AT_ERROR) gotEOT = true; // on hook
  1381.     if (flowControl == FLOW_XONXOFF)
  1382. setXONXOFF(FLOW_NONE, FLOW_NONE, ACT_DRAIN);
  1383.     return (ok);
  1384. }
  1386. /*
  1387.  * Receive an HDLC frame.  The timeout is against
  1388.  * the receipt of the HDLC flags; the frame itself must
  1389.  * be received within 3 seconds (per the spec).
  1390.  * If a carrier is received, but the complete frame
  1391.  * is not received before the timeout, the receive
  1392.  * is aborted.
  1393.  *
  1394.  * If the frame is received in error, then in instances
  1395.  * where the other end is likely to be able to receive
  1396.  * it, we can transmit CRP to get the other end to
  1397.  * retransmit the frame. 
  1398.  */
  1399. bool
  1400. Class1Modem::recvFrame(HDLCFrame& frame, u_char dir, long ms, bool readPending, bool docrp, bool usehooksensitivity)
  1401. {
  1402.     bool gotframe;
  1403.     u_short crpcnt = 0, rhcnt = 0;
  1404.     u_int onhooks = 0;
  1405.     gotCONNECT = true;
  1406.     time_t start = Sys::now();
  1407.     if (useV34) {
  1408. do {
  1409.     if (crpcnt) traceFCF(dir == FCF_SNDR ? "SEND send" : "RECV send", FCF_CRP);
  1410.     frame.reset();
  1411.     gotframe = recvRawFrame(frame);
  1412. } while (!gotframe && !gotRTNC && !gotEOT && docrp && crpcnt++ < 3 && !wasTimeout() && transmitFrame(dir|FCF_CRP));
  1413. return (gotframe);
  1414.     }
  1415.     startTimeout(ms);
  1416.     if (!readPending) {
  1417. /*
  1418.  * Hopefully the modem is smart enough to *not* do +FCERROR after +FRH=3,
  1419.  * as it is only a stumbling-block for us and cannot be beneficial.  But,
  1420.  * in case it adheres blindly to the spec, we'll repeat ourselves here
  1421.  * until we timeout or we do get the V.21 carrier.  We do slow the looping
  1422.  * with a pause to prevent unwanted massive amounts of tracing.  The pause 
  1423.  * needs to be short enough, though, that the modem will still pick up
  1424.  * any V.21 signalling if it misses that much of the startup.
  1425.  *
  1426.  * T.31 8.3.6 states that the NO CARRIER result to AT+FRH=3 indicates 
  1427.  * carrier loss.  Getting this result without first getting a CONNECT 
  1428.  * response (indicating carrier detection) seems a bit undefined.  However,
  1429.  * sample sessions T.31 I.1 and I.2 seem to give its use as a means to
  1430.  * deliberately detect carrier loss since the OK result to AT+FRH=3 does
  1431.  * not necessarily indicate carrier loss (even on final frames - although
  1432.  * smart modem developers would make it thus).  Thus could serve a purpose
  1433.  * similar to AT+FRS=1 as we haved used in Class1TCFRecvHackCmd (which is
  1434.  * generally a bad idea).  In any case, if we're trying to detect a V.21
  1435.  * HDLC frame and we get a NO CARRIER result immediately following AT+FRH=3
  1436.  * it probably means that the previous carrier was still up, that we just
  1437.  * saw its loss, and so we just need to re-issue AT+FRH=3.  See more below...
  1438.  */
  1439. do {
  1440.     readPending = atCmd(rhCmd, AT_NOTHING, 0) && waitFor(AT_CONNECT, 0);
  1441.     if (lastResponse == AT_FCERROR) pause(200);
  1442.     if (lastResponse == AT_ERROR && !wasTimeout() && ++onhooks <= conf.class1HookSensitivity) {
  1443. if (!usehooksensitivity) {
  1444.     /*
  1445.      * Class1HookSensitivity is used by the calling function, not us.
  1446.      */
  1447.     break;
  1448. } else {
  1449.     stopTimeout("");
  1450.     startTimeout(ms);
  1451. }
  1452.     }
  1453. } while (((u_int) Sys::now()-start < conf.t1Timer) && !wasTimeout() &&
  1454.     (lastResponse == AT_FCERROR || lastResponse == AT_NOCARRIER || (lastResponse == AT_ERROR && onhooks <= conf.class1HookSensitivity)));
  1455.     }
  1456.     if (readPending) {
  1457.         stopTimeout("waiting for HDLC flags");
  1458.         if (wasTimeout()){
  1459.             abortReceive();
  1460.             return (false);
  1461.         }
  1462. fxStr emsg;
  1463. do {
  1464.     if (crpcnt || rhcnt) {
  1465. if (rhcnt) crpcnt = 0;
  1466. if (crpcnt) {
  1467.     rhcnt = 0;
  1468.     traceFCF(dir == FCF_SNDR ? "SEND send" : "RECV send", FCF_CRP);
  1469. }
  1470. do {
  1471.     lastResponse = AT_NOTHING;
  1472.     startTimeout(ms);
  1473.     if (!(atCmd(rhCmd, AT_NOTHING, 0) && waitFor(AT_CONNECT,0))) {
  1474. stopTimeout("waiting for v.21 carrier");
  1475. if (wasTimeout()) {
  1476.     abortReceive();
  1477.     setTimeout(false);
  1478. }
  1479. if (lastResponse != AT_NOCARRIER || rhcnt++ > 30) return (false);
  1480.     }
  1481.     stopTimeout("waiting for v.21 carrier");
  1482.     /*
  1483.      * The meaning of a direct NO CARRIER response/result to the AT+FRH=3 
  1484.      * command can be interpreted two ways due to wording in ITU T.31.
  1485.      * The more traditional interpretation is that it is out-of-spec: that
  1486.      * a NO CARRIER response should only come after a CONNECT message.
  1487.      * However, T.31 gives sample sessions that illustrate precisely this 
  1488.      * kind of out-of-spec sequence:
  1489.      *
  1490.      * <-- AT+FRH=3
  1491.      * --> NO CARRIER
  1492.      *
  1493.      * And the interpretation is clear to indicate that in this case the
  1494.      * modem detected a carrier, but it apparently was not V.21 HDLC, and
  1495.      * the NO CARRIER response indicates that the indeterminate carrier
  1496.      * has dropped.  This functionality is more cumbersome than it is
  1497.      * helpful (its value is not much different than that of an AT+FRS=1 
  1498.      * command), and what it really means is that we just need to re-issue 
  1499.      * the AT+FRH=3 command until we get something useful as this scenario
  1500.      * will most likely occur on incidence of Phase C premature carrier loss.
  1501.      */
  1502. } while (lastResponse == AT_NOCARRIER);
  1503.     }
  1504.     frame.reset();
  1505.             gotframe = recvRawFrame(frame);
  1506.     /*
  1507.      * Some modems aren't very particular about reporting CONNECT after AT+FRH=3.
  1508.      * So, for such modems CONNECT may come with V.17 modulated audio or any noise
  1509.      * whatsoever.  Those modems tend to report NO CARRIER after CONNECT, perhaps
  1510.      * after <DLE><ETX> or some other garbage possibly.  NO CARRIER is an invalid
  1511.      * modem response at that point, anyway.  So it is a good indicator for us.
  1512.      * So we simply repeat AT+FRH=3 in that case.
  1513.      */
  1514. } while (((u_int) Sys::now()-start < howmany(conf.t1Timer, 1000)) && !gotframe && !wasTimeout() && 
  1515.     ((conf.class1HasRHConnectBug && !frame.getLength() && lastResponse == AT_NOCARRIER && rhcnt++ < 30) ||
  1516.     (docrp && crpcnt++ < 3 && switchingPause(emsg, 3) && transmitFrame(dir|FCF_CRP)))); /* triple switchingPause to avoid sending CRP during TCF */
  1517. return (gotframe);
  1518.     } else {
  1519. gotCONNECT = false;
  1520. if (lastResponse == AT_ERROR) gotEOT = true; // on hook
  1521.     }
  1522.     stopTimeout("waiting for v.21 carrier");
  1523.     if (wasTimeout()) {
  1524. abortReceive();
  1525. setTimeout(false);
  1526.     }
  1527.     return (false);
  1528. }
  1530. /*
  1531.  * Receive TCF data using the specified signalling rate.
  1532.  */
  1533. bool
  1534. Class1Modem::recvTCF(int br, HDLCFrame& buf, const u_char* bitrev, long ms)
  1535. {
  1536.     buf.reset();
  1537.     if (flowControl == FLOW_XONXOFF)
  1538. setXONXOFF(FLOW_NONE, FLOW_XONXOFF, ACT_DRAIN);
  1539.     /*
  1540.      * Loop waiting for carrier or timeout.
  1541.      */
  1542.     bool readPending, gotCarrier;
  1543.     fxStr rmCmd(br, rmCmdFmt);
  1544.     startTimeout(ms);
  1545.     u_short attempts = 0;
  1546.     do {
  1547. readPending = atCmd(rmCmd, AT_NOTHING, 0);
  1548. gotCarrier = readPending && waitFor(AT_CONNECT, 0);
  1549.     } while (readPending && !gotCarrier && lastResponse == AT_FCERROR && ++attempts < conf.class1RMPersistence);
  1550.     /*
  1551.      * If carrier was recognized, collect the data.
  1552.      */
  1553.     bool gotData = false;
  1554.     if (gotCarrier) {
  1555. int c = getModemChar(0); // NB: timeout is to first byte
  1556. stopTimeout("receiving TCF");
  1557. if (c != EOF) {
  1558.     buf.reset();
  1559.     /*
  1560.      * Use a  timer to receive the 1.5
  1561.      * second TCF--perhaps if it is too long it
  1562.      * won't permit us to send the nak in time?
  1563.      *
  1564.      * The initial timer needs to be longer than 1.5 seconds
  1565.      * to support senders that may not start the zeros
  1566.      * until a second or two after CONNECT.  This is
  1567.      * also why we restart our timeout after the zeros
  1568.      * start.
  1569.      */
  1570.     bool zerosstarted = false;
  1571.     startTimeout(ms);
  1572.     do {
  1573. if (c == 0x00 && !zerosstarted) {
  1574.     zerosstarted = true;
  1575.     startTimeout(ms);
  1576. }
  1577. if (c == DLE) {
  1578.     c = getModemChar(0);
  1579.     if (c == ETX) {
  1580. gotData = true;
  1581. break;
  1582.     }
  1583.     if (c == EOF) {
  1584. break;
  1585.     }
  1586. }
  1587. buf.put(bitrev[c]);
  1588. if (buf.getLength() > 10000) {
  1589.     setTimeout(true);
  1590.     break;
  1591. }
  1592.     } while ((c = getModemChar(0)) != EOF);
  1593. }
  1594.     }
  1595.     stopTimeout("receiving TCF");
  1596.     /*
  1597.      * If the +FRM is still pending, abort it.
  1598.      */
  1599.     if (readPending && wasTimeout())
  1600. abortReceive();
  1601.     if (flowControl == FLOW_XONXOFF)
  1602. setXONXOFF(FLOW_NONE, FLOW_NONE, ACT_DRAIN);
  1603.     return (gotData);
  1604. }
  1606. /* 
  1607.  * Modem manipulation support.
  1608.  */
  1610. /*
  1611.  * Reset a Class 1 modem.
  1612.  */
  1613. bool
  1614. Class1Modem::reset(long ms)
  1615. {
  1616.     return (FaxModem::reset(ms) && setupClass1Parameters());
  1617. }
  1619. ATResponse
  1620. Class1Modem::atResponse(char* buf, long ms)
  1621. {
  1622.     if (FaxModem::atResponse(buf, ms) == AT_OTHER && strneq(buf, "+FCERROR", 8))
  1623. lastResponse = AT_FCERROR;
  1624.     if (lastResponse == AT_OTHER && strneq(buf, "+FRH:3", 6))
  1625. lastResponse = AT_FRH3;
  1626.     if (lastResponse == AT_OTHER && strneq(buf, "+F34:", 5)) {
  1627. /*
  1628.  * V.8 handshaking was successful.  The rest of the
  1629.  * session is governed by T.31 Amendment 1 Annex B.
  1630.  * (This should only happen after ATA or ATD.)
  1631.  *
  1632.  * The +F34: response is interpreted according to T.31-A1 B.6.2.
  1633.  */
  1634. buf += 5; // skip "+F34:" prefix
  1635. primaryV34Rate = 0;
  1636. while (!isdigit(buf[0])) buf++; // move to digits
  1637. do {
  1638.     primaryV34Rate = primaryV34Rate*10 + (buf[0] - '0');
  1639.         } while (isdigit((++buf)[0]));
  1640. controlV34Rate = 0;
  1641. while (!isdigit(buf[0])) buf++; // move to digits
  1642. do {
  1643.     controlV34Rate = controlV34Rate*10 + (buf[0] - '0');
  1644.         } while (isdigit((++buf)[0]));
  1645. useV34 = true;
  1646. protoTrace("V.8 handshaking succeeded, V.34-Fax (SuperG3) capability enabled.");
  1647. protoTrace("Primary channel rate: %u bit/s, Control channel rate: %u bit/s.", primaryV34Rate*2400, controlV34Rate*1200);
  1648. modemParams.br |= BIT(primaryV34Rate) - 1;
  1649.     }
  1650.     return (lastResponse);
  1651. }
  1653. /*
  1654.  * Wait (carefully) for some response from the modem.
  1655.  */
  1656. bool
  1657. Class1Modem::waitFor(ATResponse wanted, long ms)
  1658. {
  1659.     for (;;) {
  1660. ATResponse response = atResponse(rbuf, ms);
  1661. if (response == wanted)
  1662.     return (true);
  1663. switch (response) {
  1664. case AT_TIMEOUT:
  1665. case AT_EMPTYLINE:
  1666. case AT_ERROR:
  1667. case AT_NOCARRIER:
  1668. case AT_NODIALTONE:
  1669. case AT_NOANSWER:
  1670. case AT_OFFHOOK:
  1671. case AT_RING:
  1672.     modemTrace("MODEM %s", ATresponses[response]);
  1673.     /* fall thru... */
  1674. case AT_OTHER:
  1675. case AT_FCERROR:
  1676. case AT_FRH3:
  1677. case AT_OK:
  1678.     return (false);
  1679. }
  1680.     }
  1681. }
  1683. /*
  1684.  * Send queryCmd and get a range response.
  1685.  */
  1686. bool
  1687. Class1Modem::class1Query(const fxStr& queryCmd, Class1Cap caps[])
  1688. {
  1689.     char response[1024];
  1690.     if (queryCmd[0] == '!') {
  1691. return (parseQuery(queryCmd.tail(queryCmd.length()-1), caps));
  1692.     }
  1693.     if (atCmd(queryCmd, AT_NOTHING) && atResponse(response) == AT_OTHER) {
  1694. sync(5000);
  1695. return (parseQuery(response, caps));
  1696.     }
  1697.     return (false);
  1698. }
  1700. /*
  1701.  * Map the DCS signalling rate to the appropriate
  1702.  * Class 1 capability entry.
  1703.  */
  1704. const Class1Cap*
  1705. Class1Modem::findSRCapability(u_short sr, const Class1Cap caps[])
  1706. {
  1707.     for (u_int i = NCAPS-1; i > 0; i--) {
  1708. const Class1Cap* cap = &caps[i];
  1709. if (cap->sr == sr) {
  1710.     if (cap->mod == V17 && HasShortTraining(cap-1))
  1711. cap--;
  1712.     return (cap);
  1713. }
  1714.     }
  1715.     // XXX should not happen...
  1716.     protoTrace("MODEM: unknown signalling rate %#x, using 9600 v.29", sr);
  1717.     return findSRCapability(DCSSIGRATE_9600V29, caps);
  1718. }
  1720. /*
  1721.  * Map the Class 2 bit rate to the best
  1722.  * signalling rate capability of the modem.
  1723.  */
  1724. const Class1Cap*
  1725. Class1Modem::findBRCapability(u_short br, const Class1Cap caps[])
  1726. {
  1727.     for (u_int i = NCAPS-1; i > 0; i--) {
  1728. const Class1Cap* cap = &caps[i];
  1729. if (cap->br == br && cap->ok) {
  1730.     if (cap->mod == V17 && HasShortTraining(cap-1))
  1731. cap--;
  1732.     return (cap);
  1733. }
  1734.     }
  1735.     protoTrace("MODEM: unsupported baud rate %#x", br);
  1736.     return NULL;
  1737. }
  1739. /*
  1740.  * Build upon the result from Class2Params.
  1741.  */
  1742. FaxParams
  1743. Class1Modem::modemDIS() const
  1744. {
  1745.     FaxParams dis_caps = FaxModem::modemDIS();
  1747.     // signalling rates
  1748.     for (u_short i = 0; i < 4; i++) dis_caps.setBit(11+i, (discap & (0x08>>i)));
  1749.     if (useV34) dis_caps.setBit(FaxParams::BITNUM_V8_CAPABLE, true);
  1751.     // preferred ECM frame size
  1752.     if (conf.class1ECMFrameSize == 64) dis_caps.setBit(FaxParams::BITNUM_FRAMESIZE_DIS, true);
  1754.     // we set both units preferences to allow the sender to choose
  1755.     dis_caps.setBit(FaxParams::BITNUM_METRIC_RES, true);
  1756.     dis_caps.setBit(FaxParams::BITNUM_INCH_RES, true);
  1758.     // we indicate both letter and legal page size support
  1759.     dis_caps.setBit(FaxParams::BITNUM_LETTER_SIZE, true);
  1760.     dis_caps.setBit(FaxParams::BITNUM_LEGAL_SIZE, true);
  1762.     // selective polling, subaddressing, password
  1763.     dis_caps.setBit(FaxParams::BITNUM_SEP, true);
  1764.     dis_caps.setBit(FaxParams::BITNUM_SUB, true);
  1765.     dis_caps.setBit(FaxParams::BITNUM_PWD, true);
  1767.     if (conf.class1ECMSupport) {
  1768. // JBIG
  1769. if (jbigSupported) {
  1770.     dis_caps.setBit(FaxParams::BITNUM_JBIG_BASIC, true);
  1771.     dis_caps.setBit(FaxParams::BITNUM_JBIG_L0, true); // JBIG library can handle L0 = 1-Yd
  1772. }
  1773. /* - disabled for now
  1774. // JBIG grey/color requires JPEG grey/color
  1775. if (conf.class1GreyJBIGSupport || conf.class1ColorJBIGSupport) {
  1776.     dis_caps.setBit(FaxParams::BITNUM_JPEG, true);
  1777.     dis_caps.setBit(FaxParams::BITNUM_JBIG, true);
  1778. }
  1779. if (conf.class1ColorJBIGSupport)
  1780.     dis_caps.setBit(FaxParams::BITNUM_FULLCOLOR, true);
  1781. */
  1782. // JPEG
  1783. if (conf.class1GreyJPEGSupport || conf.class1ColorJPEGSupport)
  1784.     dis_caps.setBit(FaxParams::BITNUM_JPEG, true);
  1785. if (conf.class1ColorJPEGSupport)
  1786.     dis_caps.setBit(FaxParams::BITNUM_FULLCOLOR, true);
  1787.     }
  1788.     return dis_caps;
  1789. }
  1791. const char COMMA = ',';
  1792. const char SPACE = ' ';
  1794. /*
  1795.  * Parse a Class 1 parameter string.
  1796.  */
  1797. bool
  1798. Class1Modem::parseQuery(const char* cp, Class1Cap caps[])
  1799. {
  1800.     bool bracket = false, first = true;
  1801.     
  1802.     while (cp[0]) {
  1803. if (cp[0] == SPACE) { // ignore white space
  1804.     cp++;
  1805.     continue;
  1806. }
  1808.         /* by a.pogoda@web.de, jan 21st 2002
  1809.          * workaround for modems sending (<item>,<item>,...), i.e. 
  1810.          * enclosed in brackets rather than just <item>,<item>,...
  1811.          * e.g. elsa microlink 56k internet II and maybo others
  1812.          */
  1813.         if (cp[0]=='(' && first && !bracket) {
  1814.           /* check whether the first non-space char is an 
  1815.            * opening bracket and skip it if true
  1816.            */ 
  1817.           bracket = true;
  1818.           cp++;
  1819.           continue;
  1820.         }
  1821.         else if (cp[0]==')' && !first && bracket) {
  1822.           /* if an opening bracket was scanned before and 
  1823.            * the current char is a closing one, skip it
  1824.            */
  1825.           bracket = false;
  1826.           cp++;
  1827.           continue;
  1828.         }
  1829.         else if (!isdigit(cp[0]))
  1830.   return (false);
  1832.         /* state that we already scanned past the first char */
  1833.         first = false;
  1834. int v = 0;
  1835. do {
  1836.     v = v*10 + (cp[0] - '0');
  1837. } while (isdigit((++cp)[0]));
  1838. int r = v;
  1839. if (cp[0] == '-') { // <low>-<high>
  1840.     cp++;
  1841.     if (!isdigit(cp[0])) {
  1842. return (false);
  1843.     }
  1844.     r = 0;
  1845.     do {
  1846. r = r*10 + (cp[0] - '0');
  1847.     } while (isdigit((++cp)[0]));
  1848. }
  1849. for (u_int i = 0; i < NCAPS; i++)
  1850.     if (caps[i].value >= v && caps[i].value <= r) {
  1851. caps[i].ok = true;
  1852. break;
  1853.     }
  1854. if (cp[0] == COMMA) // <item>,<item>...
  1855.     cp++;
  1856.     }
  1857.     return (true);
  1858. }