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

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

传真(Fax)编程

开发平台：

C/C++

Class2.c++：源码内容
  1. /* $Id: Class2.c++,v 1.25 2009/01/20 13:51:15 faxguy Exp $ */
  2. /*
  3.  * Copyright (c) 1990-1996 Sam Leffler
  4.  * Copyright (c) 1991-1996 Silicon Graphics, Inc.
  5.  * HylaFAX is a trademark of Silicon Graphics
  6.  *
  7.  * Permission to use, copy, modify, distribute, and sell this software and 
  8.  * its documentation for any purpose is hereby granted without fee, provided
  9.  * that (i) the above copyright notices and this permission notice appear in
  10.  * all copies of the software and related documentation, and (ii) the names of
  11.  * Sam Leffler and Silicon Graphics may not be used in any advertising or
  12.  * publicity relating to the software without the specific, prior written
  13.  * permission of Sam Leffler and Silicon Graphics.
  14.  * 
  15.  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
  16.  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
  17.  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
  18.  * 
  19.  * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
  20.  * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
  21.  * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  22.  * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
  23.  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
  24.  * OF THIS SOFTWARE.
  25.  */
  26. #include "Class2.h"
  27. #include "ModemConfig.h"
  29. #include <ctype.h>
  31. Class2Modem::Class2Modem(FaxServer& s, const ModemConfig& c) : FaxModem(s,c)
  32. {
  33.     hangupCode[0] = '';
  34.     serviceType = 0; // must be set in derived class
  35.     useExtendedDF = false; // T.32 Amendment 1 extension for data format is detectable
  36.     useJP = false; // JP +FCC option support is detectable
  37.     imagefd = 0;
  38. }
  40. Class2Modem::~Class2Modem()
  41. {
  42. }
  44. /*
  45.  * Check if the modem is a Class 2 modem and, if so,
  46.  * configure it for use.  We try to confine a lot of
  47.  * the manufacturer-specific bogosity here and leave
  48.  * the remainder of the Class 2 support fairly generic.
  49.  */
  50. bool
  51. Class2Modem::setupModem(bool isSend)
  52. {
  53.     if (!selectBaudRate(conf.maxRate, conf.flowControl, conf.flowControl))
  54. return (false);
  55.     // Query service support information
  56.     fxStr s;
  57.     if (doQuery(conf.classQueryCmd, s, 5000) && FaxModem::parseRange(s, modemServices))
  58. traceBits(modemServices & SERVICE_ALL, serviceNames);
  59.     if ((modemServices & serviceType) == 0)
  60. return (false);
  61.     atCmd(classCmd);
  63.     /*
  64.      * Query manufacturer, model, and firmware revision.
  65.      * We use the manufacturer especially as a key to
  66.      * working around firmware bugs (yech!).
  67.      */
  68.     if (setupManufacturer(modemMfr)) {
  69. modemCapability("Mfr " | modemMfr);
  70. modemMfr.raisecase();
  71.     }
  72.     (void) setupModel(modemModel);
  73.     (void) setupRevision(modemRevision);
  74.     if (modemModel != "")
  75. modemCapability("Model " | modemModel);
  76.     if (modemRevision != "")
  77. modemCapability("Revision " | modemRevision);
  79.     /*
  80.      * Get modem capabilities and calculate best signalling
  81.      * rate, data formatting capabilities, etc. for use in
  82.      * T.30 negotiations.
  83.      */
  84.     fxStr t30parms;
  85.     if (!doQuery(dccQueryCmd, t30parms, 500)) {
  86. serverTrace("Error getting modem capabilities");
  87. return (false);
  88.     }
  89.     /*
  90.      * Syntax: (vr),(br),(wd),(ln),(df),(ec),(bf),(st)[,(jp)]
  91.      * where,
  92.      * vr vertical resolution
  93.      * br bit rate
  94.      * wd page width
  95.      * ln page length
  96.      * df data compression
  97.      * ec error correction
  98.      * bf binary file transfer
  99.      * st scan time/line
  100.      * jp JPEG support (optional)
  101.      */
  102.     if (!parseRange(t30parms, modemParams)) {
  103. serverTrace("Error parsing " | dccQueryCmd | " response: "
  104.     """ | t30parms | """);
  105. return (false);
  106.     }
  107.     /*
  108.      * The EC parameter varies between the Class 2 and Class 2.0 specs.
  109.      * And because modems don't all adhere to the respective spec, we must adjust
  110.      * modemParams based both on serviceType and on configuration to compensate.
  111.      */
  112.     if (conf.class2ECMType == ClassModem::ECMTYPE_CLASS20 ||
  113.        (conf.class2ECMType == ClassModem::ECMTYPE_UNSET && serviceType != SERVICE_CLASS2)) {
  114.     // The Class 2.0 spec wisely lumps both 64-byte and 256-byte ECM together
  115.     // because an ECM receiver must support both anyway per T.30-A.
  116.     modemParams.ec ^= BIT(EC_DISABLE); // don't adjust EC_DISABLE
  117.     modemParams.ec <<= 1; // simple adjustment
  118.     modemParams.ec |= BIT(EC_DISABLE); // reset EC_DISABLE
  119.     if (modemParams.ec & BIT(EC_ENABLE256))
  120. modemParams.ec |= BIT(EC_ENABLE64);
  121.     }
  122.     bool jbigsupported = false;
  123.     switch (conf.class2JBIGSupport) {
  124. case FaxModem::JBIG_FULL:
  125.     jbigsupported = true;
  126.     break;
  127. case FaxModem::JBIG_SEND:
  128.     jbigsupported = isSend;
  129.     break;
  130. case FaxModem::JBIG_RECV:
  131.     jbigsupported = !isSend;
  132.     break;
  133. }
  134.     if (!jbigsupported) {
  135. modemParams.df &= ~BIT(DF_JBIG);
  136.     }
  137.     traceModemParams();
  138.     /*
  139.      * Check to see if the modem supports copy quality checking.
  140.      * If the modem is capable, then enable it using the configured
  141.      * commands.  If the modem is incapable of doing copy quality
  142.      * checking, then the host will do the work.
  143.      *
  144.      * The recommendation for AT+FCQ varies significantly between
  145.      * the Class 2 and Class 2.0 specification.
  146.      *
  147.      * An assumption is made that Class2CQCmd, if configured, enables
  148.      * all available copy quality services (or disables them if none
  149.      * are available).
  150.      */
  151.     cqCmds = "";
  152.     sendCQ = 0;
  153.     if (serviceType == SERVICE_CLASS2) {
  154. /*
  155.  * The AT+FCQ=? response indicates which compression
  156.          * formats are copy-quality checked.
  157.  */
  158. if (doQuery(conf.class2CQQueryCmd, s) && FaxModem::parseRange(s, modemCQ)) {
  159.     if (modemCQ >>= 1)
  160. cqCmds = conf.class2CQCmd;
  161. } else
  162.     modemCQ = 0;
  163. static const char* whatCQ[4] = { "no", "1D", "2D", "1D+2D" };
  164. modemSupports("%s copy quality checking%s", whatCQ[modemCQ&3],
  165.     (modemCQ && cqCmds == "" ? " (but not enabled)" : ""));
  166.     } else { // SERVICE_CLASS20, SERVICE_CLASS21
  167. /*
  168.  * The AT+FCQ=? response indicates whether or not copy-quality
  169.          * checking and/or correction are supported.  Host CQ cannot
  170.  * be used if the modem performs copy-quality correction.
  171.  */
  172. cqCmds = conf.class2CQCmd;
  173. if (doQuery(conf.class2CQQueryCmd, s) && FaxModem::vparseRange(s, 0, 2, &modemCQ, &sendCQ)) {
  174.     modemCQ >>= 1;
  175.     sendCQ >>= 1;
  176. } else {
  177.     modemCQ = 0;
  178.     sendCQ = 0;
  179. }
  180. static const char* whatCQ[4] = { "no", "checking", "correction", "checking and correction" };
  181. if (modemCQ)
  182.     modemSupports("receiving copy quality %s", whatCQ[modemCQ&3]);
  183. else modemSupports("no receiving copy quality services");
  184. if (sendCQ)
  185.     modemSupports("sending copy quality %s%s", whatCQ[sendCQ&3],
  186. (sendCQ && cqCmds == "" ? " (but not enabled)" : ""));
  187. else modemSupports("no sending copy quality services");
  188.     }
  189.     /*
  190.      * In Class 2 we follow spec defaults and assume that if cqCmds is null 
  191.      * that CQ is not enabled.  In Class 2.0/2.1 we follow spec default and
  192.      * assume the opposite.  In order to know otherwise we'd need to make
  193.      * sense of AT+FCQ? and incorporate that in the messages above.
  194.      */
  195.     if (serviceType == SERVICE_CLASS2) {
  196. if (cqCmds == "") modemCQ = 0;
  197.     } else { // SERVICE_CLASS20, SERVICE_CLASS21
  198. if (cqCmds == "" && modemCQ) modemCQ = 1;
  199.     }
  200.     /*
  201.      * Deduce if modem supports T.class2-defined suport for
  202.      * subaddress, selective polling address, and passwords.
  203.      */
  204.     int sub = 0;
  205.     int sep = 0;
  206.     int pwd = 0;
  207.     // some modems don't support an AP-query command
  208.     if (strcasecmp(conf.class2APQueryCmd, "none") != 0) {
  209. if (doQuery(conf.class2APQueryCmd, s))
  210.     (void) vparseRange(s, 0, 3, &sub, &sep, &pwd);
  211.     }
  212.     if (sub & BIT(1)) {
  213. saCmd = conf.class2SACmd;
  214. modemSupports("subaddressing");
  215.     } else
  216. saCmd = "";
  217.     if (sep & BIT(1)) {
  218. paCmd = conf.class2PACmd;
  219. modemSupports("selective polling");
  220.     } else
  221. paCmd = "";
  222.     if (pwd & BIT(1)) {
  223. pwCmd = conf.class2PWCmd;
  224. modemSupports("passwords");
  225.     } else
  226. pwCmd = "";
  227.     if ((sub|sep|pwd) & BIT(1))
  228. apCmd = conf.class2APCmd;
  229.     /*
  230.      * Check if the modem supports polled reception of documents.
  231.      */
  232.     u_int t;
  233.     // some modems don't support an SPL command
  234.     if (strcasecmp(splCmd, "none") != 0) {
  235. if (doQuery(splCmd | "=?", s) && FaxModem::parseRange(s, t))
  236.     hasPolling = (t & BIT(1)) != 0;
  237.     }
  238.     /*
  239.      * Define the code to send to the modem to trigger the
  240.      * transfer of received Phase C data to the host.  Most
  241.      * modems based on SP-2388-A (Class 2) use DC1 while those
  242.      * based on SP-2388-B (Class 2.0) use DC2.  There are some
  243.      * exceptions (ZyXEL and modems based on Rockwell RC32ACL
  244.      * parts), but they are expected to set the appropriate
  245.      * value in the config file.
  246.      */
  247.     if (conf.class2RecvDataTrigger == "")
  248. recvDataTrigger = (serviceType == SERVICE_CLASS2 ? DC1 : DC2);
  249.     else
  250. recvDataTrigger = conf.class2RecvDataTrigger[0];
  251.     /*
  252.      * SP-2388-A (Class 2) specifies that the modem should send
  253.      * XON to the host when it is ready to received page data
  254.      * during a transmission.  This went away in SP-2388-B and in
  255.      * the final Class 2.0 spec.  Consequently we configure the
  256.      * modem either to ignore it (Class 2.0/2.1) or to use whatever
  257.      * is configured (it defaults to true).
  258.      */
  259.     if ((serviceType == SERVICE_CLASS20) || (serviceType == SERVICE_CLASS21))
  260. xmitWaitForXON = false;
  261.     else
  262. xmitWaitForXON = conf.class2XmitWaitForXON;
  264.     /*
  265.      * Most Class2 modems require recvFillOrder == MSB2LSB
  266.      * (Rockwell bug, which has become "standard" now).
  267.      *
  268.      * The only known exception is early Multitech modems,
  269.      * that follow original Class2 specs (LSB2MSB). They  report the
  270.      * manufacturer as "Multi-Tech Sys" or "Multi-Tech Systems".
  271.      *
  272.      * Other Class2 modems that requires recvFillOrder == LSB2MSB
  273.      * (if any) are expected to set the appropriate value in the
  274.      * config file.
  275.      */
  276.     if( conf.recvFillOrder == 0 &&  serviceType == SERVICE_CLASS2 ){
  277.         if ( modemMfr.find(0, "MULTI-TECH") >= modemMfr.length()  ){
  278.             // Not a Multitech
  279.             recvFillOrder = FILLORDER_MSB2LSB;
  280.         }
  281.     }
  283.     setupClass2Parameters(); // send parameters to the modem
  284.     return (true);
  285. }
  287. void
  288. Class2Modem::pokeConfig(bool isSend)
  289. {
  290. }
  292. /*
  293.  * Switch the modem to Class 2/2.0 and  insure parameters
  294.  * are set as we want them since some modems reset state
  295.  * on switching into Class 2/2.0.  Note that receive-related
  296.  * parameters are only set on modem reset because some
  297.  * commands, like setupAACmd, can reset the modem to Class
  298.  * 0.  This interface is used only for outbound use or when
  299.  * followed by setup of receive-specific parameters.
  300.  */
  301. bool
  302. Class2Modem::setupClass2Parameters(bool enableV34, bool enableV17)
  303. {
  304.     if (modemServices & serviceType) { // when resetting at startup
  305. setupFlowControl(flowControl); // flow control
  306. // some modems don't support a TBC command
  307. if (strcasecmp(tbcCmd, "none") != 0) {
  308.     atCmd(tbcCmd); // stream mode
  309. }
  310. atCmd(borCmd); // Phase B+C bit order
  311. /*
  312.  * Set Phase C data transfer timeout parameter.
  313.  * Note that we also have our own timeout parameter
  314.  * that should be at least as large (though it
  315.  * probably doesn't matter).  Some modem manufacturers
  316.  * do not support this command (or perhaps they
  317.  * hide it under a different name).
  318.  */
  319. if (strcasecmp(phctoCmd, "none") != 0) {
  320.     atCmd(phctoCmd);
  321. }
  323. (void) atCmd(cqCmds); // copy quality checking
  324. (void) atCmd(nrCmd); // negotiation reporting
  325. (void) atCmd(apCmd); // address&polling reporting
  326. (void) atCmd(pieCmd); // program interrupt enable
  327. // HDLC frame tracing
  328. // some modems don't support a BUG command
  329. if (getHDLCTracing() && strcasecmp(bugCmd, "none") != 0)
  330.     atCmd(bugCmd);
  331. /*
  332.  * Force the DCC so that we can override
  333.  * whatever the modem defaults are.
  334.  */
  335. setupDCC(enableV34, enableV17);
  336.     }
  337.     return (true);
  338. }
  340. /*
  341.  * Setup receive-specific parameters.
  342.  */
  343. bool
  344. Class2Modem::setupReceive()
  345. {
  346.     /*
  347.      * Try to setup byte-alignment of received EOL's.
  348.      * As always, this is problematic.  If the modem
  349.      * does not support this, but accepts the command
  350.      * (as many do!), then received facsimile will be
  351.      * incorrectly tagged as having byte-aligned EOL
  352.      * codes in them--not usually much of a problem.
  353.      */
  354.     if (conf.class2RELCmd != "" && atCmd(conf.class2RELCmd))
  355. group3opts |= GROUP3OPT_FILLBITS;
  356.     else
  357. group3opts &= ~GROUP3OPT_FILLBITS;
  358.     atCmd(crCmd); // enable receiving
  359.     /*
  360.      * Enable adaptive-answer support.  If we're configured,
  361.      * we'll act like getty and initiate a login session if
  362.      * we get a data connection.  Note that we do this last
  363.      * so that the modem can be left in a state other than
  364.      * +FCLASS=2 (e.g. Rockwell-based modems often need to be
  365.      * in Class 0).
  366.      */
  367.     return atCmd(conf.setupAACmd);
  368. }
  370. /*
  371.  * Send the modem any commands needed to force use of
  372.  * the specified flow control scheme.
  373.  */
  374. bool
  375. Class2Modem::setupFlowControl(FlowControl fc)
  376. {
  377.     switch (fc) {
  378.     case FLOW_NONE: return atCmd(noFlowCmd);
  379.     case FLOW_XONXOFF: return atCmd(softFlowCmd);
  380.     case FLOW_RTSCTS: return atCmd(hardFlowCmd);
  381.     }
  382.     return (true);
  383. }
  385. /*
  386.  * Setup DCC to reflect best capabilities of the server.
  387.  */
  388. bool
  389. Class2Modem::setupDCC(bool enableV34, bool enableV17)
  390. {
  391.     params.vr = getVRes();
  392.     params.br = enableV34 ? getBestSignallingRate() : fxmin((u_int) BR_14400, getBestSignallingRate());
  393.     params.br = enableV17 ? params.br : fxmin((u_int) BR_9600, getBestSignallingRate());
  394.     params.wd = getBestPageWidth();
  395.     params.ln = getBestPageLength();
  396.     params.df = useExtendedDF ? modemParams.df : getBestDataFormat();
  397.     params.ec = getBestECM();
  398.     params.bf = BF_DISABLE;
  399.     params.st = getBestScanlineTime();
  400.     params.jp = modemParams.jp;
  401.     return class2Cmd(dccCmd, params, true);
  402. }
  404. /*
  405.  * Parse a ``capabilities'' string from the modem and
  406.  * return the values through the params parameter.
  407.  */
  408. bool
  409. Class2Modem::parseClass2Capabilities(const char* cap, Class2Params& params, bool isDIS)
  410. {
  411.     /*
  412.      * Some modems report capabilities in hex values, others decimal.
  413.      */
  414.     fxStr notation;
  415.     if (conf.class2UseHex) {
  416. if (useJP) notation = "%X,%X,%X,%X,%X,%X,%X,%X,%X";
  417. else notation = "%X,%X,%X,%X,%X,%X,%X,%X";
  418.     } else {
  419. if (useJP) notation = "%d,%d,%d,%d,%d,%d,%d,%d,%d";
  420. else notation = "%d,%d,%d,%d,%d,%d,%d,%d";
  421.     }
  422.     int n = 0;
  423.     if (useJP) {
  424. n = sscanf(cap, notation,
  425.     &params.vr, &params.br, &params.wd, &params.ln,
  426.     &params.df, &params.ec, &params.bf, &params.st, &params.jp);
  427.     } else {
  428. n = sscanf(cap, notation,
  429.     &params.vr, &params.br, &params.wd, &params.ln,
  430.     &params.df, &params.ec, &params.bf, &params.st);
  431. params.jp = 0;
  432.     }
  433.     if ((useJP && n == 9) || (n == 8)) {
  434. if (useJP && (n == 8)) {
  435.     /*
  436.      * The modem was previously determined to support JP; however,
  437.      * this response does not include it.  So we just set it to zero.
  438.      */
  439.     params.jp = 0;
  440. }
  441. if (params.ec != EC_DISABLE && (conf.class2ECMType == ClassModem::ECMTYPE_CLASS20 ||
  442.    (conf.class2ECMType == ClassModem::ECMTYPE_UNSET && serviceType != SERVICE_CLASS2)))
  443.     params.ec += 1; // simple adjustment, drops EC_ENABLE64
  444. /*
  445.  * Clamp values to insure modem doesn't feed us
  446.  * nonsense; should log bogus stuff also.
  447.  */
  448. params.vr = params.vr & VR_ALL;
  449. params.br = fxmin(params.br, (u_int) BR_33600);
  450. params.wd = fxmin(params.wd, (u_int) WD_A3);
  451. params.ln = fxmin(params.ln, (u_int) LN_INF);
  452. if (useExtendedDF) {
  453.     /*
  454.      * The T.32-A1 DF extension presents us with a bitmap-like presentation
  455.      * similar to VR here... but leaves 2D-MMR = 3 for backwards-compatibility.
  456.      *
  457.      * 0 = 1D-MH, 1 = 2D-MR, 3 = 2D-MMR, 4 = JBIG-L0, 8 = JBIG
  458.      */
  459.     u_int dfscan = params.df;
  460.     if (isDIS) {
  461. params.df = BIT(DF_1DMH);
  462. if (dfscan & 0x1) params.df |= BIT(DF_2DMR);
  463. if (dfscan & 0x2) params.df |= BIT(DF_2DMMR); // don't require MR for MMR
  464. if (dfscan & 0x4) params.df |= BIT(DF_JBIG); // JBIG L0 is JBIG to us
  465. if (dfscan & 0x8) params.df |= BIT(DF_JBIG);
  466.     } else {
  467. // Dex 855 is known to indicate MMR in addition to JBIG when sending JBIG (0x7).
  468. // Thus only interpret DF=MMR when 0x3.
  469. params.df = DF_1DMH;
  470. if (dfscan == 0x3) params.df = DF_2DMMR;
  471. else if (dfscan & 0x1) params.df = DF_2DMR;
  472. else if (dfscan & 0x4) params.df = DF_JBIG; // JBIG L0 is JBIG to us
  473. else if (dfscan & 0x8) params.df = DF_JBIG;
  474.     }
  475. } else {
  476.     params.df = fxmin(params.df, (u_int) DF_2DMMR);
  477.     /*
  478.      * Table 21 T.32 does not match Table 2 T.30 very well in some aspects.
  479.      * Data format is one of those things.  When dealing with DIS we use DF 
  480.      * as a bitmap to suit T.30, but a T.32-following modem will only report 
  481.      * one supported receiver format (and not all of them).  Thus when 
  482.      * parsing T.32 DIS we must convert the modem response to a bitmap.  
  483.      * However, due to the incongruency between T.30 and T.32 the bitmap will 
  484.      * only contain the the reported format and the required format.
  485.      */
  486.     if (isDIS) {
  487. params.df = BIT(params.df) | BIT(DF_1DMH);
  488.     }
  489. }
  490. if (params.ec > EC_ECLFULL) // unknown, disable use
  491.     params.ec = EC_DISABLE;
  492. if (params.bf > BF_ENABLE)
  493.     params.bf = BF_DISABLE;
  494. params.st = fxmin(params.st, (u_int) ST_40MS);
  495. int jpscan = params.jp;
  496. params.jp = 0;
  497. if (isDIS) {
  498.     if (jpscan & 0x1) params.jp |= BIT(JP_GREY);
  499.     if (jpscan & 0x2) params.jp |= BIT(JP_COLOR);
  500. } else {
  501.     if (jpscan == 0x1) params.jp = JP_GREY;
  502.     else if (jpscan & 0x2) params.jp = JP_COLOR;
  503. }
  504. return (true);
  505.     } else {
  506. protoTrace("MODEM protocol botch, can not parse "%s"", cap);
  507. return (false);
  508.     }
  509. }
  511. /*
  512.  * Place the modem into the appropriate state
  513.  * for sending facsimile.
  514.  */
  515. bool
  516. Class2Modem::faxService(bool enableV34, bool enableV17)
  517. {
  518.     if (!enableV17 && conf.class2DisableV17Cmd != "" && !atCmd(conf.class2DisableV17Cmd)) return (false);
  519.     if (!enableV34 && conf.class2DisableV34Cmd != "" && !atCmd(conf.class2DisableV34Cmd)) return (false);
  520.     return setupClass2Parameters(enableV34, enableV17);
  521. }
  524. bool
  525. Class2Modem::setupRevision(fxStr& revision)
  526. {
  527.     if (FaxModem::setupRevision(revision)) {
  528. /*
  529.  * Cleanup ZyXEL response (argh), modem gives:
  530.  * +FREV? "U1496E   V 5.02 M    "
  531.  */
  532. if (modemMfr == "ZYXEL") {
  533.     u_int pos = modemRevision.next(0, ' ');
  534.     if (pos != modemRevision.length()) { // rev. has model 1st
  535. pos = modemRevision.skip(pos, ' ');
  536. modemRevision.remove(0, pos);
  537.     }
  538. }
  539. return (true);
  540.     } else
  541. return (false);
  542. }
  544. bool
  545. Class2Modem::setupModel(fxStr& model)
  546. {
  547.     if (FaxModem::setupModel(model)) {
  548. /*
  549.  * Cleanup ZyXEL response (argh), modem gives:
  550.  * +FMDL? "U1496E   V 5.02 M    "
  551.  */
  552. if (modemMfr == "ZYXEL")
  553.     modemModel.resize(modemModel.next(0, ' ')); // model is first word
  554. return (true);
  555.     } else
  556. return (false);
  557. }
  559. bool
  560. Class2Modem::supportsPolling() const
  561. {
  562.     return (hasPolling);
  563. }
  565. /*
  566.  * Strip any quote marks from a string.  This
  567.  * is used for received TSI+CSI strings passed
  568.  * to the server.
  569.  */
  570. fxStr
  571. Class2Modem::stripQuotes(const char* cp)
  572. {
  573.     fxStr s(cp);
  574.     u_int pos = s.next(0, '"');
  575.     while (pos != s.length()) {
  576. s.remove(pos,1);
  577. pos = s.next(0,'"');
  578.     }
  579.     return (s);
  580. }
  582. /*
  583.  * Construct the Calling Station Identifier (CSI) string
  584.  * for the modem.  We permit any ASCII printable characters
  585.  * in the string though the spec says otherwise.  The max
  586.  * length is 20 characters (per the spec), and we pad the
  587.  * string to that length to avoid buggy modems from putting
  588.  * garbage in the void.
  589.  */
  590. void
  591. Class2Modem::setLID(const fxStr& number)
  592. {
  593.     lid.resize(0);
  594.     for (u_int i = 0, n = number.length(); i < 20; i++) {
  595. if (i < n) {
  596.     char c = number[i];
  597.     if (isprint(c) || c == ' ')
  598. lid.append(c);
  599. } else
  600.     lid.append(' ');
  601.     }
  602.     class2Cmd(lidCmd, lid); // for DynamicConfig
  603. }
  605. /* 
  606.  * Modem manipulation support.
  607.  */
  609. /*
  610.  * Reset a Class 2 modem.
  611.  */
  612. bool
  613. Class2Modem::reset(long ms)
  614. {
  615.     return (FaxModem::reset(ms) && setupClass2Parameters());
  616. }
  618. /*
  619.  * Wait (carefully) for some response from the modem.
  620.  * In particular, beware of unsolicited hangup messages
  621.  * from the modem.  Some modems seem to not use the
  622.  * Class 2 required +FHNG response--and instead give
  623.  * us an unsolicited NO CARRIER message.  Isn't life
  624.  * wondeful?
  625.  */
  626. bool
  627. Class2Modem::waitFor(ATResponse wanted, long ms)
  628. {
  629.     for (;;) {
  630. ATResponse response = atResponse(rbuf, ms);
  631. if (response == wanted)
  632.     return (true);
  633. switch (response) {
  634. case AT_TIMEOUT:
  635. case AT_EMPTYLINE:
  636. case AT_ERROR:
  637. case AT_NOCARRIER:
  638. case AT_NODIALTONE:
  639. case AT_NOANSWER:
  640. case AT_RING:
  641.     modemTrace("MODEM %s", ATresponses[response]);
  642. case AT_OK:
  643.     return (false);
  644. case AT_FHNG:
  645.     // return hangup status, but try to wait for requested response
  646.     { char buf[1024]; (void) atResponse(buf, 2*1000); }
  647.     return (isNormalHangup());
  648. }
  649.     }
  650. }
  652. /*
  653.  * Interfaces for sending a Class 2 commands.
  654.  */
  656. /*
  657.  * Send <cmd>=<a0> and wait for response.
  658.  */
  659. bool
  660. Class2Modem::class2Cmd(const fxStr& cmd, int a0, ATResponse r, long ms)
  661. {
  662.     return atCmd(cmd | fxStr(a0, "=%u"), r, ms);
  663. }
  665. /*
  666.  * Send <cmd>=<t.30 parameters> and wait response.
  667.  */
  668. bool
  669. Class2Modem::class2Cmd(const fxStr& cmd, const Class2Params& p, bool isDCC, ATResponse r, long ms)
  670. {
  671.     bool ecm20 = false;
  672.     if (conf.class2ECMType == ClassModem::ECMTYPE_CLASS20 ||
  673.        (conf.class2ECMType == ClassModem::ECMTYPE_UNSET && serviceType != SERVICE_CLASS2))
  674. ecm20 = true;
  675.     return atCmd(cmd | "=" | p.cmd(conf.class2UseHex, ecm20, (isDCC && useExtendedDF), useJP), r, ms);
  676. }
  678. /*
  679.  * Send <cmd>="<s>" and wait for response.
  680.  */
  681. bool
  682. Class2Modem::class2Cmd(const fxStr& cmd, const fxStr& s, ATResponse r, long ms)
  683. {
  684.     return atCmd(cmd | "="" | s | """, r, ms); // XXX handle escapes
  685. }
  687. /*
  688.  * Parse a Class 2 parameter specification
  689.  * and return the resulting bit masks.
  690.  */
  691. bool
  692. Class2Modem::parseRange(const char* cp, Class2Params& p)
  693. {
  694.     /*
  695.      * VR, BF, and JP are already reported as bitmap
  696.      * values accoring to T.32 Table 21.
  697.      * In vparseRange(), VR:nargs=7, BF:nargs=1.
  698.      */
  699.     int masked = (1 << 7) + (1 << 1); // reversed, count-down style
  700.     if (!vparseRange(cp, masked, 8, &p.vr,&p.br,&p.wd,&p.ln,&p.df,&p.ec,&p.bf,&p.st))
  701. return (false);
  702.     p.vr &= VR_ALL;
  703.     p.br &= BR_ALL;
  704.     p.wd &= WD_ALL;
  705.     p.ln &= LN_ALL;
  706.     if ((p.df & 0x10) && (p.df & 0x100)) { // supports JBIG via T.32-A1 extension
  707. /*
  708.  * Old T.32 Table 21 does not provide for JBIG data formats.
  709.  * In amendment 1 the ITU has extended the DF parameter to include JBIG by 
  710.  * assigning "4" to JBIG L0 and "8" to JBIG.  The +FCC response for DF may  
  711.  * look like (00-0F) or possibly even (00-01,03-05,07-09,0B-0D,0F).  However, 
  712.  * in so doing the ITU has also changed the DF parameter (in +FIS and +FCS 
  713.  * responses) into a bitmap.  Yet, an +FCC response for DF of "(5DDD)" or "(0F)" 
  714.  * is not backwards-compatible with older T.32.  So the +FCC response is in 
  715.  * this backwards-compatible presentation (00-0F), and +FCS and +FIS responses 
  716.  * are not.
  717.  */
  718. useExtendedDF = true;
  719. p.df &= DF_ALL;
  720. p.df |= BIT(DF_JBIG);
  721.     } else
  722. p.df &= DF_ALL;
  723.     p.ec &= EC_ALL;
  724.     p.bf &= BF_ALL;
  725.     p.st &= ST_ALL;
  727.     /*
  728.      * As JP is optional we do a second, non-fatal parse for it.
  729.      */
  730.     int n;
  731.     masked = 1;
  732.     if (vparseRange(cp, masked, 9, &n,&n,&n,&n,&n,&n,&n,&n,&p.jp)) {
  733. useJP = true;
  734. if (conf.class2JPEGSupport) p.jp &= JP_ALL;
  735. else p.jp = 0;
  736.     } else
  737. p.jp = 0;
  739.     return true;
  740. }
  742. const char*
  743. Class2Modem::skipStatus(const char* s)
  744. {
  745.     const char* cp;
  746.     for (cp = s; *cp != '' && *cp != ':'; cp++)
  747. ;
  748.     return (*cp == ':' ? cp+1 : s);
  749. }
  751. /*
  752.  * Hangup codes are broken up according to:
  753.  *   2388/89
  754.  *   2388/90 and 2388-A
  755.  *   2388-B (Class 2.0)
  756.  * The table to search is based on the modem type deduced
  757.  * at modem configuration time.
  758.  *
  759.  * Note that we keep the codes as strings to avoid having
  760.  * to distinguish the decimal numbers of 2388-A from the
  761.  * hexadecimal renumbering done in 2388-B!
  762.  */
  763. static struct HangupCode {
  764.     const char* code[4]; // from 2388/89, 2388/90, 2388-A, 2388-B, and ours
  765.     const char* message; // what code means
  766. } hangupCodes[] = {
  767. // Call placement and termination
  768.     {{  "0",  "0",  "0", "E211" }, "Normal and proper end of connection" },
  769.     {{  "1",  "1",  "1", "E212" }, "Ring detect without successful handshake" },
  770.     {{  "2",  "2",  "2", "E213" }, "Call aborted,  from +FK or <CAN>" },
  771.     {{ NULL,  "3",  "3", "E214" }, "No loop current" },
  772.     {{ NULL, NULL,  "4", "E215" }, "Ringback detected, no answer (timeout)" },
  773.     {{ NULL, NULL,  "5", "E216" }, "Ringback detected, no answer without CED" },
  774. // Transmit Phase A & miscellaneous errors
  775.     {{ "10", "10", "10", "E217" }, "Unspecified Phase A error" },
  776.     {{ "11", "11", "11", "E218" }, "No answer (T.30 T1 timeout)" },
  777. // Transmit Phase B
  778.     {{ "20", "20", "20", "E219" }, "Unspecified Transmit Phase B error" },
  779.     {{ "21", "21", "21", "E220" }, "Remote cannot be polled" },
  780.     {{ "22", "22", "22", "E221" }, "COMREC error in transmit Phase B/got DCN" },
  781.     {{ "23", "23", "23", "E222" }, "COMREC invalid command received/no DIS or DTC" },
  782.     {{ "24", "24", "24", "E223" }, "RSPREC error/got DCN" },
  783.     {{ "25", "25", "25", "E224" }, "DCS sent 3 times without response" },
  784.     {{ "26", "26", "26", "E225" }, "DIS/DTC received 3 times; DCS not recognized" },
  785.     {{ "27", "27", "27", "E226" }, "Failure to train at 2400 bps or +FMINSP value" },
  786.     {{ "28", "28", "28", "E227" }, "RSPREC invalid response received" },
  787. // Transmit Phase C
  788.     {{ "30", "40", "40", "E228" }, "Unspecified Transmit Phase C error" },
  789.     {{ NULL, NULL, "41", "E229" }, "Unspecified Image format error" },
  790.     {{ NULL, NULL, "42", "E230" }, "Image conversion error" },
  791.     {{ "33", "43", "43", "E231" }, "DTE to DCE data underflow" },
  792.     {{ NULL, NULL, "44", "E232" }, "Unrecognized Transparent data command" },
  793.     {{ NULL, NULL, "45", "E233" }, "Image error, line length wrong" },
  794.     {{ NULL, NULL, "46", "E234" }, "Image error, page length wrong" },
  795.     {{ NULL, NULL, "47", "E235" }, "Image error, wrong compression code" },
  796. // Transmit Phase D
  797.     {{ "40", "50", "50", "E236" }, "Unspecified Transmit Phase D error, including"
  798.    " +FPHCTO timeout between data and +FET command" },
  799.     {{ "41", "51", "51", "E237" }, "RSPREC error/got DCN" },
  800.     {{ "42", "52", "52", "E238" }, "No response to MPS repeated 3 times" },
  801.     {{ "43", "53", "53", "E239" }, "Invalid response to MPS" },
  802.     {{ "44", "54", "54", "E240" }, "No response to EOP repeated 3 times" },
  803.     {{ "45", "55", "55", "E241" }, "Invalid response to EOP" },
  804.     {{ "46", "56", "56", "E242" }, "No response to EOM repeated 3 times" },
  805.     {{ "47", "57", "57", "E243" }, "Invalid response to EOM" },
  806.     {{ "48", "58", "58", "E244" }, "Unable to continue after PIN or PIP" },
  807. // Received Phase B
  808.     {{ "50", "70", "70", "E245" }, "Unspecified Receive Phase B error" },
  809.     {{ "51", "71", "71", "E246" }, "RSPREC error/got DCN" },
  810.     {{ "52", "72", "72", "E247" }, "COMREC error" },
  811.     {{ "53", "73", "73", "E248" }, "T.30 T2 timeout, expected page not received" },
  812.     {{ "54", "74", "74", "E249" }, "T.30 T1 timeout after EOM received" },
  813. // Receive Phase C
  814.     {{ "60", "90", "90", "E250" }, "Unspecified Phase C error, including too much delay"
  815.    " between TCF and +FDR command" },
  816.     {{ "61", "91", "91", "E251" }, "Missing EOL after 5 seconds (section 3.2/T.4)" },
  817.     {{ "63", "93", "93", "E252" }, "DCE to DTE buffer overflow" },
  818.     {{ "64", "94", "92", "E253" }, "Bad CRC or frame (ECM or BFT modes)" },
  819. // Receive Phase D
  820.     {{ "70","100", "A0", "E254" }, "Unspecified Phase D error" },
  821.     {{ "71","101", "A1", "E255" }, "RSPREC invalid response received" },
  822.     {{ "72","102", "A2", "E256" }, "COMREC invalid response received" },
  823.     {{ "73","103", "A3", "E257" }, "Unable to continue after PIN or PIP, no PRI-Q" },
  824. // Agere proprietary error codes
  825.     {{ NULL, NULL, "E0", "E258" }, "Command or signal 10 sec. timeout" },
  826. // Everex proprietary error codes (9/28/90)
  827.     {{ NULL,"128", NULL, "E259" }, "Cannot send: +FMINSP > remote's +FDIS(BR) code" },
  828.     {{ NULL,"129", NULL, "E260" }, "Cannot send: remote is V.29 only,"
  829.    " local DCE constrained to 2400 or 4800 bps" },
  830.     {{ NULL,"130", NULL, "E261" }, "Remote station cannot receive (DIS bit 10)" },
  831.     {{ NULL,"131", NULL, "E262" }, "+FK aborted or <CAN> aborted" },
  832.     {{ NULL,"132", NULL, "E263" }, "+Format conversion error in +FDT=DF,VR, WD,LN"
  833.    " Incompatible and inconvertable data format" },
  834.     {{ NULL,"133", NULL, "E264" }, "Remote cannot receive" },
  835.     {{ NULL,"134", NULL, "E265" }, "After +FDR, DCE waited more than 30 seconds for"
  836.    " XON from DTE after XOFF from DTE" },
  837.     {{ NULL,"135", NULL, "E266" }, "In Polling Phase B, remote cannot be polled" },
  838. };
  839. #define NCODES (sizeof (hangupCodes) / sizeof (hangupCodes[0]))
  841. /*
  842.  * Given a hangup code from a modem return a
  843.  * descriptive string.  We use strings here to
  844.  * avoid having to know what type of modem we're
  845.  * talking to (Rev A or Rev B or SP-2388).  This
  846.  * works right now becase the codes don't overlap
  847.  * (as strings).  Hopefully this'll continue to
  848.  * be true.
  849.  */
  850. const char*
  851. Class2Modem::hangupCause(const char* code, bool codetocode)
  852. {
  853.     for (u_int i = 0; i < NCODES; i++) {
  854. const HangupCode& c = hangupCodes[i];
  855. if ((c.code[1] != NULL && strcasecmp(code, c.code[1]) == 0) ||
  856.     (c.code[2] != NULL && strcasecmp(code, c.code[2]) == 0)) {
  857.     if (codetocode) {
  858. return (c.code[3]);
  859.     } else {
  860. return (c.message);
  861.     }
  862. }
  863.     }
  864.     if (codetocode) return ("E210");
  865.     return ("Unknown hangup code");
  866. }
  868. /*
  869.  * Process a hangup code string.
  870.  */
  871. void
  872. Class2Modem::processHangup(const char* cp)
  873. {
  874.     while (isspace(*cp)) // strip leading white space
  875. cp++;
  876.     while (*cp == '0' && cp[1] != '') // strip leading 0's
  877. cp++;
  878.     strncpy(hangupCode, cp, sizeof (hangupCode));
  879.     protoTrace("REMOTE HANGUP: %s (code %s)",
  880. hangupCause(hangupCode), hangupCode);
  881. }
  883. /*
  884.  * Does the current hangup code string indicate
  885.  * that the remote side hung up the phone in a
  886.  * "normal and proper way".
  887.  */
  888. bool
  889. Class2Modem::isNormalHangup()
  890. {
  891.     // normal hangup is "", "0", or "00"
  892.     return (hangupCode[0] == '' ||
  893. (hangupCode[0] == '0' &&
  894.  (hangupCode[1] == '0' || hangupCode[1] == '')));
  895. }
  897. #include "t.30.h"
  899. void
  900. Class2Modem::tracePPM(const char* dir, u_int ppm)
  901. {
  902.     static u_int ppm2fcf[8] = {
  903. FCF_MPS,
  904. FCF_EOM,
  905. FCF_EOP,
  906. 0,
  907. FCF_PRI_MPS,
  908. FCF_PRI_EOM,
  909. FCF_PRI_EOP,
  910. 0
  911.     };
  912.     FaxModem::traceFCF(dir, ppm2fcf[ppm&7]);
  913. }
  915. void
  916. Class2Modem::tracePPR(const char* dir, u_int ppr)
  917. {
  918.     static u_int ppr2fcf[8] = {
  919. 0,
  920. FCF_MCF,
  921. FCF_RTN,
  922. FCF_RTP,
  923. FCF_PIN,
  924. FCF_PIP,
  925. 0,
  926. 0
  927.     };
  928.     FaxModem::traceFCF(dir, ppr2fcf[ppr&7]);
  929. }