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

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

传真(Fax)编程

开发平台：

C/C++

Class1Send.c++：源码内容
  1. /* $Id: Class1Send.c++,v 1.48 2009/07/13 05:39:20 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.  * Send protocol.
  31.  */
  32. #include "Sys.h"
  33. #include "Class1.h"
  34. #include "ModemConfig.h"
  35. #include "HDLCFrame.h"
  36. #include "t.30.h"
  38. /*
  39.  * Force the tty into a known flow control state.
  40.  */
  41. bool
  42. Class1Modem::sendSetup(FaxRequest& req, const Class2Params& dis, fxStr& emsg)
  43. {
  44.     if (flowControl == FLOW_XONXOFF)
  45. setXONXOFF(FLOW_NONE, FLOW_NONE, ACT_FLUSH);
  46.     return (FaxModem::sendSetup(req, dis, emsg));
  47. }
  49. /*
  50.  * Wait-for and process a dial command response.
  51.  */
  52. CallStatus
  53. Class1Modem::dialResponse(fxStr& emsg)
  54. {
  55.     // This is as good a time as any, perhaps, to reset modemParams.br.
  56.     // If the call does V.8 handshaking, then it will be altered.
  57.     modemParams.br = nonV34br;
  59.     int ntrys = 0;
  60.     ATResponse r;
  61.     do {
  62. r = atResponse(rbuf, conf.dialResponseTimeout);
  64. /*
  65.  * Blacklisting is handled internally just like a NOCARRIER.
  66.  * emsg is customized to let the user know the problem lies in
  67.  * the modem and not in line conditions, cables ...
  68.  * The known blacklisting modem responses are:
  69.  * 1. "BLACKLISTED"
  70.  * 2. "DELAYED HH:MM:SS" (ie: "DELAYED 00:59:02")
  71.  * 3. "DIALING DISABLED" (USR)
  72.  * User can switch on/off the modem or use appropriate reset commands
  73.  * to clear/disable blacklisted numbers, ie:
  74.  * ModemResetCmds: AT%TCB  (Some rockwell chipsets)
  75.  * ModemResetCmds: AT%D0   (Some topic chipsets)
  76.  * ModemResetCmds: ATS40=7 (Some usr chipsets)
  77.  */
  78. if (strncmp(rbuf, "BLACKLISTED", 11) == 0
  79. || strncmp(rbuf, "DELAYED", 7) == 0
  80. || strncmp(rbuf, "DIALING DISABLED", 16) == 0) {
  81.     emsg = "Blacklisted by modem {E010}";
  82.     return (NOCARRIER);
  83. }
  85. switch (r) {
  86. case AT_ERROR:     return (ERROR); // error in dial command
  87. case AT_BUSY:     return (BUSY); // busy signal
  88. case AT_NOCARRIER:  return (NOCARRIER); // no carrier detected
  89. case AT_OK:     return (NOCARRIER); // (for AT&T DataPort)
  90. case AT_NODIALTONE: return (NODIALTONE);// local phone connection hosed
  91. case AT_NOANSWER:   return (NOANSWER); // no answer or ring back
  92. case AT_TIMEOUT:    return (FAILURE); // timed out w/o response
  93. case AT_CONNECT:    return (OK); // fax connection
  94. case AT_FCERROR:
  95.     /*
  96.      * Some modems that support adaptive-answer assert a data
  97.      * carrier first and then fall back to answering as a fax
  98.      * modem.  For these modems we'll get an initial +FCERROR
  99.      * (wrong carrier) result that we ignore.  We actually
  100.      * accept three of these in case the modem switches carriers
  101.      * several times (haven't yet encountered anyone that does).
  102.      */
  103. case AT_DLEETX: // silly modem
  104.     if (++ntrys == 3) {
  105. emsg = "Ringback detected, no answer without CED {E011}"; // XXX
  106. protoTrace(emsg);
  107. return (NOFCON);
  108.     }
  109.     r = AT_OTHER;
  110.     break;
  111. }
  112.     } while (r == AT_OTHER && isNoise(rbuf));
  113.     return (FAILURE);
  114. }
  116. void
  117. Class1Modem::sendBegin()
  118. {
  119.     FaxModem::sendBegin();
  120.     setInputBuffering(false);
  121.     // polling accounting?
  122.     params.br = (u_int) -1; // force initial training
  123. }
  125. #define BATCH_FIRST 1
  126. #define BATCH_LAST  2
  128. void
  129. Class1Modem::checkReceiverDIS(Class2Params& params)
  130. {
  131.     if (useV34) {
  132. if (params.ec == EC_DISABLE) {
  133.     protoTrace("V.34-Fax session, but DIS signal contains no ECM bit; ECM forced.");
  134.     params.ec = EC_ENABLE256;
  135. }
  136. if (params.br != BR_33600) {
  137.     protoTrace("V.34-Fax session, but DIS signal contains no V.8 bit; compensating.");
  138.     params.br = BR_33600;
  139. }
  140.     }
  141. }
  143. /*
  144.  * Get the initial DIS command.
  145.  */
  146. FaxSendStatus
  147. Class1Modem::getPrologue(Class2Params& params, bool& hasDoc, fxStr& emsg, u_int& batched)
  148. {
  149.     u_int t1 = howmany(conf.t1Timer, 1000); // T1 timer in seconds
  150.     time_t start = Sys::now();
  151.     HDLCFrame frame(conf.class1FrameOverhead);
  153.     if (useV34 && (batched & BATCH_FIRST))
  154. waitForDCEChannel(true); // expect control channel
  156.     bool framerecvd = false;
  157.     if (batched & BATCH_FIRST) // receive carrier raised
  158. framerecvd = recvFrame(frame, FCF_SNDR, conf.t1Timer, true); // T1 is used here
  159.     else { // receive carrier not raised
  160. // We're not really switching directions of communication, but we don't want
  161. // to start listening for prologue frames until we're sure that the receiver 
  162. // has dropped the carrier used to signal MCF.
  163. if (!useV34) (void) switchingPause(emsg);
  164. // The receiver will allow T2 to elapse intentionally here.
  165. // To keep recvFrame from timing out we double our wait.
  166. framerecvd = recvFrame(frame, FCF_SNDR, conf.t2Timer * 2);
  167.     }
  169.     for (;;) {
  170. if (gotEOT) break;
  171. if (framerecvd) {
  172.     /*
  173.      * An HDLC frame was received; process any
  174.      * optional frames that precede the DIS.
  175.      */
  176.     do {
  177. switch (frame.getRawFCF()) {
  178. case FCF_NSF:
  179.                     recvNSF(NSF(frame.getFrameData(), frame.getFrameDataLength()-1, frameRev));
  180.     break;
  181. case FCF_CSI:
  182.     { fxStr csi; recvCSI(decodeTSI(csi, frame)); }
  183.     break;
  184. case FCF_DIS:
  185.     dis_caps = frame.getDIS();
  186.     params.setFromDIS(dis_caps);
  187.     checkReceiverDIS(params);
  188.     curcap = NULL; // force initial setup
  189.     break;
  190. }
  191.     } while (frame.moreFrames() && recvFrame(frame, FCF_SNDR, conf.t2Timer));
  192.     if (frame.isOK()) {
  193. switch (frame.getRawFCF()) {
  194. case FCF_DIS:
  195.     hasDoc = dis_caps.isBitEnabled(FaxParams::BITNUM_T4XMTR);// documents to poll?
  196.     if (!dis_caps.isBitEnabled(FaxParams::BITNUM_T4RCVR)) {
  197. emsg = "Remote has no T.4 receiver capability {E122}";
  198. protoTrace(emsg);
  199.      if (! hasDoc) // don't die if we can poll
  200.     return (send_failed);
  201.     }
  202.     emsg = "";
  203.     return (send_ok);
  204. case FCF_DTC: // NB: don't handle DTC
  205.     emsg = "DTC received when expecting DIS (not supported) {E123}";
  206.     protoTrace(emsg);
  207.     return (send_retry);
  208. case FCF_DCN:
  209.     emsg = "COMREC error in transmit Phase B/got DCN {E124}";
  210.     protoTrace(emsg);
  211.     return (send_retry);
  212. default:
  213.     emsg = "COMREC invalid command received/no DIS or DTC {E125}";
  214.     protoTrace(emsg);
  215.     break;
  216. }
  217.     }
  218. }
  219. /*
  220.  * Wait up to T1 for a valid DIS.
  221.  */
  222. if ((unsigned) Sys::now()-start >= t1)
  223.     break;
  224. if (!useV34) (void) switchingPause(emsg);
  225. framerecvd = recvFrame(frame, FCF_SNDR, (Sys::now()-start)*1000); // timer here is T1
  226.     }
  227.     if (emsg == "") {
  228. emsg = "No receiver protocol (T.30 T1 timeout) {E126}";
  229. protoTrace(emsg);
  230.     }
  231.     return (send_retry);
  232. }
  234. /*
  235.  * Setup file-independent parameters prior
  236.  * to entering Phase B of the send protocol.
  237.  */
  238. void
  239. Class1Modem::sendSetupPhaseB(const fxStr& p, const fxStr& s)
  240. {
  241.     if (p != fxStr::null && dis_caps.isBitEnabled(FaxParams::BITNUM_PWD))
  242. encodePWD(pwd, p);
  243.     else
  244. pwd = fxStr::null;
  245.     if (s != fxStr::null && dis_caps.isBitEnabled(FaxParams::BITNUM_SUB))
  246. encodePWD(sub, s);
  247.     else
  248. sub = fxStr::null;
  249. }
  251. const u_int Class1Modem::modemPFMCodes[8] = {
  252.     FCF_MPS, // PPM_MPS
  253.     FCF_EOM, // PPM_EOM
  254.     FCF_EOP, // PPM_EOP
  255.     FCF_EOP, // 3 ??? XXX
  256.     FCF_PRI_MPS, // PPM_PRI_MPS
  257.     FCF_PRI_EOM, // PPM_PRI_EOM
  258.     FCF_PRI_EOP, // PPM_PRI_EOP
  259.     FCF_EOP, // 7 ??? XXX
  260. };
  262. bool
  263. Class1Modem::decodePPM(const fxStr& pph, u_int& ppm, fxStr& emsg)
  264. {
  265.     if (FaxModem::decodePPM(pph, ppm, emsg)) {
  266. ppm = modemPFMCodes[ppm];
  267. return (true);
  268.     } else
  269. return (false);
  270. }
  272. /*
  273.  * Send the specified document using the supplied
  274.  * parameters.  The pph is the post-page-handling
  275.  * indicators calculated prior to initiating the call.
  276.  */
  277. FaxSendStatus
  278. Class1Modem::sendPhaseB(TIFF* tif, Class2Params& next, FaxMachineInfo& info,
  279.     fxStr& pph, fxStr& emsg, u_int& batched)
  280. {
  281.     int ntrys = 0; // # retraining/command repeats
  282.     bool morePages = true; // more pages still to send
  283.     HDLCFrame frame(conf.class1FrameOverhead);
  285.     do {
  286.         hadV34Trouble = false; // to monitor failure type
  287.         hadV17Trouble = false; // to monitor failure type
  288. batchingError = false;
  289. signalRcvd = 0;
  290. if (abortRequested())
  291.     return (send_failed);
  292. if (repeatPhaseB) {
  293.     /*
  294.      * We need to repeat protocol from the beginning of Phase B
  295.      * due to a non-batched EOM signal (formatting change).
  296.      */
  297.     params.br = (u_int) -1; // force retraining
  298.     batched = batched & ~BATCH_FIRST; // must raise V.21 receive carrier
  299.     bool hasDoc;
  300.     FaxSendStatus status = getPrologue(params, hasDoc, emsg, batched);
  301.     if (status != send_ok) return (send_retry);
  302.     repeatPhaseB = false;
  303. }
  304. /*
  305.  * Check the next page to see if the transfer
  306.  * characteristics change.  If so, update the
  307.  * T.30 session parameters and do training.
  308.  * Note that since the initial parameters are
  309.  * setup to be "undefined", training will be
  310.  * sent for the first page after receiving the
  311.  * DIS frame.
  312.  */
  313. if (params != next) {
  314.     if (!sendTraining(next, 3, emsg)) {
  315. if (hadV34Trouble) {
  316.     protoTrace("The destination appears to have trouble with V.34-Fax.");
  317.     return (send_v34fail);
  318. }
  319. if (hadV17Trouble) {
  320.     protoTrace("The destination appears to have trouble with V.17.");
  321.     return (send_v17fail);
  322. }
  323. if (!(batched & BATCH_FIRST)) {
  324.     protoTrace("The destination appears to not support batching.");
  325.     return (send_batchfail);
  326. }
  327. return (send_retry);
  328.     }
  329.     params = next;
  330. }
  332. if (params.ec == EC_DISABLE) { // ECM does it later
  333.     /*
  334.      * According to T.30 5.3.2.4 we must pause at least 75 ms "after 
  335.      * receipt of a signal using the T.30 binary coded modulation" and 
  336.      * "before sending any signals using V.27 ter/V.29/V.33/V.17 
  337.      * modulation system"
  338.      */
  339.     if (!switchingPause(emsg)) {
  340. return (send_failed);
  341.     }
  342. }
  344. /*
  345.  * The ECM protocol needs to know PPM, so this must be done beforehand...
  346.  */
  347. morePages = !TIFFLastDirectory(tif);
  348. u_int cmd;
  349. if (!decodePPM(pph, cmd, emsg))
  350.     return (send_failed);
  351. /*
  352.  * If pph tells us that the PPM is going to be EOM it means that the
  353.  * next page is formatted differently from the current page.  To handle this
  354.  * situation properly, EOM is used.  Following EOM we must repeat the
  355.  * entire protocol of Phase B.  This triggers that.  Batching is handled
  356.  * also with EOM, but not with the repeatPhaseB flag.
  357.  */
  358. repeatPhaseB = (cmd == FCF_EOM);
  359. if (cmd == FCF_EOP && !(batched & BATCH_LAST))
  360.     cmd = FCF_EOM;
  362. /*
  363.  * Transmit the facsimile message/Phase C.
  364.  */
  365. if (!sendPage(tif, params, decodePageChop(pph, params), cmd, emsg)) {
  366.     if (hadV34Trouble) {
  367. protoTrace("The destination appears to have trouble with V.34-Fax.");
  368. return (send_v34fail);
  369.     }
  370.     if (batchingError && (batched & BATCH_FIRST)) {
  371. protoTrace("The destination appears to not support batching.");
  372. return (send_batchfail);
  373.     }
  374.     return (send_retry); // a problem, disconnect
  375. }
  377. int ncrp = 0;
  379. if (params.ec == EC_DISABLE) {
  380.     /*
  381.      * Delay before switching to the low speed carrier to
  382.      * send the post-page-message frame according to 
  383.      * T.30 chapter 5 note 4.  We provide for a different
  384.      * setting following EOP because, empirically, some 
  385.      * machines may need more time. Beware that, reportedly, 
  386.      * lengthening this delay too much can permit echo 
  387.      * suppressors to kick in with bad results.
  388.      *
  389.      * Historically this delay was done using a software pause
  390.      * rather than +FTS because the time between +FTS and the 
  391.      * OK response is longer than expected, and this was blamed
  392.      * for timing problems.  However, this "longer than expected"
  393.      * delay is a result of the time required by the modem's
  394.      * firmware to actually release the carrier.  T.30 requires
  395.      * a delay (period of silence), and this cannot be guaranteed
  396.      * by a simple pause.  +FTS must be used.
  397.      */
  398.     if (!atCmd(cmd == FCF_MPS ? conf.class1PPMWaitCmd : conf.class1EOPWaitCmd, AT_OK)) {
  399. emsg = "Stop and wait failure (modem on hook) {E127}";
  400. protoTrace(emsg);
  401. return (send_retry);
  402.     }
  403. }
  405. u_int ppr;
  406. do {
  407.     if (signalRcvd == 0) {
  408. /*
  409.  * Send post-page message and get response.
  410.  */
  411. if (!sendPPM(cmd, frame, emsg)) {
  412.     if (cmd == FCF_EOM && (batched & BATCH_FIRST)) {
  413. protoTrace("The destination appears to not support batching.");
  414. return (send_batchfail);
  415.     }
  416.     return (send_retry);
  417. }
  418. ppr = frame.getFCF();
  419. traceFCF("SEND recv", ppr);
  420.     } else {
  421. // ECM protocol already got post-page response
  422. ppr = signalRcvd;
  423.     }
  424.     switch (ppr) {
  425.     case FCF_RTP: // ack, continue after retraining
  426. params.br = (u_int) -1; // force retraining above
  427. /* fall thru... */
  428.     case FCF_MCF: // ack confirmation
  429.     case FCF_PIP: // ack, w/ operator intervention
  430. countPage(); // bump page count
  431. notifyPageSent(tif); // update server
  432. if (pph[2] == 'Z')
  433.     pph.remove(0,2+5+1);// discard page-chop+handling info
  434. else
  435.     pph.remove(0,3); // discard page-handling info
  436. if (params.ec == EC_DISABLE) (void) switchingPause(emsg);
  437. ntrys = 0;
  438. if (morePages) { // meaning, more pages in this file, but there may be other files
  439.     if (!TIFFReadDirectory(tif)) {
  440. emsg = "Problem reading document directory {E302}";
  441. protoTrace(emsg);
  442. return (send_failed);
  443.     }
  444. }
  445. if (cmd != FCF_EOP) {
  446.     if (ppr == FCF_PIP) {
  447. emsg = "Procedure interrupt (operator intervention) {E129}";
  448. protoTrace(emsg);
  449. return (send_failed);
  450.     }
  451.     if (ppr == FCF_MCF && !repeatPhaseB) {
  452. /*
  453.  * The session parameters cannot change except following
  454.  * the reception of an RTN or RTP signal or the transmission
  455.  * of an EOM signal.
  456.  *
  457.  * Since we did not receive RTN or RTP, if EOM was not used
  458.  * (repeating from the start of Phase B) then we require that
  459.  * the next page have the same characteristics as this page.
  460.  */
  461. next = params;
  462.     }
  463. }
  464. break;
  465.     case FCF_DCN: // disconnect, abort
  466. emsg = "Remote fax disconnected prematurely {E128}";
  467. protoTrace(emsg);
  468. return (send_retry);
  469.     case FCF_RTN: // nak, retry after retraining
  470.                 switch( conf.rtnHandling ){
  471. case RTN_RETRANSMITIGNORE:
  472.     if (ntrys < 2) break;
  473.                 case RTN_IGNORE:
  474. // ignore error and try to send next page
  475. // after retraining
  476.     params.br = (u_int) -1; // force retraining above
  477.     countPage(); // bump page count
  478.     notifyPageSent(tif); // update server
  479.     if (pph[2] == 'Z')
  480. pph.remove(0,2+5+1);// discard page-chop+handling info
  481.     else
  482. pph.remove(0,3); // discard page-handling info
  483.     ntrys = 0;
  484.     if (ppr == FCF_PIP) {
  485. emsg = "Procedure interrupt (operator intervention) {E129}";
  486. protoTrace(emsg);
  487. return (send_failed);
  488.     }
  489.     if (morePages) {
  490. if (!TIFFReadDirectory(tif)) {
  491.     emsg = "Problem reading document directory {E302}";
  492.     protoTrace(emsg);
  493.     return (send_failed);
  494. }
  495. FaxSendStatus status =
  496.     sendSetupParams(tif, next, info, emsg);
  497. if (status != send_ok)
  498.     return (status);
  499.     }
  500.     continue;
  501.                 case RTN_GIVEUP:
  502.                     emsg = "Unable to transmit page (giving up after RTN) {E130}";
  503.     protoTrace(emsg);
  504.                     return (send_failed); // "over and out"
  505.                 }
  506.                 // case RTN_RETRANSMIT
  507.                 if (++ntrys >= 3) {
  508.                     emsg = "Unable to transmit page (giving up after 3 attempts) {E131}";
  509.     protoTrace(emsg);
  510.                     return (send_retry);
  512.                 }
  513. params.br = (u_int) -1; // force training
  514. if (!dropToNextBR(next)) {
  515.                     emsg = "Unable to transmit page (NAK at all possible signalling rates) {E132}";
  516.     protoTrace(emsg);
  517.                     return (send_retry);
  518. }
  519.                 morePages = true; // retransmit page
  520. break;
  521.     case FCF_PIN: // nak, retry w/ operator intervention
  522. emsg = "Unable to transmit page (NAK with operator intervention) {E133}";
  523. protoTrace(emsg);
  524. return (send_failed);
  525.     case FCF_CRP:
  526. if (!useV34 && !switchingPause(emsg)) {
  527.     return (send_retry);
  528. }
  529. break;
  530.     default: // unexpected abort
  531. emsg = "Fax protocol error (unknown frame received) {E134}";
  532. protoTrace(emsg);
  533. return (send_retry);
  534.     }
  535. } while (ppr == FCF_CRP && ++ncrp < 3);
  536. if (ncrp == 3) {
  537.     emsg = "Fax protocol error (command repeated 3 times) {E135}";
  538.     protoTrace(emsg);
  539.     return (send_retry);
  540. }
  541.     } while (morePages);
  542.     if (hadV17Trouble) return (send_v17fail);
  543.     return (send_ok);
  544. }
  546. /*
  547.  * Send ms's worth of zero's at the current signalling rate.
  548.  * Note that we send real zero data here as recommended
  549.  * by T.31 8.3.3 rather than using the Class 1 modem facility
  550.  * to do zero fill.
  551.  */
  552. bool
  553. Class1Modem::sendTCF(const Class2Params& params, u_int ms)
  554. {
  555.     u_int tcfLen = params.transferSize(ms);
  556.     u_char* tcf = new u_char[tcfLen];
  557.     memset(tcf, 0, tcfLen);
  558.     bool ok = transmitData(curcap->value, tcf, tcfLen, frameRev, true);
  559.     delete tcf;
  560.     return ok;
  561. }
  563. /*
  564.  * Send the training prologue frames:
  565.  *     PWD password (optional)
  566.  *     SUB subaddress (optional)
  567.  *     TSI transmitter subscriber id
  568.  *     DCS digital command signal
  569.  */
  570. bool
  571. Class1Modem::sendPrologue(FaxParams& dcs_caps, const fxStr& tsi)
  572. {
  573.     /*
  574.      * T.31 8.3.5 requires the DCE to respond CONNECT or result OK within
  575.      * five seconds or it must result ERROR.  T.30 requires the data of
  576.      * the HDLC frame to be tranmsitted in 3 s +/- 15%.  Thus, our
  577.      * timeouts here must be at least 7500 ms and no more than 8500 ms.
  578.      */
  579.     bool frameSent;
  580.     if (useV34) frameSent = true;
  581.     else {
  582. fxStr emsg;
  583. if (!switchingPause(emsg)) {
  584.     return (false);
  585. }
  586. frameSent = (atCmd(thCmd, AT_NOTHING) && atResponse(rbuf, 7550) == AT_CONNECT);
  587.     }
  588.     if (!frameSent)
  589. return (false);
  590.     if (pwd != fxStr::null) {
  591. startTimeout(7550);
  592. bool frameSent = sendFrame(FCF_PWD|FCF_SNDR, pwd, false);
  593. stopTimeout("sending PWD frame");
  594. if (!frameSent)
  595.     return (false);
  596.     }
  597.     if (sub != fxStr::null) {
  598. startTimeout(7550);
  599. bool frameSent = sendFrame(FCF_SUB|FCF_SNDR, sub, false);
  600. stopTimeout("sending SUB frame");
  601. if (!frameSent)
  602.     return (false);
  603.     }
  604.     startTimeout(7550);
  605.     frameSent = sendFrame(FCF_TSI|FCF_SNDR, tsi, false);
  606.     stopTimeout("sending TSI frame");
  607.     if (!frameSent)
  608. return (false);
  609.     startTimeout(7550);
  610.     frameSent = sendFrame(FCF_DCS|FCF_SNDR, dcs_caps);
  611.     stopTimeout("sending DCS frame");
  612.     return (frameSent);
  613. }
  615. /*
  616.  * Return whether or not the previously received DIS indicates
  617.  * the remote side is capable of the T.30 DCS signalling rate.
  618.  */
  619. bool
  620. Class1Modem::isCapable(u_int sr, FaxParams& dis)
  621. {
  622.     switch (sr) {
  623.     case DCSSIGRATE_2400V27:
  624.         if (!dis.isBitEnabled(FaxParams::BITNUM_SIGRATE_11) &&
  625.             !dis.isBitEnabled(FaxParams::BITNUM_SIGRATE_12) &&
  626.             !dis.isBitEnabled(FaxParams::BITNUM_SIGRATE_13) &&
  627.             !dis.isBitEnabled(FaxParams::BITNUM_SIGRATE_14))
  628.     return (true);
  629. /* fall thru... */
  630.     case DCSSIGRATE_4800V27:
  631. return dis.isBitEnabled(FaxParams::BITNUM_SIGRATE_12);
  632.     case DCSSIGRATE_9600V29:
  633.     case DCSSIGRATE_7200V29:
  634. return dis.isBitEnabled(FaxParams::BITNUM_SIGRATE_11);
  635.     case DCSSIGRATE_14400V33:
  636.     case DCSSIGRATE_12000V33:
  637. // post-1994 revisions of T.30 indicate that V.33 should
  638. // only be used when it is specifically permitted by DIS
  639. return(dis.isBitEnabled(FaxParams::BITNUM_SIGRATE_11) &&
  640.     dis.isBitEnabled(FaxParams::BITNUM_SIGRATE_12) &&
  641.     dis.isBitEnabled(FaxParams::BITNUM_SIGRATE_13) &&
  642.     !dis.isBitEnabled(FaxParams::BITNUM_SIGRATE_14));
  643.     case DCSSIGRATE_14400V17:
  644.     case DCSSIGRATE_12000V17:
  645.     case DCSSIGRATE_9600V17:
  646.     case DCSSIGRATE_7200V17:
  647. return(dis.isBitEnabled(FaxParams::BITNUM_SIGRATE_11) &&
  648.     dis.isBitEnabled(FaxParams::BITNUM_SIGRATE_12) &&
  649.     !dis.isBitEnabled(FaxParams::BITNUM_SIGRATE_13) &&
  650.     dis.isBitEnabled(FaxParams::BITNUM_SIGRATE_14));
  651.     }
  652.     return (false);
  653. }
  655. /*
  656.  * Send capabilities and do training.
  657.  */
  658. bool
  659. Class1Modem::sendTraining(Class2Params& params, int tries, fxStr& emsg)
  660. {
  661.     bool again = false;
  662.     u_short attempt = 0;
  663.     if (tries == 0) {
  664. emsg = "DIS/DTC received 3 times; DCS not recognized {E136}";
  665. protoTrace(emsg);
  666. if (useV34) hadV34Trouble = true; // sadly, some receivers will do this with V.34
  667. return (false);
  668.     }
  669.     params.update(false);
  670.     // we should respect the frame-size preference indication by the remote (DIS_FRAMESIZE)
  671.     if (params.ec != EC_DISABLE && 
  672. (params.ec == EC_ENABLE64 || conf.class1ECMFrameSize == 64 || dis_caps.isBitEnabled(FaxParams::BITNUM_FRAMESIZE_DIS))) {
  673. params.setBit(FaxParams::BITNUM_FRAMESIZE_DCS, true); // we don't want to add this bit if not using ECM
  674. frameSize = 64;
  675.     } else
  676. frameSize = 256;
  678.     if (!useV34) {
  679. /*
  680.  * Select Class 1 capability: use params.br to hunt
  681.  * for the best signalling scheme acceptable to both
  682.  * local and remote (based on received DIS and modem
  683.  * capabilities gleaned at modem setup time).
  684.  */
  685. if (!curcap)
  686.     curcap = findBRCapability(params.br, xmitCaps);
  687. curcap++;
  688. /*
  689.  * We assume that if the sender requested 9600 or 7200 baud
  690.  * and if the modem supports both V.17 and V.29 that the
  691.  * desired modulation is V.29.
  692.  */
  693. do {
  694.     if (!dropToNextBR(params))
  695. goto failed;
  696. } while ((params.br == BR_9600 || params.br == BR_7200) && curcap->mod != V29);
  697.     }
  698.     do {
  699. attempt++;
  700. if (!useV34) {
  701.     /*
  702.      * Override the Class 2 parameter bit rate
  703.      * capability and use the signalling rate
  704.      * calculated from the modem's capabilities
  705.      * and the received DIS.  This is because
  706.      * the Class 2 state does not include the
  707.      * modulation technique (v.27, v.29, v.17, v.33).
  708.      *
  709.      * Technically, according to post-1994 revisions
  710.      * of T.30, V.33 should not be used except
  711.      * in the case where the remote announces
  712.      * specific V.33 support with the 1,1,1,0 rate
  713.      * bits set.  However, for the sake of versatility
  714.      * we'll not enforce this upon modems that support
  715.      * V.33 but not V.17 and will require the user
  716.      * to disable V.33 if it becomes problematic.  For
  717.      * modems that support both V.17 and V.33 the
  718.      * latter is never used.
  719.      */
  720.     params.br = curcap->br;
  721.     params.setBit(FaxParams::BITNUM_SIGRATE_11, curcap->sr&DCSSIGRATE_9600V29);
  722.     params.setBit(FaxParams::BITNUM_SIGRATE_12, curcap->sr&DCSSIGRATE_4800V27);
  723.     params.setBit(FaxParams::BITNUM_SIGRATE_13, curcap->sr&DCSSIGRATE_14400V33);
  724.     params.setBit(FaxParams::BITNUM_SIGRATE_14, curcap->sr&DCSSIGRATE_14400V17);
  725.     /*
  726.      * Set the number of train attemps on the same
  727.      * modulation; having set it to 1 we immediately drop
  728.      * the speed if the training has been failed.
  729.      * This parameter is not specified by T.30
  730.      * (the algorith left implementation defined),
  731.      * so we choose the exact value according to our
  732.      * common sense.
  733.      */
  734. } else {
  735.     /*
  736.      * T.30 Table 2 Note 33 says that when V.34-fax is used
  737.      * DCS bits 11-14 should be set to zero.
  738.      */
  739.     params.setBit(FaxParams::BITNUM_SIGRATE_11, false);
  740.     params.setBit(FaxParams::BITNUM_SIGRATE_12, false);
  741.     params.setBit(FaxParams::BITNUM_SIGRATE_13, false);
  742.     params.setBit(FaxParams::BITNUM_SIGRATE_14, false);
  743. }
  744. int t = 1;
  745. do {
  746.     if (!useV34) protoTrace("SEND training at %s %s",
  747. modulationNames[curcap->mod],
  748. Class2Params::bitRateNames[curcap->br]);
  749.     if (!sendPrologue(params, lid)) {
  750. if (abortRequested())
  751.     goto done;
  752. protoTrace("Error sending T.30 prologue frames");
  753. continue;
  754.     }
  756.     /*
  757.      * V.8 handshaking provides training for V.34-fax connections
  758.      */
  759.     if (!useV34) {
  760. /*
  761.  * Delay before switching to high speed carrier
  762.  * to send the TCF data as required by T.30 chapter
  763.  * 5 note 3.
  764.  *
  765.  * Historically this delay was enforced by a pause,
  766.  * however, +FTS must be used.  See the notes preceding
  767.  * Class1PPMWaitCmd above.
  768.  */
  769. if (!atCmd(conf.class1TCFWaitCmd, AT_OK)) {
  770.     emsg = "Stop and wait failure (modem on hook) {E127}";
  771.     protoTrace(emsg);
  772.     return (send_retry);
  773. }
  775. setDataTimeout(5, params.br); // TCF data is only 1.5 s
  776. if (!sendTCF(params, TCF_DURATION)) {
  777.     if (abortRequested())
  778. goto done;
  779.     protoTrace("Problem sending TCF data");
  780. }
  782. /*
  783.  * Some modems may respond OK following TCF transmission
  784.  * so quickly that the carrier signal has not actually 
  785.  * dropped.  T.30 requires the receiver to wait 75 +/- 20 
  786.  * ms before sending a response.  Here we explicitly look for 
  787.  * that silence before looking for the low-speed carrier.  
  788.  * Doing this resolves "DIS/DTC received 3 times" errors 
  789.  * between USR modems and certain HP OfficeJets, in 
  790.  * particular.
  791.           */
  792. if (conf.class1ResponseWaitCmd != "") {
  793.     atCmd(conf.class1ResponseWaitCmd, AT_OK);
  794. }
  795.     }
  797.     /*
  798.      * Receive response to training.  Acceptable
  799.      * responses are: DIS or DTC (DTC not handled),
  800.      * FTT, or CFR; and also a premature DCN.
  801.      */
  802.     HDLCFrame frame(conf.class1FrameOverhead);
  803.     if (recvFrame(frame, FCF_SNDR, conf.t4Timer)) {
  804. do {
  805.     switch (frame.getFCF()) {
  806.     case FCF_NSF:
  807. recvNSF(NSF(frame.getFrameData(), frame.getFrameDataLength()-1, frameRev));
  808. break;
  809.     case FCF_CSI:
  810. { fxStr csi; recvCSI(decodeTSI(csi, frame)); }
  811. break;
  812.     }
  813. } while (frame.moreFrames() && recvFrame(frame, FCF_SNDR, conf.t2Timer));
  814.     } 
  815.     if (frame.isOK()) {
  816. switch (frame.getFCF()) {
  817. case FCF_CFR: // training confirmed
  818.     if (!useV34) protoTrace("TRAINING succeeded");
  819.     setDataTimeout(60, params.br);
  820.     return (true);
  821. case FCF_CRP: // command repeat
  822. case FCF_FTT: // failure to train, retry
  823.     break;
  824. case FCF_DIS: // new capabilities, maybe
  825.     {
  826. FaxParams newDIS = frame.getDIS();
  827. if (newDIS != dis_caps) {
  828.     /*
  829.        dis_caps = newDIS;
  830.        params.setFromDIS(dis_caps);
  831.      *
  832.      * The above code was commented because to
  833.      * use the newDIS we need to do more work like
  834.      *     sendClientCapabilitiesOK()
  835.      *     sendSetupParams()
  836.      * So we ignore newDIS.
  837.      * It will work if old dis 'less' then newDIS.
  838.      */
  839.     checkReceiverDIS(params);
  840.     curcap = NULL;
  841. }
  842.     }
  843.     return (sendTraining(params, --tries, emsg));
  844. default:
  845.     if (frame.getFCF() == FCF_DCN) {
  846. /*
  847.  * The receiver is disconnecting.  This can happen
  848.  * if the receiver is exhaused from retraining, but
  849.  * it also happens in situations where, for example,
  850.  * the receiver determines that there is a modulator
  851.  * incompatibility (i.e. with V.17).  In that case,
  852.  * we must prevent ourselves from redialing and
  853.  * reattempting V.17 training, or we'll never get
  854.  * through.
  855.  */
  856. if (curcap->mod == V17 && attempt == 1 && tries == 3) hadV17Trouble = true;
  857. emsg = "RSPREC error/got DCN (receiver abort) {E103}";
  858.     } else
  859. emsg = "RSPREC invalid response received {E104}";
  860.     goto done;
  861. }
  862.     } else {
  863. /*
  864.  * Historically we waited "Class1TrainingRecovery" (1500 ms)
  865.  * at this point to try to try to avoid retransmitting while
  866.  * the receiver is also transmitting.  Sometimes it proved to be
  867.  * a faulty approach.  Really what we're trying to do is to
  868.  * not be transmitting at the same time as the other end is.
  869.  * The best way to do that is to make sure that there is
  870.  * silence on the line, and  we do that with Class1SwitchingCmd.
  871.  */
  872. if (useV34 || !switchingPause(emsg)) {
  873.     return (false);
  874. }
  875.     }
  876. } while (--t > 0);
  877. /*
  878.  * (t) attempts at the current speed failed, drop
  879.  * the signalling rate to the next lower rate supported
  880.  * by the local & remote sides and try again.
  881.  */
  882. if (!useV34) {
  883.     do {
  884. /*
  885.  * We don't fallback to V.17 9600 or V.17 7200 because
  886.  * after V.17 14400 and V.17 12000 fail they're not likely
  887.  * to succeed, and some receivers will give up after three
  888.  * failed TCFs.
  889.  */
  890. again = dropToNextBR(params);
  891.     } while (again && (params.br == BR_9600 || params.br == BR_7200) && curcap->mod != V29);
  892. }
  893.     } while (!useV34 && (again || attempt < 3));
  894. failed:
  895.     emsg = "Failure to train remote modem at 2400 bps or minimum speed {E137}";
  896. done:
  897.     if (!useV34) protoTrace("TRAINING failed");
  898.     return (false);
  899. }
  901. /*
  902.  * Select the next lower signalling rate that's
  903.  * acceptable to both local and remote machines.
  904.  */
  905. bool
  906. Class1Modem::dropToNextBR(Class2Params& params)
  907. {
  908.     if (curcap->br == BR_2400)
  909. return (false);
  910.     const Class1Cap* oldcap = curcap;
  911.     curcap--;
  912.     for (;;) {
  913. if (curcap) {
  914.     /*
  915.      * Hunt for compatibility with remote at this baud rate.
  916.      * We don't drop from V.29 to V.17 because if the 
  917.      * receiver supports V.17 then we probably tried
  918.      * it already without success.
  919.      */
  920.     while (curcap->br == params.br) {
  921. if (isCapable(curcap->sr, dis_caps) && !(oldcap->mod == V29 && curcap->mod == V17))
  922.     return (true);
  923. curcap--;
  924.     }
  925. }
  926. if (params.br <= minsp)
  927.     return (false);
  928. params.br--;
  929. // get ``best capability'' of modem at this baud rate
  930. curcap = findBRCapability(params.br, xmitCaps);
  931.     }
  932.     /*NOTREACHED*/
  933. }
  935. /*
  936.  * Select the next higher signalling rate that's
  937.  * acceptable to both local and remote machines.
  938.  */
  939. bool
  940. Class1Modem::raiseToNextBR(Class2Params& params)
  941. {
  942.     for (;;) {
  943. if (params.br == BR_14400) // highest speed
  944.     return (false);
  945. // get ``best capability'' of modem at this baud rate
  946. curcap = findBRCapability(++params.br, xmitCaps);
  947. if (curcap) {
  948.     // hunt for compatibility with remote at this baud rate
  949.     do {
  950. if (isCapable(curcap->sr, dis_caps))
  951.     return (true);
  952. curcap--;
  953.     } while (curcap->br == params.br);
  954. }
  955.     }
  956.     /*NOTREACHED*/
  957. }
  959. void
  960. Class1Modem::blockData(u_int byte, bool flag)
  961. {
  962.     if (useV34) {
  963. // With V.34-fax the DTE makes the stuffing
  964. byte =  (((byte>>0)&1)<<7)|(((byte>>1)&1)<<6)|
  965. (((byte>>2)&1)<<5)|(((byte>>3)&1)<<4)|
  966. (((byte>>4)&1)<<3)|(((byte>>5)&1)<<2)|
  967. (((byte>>6)&1)<<1)|(((byte>>7)&1)<<0);
  968. ecmStuffedBlock[ecmStuffedBlockPos++] = byte;
  969. return;
  970.     }
  971.     for (u_int j = 8; j > 0; j--) {
  972. u_short bit = (byte & (1 << (j - 1))) != 0 ? 1 : 0;
  973. ecmByte |= (bit << ecmBitPos);
  974. ecmBitPos++;
  975. if (ecmBitPos == 8) {
  976.     ecmStuffedBlock[ecmStuffedBlockPos++] = ecmByte;
  977.     ecmBitPos = 0;
  978.     ecmByte = 0;
  979. }
  980. // add transparent zero bits if needed
  981. if (bit == 1 && !flag) ecmOnes++;
  982. else ecmOnes = 0;
  983. if (ecmOnes == 5) {
  984.     ecmBitPos++;
  985.     if (ecmBitPos == 8) {
  986. ecmStuffedBlock[ecmStuffedBlockPos++] = ecmByte;
  987. ecmBitPos = 0;
  988. ecmByte = 0;
  989.     }
  990.     ecmOnes = 0;
  991. }
  992.     }
  993. }
  995. /*
  996.  * Buffer ECM HDLC image frames until a full block is received.
  997.  * Perform T.30-A image block transmission protocol.
  998.  */
  999. bool
  1000. Class1Modem::blockFrame(const u_char* bitrev, bool lastframe, u_int ppmcmd, fxStr& emsg)
  1001. {
  1002.     // we have a full image frame
  1004.     for (u_int i = 0; i < ecmFramePos; i++)
  1005. ecmBlock[ecmBlockPos++] = ecmFrame[i];
  1006.     ecmFramePos = 0;
  1007.     if (frameNumber == 256 || lastframe) {
  1008. fxAssert(frameNumber <= 256, "Invalid frameNumber value.");
  1009. ecmBlockPos = 0;
  1010. bool lastblock = lastframe;
  1012. // We now have a full image block without stuffed zero bits.
  1013. // As the remote can request any frame of the block until
  1014. // MCF we must keep the full image block available.
  1016. bool blockgood = false, renegotiate = false, constrain = false, duplicate = false;
  1017. u_short pprcnt = 0;
  1018. char ppr[32]; // 256 bits
  1019. for (u_int i = 0; i < 32; i++) ppr[i] = 0xff;
  1020. u_short badframes = frameNumber, badframesbefore = 0;
  1021. bool dolongtrain = false;
  1023. do {
  1024.     u_short fcount = 0;
  1025.     u_short fcountuniq = 0;
  1026.     ecmStuffedBlockPos = 0;
  1028.     if (!useV34) {
  1029. // synchronize with 200 ms of 0x7e flags
  1030. for (u_int i = 0; i < params.transferSize(200); i++)
  1031.     blockData(0x7e, true);
  1032.     }
  1034.     u_char* firstframe = (u_char*) malloc(frameSize + 6);
  1035.     fxAssert(firstframe != NULL, "ECM procedure error (frame duplication).");
  1036.     firstframe[0] = 0x1; // marked as unused
  1037.     for (u_short fnum = 0; fnum < frameNumber; fnum++) {
  1038. u_int pprpos, pprval;
  1039.          for (pprpos = 0, pprval = fnum; pprval >= 8; pprval -= 8) pprpos++;
  1040.          if (ppr[pprpos] & frameRev[1 << pprval]) {
  1041.     HDLCFrame ecmframe(5);
  1042.     // frame bit marked for transmission
  1043.     fcount++;
  1044.     for (u_int i = fnum * (frameSize + 4);
  1045. i < (fnum + 1) * (frameSize + 4); i++) {
  1046. ecmframe.put(ecmBlock[i]);
  1047. blockData(ecmBlock[i], false);
  1048.     }
  1049.     int fcs1 = ecmframe.getCRC() >> 8; // 1st byte FCS
  1050.     int fcs2 = ecmframe.getCRC() & 0xff; // 2nd byte FCS
  1051.     ecmframe.put(fcs1); ecmframe.put(fcs2);
  1052.     blockData(fcs1, false);
  1053.     blockData(fcs2, false);
  1054.     traceHDLCFrame("<--", ecmframe, true);
  1055.     protoTrace("SEND send frame number %u", fnum);
  1057.     if (!useV34) {
  1058. // separate frames with a 0x7e flag
  1059. blockData(0x7e, true);
  1060.     }
  1062.     if (firstframe[0] == 0x1) {
  1063. for (u_int i = 0; i < (frameSize + 6); i++) {
  1064.     firstframe[i] = ecmframe[i];
  1065. }
  1066.     }
  1067. }
  1068.     }
  1069.     fcountuniq = fcount;
  1070.     if (fcount == 1 && pprcnt > 0 && firstframe[3] == 0) {
  1071. /*
  1072.  * Some receivers may have a hard time hearing the first frame,
  1073.  * However, some receivers do not like frame duplication within a
  1074.  * block.  So the first time we get here we merely send a single
  1075.  * frame, but we flag duplicate so that if we come back through
  1076.  * here we'll repeat it and hopefully catch those that have a
  1077.  * hard time hearing the first frame.
  1078.  */
  1079. if (duplicate) {
  1080.     HDLCFrame ecmframe(5);
  1081.     fcount++;
  1082.     for (u_int i = 0; i < (frameSize + 6); i++) {
  1083. blockData(firstframe[i], false);
  1084.     }
  1085.     ecmframe.put(firstframe, (frameSize + 6));
  1086.     traceHDLCFrame("<--", ecmframe, true);
  1087.     protoTrace("SEND send frame number %u", frameRev[firstframe[3]]);
  1088.     if (!useV34) blockData(0x7e, true);
  1089. } else {
  1090.     duplicate = true;
  1091. }
  1092.     }
  1093.     free(firstframe);
  1094.     HDLCFrame rcpframe(5);
  1095.     rcpframe.put(0xff); rcpframe.put(0xc0); rcpframe.put(0x61); rcpframe.put(0x96); rcpframe.put(0xd3);
  1096.     for (u_short k = 0; k < 3; k++) { // three RCP frames
  1097. for (u_short j = 0; j < 5; j++)
  1098.     blockData(rcpframe[j], false);
  1099. traceHDLCFrame("<--", rcpframe, true);
  1101. // separate frames with a 0x7e flag
  1102. if (!useV34) blockData(0x7e, true);
  1103.     }
  1104.     // add one more flag to ensure one full flag gets transmitted before DLE+ETX
  1105.     if (!useV34) blockData(0x7e, true);
  1107.     // start up the high-speed carrier...
  1108.     if (flowControl == FLOW_XONXOFF)   
  1109. setXONXOFF(FLOW_XONXOFF, FLOW_NONE, ACT_FLUSH);
  1110.     if (!useV34) {
  1111. // T.30 5.3.2.4 (03/93) gives this to be a 75ms minimum
  1112. if (!switchingPause(emsg)) {
  1113.     return (false);
  1114. }
  1115. /*
  1116.  * T.30 Section 5, Note 5 states that we must use long training
  1117.  * on the first high-speed data message following CTC.
  1118.  */
  1119. fxStr tmCmd;
  1120. if (dolongtrain) tmCmd = fxStr(curcap->value, tmCmdFmt);
  1121. else tmCmd = fxStr(curcap[HasShortTraining(curcap)].value, tmCmdFmt);
  1122. if (!atCmd(tmCmd, AT_CONNECT))
  1123.     return (false);
  1124. pause(conf.class1TMConnectDelay);
  1125.     }
  1126.     dolongtrain = false;
  1128.     // The block is assembled.  Transmit it, adding transparent DLEs.  End with DLE+ETX.
  1129.     u_char buf[2];
  1130.     if (useV34) {
  1131. // switch to primary channel
  1132. buf[0] = DLE; buf[1] = 0x6B; // <DLE><pri>
  1133. HDLCFrame rtncframe(conf.class1FrameOverhead);
  1134. u_short limit = 5;
  1135. bool gotprate, gotrtncframe = false;
  1136. // wait for the ready indicator, <DLE><pri><DLE><prate>
  1137. do {
  1138.     if (!putModemData(buf, 2)) return (false);
  1139.     gotprate = waitForDCEChannel(false);
  1140.     if (!gotprate && ctrlFrameRcvd != fxStr::null) {
  1141. /*
  1142.  * Maybe we took so long to assemble the block that 
  1143.  * the receiver has retransmitted CFR or MCF.
  1144.  */
  1145. for (u_int i = 0; i < ctrlFrameRcvd.length(); i++)
  1146.     rtncframe.put(frameRev[ctrlFrameRcvd[i] & 0xFF]);
  1147. traceHDLCFrame("-->", rtncframe);
  1148. gotrtncframe = true;
  1149.     }
  1150. } while (!gotprate && gotrtncframe && --limit);
  1151. if (renegotiate) {
  1152.     // Although spec says this can be done any time,
  1153.     // in practice it must be done at this moment.
  1154.     renegotiatePrimary(constrain);
  1155.     renegotiate = false;
  1156.     constrain = false;
  1157. }
  1158.     }
  1159.     if (useV34) {
  1160. // we intentionally do not send the FCS bytes as the DCE regenerates them
  1161. // send fcount frames separated by <DLE><ETX>
  1162. u_short v34frame;
  1163. for (v34frame = 0; v34frame < fcount; v34frame++) {
  1164.     if (!sendClass1Data(ecmStuffedBlock, frameSize + 4, bitrev, true, getDataTimeout()))
  1165. return (false);
  1166.     ecmStuffedBlock += (frameSize + 6);
  1167. }
  1168. // send 3 RCP frames separated by <DLE><ETX>
  1169. for (v34frame = 0; v34frame < 3; v34frame++) {
  1170.     if (!sendClass1Data(ecmStuffedBlock, 3, bitrev, true, getDataTimeout()))
  1171. return (false);
  1172.     ecmStuffedBlock += 5;
  1173. }
  1174. ecmStuffedBlock -= ecmStuffedBlockPos;
  1175.     } else {
  1176. if (!sendClass1Data(ecmStuffedBlock, ecmStuffedBlockPos, bitrev, true, getDataTimeout()))
  1177.     return (false);
  1178.     }
  1179.     if (useV34) {
  1180. // switch to control channel
  1181. buf[0] = DLE; buf[1] = 0x6D; // <DLE><ctrl>
  1182. if (!putModemData(buf, 2)) return (false);
  1183. // wait for the ready indicator, <DLE><ctrl><DLE><crate>
  1184. if (!waitForDCEChannel(true)) {
  1185.     emsg = "Failed to properly open control V.34 channel. {E116}";
  1186.     protoTrace(emsg);
  1187.     return (false);
  1188. }
  1189.     } else {
  1190. // Wait for transmit buffer to empty.
  1191. ATResponse r;
  1192. while ((r = atResponse(rbuf, getDataTimeout())) == AT_OTHER);
  1193.          if (!(r == AT_OK)) {
  1194.     if (r == AT_NOCARRIER) {
  1195. /*
  1196.  * The NO CARRIER result here is not per-spec.  However,
  1197.  * some modems capable of detecting hangup conditions will
  1198.  * use this to indicate a disconnection.  Because we did
  1199.  * not check for modem responses during the entire data
  1200.  * transfer we flush the modem input so as to avoid reading
  1201.  * any modem responses related to misinterpreted Phase C
  1202.  * data that occurred after the hangup.
  1203.  */
  1204. flushModemInput();
  1205.     }
  1206.     return (false);
  1207. }
  1208.     }
  1210.     if (flowControl == FLOW_XONXOFF)
  1211. setXONXOFF(FLOW_NONE, FLOW_NONE, ACT_DRAIN);
  1213.     if (!useV34 && !atCmd(ppmcmd == FCF_MPS ? conf.class1PPMWaitCmd : conf.class1EOPWaitCmd, AT_OK)) {
  1214. emsg = "Stop and wait failure (modem on hook) {E127}";
  1215. protoTrace(emsg);
  1216. return (false);
  1217.     }
  1218.     /*
  1219.      * Build PPS frame and send it.  We don't use I3 = 0xFF when sending
  1220.      * zero-count frames because some receivers will read it as 256.
  1221.      * Instead we send I3 = 0x00, which technically indicates one frame,
  1222.      * but it should be harmless since any interpretation of I3 will not
  1223.      * exceed previous indications, and the receiver has already acknowledged
  1224.      * all frames properly received.  I3 indicates the *unique* frame count.
  1225.      */
  1226.     char pps[4];
  1227.     if (!lastblock)
  1228. pps[0] = 0x00;
  1229.     else
  1230. pps[0] = ppmcmd | 0x80;
  1231.     pps[1] = frameRev[FaxModem::getPageNumberOfCall() - 1];
  1232.     pps[2] = frameRev[blockNumber];
  1233.     pps[3] = frameRev[(fcountuniq == 0 ? 0 : (fcountuniq - 1))];
  1234.     u_short ppscnt = 0, crpcnt = 0;
  1235.     bool gotppr = false;
  1236.     /* get MCF/PPR/RNR */
  1237.     HDLCFrame pprframe(conf.class1FrameOverhead);
  1238.     do {
  1239. if (!useV34 && !atCmd(thCmd, AT_CONNECT))
  1240.     break;
  1241. startTimeout(3000);
  1242. sendFrame(FCF_PPS|FCF_SNDR, fxStr(pps, 4));
  1243. stopTimeout("sending PPS frame");
  1244. traceFCF("SEND send", FCF_PPS);
  1245. traceFCF("SEND send", pps[0]);
  1247. // Some receivers will almost always miss our first PPS message, and
  1248. // in those cases waiting T2 for a response will cause the remote to
  1249. // hang up.  So, using T4 here is imperative so that our second PPS
  1250. // message happens before the remote decides to hang up. As we're in
  1251. // a "RESPONSE REC" operation, anyway, this is correct behavior.
  1252. //
  1253. // We don't use CRP here, because it isn't well-received.
  1254. do {
  1255.     gotppr = recvFrame(pprframe, FCF_SNDR, conf.t4Timer, false, false);
  1256. } while (pprframe.getFCF() == FCF_PPS && crpcnt++ < 3); // handle echo of our PPS
  1257. if (gotppr) {
  1258.     traceFCF("SEND recv", pprframe.getFCF());
  1259.     if (pprframe.getFCF() == FCF_CRP) {
  1260. gotppr = false;
  1261. crpcnt++;
  1262. ppscnt = 0;
  1263. if (!useV34 && !switchingPause(emsg)) {
  1264.     return (false);
  1265. }
  1266.     }
  1267. }
  1268.     } while (!gotppr && (++ppscnt < 3) && (crpcnt < 3) && !(useV34 && gotEOT));
  1269.     if (gotppr) {
  1270. if (!useV34 && !switchingPause(emsg)) {
  1271.     return (false);
  1272. }
  1273. if (pprframe.getFCF() == FCF_RNR) {
  1274.     u_int t1 = howmany(conf.t1Timer, 1000);
  1275.     time_t start = Sys::now();
  1276.     gotppr = false;
  1277.     do {
  1278. if ((unsigned) Sys::now()-start >= t1) {
  1279.     // we use T1 rather than T5 to "minimize transmission inefficiency" (T.30 A.5.4.1)
  1280.     emsg = "Receiver flow control exceeded timer. {E138}";
  1281.     if (ppmcmd == FCF_EOM) batchingError = true;
  1282.     protoTrace(emsg);
  1283.     return (false);
  1284. }
  1285. u_short rrcnt = 0, crpcnt = 0;
  1286. bool gotmsg = false;
  1287. do {
  1288.     if (!useV34 && !atCmd(thCmd, AT_CONNECT))
  1289. break;
  1290.     startTimeout(3000);
  1291.     sendFrame(FCF_RR|FCF_SNDR);
  1292.     stopTimeout("sending RR frame");
  1293.     traceFCF("SEND send", FCF_RR);
  1294.     // T.30 states that we must wait no more than T4 between unanswered RR signals.
  1295.     gotmsg = recvFrame(pprframe, FCF_SNDR, conf.t4Timer, false, false);
  1296.     if (gotmsg) { // no CRP, stick to RR only
  1297. traceFCF("SEND recv", pprframe.getFCF());
  1298. if (pprframe.getFCF() == FCF_CRP) {
  1299.     gotmsg = false;
  1300.     crpcnt++;
  1301.     rrcnt = 0;
  1302.     if (!useV34 && !switchingPause(emsg)) {
  1303. return (false);
  1304.     }
  1305. }
  1306.     }
  1307. } while (!gotmsg && (++rrcnt < 3) && (crpcnt < 3) && (useV34 || switchingPause(emsg)));
  1308. if (!gotmsg) {
  1309.     emsg = "No response to RR repeated 3 times. {E139}";
  1310.     protoTrace(emsg);
  1311.     return (false);
  1312. }
  1313. switch (pprframe.getFCF()) {
  1314.     case FCF_PPR:
  1315.     case FCF_MCF:
  1316. gotppr = true;
  1317. break;
  1318.     case FCF_RNR:
  1319. if (!useV34 && !switchingPause(emsg)) {
  1320.     return (false);
  1321. }
  1322. break;
  1323.     default:
  1324. emsg = "COMREC invalid response received to RR. {E140}";
  1325. protoTrace(emsg);
  1326. return (false);
  1327. }
  1328.     } while (!gotppr);
  1329. }
  1330. bool doctceor;
  1331. switch (pprframe.getFCF()) {
  1332.     case FCF_MCF:
  1333.     case FCF_PIP:
  1334. hadV34Trouble = false;
  1335. blockgood = true;
  1336. signalRcvd = pprframe.getFCF();
  1337. break;
  1338.     case FCF_PPR:
  1339. {
  1340.     pprcnt++;
  1341.     // update ppr
  1342.     for (u_int i = 3; i < (pprframe.getLength() - (conf.class1FrameOverhead - 2)); i++) {
  1343. ppr[i-3] = pprframe[i];
  1344.     }
  1345.     badframesbefore = badframes;
  1346.     badframes = 0;
  1347.     for (u_int j = 0; j < frameNumber; j++) {
  1348. u_int pprpos, pprval;
  1349. for (pprpos = 0, pprval = j; pprval >= 8; pprval -= 8) pprpos++;
  1350. if (ppr[pprpos] & frameRev[1 << pprval]) {
  1351.     badframes++;
  1352. }
  1353.     }
  1354. }
  1355. doctceor = (pprcnt == 4);
  1356. /*
  1357.  * T.30 Annex F prohibits CTC in V.34-Fax.  Per the spec our options
  1358.  * are to do EOR or DCN.  However, many receivers will allow us to
  1359.  * simply continue sending image blocks followed by PPS.  Coupled with
  1360.  * primary rate negotiations, this becomes a better-than-CTC solution.
  1361.  * Do this up to 12 attempts and only when something has gotten through.
  1362.  */
  1363. if (useV34) {
  1364.     if (pprcnt >= 4 && badframes) hadV34Trouble = true; // problematic V.34?
  1365.     if (pprcnt == 8) doctceor = true;
  1366.     if (conf.class1PersistentECM && badframes && badframes != frameNumber) doctceor = false;
  1367.     if (pprcnt == 12) doctceor = true;
  1368.     if (!doctceor && badframes && badframes >= (badframesbefore / 2)) {
  1369. /*
  1370.  * Request to renegotiate the primary rate.  (T.31-A1 B.8.5)
  1371.  * In practice, if we do not constrain the rate then
  1372.  * we may likely speed up the rate; so we constrain it.
  1373.  */
  1374. renegotiate = true;
  1375. constrain = true;
  1376.     }
  1377. }
  1378. if (doctceor) {
  1379.     pprcnt = 0;
  1380.     // Some receivers will ignorantly transmit PPR showing all frames good,
  1381.     // so if that's the case then do EOR instead of CTC.
  1382.     if (badframes == 0) {
  1383. hadV34Trouble = false;
  1384. blockgood = true;
  1385. signalRcvd = FCF_MCF;
  1386.     }
  1387.     if (!useV34 && curcap->mod == V17 && badframes == frameNumber && FaxModem::getPageNumberOfCall() == 1) {
  1388. // looks like a V.17 modulator incompatibility that managed to pass TCF
  1389. // we set hasV17Trouble to help future calls to this destination
  1390. protoTrace("The destination appears to have trouble with V.17.");
  1391. hadV17Trouble = true;
  1392.     }
  1393.     // There is no CTC with V.34-fax (T.30 Annex F.3.4.5 Note 1).
  1394.     if (conf.class1PersistentECM && !useV34 && (blockgood == false) && 
  1395. !((curcap->br == 0) && (badframes >= badframesbefore))) {
  1396. /*
  1397.  * We send ctc even at 2400 baud if we're getting somewhere, and
  1398.  * often training down to a slower speed only makes matters worse.
  1399.  * So, if we seem to be making adequate progress we don't train down.
  1400.  */
  1401. if (curcap->br != 0 && (badframes >= badframesbefore/2)) {
  1402.     u_char oldmod = curcap->mod;
  1403.     do {
  1404. if (!dropToNextBR(params)) {
  1405.     // We have a minimum speed that's not BR_2400,
  1406.     // and we're there now.  Undo curcap change...
  1407.     curcap++;
  1408. }
  1409. // drop to the next modulation protocol if we're not getting anywhere
  1410.     } while (curcap->br != 0 && badframes >= badframesbefore && curcap->mod == oldmod);
  1411. }
  1412. char ctc[2];
  1413. ctc[0] = 0;
  1414. ctc[1] = curcap->sr >> 8;
  1415. bool gotctr = false;
  1416. u_short ctccnt = 0, crpcnt = 0;
  1417. HDLCFrame ctrframe(conf.class1FrameOverhead);
  1418. do {
  1419.     if (!atCmd(thCmd, AT_CONNECT))
  1420. break;
  1421.     startTimeout(3000);
  1422.     sendFrame(FCF_CTC|FCF_SNDR, fxStr(ctc, 2));
  1423.     stopTimeout("sending CTC frame");
  1424.     traceFCF("SEND send", FCF_CTC);
  1425.     gotctr = recvFrame(ctrframe, FCF_SNDR, conf.t4Timer);
  1426.     if (gotctr) {
  1427. traceFCF("SEND recv", ctrframe.getFCF());
  1428. if (ctrframe.getFCF() == FCF_CRP) {
  1429.     gotctr = false;
  1430.     crpcnt++;
  1431.     ctccnt = 0;
  1432.     if (!switchingPause(emsg)) {
  1433. return (false);
  1434.     }
  1435. }
  1436.     }
  1437. } while (!gotctr && (++ctccnt < 3) && (crpcnt < 3));
  1438. if (!gotctr) {
  1439.     emsg = "No response to CTC repeated 3 times. {E141}";
  1440.     protoTrace(emsg);
  1441.     return (false);
  1442. }
  1443. if (!ctrframe.getFCF() == FCF_CTR) {
  1444.     emsg = "COMREC invalid response received to CTC. {E142}";
  1445.     protoTrace(emsg);
  1446.     return (false);
  1447. }
  1448. dolongtrain = true; // T.30 states that we must use long-training next
  1449.     } else {
  1450. /*
  1451.  * At this point data corruption is inevitable if all data
  1452.  * frames have not been received correctly.  With MH and MR 
  1453.  * data formats this may be tolerable if the bad frames are 
  1454.  * few and not in an unfortunate sequence.  With MMR data the
  1455.  * receiving decoder should truncate the image at the point
  1456.  * of the corruption.  The effect of corruption in JBIG or JPEG
  1457.  * data is quite unpredictable.  So if all frames have not been
  1458.  * received correctly and we're looking at an unacceptable
  1459.  * imaging situation on the receiver's end, then we disconnect,
  1460.  * and hopefully we try again successfully.
  1461.  */
  1462. if (blockgood == false && (params.df >= DF_2DMMR ||
  1463.     (params.df <= DF_2DMR && badframes > frameNumber/2))) {
  1464.     emsg = "Failure to transmit clean ECM image data. {E143}";
  1465.     protoTrace(emsg);
  1466.     return (false);
  1467. }
  1468. bool goterr = false;
  1469. u_short eorcnt = 0, crpcnt = 0;
  1470. HDLCFrame errframe(conf.class1FrameOverhead);
  1471. do {
  1472.     if (!useV34 && !atCmd(thCmd, AT_CONNECT))
  1473. break;
  1474.     startTimeout(3000);
  1475.     sendFrame(FCF_EOR|FCF_SNDR, fxStr(pps, 1));
  1476.     stopTimeout("sending EOR frame");
  1477.     traceFCF("SEND send", FCF_EOR);
  1478.     traceFCF("SEND send", pps[0]);
  1479.     goterr = recvFrame(errframe, FCF_SNDR, conf.t4Timer);
  1480.     if (goterr) {
  1481. traceFCF("SEND recv", errframe.getFCF());
  1482. if (errframe.getFCF() == FCF_CRP) {
  1483.     goterr = false;
  1484.     crpcnt++;
  1485.     eorcnt = 0;
  1486.     if (!useV34 && !switchingPause(emsg)) {
  1487. return (false);
  1488.     }
  1489. }
  1490.     }
  1491. } while (!goterr && (++eorcnt < 3) && (crpcnt < 3));
  1492. if (!goterr) {
  1493.     emsg = "No response to EOR repeated 3 times. {E144}";
  1494.     if (ppmcmd == FCF_EOM) batchingError = true;
  1495.     protoTrace(emsg);
  1496.     return (false);
  1497. }
  1498. if (errframe.getFCF() == FCF_RNR) {
  1499.     u_int t1 = howmany(conf.t1Timer, 1000);
  1500.     time_t start = Sys::now();
  1501.     goterr = false;
  1502.     do {
  1503. if ((unsigned) Sys::now()-start >= t1) {
  1504.     // we use T1 rather than T5 to "minimize transmission inefficiency" (T.30 A.5.4.1)
  1505.     emsg = "Receiver flow control exceeded timer. {E138}";
  1506.     if (ppmcmd == FCF_EOM) batchingError = true;
  1507.     protoTrace(emsg);
  1508.     return (false);
  1509. }
  1510. u_short rrcnt = 0, crpcnt = 0;
  1511. bool gotmsg = false;
  1512. do {
  1513.     if (!useV34 && !atCmd(thCmd, AT_CONNECT))
  1514. break;
  1515.     startTimeout(3000);
  1516.     sendFrame(FCF_RR|FCF_SNDR);
  1517.     stopTimeout("sending RR frame");
  1518.     traceFCF("SEND send", FCF_RR);
  1519.     // T.30 states that we must wait no more than T4 between unanswered RR signals.
  1520.     gotmsg = recvFrame(errframe, FCF_SNDR, conf.t4Timer, false, false);
  1521.     if (gotmsg) { // no CRP, stick to RR only
  1522. traceFCF("SEND recv", errframe.getFCF());
  1523. if (errframe.getFCF() == FCF_CRP) {
  1524.     gotmsg = false;
  1525.     crpcnt++;
  1526.     rrcnt = 0;
  1527.     if (!useV34 && !switchingPause(emsg)) {
  1528. return (false);
  1529.     }
  1530. }
  1531.     }
  1532. } while (!gotmsg && (++rrcnt < 3) && (crpcnt < 3) && (useV34 || switchingPause(emsg)));
  1533. if (!gotmsg) {
  1534.     emsg = "No response to RR repeated 3 times. {E139}";
  1535.     protoTrace(emsg);
  1536.     return (false);
  1537. }
  1538. switch (errframe.getFCF()) {
  1539.     case FCF_ERR:
  1540. goterr = true;
  1541. break;
  1542.     case FCF_RNR:
  1543. if (!useV34 && !switchingPause(emsg)) {
  1544.     return (false);
  1545. }
  1546. break;
  1547.     default:
  1548. emsg = "COMREC invalid response received to RR. {E140}";
  1549. protoTrace(emsg);
  1550. return (false);
  1551. }
  1552.     } while (!goterr);
  1553. }
  1554. if (!(errframe.getFCF() == FCF_ERR)) {
  1555.     emsg = "COMREC invalid response received to EOR. {E145}";
  1556.     protoTrace(emsg);
  1557.     return (false);
  1558. }
  1559. blockgood = true;
  1560. signalRcvd = FCF_MCF;
  1561.     }
  1562. }
  1563. break;
  1564.     default:
  1565. emsg = "COMREC invalid response received to PPS. {E146}";
  1566. protoTrace(emsg);
  1567. return(false);
  1568. }
  1569.     } else {
  1570. emsg = "No response to PPS repeated 3 times. {E147}";
  1571. if (ppmcmd == FCF_EOM) batchingError = true;
  1572. protoTrace(emsg);
  1573. return (false);
  1574.     }
  1575. } while (!blockgood);
  1576. frameNumber = 0;
  1577. if (lastblock) blockNumber = 0;
  1578. else blockNumber++;
  1579.     }
  1580.     return (true);
  1581. }
  1583. /*
  1584.  * Send T.30-A framed image data.
  1585.  */
  1586. bool
  1587. Class1Modem::sendClass1ECMData(const u_char* data, u_int cc, const u_char* bitrev, bool eod, u_int ppmcmd, fxStr& emsg)
  1588. {
  1589.     /*
  1590.      * Buffer data into the block.  We buffer the entire block
  1591.      * before sending it to prevent any modem buffer underruns.
  1592.      * Later we send it to sendClass1Data() which adds the 
  1593.      * transparent DLE characters and transmits it.
  1594.      */
  1595.     for (u_int i = 0; i < cc; i++) {
  1596. if (ecmFramePos == 0) {
  1597.     ecmFrame[ecmFramePos++] = 0xff;  // address field
  1598.     ecmFrame[ecmFramePos++] = 0xc0; // control field
  1599.     ecmFrame[ecmFramePos++] = 0x60; // FCD FCF
  1600.     ecmFrame[ecmFramePos++] = frameRev[frameNumber++]; // block frame number
  1601. }
  1602. ecmFrame[ecmFramePos++] = frameRev[data[i]];
  1603. if (ecmFramePos == (frameSize + 4)) {
  1604.     bool lastframe = ((i == (cc - 1)) && eod);
  1605.     if (!blockFrame(bitrev, lastframe, ppmcmd, emsg))
  1606. return (false);
  1607.     if (lastframe)
  1608. return (true);
  1609. }
  1610.     }
  1611.     if (eod) {
  1612. if (ecmFramePos != 0) {
  1613.     // frame must be filled to end with zero-data
  1614.     while (ecmFramePos < (frameSize + 4)) ecmFrame[ecmFramePos++] = 0x00;
  1615. }
  1616. if (!blockFrame(bitrev, true, ppmcmd, emsg))
  1617.     return (false);
  1618.     }
  1619.     return (true);
  1620. }
  1622. /*
  1623.  * Send data for the current page.
  1624.  */
  1625. bool
  1626. Class1Modem::sendPageData(u_char* data, u_int cc, const u_char* bitrev, bool ecm, fxStr& emsg)
  1627. {
  1628.     if (imagefd > 0) Sys::write(imagefd, (const char*) data, cc);
  1629.     beginTimedTransfer();
  1630.     bool rc;
  1631.     if (ecm)
  1632. rc = sendClass1ECMData(data, cc, bitrev, false, 0, emsg);
  1633.     else {
  1634. rc = sendClass1Data(data, cc, bitrev, false, getDataTimeout());
  1635. protoTrace("SENT %u bytes of data", cc);
  1636.     }
  1637.     endTimedTransfer();
  1638.     return rc;
  1639. }
  1641. /*
  1642.  * Send RTC to terminate a page.  Note that we pad the
  1643.  * RTC with zero fill to "push it out on the wire".  It
  1644.  * seems that some Class 1 modems do not immediately
  1645.  * send all the data they are presented.
  1646.  */
  1647. bool
  1648. Class1Modem::sendRTC(Class2Params params, u_int ppmcmd, uint32 rows, fxStr& emsg)
  1649. {
  1650.     if (params.df > DF_2DMR) {
  1651. /*
  1652.  * If we ever needed to send NEWLEN or other JBIG-terminating
  1653.  * markers this is where we would do it.
  1654.  */
  1655. //u_char newlen[8] = { 0xFF, 0x05, 
  1656. //    (rows>>24)&0xFF, (rows>>16)&0xFF, (rows>>8)&0xFF, rows&0xFF,
  1657. //    0xFF, 0x02 }; // SDNORM is added per spec
  1658. //return sendClass1ECMData(newlen, 8, rtcRev, true, ppmcmd, emsg);
  1659. return sendClass1ECMData(NULL, 0, rtcRev, true, ppmcmd, emsg);
  1660.     }
  1661.     /*
  1662.      * These are intentionally reverse-encoded in order to keep
  1663.      * rtcRev and bitrev in sendPage() in agreement.  They are also
  1664.      * end-padded with zeros to help "push" them out of the modem.
  1665.      * We explicitly set the zeros in the padding so as to prevent
  1666.      * the "unset" garbage values from confusing the receiver.
  1667.      * We don't send that padding with ECM, as it's unnecessary.
  1668.      */
  1669.     static const u_char RTC1D[9+20] =
  1670. { 0x00,0x08,0x80,0x00,0x08,0x80,0x00,0x08,0x80,
  1671.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  1672.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 };
  1673.     static const u_char RTC2D[10+20] =
  1674. { 0x00,0x18,0x00,0x03,0x60,0x00,0x0C,0x80,0x01,0x30,
  1675.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  1676.   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 };
  1677.     if (params.is2D()) {
  1678. protoTrace("SEND 2D RTC");
  1679. if (params.ec != EC_DISABLE)
  1680.     return sendClass1ECMData(RTC2D, 10, rtcRev, true, ppmcmd, emsg);
  1681. else
  1682.     return sendClass1Data(RTC2D, sizeof (RTC2D), rtcRev, true, getDataTimeout());
  1683.     } else {
  1684. protoTrace("SEND 1D RTC");
  1685. if (params.ec != EC_DISABLE)
  1686.     return sendClass1ECMData(RTC1D, 9, rtcRev, true, ppmcmd, emsg);
  1687. else
  1688.     return sendClass1Data(RTC1D, sizeof (RTC1D), rtcRev, true, getDataTimeout());
  1689.     }
  1690. }
  1692. #define EOLcheck(w,mask,code) 
  1693.     if ((w & mask) == code) { w |= mask; return (true); }
  1695. /*
  1696.  * Check the last 24 bits of received T.4-encoded
  1697.  * data (presumed to be in LSB2MSB bit order) for
  1698.  * an EOL code and, if one is found, foul the data
  1699.  * to insure future calls do not re-recognize an
  1700.  * EOL code.
  1701.  */
  1702. static bool
  1703. EOLcode(u_long& w)
  1704. {
  1705.     if ((w & 0x00f00f) == 0) {
  1706. EOLcheck(w, 0x00f0ff, 0x000080);
  1707. EOLcheck(w, 0x00f87f, 0x000040);
  1708. EOLcheck(w, 0x00fc3f, 0x000020);
  1709. EOLcheck(w, 0x00fe1f, 0x000010);
  1710.     }
  1711.     if ((w & 0x00ff00) == 0) {
  1712. EOLcheck(w, 0x00ff0f, 0x000008);
  1713. EOLcheck(w, 0x80ff07, 0x000004);
  1714. EOLcheck(w, 0xc0ff03, 0x000002);
  1715. EOLcheck(w, 0xe0ff01, 0x000001);
  1716.     }
  1717.     if ((w & 0xf00f00) == 0) {
  1718. EOLcheck(w, 0xf0ff00, 0x008000);
  1719. EOLcheck(w, 0xf87f00, 0x004000);
  1720. EOLcheck(w, 0xfc3f00, 0x002000);
  1721. EOLcheck(w, 0xfe1f00, 0x001000);
  1722.     }
  1723.     return (false);
  1724. }
  1725. #undef EOLcheck
  1727. /*
  1728.  * Send a page of data.
  1729.  */
  1730. bool
  1731. Class1Modem::sendPage(TIFF* tif, Class2Params& params, u_int pageChop, u_int ppmcmd, fxStr& emsg)
  1732. {
  1733.     if (params.ec == EC_DISABLE) { // ECM does it later
  1734. /*
  1735.  * Set high speed carrier & start transfer.  If the
  1736.  * negotiated modulation technique includes short
  1737.  * training, then we use it here (it's used for all
  1738.  * high speed carrier traffic other than the TCF).
  1739.  */
  1740. fxStr tmCmd(curcap[HasShortTraining(curcap)].value, tmCmdFmt);
  1741. if (!atCmd(tmCmd, AT_CONNECT)) {
  1742.     emsg = "Unable to establish message carrier {E148}";
  1743.     protoTrace(emsg);
  1744.     return (false);
  1745. }
  1746. // As with TCF, T.31 8.3.3 requires the DCE to report CONNECT at the beginning
  1747. // of transmission of the training pattern rather than at the end.  We pause here
  1748. // to allow the remote's +FRM to result in CONNECT.
  1749. pause(conf.class1TMConnectDelay);
  1750. if (flowControl == FLOW_XONXOFF)
  1751.     setXONXOFF(FLOW_XONXOFF, FLOW_NONE, ACT_FLUSH);
  1752.     }
  1754.     bool rc = true;
  1755.     blockNumber = frameNumber = ecmBlockPos = ecmFramePos = ecmBitPos = ecmOnes = ecmByte = 0;
  1756.     protoTrace("SEND begin page");
  1758.     tstrip_t nstrips = TIFFNumberOfStrips(tif);
  1759.     uint32 rowsperstrip = 0;
  1760.     if (nstrips > 0) {
  1762. /*
  1763.  * RTFCC may mislead us here, so we temporarily
  1764.  * adjust params.
  1765.  */
  1766. Class2Params newparams = params;
  1767. uint16 compression;
  1768. TIFFGetField(tif, TIFFTAG_COMPRESSION, &compression);
  1769. if (compression != COMPRESSION_CCITTFAX4) {  
  1770.     uint32 g3opts = 0;
  1771.     TIFFGetField(tif, TIFFTAG_GROUP3OPTIONS, &g3opts);
  1772.     if ((g3opts & GROUP3OPT_2DENCODING) == DF_2DMR)
  1773. params.df = DF_2DMR;
  1774.     else
  1775. params.df = DF_1DMH;
  1776. } else
  1777.     params.df = DF_2DMMR;
  1779. /*
  1780.  * Correct bit order of data if not what modem expects.
  1781.  */
  1782. uint16 fillorder;
  1783. TIFFGetFieldDefaulted(tif, TIFFTAG_FILLORDER, &fillorder);
  1784. const u_char* bitrev =
  1785.     TIFFGetBitRevTable(sendFillOrder != FILLORDER_LSB2MSB);
  1786. /*
  1787.  * Setup tag line processing.
  1788.  */
  1789. bool doTagLine = setupTagLineSlop(params);
  1790. u_int ts = getTagLineSlop();
  1791. /*
  1792.  * Calculate total amount of space needed to read
  1793.  * the image into memory (in its encoded format).
  1794.  */
  1795. uint32* stripbytecount;
  1796. (void) TIFFGetField(tif, TIFFTAG_STRIPBYTECOUNTS, &stripbytecount);
  1797. tstrip_t strip;
  1798. u_long totdata = 0;
  1799. for (strip = 0; strip < nstrips; strip++)
  1800.     totdata += stripbytecount[strip];
  1801. /*
  1802.  * Read the image into memory.
  1803.  */
  1804. u_char* data = new u_char[totdata+ts];
  1805. u_int off = ts; // skip tag line slop area
  1806. for (strip = 0; strip < nstrips; strip++) {
  1807.     uint32 sbc = stripbytecount[strip];
  1808.     if (sbc > 0 && TIFFReadRawStrip(tif, strip, data+off, sbc) >= 0)
  1809. off += (u_int) sbc;
  1810. }
  1811. totdata -= pageChop; // deduct trailing white space not sent
  1812. TIFFGetFieldDefaulted(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip);
  1813. if (rowsperstrip == (uint32) -1)
  1814.     TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &rowsperstrip);
  1816. /*
  1817.  * Image the tag line, if intended.
  1818.  */
  1819. u_char* dp;
  1820. if (doTagLine) {
  1821.     u_long totbytes = totdata;
  1822.     dp = imageTagLine(data+ts, fillorder, params, totbytes);
  1823.     // Because the whole image is processed with MMR, 
  1824.     // totdata is then determined during encoding.
  1825.     totdata = (params.df == DF_2DMMR) ? totbytes : totdata+ts - (dp-data);
  1826. } else
  1827.     dp = data;
  1829. /*
  1830.  * After a page chop rowsperstrip is no longer valid, as the strip will
  1831.  * be shorter.  Therefore, convertPhaseCData (for the benefit of supporting
  1832.  * the sending of JBIG NEWLEN markers) and correctPhaseCData (only in the 
  1833.  * case of MMR data) deliberately update rowsperstrip.  Page-chopped and
  1834.  * un-converted MH and MR data will not have updated rowsperstrip.
  1835.  * However, this only amounts to a allocating more memory than is needed,
  1836.  * and this is not consequential.
  1837.  */
  1839. if (conf.softRTFCC && params.df != newparams.df) {
  1840.     switch (params.df) {
  1841. case DF_1DMH:
  1842.     protoTrace("Reading MH-compressed image file");
  1843.     break;
  1844. case DF_2DMR:
  1845.     protoTrace("Reading MR-compressed image file");
  1846.     break;
  1847. case DF_2DMMR:
  1848.     protoTrace("Reading MMR-compressed image file");
  1849.     break;
  1850.     }
  1851.     dp = convertPhaseCData(dp, totdata, fillorder, params, newparams, rowsperstrip);
  1852.     params = newparams; // revert back
  1853. }
  1855.         /*
  1856.          * correct broken Phase C (T.4) data if neccessary 
  1857.          */
  1858. if (params.df < DF_2DMMR)
  1859.     correctPhaseCData(dp, totdata, fillorder, params, rowsperstrip);
  1861. /*
  1862.  * Send the page of data.  This is slightly complicated
  1863.  * by the fact that we may have to add zero-fill before the
  1864.  * EOL codes to bring the transmit time for each scanline
  1865.  * up to the negotiated min-scanline time.
  1866.  *
  1867.  * Note that we blindly force the data to be in LSB2MSB bit
  1868.  * order so that the EOL locating code works (if needed).
  1869.  * This may result in two extraneous bit reversals if the
  1870.  * modem wants the data in MSB2LSB order, but for now we'll
  1871.  * avoid the temptation to optimize.
  1872.  */
  1873. if (params.df <= DF_2DMMR && fillorder != FILLORDER_LSB2MSB) {
  1874.     TIFFReverseBits(dp, totdata);
  1875. }
  1877. /* For debugging purposes we may want to write the image-data to file. */
  1878. if (conf.saverawimage) imagefd = Sys::open("/tmp/out.fax", O_RDWR|O_CREAT|O_EXCL);
  1880. u_int minLen = params.minScanlineSize();
  1881. if (minLen > 0) { // only in non-ECM
  1882.     /*
  1883.      * Client requires a non-zero min-scanline time.  We
  1884.      * comply by zero-padding scanlines that have <minLen
  1885.      * bytes of data to send.  To minimize underrun we
  1886.      * do this padding in a strip-sized buffer.
  1887.      */
  1888.     u_char* fill = new u_char[minLen*rowsperstrip];
  1889.     u_char* eoFill = fill + minLen*rowsperstrip;
  1890.     u_char* fp = fill;
  1892.     u_char* bp = dp;
  1893.     u_char* ep = dp+totdata;
  1894.     u_long w = 0xffffff;
  1896.             /*
  1897.              * Immediately copy leading EOL into the fill buffer,
  1898.              * because it has not to be padded. Note that leading
  1899.              * EOL is not byte-aligned, and so we also copy 4 bits
  1900.              * if image data. But that's OK, and may only lead to
  1901.              * adding one extra zero-fill byte to the first image
  1902.              * row.
  1903.              */
  1904.             *fp++ = *bp++;
  1905.             *fp++ = *bp++;
  1906.     do {
  1907. u_char* bol = bp;
  1908.                 bool foundEOL;
  1909. do {
  1910.     w = (w<<8) | *bp++;
  1911.                     foundEOL = EOLcode(w);
  1912.                 } while (!foundEOL && bp < ep);
  1913. /*
  1914.                  * We're either after an EOL code or at the end of data.
  1915.  * If necessary, insert zero-fill before the last byte
  1916.  * in the EOL code so that we comply with the
  1917.  * negotiated min-scanline time.
  1918.  */
  1919. u_int lineLen = bp - bol;
  1920. if ((fp + fxmax(lineLen, minLen) >= eoFill) && (fp-fill != 0)) {
  1921.     /*
  1922.      * Not enough space for this scanline, flush
  1923.      * the current data and reset the pointer into
  1924.      * the zero fill buffer.
  1925.      */
  1926.     rc = sendPageData(fill, fp-fill, bitrev, (params.ec != EC_DISABLE), emsg);
  1927.     fp = fill;
  1928.     if (!rc) // error writing data
  1929. break;
  1930. }
  1931. if (lineLen >= minLen*rowsperstrip) {
  1932.     /*
  1933.      * The fill buffer is smaller than this
  1934.      * scanline alone.  Flush this scanline
  1935.      * also.  lineLen is greater than minLen.
  1936.      */
  1937.     rc = sendPageData(bol, lineLen, bitrev, (params.ec != EC_DISABLE), emsg);
  1938.     if (!rc) // error writing
  1939. break;
  1940. } else {
  1941.     memcpy(fp, bol, lineLen); // first part of line
  1942.     fp += lineLen;
  1943.     if (lineLen < minLen) { // must zero-fill
  1944. u_int zeroLen = minLen - lineLen;
  1945.                  if ( foundEOL ) {
  1946.                      memset(fp-1, 0, zeroLen); // zero padding
  1947.     fp += zeroLen;
  1948.     fp[-1] = bp[-1]; // last byte in EOL
  1949. } else {
  1950.     /*
  1951.      * Last line does not contain EOL
  1952.      */
  1953.     memset(fp, 0, zeroLen); // zero padding
  1954.     fp += zeroLen;
  1955. }
  1956.     }
  1957. }
  1958.     } while (bp < ep);
  1959.     /*
  1960.      * Flush anything that was not sent above.
  1961.      */
  1962.     if (fp > fill && rc) {
  1963. rc = sendPageData(fill, fp-fill, bitrev, (params.ec != EC_DISABLE), emsg);
  1964.     }
  1965.     delete fill;
  1966. } else {
  1967.     /*
  1968.      * No EOL-padding needed, just jam the bytes.
  1969.      */
  1970.     rc = sendPageData(dp, (u_int) totdata, bitrev, (params.ec != EC_DISABLE), emsg);
  1971. }
  1972. delete data;
  1973. if (imagefd > 0) {
  1974.     Sys::close(imagefd);
  1975.     imagefd = 0;
  1976. }
  1977.     }
  1978.     if (rc || abortRequested())
  1979. rc = sendRTC(params, ppmcmd, rowsperstrip, emsg);
  1980.     protoTrace("SEND end page");
  1981.     if (params.ec == EC_DISABLE) {
  1982. // these were already done by ECM protocol
  1983. if (rc) {
  1984.     /*
  1985.      * Wait for transmit buffer to empty.
  1986.      */
  1987.     ATResponse r;
  1988.     while ((r = atResponse(rbuf, getDataTimeout())) == AT_OTHER)
  1989. ;
  1990.     rc = (r == AT_OK);
  1991.     if (r == AT_NOCARRIER) {
  1992. /*
  1993.  * The NO CARRIER result here is not per-spec.  However,
  1994.  * some modems capable of detecting hangup conditions will
  1995.  * use this to indicate a disconnection.  Because we did
  1996.  * not check for modem responses during the entire data
  1997.  * transfer we flush the modem input so as to avoid reading
  1998.  * any modem responses related to misinterpreted Phase C
  1999.  * data that occurred after the hangup.
  2000.  */
  2001. flushModemInput();
  2002.     }
  2003. }
  2004. if (flowControl == FLOW_XONXOFF)
  2005.     setXONXOFF(FLOW_NONE, FLOW_NONE, ACT_DRAIN);
  2006.     }
  2007.     if (!rc && (emsg == "")) {
  2008. emsg = "Unspecified Transmit Phase C error {E149}"; // XXX
  2009.      protoTrace(emsg);
  2010.     }
  2011.     return (rc);
  2012. }
  2014. /*
  2015.  * Send the post-page-message and wait for a response.
  2016.  */
  2017. bool
  2018. Class1Modem::sendPPM(u_int ppm, HDLCFrame& mcf, fxStr& emsg)
  2019. {
  2020.     for (int t = 0; t < 3; t++) {
  2021. traceFCF("SEND send", ppm);
  2022. // don't use CRP here because it isn't well-received
  2023. if (transmitFrame(ppm|FCF_SNDR) && recvFrame(mcf, FCF_SNDR, conf.t4Timer, false, false))
  2024.     return (true);
  2025. if (abortRequested())
  2026.     return (false);
  2027. switchingPause(emsg);
  2028.     }
  2029.     switch (ppm) {
  2030. case FCF_MPS:
  2031.     emsg = "No response to MPS repeated 3 tries {E150}";
  2032.     break;
  2033. case FCF_EOP:
  2034.     emsg = "No response to EOP repeated 3 tries {E151}";
  2035.     break;
  2036. case FCF_EOM:
  2037.     emsg = "No response to EOM repeated 3 tries {E152}";
  2038.     break;
  2039. default:
  2040.     emsg = "No response to PPM repeated 3 tries {E153}";
  2041.     break;
  2042.     }
  2043.     protoTrace(emsg);
  2044.     return (false);
  2045. }
  2047. /*
  2048.  * Terminate a send session.
  2049.  */
  2050. void
  2051. Class1Modem::sendEnd()
  2052. {
  2053.     fxStr emsg;
  2054.     if (!useV34) (void) switchingPause(emsg);
  2055.     transmitFrame(FCF_DCN|FCF_SNDR); // disconnect
  2056.     setInputBuffering(true);
  2057. }
  2059. /*
  2060.  * Abort an active send session.
  2061.  */
  2062. void
  2063. Class1Modem::sendAbort()
  2064. {
  2065.     // nothing to do--DCN gets sent in sendEnd
  2066. }