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

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

传真(Fax)编程

开发平台：

C/C++

Class1Recv.c++：源码内容
  1. /* $Id: Class1Recv.c++,v 1.101 2009/06/22 06:21:48 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.  * Receive protocol.
  31.  */
  32. #include <stdio.h>
  33. #include <sys/time.h>
  34. #include "Class1.h"
  35. #include "ModemConfig.h"
  36. #include "HDLCFrame.h"
  37. #include "StackBuffer.h" // XXX
  39. #include "t.30.h"
  40. #include "Sys.h"
  41. #include "config.h"
  42. #include "FaxParams.h"
  44. /*
  45.  * Tell the modem to answer the phone.  We override
  46.  * this method so that we can force the terminal's
  47.  * flow control state to be setup to our liking.
  48.  */
  49. CallType
  50. Class1Modem::answerCall(AnswerType type, fxStr& emsg, const char* number)
  51. {
  52.     // Reset modemParams.br to non-V.34 settings.  If V.8 handshaking
  53.     // succeeds, then it will be changed again.
  54.     modemParams.br = nonV34br;
  56.     if (flowControl == FLOW_XONXOFF)
  57. setXONXOFF(FLOW_NONE, FLOW_NONE, ACT_FLUSH);
  58.     return ClassModem::answerCall(type, emsg, number);
  59. }
  61. /*
  62.  * Process an answer response from the modem.
  63.  * Since some Class 1 modems do not give a connect
  64.  * message that distinguishes between DATA and FAX,
  65.  * we override the default handling of "CONNECT"
  66.  * message here to force the high level code to
  67.  * probe further.
  68.  */
  69. const AnswerMsg*
  70. Class1Modem::findAnswer(const char* s)
  71. {
  72.     static const AnswerMsg answer[2] = {
  73.     { "CONNECT ", 8,
  74.       FaxModem::AT_NOTHING, FaxModem::OK, FaxModem::CALLTYPE_DATA },
  75.     { "CONNECT",  7,
  76.       FaxModem::AT_NOTHING, FaxModem::OK, FaxModem::CALLTYPE_UNKNOWN },
  77.     };
  78.     return strneq(s, answer[0].msg, answer[0].len) ? &answer[0] :
  79.    strneq(s, answer[1].msg, answer[1].len) ? &answer[1] :
  80.       FaxModem::findAnswer(s);
  81. }
  83. /*
  84.  * Begin the receive protocol.
  85.  */
  86. bool
  87. Class1Modem::recvBegin(FaxSetup* setupinfo, fxStr& emsg)
  88. {
  89.     setInputBuffering(false);
  90.     prevPage = 0; // no previous page received
  91.     pageGood = false; // quality of received page
  92.     messageReceived = false; // expect message carrier
  93.     recvdDCN = false; // haven't seen DCN
  94.     lastPPM = FCF_DCN; // anything will do
  95.     sendCFR = false; // TCF was not received
  96.     lastMCF = 0; // no MCF heard yet
  97.     capsUsed = 0; // no DCS or CTC seen yet
  99.     if (setupinfo) {
  100. senderSkipsV29 = setupinfo->senderSkipsV29;
  101. senderHasV17Trouble = setupinfo->senderHasV17Trouble;
  102.     }
  104.     fxStr nsf;
  105.     encodeNSF(nsf, HYLAFAX_VERSION);
  107.     if (useV34 && !gotCTRL) waitForDCEChannel(true); // expect control channel
  109.     FaxParams dis = modemDIS();
  111.     if (senderSkipsV29 && senderHasV17Trouble) {
  112. dis.setBit(FaxParams::BITNUM_SIGRATE_14, false); // disable V.17 support
  113. protoTrace("This sender skips V.29 and has trouble with V.17.  Concealing V.17 support.");
  114.     }
  116.     bool ok = FaxModem::recvBegin(setupinfo, emsg) && recvIdentification(
  117. 0, fxStr::null,
  118. 0, fxStr::null,
  119. FCF_NSF|FCF_RCVR, nsf,
  120. FCF_CSI|FCF_RCVR, lid,
  121. FCF_DIS|FCF_RCVR, dis,
  122. conf.class1RecvIdentTimer, false, emsg);
  123.     if (setupinfo) {
  124. /*
  125.  * Update FaxMachine info...
  126.  */
  127. setupinfo->senderSkipsV29 = senderSkipsV29;
  128. setupinfo->senderHasV17Trouble = senderHasV17Trouble;
  129.     }
  130.     return (ok);
  131. }
  133. /*
  134.  * Begin the receive protocol after an EOM signal.
  135.  */
  136. bool
  137. Class1Modem::recvEOMBegin(FaxSetup* setupinfo, fxStr& emsg)
  138. {
  139.     /*
  140.      * We must raise the transmission carrier to mimic the state following ATA.
  141.      */
  142.     if (!useV34) {
  143. pause(conf.t2Timer); // T.30 Fig 5.2B requires T2 to elapse
  144. if (!(atCmd(thCmd, AT_NOTHING) && atResponse(rbuf, 0) == AT_CONNECT)) {
  145.     emsg = "Failure to raise V.21 transmission carrier. {E101}";
  146.     protoTrace(emsg);
  147.     return (false);
  148. }
  149.     }
  150.     return Class1Modem::recvBegin(setupinfo, emsg);
  151. }
  153. /*
  154.  * Transmit local identification and wait for the
  155.  * remote side to respond with their identification.
  156.  */
  157. bool
  158. Class1Modem::recvIdentification(
  159.     u_int f1, const fxStr& pwd,
  160.     u_int f2, const fxStr& addr,
  161.     u_int f3, const fxStr& nsf,
  162.     u_int f4, const fxStr& id,
  163.     u_int f5, FaxParams& dics,
  164.     u_int timer, bool notransmit, fxStr& emsg)
  165. {
  166.     u_int t1 = howmany(timer, 1000); // in seconds
  167.     time_t start = Sys::now();
  168.     HDLCFrame frame(conf.class1FrameOverhead);
  169.     bool framesSent = false;
  170.     u_int onhooks = 0;
  172.     emsg = "No sender protocol (T.30 T1 timeout) {E102}";
  173.     if (!notransmit) {
  174. /*
  175.  * Transmit (PWD) (SUB) (CSI) DIS frames when the receiving
  176.  * station or (PWD) (SEP) (CIG) DTC when initiating a poll.
  177.  */
  178. if (f1) {
  179.     startTimeout(7550);
  180.     framesSent = sendFrame(f1, pwd, false);
  181.     stopTimeout("sending PWD frame");
  182. } else if (f2) {
  183.     startTimeout(7550);
  184.     framesSent = sendFrame(f2, addr, false);
  185.     stopTimeout("sending SUB/SEP frame");
  186. } else if (f3) {
  187.     startTimeout(7550);
  188.     framesSent = sendFrame(f3, (const u_char*)HYLAFAX_NSF, nsf, false);
  189.     stopTimeout("sending NSF frame");
  190. } else {
  191.     startTimeout(7550);
  192.     framesSent = sendFrame(f4, id, false);
  193.     stopTimeout("sending CSI/CIG frame");
  194. }
  195.     }
  196.     for (;;) {
  197. if (framesSent && !notransmit) {
  198.     if (f1) {
  199. startTimeout(7550);
  200. framesSent = sendFrame(f2, addr, false);
  201. stopTimeout("sending SUB/SEP frame");
  202.     }
  203.     if (framesSent && f2) {
  204. startTimeout(7550);
  205. framesSent = sendFrame(f3, (const u_char*)HYLAFAX_NSF, nsf, false);
  206. stopTimeout("sending NSF frame");
  207.     }
  208.     if (framesSent && f3) {
  209. startTimeout(7550);
  210. framesSent = sendFrame(f4, id, false);
  211. stopTimeout("sending CSI/CIG frame");
  212.     }
  213.     if (framesSent) {
  214. startTimeout(7550);
  215. framesSent = sendFrame(f5, dics);
  216. stopTimeout("sending DIS/DCS frame");
  217.     }
  218. }
  219. if (framesSent || notransmit) {
  220.     /*
  221.      * Wait for a response to be received.  We wait T2
  222.      * rather than T4 due to empirical evidence for that need.
  223.      */
  224.     if (recvFrame(frame, FCF_RCVR, conf.t2Timer, false, true, false)) {
  225. do {
  226.     /*
  227.      * Verify a DCS command response and, if
  228.      * all is correct, receive phasing/training.
  229.      */
  230.     bool gotframe = true;
  231.     while (gotframe) {
  232. if (!recvDCSFrames(frame)) {
  233.     switch (frame.getFCF()) {
  234. case FCF_DCN:
  235.     emsg = "RSPREC error/got DCN (sender abort) {E103}";
  236.     recvdDCN = true;
  237.     return (false);
  238. case FCF_MPS:
  239. case FCF_EOP:
  240. case FCF_EOM:
  241.     if (!useV34 && !switchingPause(emsg)) return (false);
  242.     transmitFrame(signalSent);
  243.     traceFCF("RECV send", (u_char) signalSent[2]);
  244.     break;
  245. case FCF_FTT:
  246.     /* probably just our own echo */
  247.     break;
  248. case FCF_CRP:
  249.     /* do nothing here, just let us repeat NSF, CSI, DIS */
  250.     break;
  251. default: // XXX DTC/DIS not handled
  252.     emsg = "RSPREC invalid response received {E104}";
  253.     break;
  254.     }
  255.     break;
  256. }
  257. gotframe = false;
  258. if (recvTraining()) {
  259.     emsg = "";
  260.     return (true);
  261. } else {
  262.     if (lastResponse == AT_FRH3 && waitFor(AT_CONNECT,0)) {
  263. // It's unclear if we are in "COMMAND REC" or "RESPONSE REC" mode,
  264. // but since we are already detecting the carrier, wait the longer.
  265. gotframe = recvFrame(frame, FCF_RCVR, conf.t2Timer, true, true, false);
  266. lastResponse = AT_NOTHING;
  267.     }
  268. }
  269.     }
  270.     if (gotframe) break; // where recvDCSFrames fails without DCN
  271.     emsg = "Failure to train modems {E105}";
  272.     /*
  273.      * Reset the timeout to insure the T1 timer is
  274.      * used.  This is done because the adaptive answer
  275.      * strategy may setup a shorter timeout that's
  276.      * used to wait for the initial identification
  277.      * frame.  If we get here then we know the remote
  278.      * side is a fax machine and so we should wait
  279.      * the full T1 timeout, as specified by the protocol.
  280.      */
  281.     t1 = howmany(conf.t1Timer, 1000);
  282. } while (recvFrame(frame, FCF_RCVR, conf.t2Timer, false, true, false));
  283.     }
  284. }
  285. if (gotEOT && ++onhooks > conf.class1HookSensitivity) {
  286.     emsg = "RSPREC error/got EOT {E106}";
  287.     return (false);
  288. }
  289. /*
  290.  * We failed to send our frames or failed to receive
  291.  * DCS from the other side.  First verify there is
  292.  * time to make another attempt...
  293.  */
  294. if ((u_int) Sys::now()-start >= t1)
  295.     return (false);
  296. if (frame.getFCF() != FCF_CRP) {
  297.     /*
  298.      * Historically we waited "Class1TrainingRecovery" (1500 ms)
  299.      * at this point to try to try to avoid retransmitting while
  300.      * the sender is also transmitting.  Sometimes it proved to be
  301.      * a faulty approach.  Really what we're trying to do is to
  302.      * not be transmitting at the same time as the other end is.
  303.      * The best way to do that is to make sure that there is
  304.      * silence on the line, and  we do that with Class1SwitchingCmd.
  305.      */
  306.     if (!useV34 && !switchingPause(emsg)) {
  307. return (false);
  308.     }
  309. }
  310. if (!notransmit) {
  311.     /*
  312.      * Retransmit ident frames.
  313.      */
  314.     if (f1)
  315. framesSent = transmitFrame(f1, pwd, false);
  316.     else if (f2)
  317. framesSent = transmitFrame(f2, addr, false);
  318.     else if (f3)
  319. framesSent = transmitFrame(f3, (const u_char*)HYLAFAX_NSF, nsf, false);
  320.     else
  321. framesSent = transmitFrame(f4, id, false);
  322. }
  323.     }
  324.     return (false);
  325. }
  327. /*
  328.  * Receive DCS preceded by any optional frames.
  329.  * Although technically this is "RESPONSE REC",
  330.  * we wait T2 due to empirical evidence of that need.
  331.  */
  332. bool
  333. Class1Modem::recvDCSFrames(HDLCFrame& frame)
  334. {
  335.     fxStr s;
  336.     do {
  337. traceFCF("RECV recv", frame.getFCF());
  338. switch (frame.getFCF()) {
  339. case FCF_PWD:
  340.     recvPWD(decodePWD(s, frame));
  341.     break;
  342. case FCF_SUB:
  343.     recvSUB(decodePWD(s, frame));
  344.     break;
  345. case FCF_TSI:
  346.     recvTSI(decodeTSI(s, frame));
  347.     break;
  348. case FCF_DCS:
  349.     if (frame.getFrameDataLength() < 4) return (false); // minimum acceptable DCS frame size
  350.     processDCSFrame(frame);
  351.     break;
  352. case FCF_DCN:
  353.     gotEOT = true;
  354.     recvdDCN = true;
  355.     break;
  356. }
  357. /*
  358.  * Sometimes echo is bad enough that we hear ourselves.  So if we hear DIS, we're probably
  359.  * hearing ourselves.  Just ignore it and listen again.
  360.  */
  361.     } while (!recvdDCN && (frame.moreFrames() || frame.getFCF() == FCF_DIS) && recvFrame(frame, FCF_RCVR, conf.t2Timer));
  362.     return (frame.isOK() && frame.getFCF() == FCF_DCS);
  363. }
  365. /*
  366.  * Receive training and analyze TCF.
  367.  */
  368. bool
  369. Class1Modem::recvTraining()
  370. {
  371.     if (useV34) {
  372. sendCFR = true;
  373. return (true);
  374.     }
  375.     /*
  376.      * It is possible (and with some modems likely) that the sending
  377.      * system has not yet dropped its V.21 carrier because the modem may
  378.      * simply signal OK when the HDLC frame is received completely and not
  379.      * not wait for the carrier drop to occur.  We don't follow the strategy 
  380.      * documented in T.31 Appendix II.1 about issuing another +FRH and 
  381.      * waiting for NO CARRIER because it's possible that the sender does not
  382.      * send enough V.21 HDLC after the last frame to make that work.
  383.      *
  384.      * The remote has to wait 75 +/- 20 ms after DCS before sending us TCF 
  385.      * as dictated by T.30 Chapter 5, Note 3.  If we have a modem that gives
  386.      * us an OK after DCS before the sender actually drops the carrier, then
  387.      * the best approach will be to simply look for silence with AT+FRS=1.
  388.      * Unfortunately, +FRS is not supported on all modems, and so when they
  389.      * need it, they will have to simply use a <delay:n> or possibly use
  390.      * a different command sequence.
  391.      *
  392.      */
  393.     if (!atCmd(conf.class1TCFRecvHackCmd, AT_OK)) {
  394. return (false);
  395.     }
  397.     protoTrace("RECV training at %s %s",
  398. modulationNames[curcap->mod],
  399. Class2Params::bitRateNames[curcap->br]);
  400.     HDLCFrame buf(conf.class1FrameOverhead);
  401.     bool ok = recvTCF(curcap->value, buf, frameRev, conf.class1TCFRecvTimeout);
  402.     if (curcap->mod == V17) senderHasV17Trouble = !ok; // if TCF failed
  403.     if (ok) { // check TCF data
  404. u_int n = buf.getLength();
  405. u_int nonzero = 0;
  406. u_int zerorun = 0;
  407. u_int i = 0;
  408. /*
  409.  * Skip any initial non-zero training noise.
  410.  */
  411. while (i < n && buf[i] != 0)
  412.     i++;
  413. /*
  414.  * Determine number of non-zero bytes and
  415.  * the longest zero-fill run in the data.
  416.  */
  417. if (i < n) {
  418.     while (i < n) {
  419. u_int j;
  420. for (; i < n && buf[i] != 0; i++)
  421.     nonzero++;
  422. for (j = i; j < n && buf[j] == 0; j++)
  423.     ;
  424. if (j-i > zerorun)
  425.     zerorun = j-i;
  426. i = j;
  427.     }
  428. } else {
  429.     /*
  430.      * There was no non-zero data.
  431.      */
  432.     nonzero = n;
  433. }
  434. /*
  435.  * Our criteria for accepting is that there must be
  436.  * no more than 10% non-zero (bad) data and the longest
  437.  * zero-run must be at least at least 2/3'rds of the
  438.  * expected TCF duration.  This is a hack, but seems
  439.  * to work well enough.  What would be better is to
  440.  * anaylze the bit error distribution and decide whether
  441.  * or not we would receive page data with <N% error,
  442.  * where N is probably ~5.  If we had access to the
  443.  * modem hardware, the best thing that we could probably
  444.  * do is read the Eye Quality register (or similar)
  445.  * and derive an indicator of the real S/N ratio.
  446.  */
  447. u_int fullrun = params.transferSize(TCF_DURATION);
  448. u_int minrun = params.transferSize(conf.class1TCFMinRun);
  449. if (params.ec != EC_DISABLE && conf.class1TCFMinRunECMMod > 0) {
  450.     /*
  451.      * When using ECM it may not be wise to fail TCF so easily
  452.      * as retransmissions can compensate for data corruption.
  453.      * For example, if there is a regular disturbance in the 
  454.      * audio every second that will cause TCFs to fail, but where
  455.      * the majority of the TCF data is "clean", then it will
  456.      * likely be better to pass TCF more easily at the faster
  457.      * rate rather than letting things slow down where the 
  458.      * disturbance will only cause slower retransmissions (and
  459.      * more of them, too).
  460.      */
  461.     minrun /= conf.class1TCFMinRunECMMod;
  462. }
  463. nonzero = (100*nonzero) / (n == 0 ? 1 : n);
  464. protoTrace("RECV: TCF %u bytes, %u%% non-zero, %u zero-run",
  465.     n, nonzero, zerorun);
  466. if (zerorun < fullrun && nonzero > conf.class1TCFMaxNonZero) {
  467.     protoTrace("RECV: reject TCF (too many non-zero, max %u%%)",
  468. conf.class1TCFMaxNonZero);
  469.     ok = false;
  470. }
  471. if (zerorun < minrun) {
  472.     protoTrace("RECV: reject TCF (zero run too short, min %u)", minrun);
  473.     ok = false;
  474. }
  475. if (!wasTimeout()) {
  476.     /*
  477.      * We expect the message carrier to drop.  However, some senders will
  478.      * transmit garbage after we see <DLE><ETX> but before we see NO CARRIER.
  479.      */
  480.     time_t nocarrierstart = Sys::now();
  481.     bool gotnocarrier = false;
  482.     do {
  483. gotnocarrier = waitFor(AT_NOCARRIER, 2*1000);
  484.     } while (!gotnocarrier && Sys::now() < (nocarrierstart + 5));
  485. }
  486.     } else {
  487. // the CONNECT is waited for later...
  488. if (lastResponse == AT_FCERROR && atCmd(rhCmd, AT_NOTHING)) lastResponse = AT_FRH3;
  489. if (lastResponse == AT_FRH3) return (false); // detected V.21 carrier
  490.     }
  491.     /*
  492.      * Send training response; we follow the spec
  493.      * by delaying 75ms before switching carriers.
  494.      */
  495.     fxStr emsg;
  496.     if (!switchingPause(emsg)) return (false);
  497.     if (ok) {
  498. /*
  499.  * Send CFR later so that we can cancel
  500.  * session by DCN if it's needed. 
  501.  */
  502. sendCFR = true;
  503. protoTrace("TRAINING succeeded");
  504.     } else {
  505. transmitFrame(FCF_FTT|FCF_RCVR);
  506. sendCFR = false;
  507. protoTrace("TRAINING failed");
  508.     }
  509.     return (ok);
  510. }
  512. void
  513. Class1Modem::processNewCapabilityUsage()
  514. {
  515.     capsUsed |= BIT(curcap->num); // add this modulation+bitrate to the used list
  516.     if ((capsUsed & 0x94) == 0x94) {
  517. senderSkipsV29 = ((capsUsed & 0xDC) == 0x94);
  518.     }
  519. }
  521. /*
  522.  * Process a received DCS frame.
  523.  */
  524. void
  525. Class1Modem::processDCSFrame(const HDLCFrame& frame)
  526. {
  527.     FaxParams dcs_caps = frame.getDIS(); // NB: really DCS
  529.     if (dcs_caps.isBitEnabled(FaxParams::BITNUM_FRAMESIZE_DCS)) frameSize = 64;
  530.     else frameSize = 256;
  531.     params.setFromDCS(dcs_caps);
  532.     if (useV34) params.br = primaryV34Rate-1;
  533.     else {
  534. curcap = findSRCapability((dcs_caps.getByte(1)<<8)&DCS_SIGRATE, recvCaps);
  535. processNewCapabilityUsage();
  536.     }
  537.     setDataTimeout(60, params.br);
  538.     recvDCS(params); // announce session params
  539. }
  541. const u_int Class1Modem::modemPPMCodes[8] = {
  542.     0, // 0
  543.     PPM_EOM, // FCF_EOM+FCF_PRI_EOM
  544.     PPM_MPS, // FCF_MPS+FCF_PRI_MPS
  545.     0, // 3
  546.     PPM_EOP, // FCF_EOP+FCF_PRI_EOP
  547.     0, // 5
  548.     0, // 6
  549.     0, // 7
  550. };
  552. /*
  553.  * Receive a page of data.
  554.  *
  555.  * This routine is called after receiving training or after
  556.  * sending a post-page response in a multi-page document.
  557.  */
  558. bool
  559. Class1Modem::recvPage(TIFF* tif, u_int& ppm, fxStr& emsg, const fxStr& id)
  560. {
  561.     if (lastPPM == FCF_MPS && prevPage) {
  562. /*
  563.  * Resume sending HDLC frame (send data)
  564.  * The carrier is already raised.  Thus we
  565.  * use sendFrame() instead of transmitFrame().
  566.  */
  567. if (pageGood) {
  568.     startTimeout(7550);
  569.     (void) sendFrame((sendERR ? FCF_ERR : FCF_MCF)|FCF_RCVR);
  570.     stopTimeout("sending HDLC frame");
  571.     lastMCF = Sys::now();
  572. } else if (conf.badPageHandling == FaxModem::BADPAGE_RTNSAVE) {
  573.     startTimeout(7550);
  574.     (void) sendFrame(FCF_RTN|FCF_RCVR);
  575.     stopTimeout("sending HDLC frame");
  576.     FaxParams dis = modemDIS();
  577.     if (!recvIdentification(0, fxStr::null, 0, fxStr::null, 
  578. 0, fxStr::null, 0, fxStr::null, 0, dis,
  579. conf.class1RecvIdentTimer, true, emsg)) {
  580. return (false);
  581.     }
  582. }
  583.     }
  585.     time_t t2end = 0;
  586.     signalRcvd = 0;
  587.     sendERR = false;
  588.     gotCONNECT = true;
  590.     do {
  591. ATResponse rmResponse = AT_NOTHING;
  592. long timer = conf.t2Timer;
  593. if (!messageReceived) {
  594.     if (sendCFR ) {
  595. transmitFrame(FCF_CFR|FCF_RCVR);
  596. sendCFR = false;
  597.     }
  598.     pageGood = pageStarted = false;
  599.     resetLineCounts(); // in case we don't make it to initializeDecoder
  600.     recvSetupTIFF(tif, group3opts, FILLORDER_LSB2MSB, id);
  601.     rmResponse = AT_NOTHING;
  602.     if (params.ec != EC_DISABLE || useV34) {
  603. pageGood = recvPageData(tif, emsg);
  604. messageReceived = true;
  605. prevPage++;
  606.     } else {
  607. /*
  608.  * Look for message carrier and receive Phase C data.
  609.  */
  610. /*
  611.  * Same reasoning here as before receiving TCF.
  612.  */
  613. if (!atCmd(conf.class1MsgRecvHackCmd, AT_OK)) {
  614.     emsg = "Failure to receive silence (synchronization failure). {E100}";
  615.     return (false);
  616. }
  617. /*
  618.  * Set high speed carrier & start receive.  If the
  619.  * negotiated modulation technique includes short
  620.  * training, then we use it here (it's used for all
  621.  * high speed carrier traffic other than the TCF).
  622.  *
  623.  * Timing here is very critical.  It is more "tricky" than timing
  624.  * for AT+FRM for TCF because unlike with TCF, where the direction
  625.  * of communication doesn't change, here it does change because 
  626.  * we just sent CFR but now have to do AT+FRM.  In practice, if we 
  627.  * issue AT+FRM after the sender does AT+FTM then we'll get +FCERROR.
  628.  * Using Class1MsgRecvHackCmd often only complicates the problem.
  629.  * If the modem doesn't drop its transmission carrier (OK response
  630.  * following CFR) quickly enough, then we'll see more +FCERROR.
  631.  */
  632. fxStr rmCmd(curcap[HasShortTraining(curcap)].value, rmCmdFmt);
  633. u_short attempts = 0;
  634. do {
  635.     (void) atCmd(rmCmd, AT_NOTHING);
  636.     rmResponse = atResponse(rbuf, conf.class1RMPersistence ? conf.t2Timer + 2900 : conf.t2Timer - 2900);
  637. } while ((rmResponse == AT_NOTHING || rmResponse == AT_FCERROR) && ++attempts < conf.class1RMPersistence);
  638. if (rmResponse == AT_CONNECT) {
  639.     /*
  640.      * We don't want the AT+FRM=n command to get buffered,
  641.      * so buffering and flow control must be done after CONNECT.
  642.      */
  643.     setInputBuffering(true);
  644.     if (flowControl == FLOW_XONXOFF)
  645. (void) setXONXOFF(FLOW_NONE, FLOW_XONXOFF, ACT_FLUSH);
  646.     /*
  647.      * The message carrier was recognized;
  648.      * receive the Phase C data.
  649.      */
  650.     protoTrace("RECV: begin page");
  651.     pageGood = recvPageData(tif, emsg);
  652.     protoTrace("RECV: end page");
  653.     if (!wasTimeout()) {
  654. /*
  655.  * The data was received correctly, wait
  656.  * for the modem to signal carrier drop.
  657.  */
  658. time_t nocarrierstart = Sys::now();
  659. do {
  660.     messageReceived = waitFor(AT_NOCARRIER, 5*1000);
  661. } while (!messageReceived && Sys::now() < (nocarrierstart + 5));
  662. if (messageReceived)
  663.     prevPage++;
  664.         timer = BIT(curcap->br) & BR_ALL ? 273066 / (curcap->br+1) : conf.t2Timer; // wait longer for PPM (estimate 80KB)
  665.     }
  666. } else {
  667.     if (wasTimeout()) {
  668. abortReceive(); // return to command mode
  669. setTimeout(false);
  670.     }
  671.     bool getframe = false;
  672.     long wait = BIT(curcap->br) & BR_ALL ? 273066 / (curcap->br+1) : conf.t2Timer;
  673.     if (rmResponse == AT_FRH3) getframe = waitFor(AT_CONNECT, 0);
  674.     else if (rmResponse != AT_NOCARRIER && rmResponse != AT_ERROR) getframe = atCmd(rhCmd, AT_CONNECT, wait); // wait longer
  675.     if (getframe) {
  676. HDLCFrame frame(conf.class1FrameOverhead);
  677. if (recvFrame(frame, FCF_RCVR, conf.t2Timer, true)) {
  678.     traceFCF("RECV recv", frame.getFCF());
  679.     signalRcvd = frame.getFCF();
  680.     messageReceived = true;
  681. }
  682.     }
  683. }
  684.     }
  685.     if (signalRcvd != 0) {
  686. if (flowControl == FLOW_XONXOFF)
  687.     (void) setXONXOFF(FLOW_NONE, FLOW_NONE, ACT_DRAIN);
  688. setInputBuffering(false);
  689.     }
  690.     if (!messageReceived && rmResponse != AT_FCERROR && rmResponse != AT_FRH3) {
  691. if (rmResponse != AT_ERROR) {
  692.     /*
  693.      * One of many things may have happened:
  694.      * o if we lost carrier, then some modems will return
  695.      *   AT_NOCARRIER or AT_EMPTYLINE in response to the
  696.      *   AT+FRM request.
  697.      * o otherwise, there may have been a timeout receiving
  698.      *   the message data, or there was a timeout waiting
  699.      *   for the carrier to drop.
  700.      */
  701.     if (!wasTimeout()) {
  702. /*
  703.  * We found the wrong carrier, which means that there
  704.  * is an HDLC frame waiting for us--in which case it
  705.  * should get picked up below.
  706.  */
  707. break;
  708.     }
  709.     /*
  710.      * The timeout expired - thus we missed the carrier either
  711.      * raising or dropping.
  712.      */
  713.     abortReceive(); // return to command state
  714.     break;
  715. } else {
  716.     /*
  717.      * Some modems respond ERROR instead +FCERROR on wrong carrier
  718.      * and not return to command state.
  719.      */
  720.     abortReceive(); // return to command state
  721. }
  722.     }
  723. }
  724. /*
  725.  * T.30 says to process operator intervention requests
  726.  * here rather than before the page data is received.
  727.  * This has the benefit of not recording the page as
  728.  * received when the post-page response might need to
  729.  * be retransmited.
  730.  */
  731. if (abortRequested()) {
  732.     // XXX no way to purge TIFF directory
  733.     emsg = "Receive aborted due to operator intervention {E301}";
  734.     return (false);
  735. }
  737. /*
  738.  * Acknowledge PPM from ECM protocol.
  739.  */
  740. HDLCFrame frame(conf.class1FrameOverhead);
  741. bool ppmrcvd;
  742. if (signalRcvd != 0) {
  743.     ppmrcvd = true;
  744.     lastPPM = signalRcvd;
  745.     for (u_int i = 0; i < frameRcvd.length(); i++) frame.put(frameRcvd[i]);
  746.     frame.setOK(true);
  747. } else {
  748.     gotCONNECT = false;
  749.     u_short recvFrameCount = 0;
  750.     do {
  751. /*
  752.  * Some modems will report CONNECT erroniously on high-speed Phase C data.
  753.  * Then they will time-out on HDLC data presentation instead of dumping
  754.  * garbage or quickly resulting ERROR.  So we give instances where CONNECT
  755.  * occurs a bit more tolerance here...
  756.  */
  757. ppmrcvd = recvFrame(frame, FCF_RCVR, timer);
  758.     } while (!ppmrcvd && gotCONNECT && wasTimeout() && !gotEOT && ++recvFrameCount < 3);
  759.     if (ppmrcvd) lastPPM = frame.getFCF();
  760. }
  761. /*
  762.  * Do command received logic.
  763.  */
  764. if (ppmrcvd) {
  765.     switch (lastPPM) {
  766.     case FCF_DIS: // XXX no support
  767. if (!pageGood) recvResetPage(tif);
  768. protoTrace("RECV DIS/DTC");
  769. emsg = "Can not continue after DIS/DTC {E107}";
  770. return (false);
  771.     case FCF_PWD:
  772.     case FCF_SUB:
  773.     case FCF_NSS:
  774.     case FCF_TSI:
  775.     case FCF_DCS:
  776. {
  777.     signalRcvd = 0;
  778.     if (!pageGood) recvResetPage(tif);
  779.     // look for high speed carrier only if training successful
  780.     messageReceived = !(FaxModem::recvBegin(NULL, emsg));
  781.     bool trainok = true;
  782.     short traincount = 0;
  783.     do {
  784. if (!messageReceived) messageReceived = !(recvDCSFrames(frame));
  785. if (recvdDCN) {
  786.     messageReceived = true;
  787.     signalRcvd = FCF_DCN;
  788.     lastResponse = AT_NOTHING;
  789.     return (false);
  790. }
  791. if (!messageReceived) {
  792.     trainok = recvTraining();
  793.     messageReceived = (!trainok && lastResponse == AT_FRH3);
  794. }
  795.     } while (!trainok && traincount++ < 3 && lastResponse != AT_FRH3 && recvFrame(frame, FCF_RCVR, timer));
  796.     if (messageReceived && lastResponse == AT_FRH3 && waitFor(AT_CONNECT,0)) {
  797. messageReceived = false;
  798. if (recvFrame(frame, FCF_RCVR, conf.t2Timer, true)) {
  799.     messageReceived = true;
  800.     signalRcvd = frame.getFCF();
  801. }
  802. lastResponse = AT_NOTHING;
  803.     } else messageReceived = false;
  804.     break;
  805. }
  806.     case FCF_MPS: // MPS
  807.     case FCF_EOM: // EOM
  808.     case FCF_EOP: // EOP
  809.     case FCF_PRI_MPS: // PRI-MPS
  810.     case FCF_PRI_EOM: // PRI-EOM
  811.     case FCF_PRI_EOP: // PRI-EOP
  812. if (!getRecvEOLCount()) {
  813.     // We have a null page, don't save it because it makes readers fail.
  814.     pageGood = false;
  815.     if (params.ec != EC_DISABLE) {
  816. if (emsg == "") {
  817.     /*
  818.      * We negotiated ECM, got no valid ECM image data, and the 
  819.      * ECM page reception routines did not set an error message.
  820.      * The empty emsg is due to the ECM routines detecting a 
  821.      * non-ECM-specific partial-page signal and wants it to
  822.      * be handled here.  The sum total of all of this, and the 
  823.      * fact that we got MPS/EOP/EOM tells us that the sender
  824.      * is not using ECM.  In an effort to salvage the session we'll
  825.      * disable ECM now and try to continue.
  826.      */
  827.     params.ec = EC_DISABLE;
  828. } else
  829.     return (false);
  830.     }
  831. }
  832. if (!pageGood && conf.badPageHandling == FaxModem::BADPAGE_RTN)
  833.     recvResetPage(tif);
  834. if (signalRcvd == 0) traceFCF("RECV recv", lastPPM);
  836. /*
  837.  * [Re]transmit post page response.
  838.  */
  839. if (pageGood || (conf.badPageHandling == FaxModem::BADPAGE_RTNSAVE && getRecvEOLCount())) {
  840.     if (!pageGood) lastPPM = FCF_MPS; // FaxModem::BADPAGE_RTNSAVE
  841.     /*
  842.      * If post page message confirms the page
  843.      * that we just received, write it to disk.
  844.      */
  845.     if (messageReceived) {
  846. if (!useV34 && emsg == "") (void) switchingPause(emsg);
  847. /*
  848.  * On servers where disk access may be bottlenecked or stressed,
  849.  * the TIFFWriteDirectory call can lag.  The strategy, then, is
  850.  * to employ RNR/RR flow-control for ECM sessions and to use CRP
  851.  * in non-ECM sessions in order to grant TIFFWriteDirectory
  852.  * sufficient time to complete.
  853.  */
  854. int fcfd[2]; // flow control file descriptors for the pipe
  855. pid_t fcpid = -1; // flow control process id for the child
  856. if (pipe(fcfd) >= 0) {
  857.     fcpid = fork();
  858.     char tbuf[1]; // trigger signal
  859.     tbuf[0] = 0xFF;
  860.     time_t rrstart = Sys::now();
  861.     switch (fcpid) {
  862. case -1: // error
  863.     protoTrace("Protocol flow control unavailable due to fork error.");
  864.     TIFFWriteDirectory(tif);
  865.     Sys::close(fcfd[0]);
  866.     Sys::close(fcfd[1]);
  867.     break;
  868. case 0: // child
  869.     Sys::close(fcfd[1]);
  870.     do {
  871. fd_set rfds;
  872. FD_ZERO(&rfds);
  873. FD_SET(fcfd[0], &rfds);
  874. struct timeval tv;
  875. tv.tv_sec = 2; // we've got a 3-second window, use it
  876. tv.tv_usec = 0;
  877. #if CONFIG_BADSELECTPROTO
  878. if (!select(fcfd[0]+1, (int*) &rfds, NULL, NULL, &tv)) {
  879. #else
  880. if (!select(fcfd[0]+1, &rfds, NULL, NULL, &tv)) {
  881. #endif
  882.     bool gotresponse = true;
  883.     u_short rnrcnt = 0;
  884.     do {
  885. if (emsg != "") break;
  886. (void) transmitFrame(params.ec != EC_DISABLE ? FCF_RNR : FCF_CRP|FCF_RCVR);
  887. traceFCF("RECV send", params.ec != EC_DISABLE ? FCF_RNR : FCF_CRP);
  888. HDLCFrame rrframe(conf.class1FrameOverhead);
  889. gotresponse = recvFrame(rrframe, FCF_RCVR, conf.t2Timer);
  890. if (gotresponse) {
  891.     traceFCF("RECV recv", rrframe.getFCF());
  892.     if (rrframe.getFCF() == FCF_DCN) {
  893. protoTrace("RECV recv DCN");
  894. emsg = "COMREC received DCN (sender abort) {E108}";
  895. gotEOT = true;
  896. recvdDCN = true;
  897.     } else if (params.ec != EC_DISABLE && rrframe.getFCF() != FCF_RR) {
  898. protoTrace("Ignoring invalid response to RNR.");
  899.     }
  900.     if (!useV34) (void) switchingPause(emsg);
  901. }
  902.     } while (!gotEOT && !recvdDCN && !gotresponse && ++rnrcnt < 2 && Sys::now()-rrstart < 60);
  903.     if (!gotresponse) emsg = "No response to RNR repeated 3 times. {E109}";
  904. } else { // parent finished TIFFWriteDirectory
  905.     tbuf[0] = 0;
  906. }
  907.     } while (!gotEOT && !recvdDCN && tbuf[0] != 0 && Sys::now()-rrstart < 60);
  908.     Sys::read(fcfd[0], NULL, 1);
  909.     _exit(0);
  910. default: // parent
  911.     Sys::close(fcfd[0]);
  912.     TIFFWriteDirectory(tif);
  913.     Sys::write(fcfd[1], tbuf, 1);
  914.     (void) Sys::waitpid(fcpid);
  915.     Sys::close(fcfd[1]);
  916.     break;
  917.     }
  918. } else {
  919.     protoTrace("Protocol flow control unavailable due to pipe error.");
  920.     TIFFWriteDirectory(tif);
  921. }
  922. if (emsg == "") { // confirm only if there was no error
  923.     if (pageGood) {
  924. traceFCF("RECV send", sendERR ? FCF_ERR : FCF_MCF);
  925. lastMCF = Sys::now();
  926.     } else
  927. traceFCF("RECV send", FCF_RTN);
  929.     if (lastPPM == FCF_MPS) {
  930. /*
  931.  * Raise the HDLC transmission carrier but do not
  932.  * transmit MCF now.  This gives us at least a 3-second
  933.  * window to buffer any delays in the post-page
  934.  * processes.
  935.  */
  936. if (!useV34 && !atCmd(thCmd, AT_CONNECT)) {
  937.     emsg = "Failure to raise V.21 transmission carrier. {E101}";
  938.     return (false);
  939. }
  940.     } else {
  941. (void) transmitFrame((sendERR ? FCF_ERR : FCF_MCF)|FCF_RCVR);
  942. lastMCF = Sys::now();
  943. if (lastPPM == FCF_EOP) {
  944.     /*
  945.      * Because there are a couple of notifications that occur after this
  946.      * things can hang and we can miss hearing DCN.  So we do it now.
  947.      */
  948.     recvdDCN = recvEnd(NULL, emsg);
  949. }
  950.     }
  951. }
  952. /*
  953.  * Reset state so that the next call looks
  954.  * first for page carrier or frame according
  955.  * to what's expected.  (Grr, where's the
  956.  * state machine...)
  957.  */
  958. messageReceived = (lastPPM == FCF_EOM);
  959. ppm = modemPPMCodes[lastPPM&7];
  960. return (true);
  961.     }
  962. } else {
  963.     /*
  964.      * Page not received, or unacceptable; tell
  965.      * other side to retransmit after retrain.
  966.      */
  967.     /*
  968.      * As recommended in T.31 Appendix II.1, we try to
  969.      * prevent the rapid switching of the direction of 
  970.      * transmission by using +FRS.  Theoretically, "OK"
  971.      * is the only response, but if the sender has not
  972.      * gone silent, then we cannot continue anyway,
  973.      * and aborting here will give better information.
  974.      *
  975.      * Using +FRS is better than a software pause, which
  976.      * could not ensure loss of carrier.  +FRS is easier
  977.      * to implement than using +FRH and more reliable than
  978.      * using +FTS
  979.      */
  980.     if (!switchingPause(emsg)) {
  981. return (false);
  982.     }
  983.     signalRcvd = 0;
  984.     if (params.ec == EC_DISABLE && rmResponse != AT_CONNECT && !getRecvEOLCount() && (Sys::now() - lastMCF < 9)) {
  985. /*
  986.  * We last transmitted MCF a very, very short time ago, received no image data
  987.  * since then, and now we're seeing a PPM again.  In non-ECM mode the chances of 
  988.  * this meaning that we simply missed a very short page is extremely remote.  It
  989.  * probably means that the sender did not properly hear our MCF and that we just
  990.  * need to retransmit it. 
  991.  */
  992. (void) transmitFrame(FCF_MCF|FCF_RCVR);
  993. traceFCF("RECV send", FCF_MCF);
  994. lastMCF = Sys::now();
  995. messageReceived = (lastPPM != FCF_MPS); // expect Phase C if MPS
  996.     } else {
  997. u_int rtnfcf = FCF_RTN;
  998. if (!getRecvEOLCount() || conf.badPageHandling == FaxModem::BADPAGE_DCN) {
  999.     /*
  1000.      * Regardless of the BadPageHandling setting, if we get no page image data at
  1001.      * all, then sending RTN at all risks confirming the non-page to RTN-confused 
  1002.      * senders, which risk is far worse than just simply hanging up.
  1003.      */
  1004.     emsg = "PPM received with no image data.  To continue risks receipt confirmation. {E155}";
  1005.     rtnfcf = FCF_DCN;
  1006. }
  1007. (void) transmitFrame(rtnfcf|FCF_RCVR);
  1008. traceFCF("RECV send", rtnfcf);
  1009. if (rtnfcf == FCF_DCN) {
  1010.     recvdDCN = true;
  1011.     return (false);
  1012. }
  1013. /*
  1014.  * Reset the TIFF-related state so that subsequent
  1015.  * writes will overwrite the previous data.
  1016.  */
  1017. messageReceived = true; // expect DCS next
  1018.     }
  1019. }
  1020. break;
  1021.     case FCF_CRP:
  1022. // command repeat... just repeat whatever we last sent
  1023. if (!useV34 && !switchingPause(emsg)) return (false);
  1024. transmitFrame(signalSent);
  1025. traceFCF("RECV send", (u_char) signalSent[2]);
  1026. /* fall through - to clear messageReceived and signalRcvd */
  1027.     case FCF_MCF:
  1028.     case FCF_CFR:
  1029. /* It's probably just our own echo. */
  1030. messageReceived = false;
  1031. signalRcvd = 0;
  1032. break;
  1033.     case FCF_DCN: // DCN
  1034. protoTrace("RECV recv DCN");
  1035. emsg = "COMREC received DCN (sender abort) {E108}";
  1036. recvdDCN = true;
  1037. if (prevPage && conf.saveUnconfirmedPages && getRecvEOLCount()) { // only if there was data
  1038.     TIFFWriteDirectory(tif);
  1039.     protoTrace("RECV keeping unconfirmed page");
  1040.     return (true);
  1041. }
  1042. return (false);
  1043.     default:
  1044. if (!pageGood) recvResetPage(tif);
  1045. emsg = "COMREC invalid response received {E110}";
  1046. return (false);
  1047.     }
  1048.     t2end = 0;
  1049. } else {
  1050.     /*
  1051.      * We didn't get a message.  Try to be resiliant by
  1052.      * looking for the signal again, but prevent infinite
  1053.      * looping with a timer.  However, if the modem is on
  1054.      * hook, then modem responds ERROR or NO CARRIER, and
  1055.      * for those cases there is no point in resiliancy.
  1056.      */
  1057.     if (lastResponse == AT_NOCARRIER || lastResponse == AT_ERROR) break;
  1058.     if (t2end) {
  1059. if (Sys::now() > t2end)
  1060.     break;
  1061.     } else {
  1062. t2end = Sys::now() + howmany(conf.t2Timer, 1000);
  1063.     }
  1064. }
  1065.     } while (gotCONNECT && !wasTimeout() && lastResponse != AT_EMPTYLINE);
  1066.     emsg = "V.21 signal reception timeout; expected page possibly not received in full {E111}";
  1067.     if (prevPage && conf.saveUnconfirmedPages && getRecvEOLCount()) {
  1068. TIFFWriteDirectory(tif);
  1069. protoTrace("RECV keeping unconfirmed page");
  1070. return (true);
  1071.     }
  1072.     return (false);
  1073. }
  1075. void
  1076. Class1Modem::abortPageRecv()
  1077. {
  1078.     if (useV34) return; // nothing to do in V.34
  1079.     char c = CAN; // anything other than DC1/DC3
  1080.     putModem(&c, 1, 1);
  1081. }
  1083. bool
  1084. Class1Modem::raiseRecvCarrier(bool& dolongtrain, fxStr& emsg)
  1085. {
  1086.     if (!atCmd(conf.class1MsgRecvHackCmd, AT_OK)) {
  1087. emsg = "Failure to receive silence (synchronization failure). {E100}";
  1088. return (false);
  1089.     }
  1090.     /*
  1091.      * T.30 Section 5, Note 5 states that we must use long training
  1092.      * on the first high-speed data message following CTR.
  1093.      */
  1094.     fxStr rmCmd;
  1095.     if (dolongtrain) rmCmd = fxStr(curcap->value, rmCmdFmt);
  1096.     else rmCmd = fxStr(curcap[HasShortTraining(curcap)].value, rmCmdFmt);
  1097.     u_short attempts = 0;
  1098.     lastResponse = AT_NOTHING;
  1099.     do {
  1100. (void) atCmd(rmCmd, AT_NOTHING);
  1101. lastResponse = atResponse(rbuf, conf.class1RMPersistence ? conf.t2Timer + 2900 : conf.t2Timer - 2900);
  1102.     } while ((lastResponse == AT_NOTHING || lastResponse == AT_FCERROR) && ++attempts < conf.class1RMPersistence);
  1103.     if (lastResponse == AT_ERROR) gotEOT = true; // on hook
  1104.     if (lastResponse == AT_FRH3 && waitFor(AT_CONNECT,0)) {
  1105. gotRTNC = true;
  1106. gotEOT = false;
  1107.     }
  1108.     if (lastResponse != AT_CONNECT && !gotRTNC) {
  1109. emsg = "Failed to properly detect high-speed data carrier. {E112}";
  1110. return (false);
  1111.     }
  1112.     dolongtrain = false;
  1113.     return (true);
  1114. }
  1116. void
  1117. Class1Modem::abortPageECMRecv(TIFF* tif, const Class2Params& params, u_char* block, u_int fcount, u_short seq, bool pagedataseen, fxStr& emsg)
  1118. {
  1119.     if (pagedataseen) {
  1120. writeECMData(tif, block, (fcount * frameSize), params, (seq |= 2), emsg);
  1121. if (conf.saveUnconfirmedPages) {
  1122.     protoTrace("RECV keeping unconfirmed page");
  1123.     prevPage++;
  1124. }
  1125.     }
  1126.     free(block);
  1127. }
  1129. /*
  1130.  * Receive Phase C data in T.30-A ECM mode.
  1131.  */
  1132. bool
  1133. Class1Modem::recvPageECMData(TIFF* tif, const Class2Params& params, fxStr& emsg)
  1134. {
  1135.     HDLCFrame frame(5); // A+C+FCF+FCS=5 bytes
  1136.     u_char* block = (u_char*) malloc(frameSize*256); // 256 frames per block - totalling 16/64KB
  1137.     fxAssert(block != NULL, "ECM procedure error (receive block).");
  1138.     memset(block, 0, (size_t) frameSize*256);
  1139.     bool lastblock = false;
  1140.     bool pagedataseen = false;
  1141.     u_short seq = 1; // sequence code for the first block
  1142.     prevBlock = 0;
  1144.     do {
  1145. u_int fnum = 0;
  1146. char ppr[32]; // 256 bits
  1147. for (u_int i = 0; i < 32; i++) ppr[i] = 0xff; // ppr defaults to all 1's, T.4 A.4.4
  1148. u_short rcpcnt = 0;
  1149. u_short pprcnt = 0;
  1150. u_int fcount = 0;
  1151. u_short syncattempts = 0;
  1152. bool blockgood = false, dolongtrain = false;
  1153. bool gotoPhaseD = false;
  1154. do {
  1155.     sendERR = false;
  1156.     resetBlock();
  1157.     signalRcvd = 0;
  1158.     rcpcnt = 0;
  1159.     bool dataseen = false;
  1160.     if (!useV34 && !gotoPhaseD) {
  1161. gotRTNC = false;
  1162. if (!raiseRecvCarrier(dolongtrain, emsg) && !gotRTNC) {
  1163.     if (wasTimeout()) {
  1164. abortReceive(); // return to command mode
  1165. setTimeout(false);
  1166.     }
  1167.     long wait = BIT(curcap->br) & BR_ALL ? 273066 / (curcap->br+1) : conf.t2Timer;
  1168.     if (lastResponse != AT_NOCARRIER && atCmd(rhCmd, AT_CONNECT, wait)) { // wait longer
  1169. // sender is transmitting V.21 instead, we may have
  1170. // missed the first signal attempt, but should catch
  1171. // the next attempt.  This "simulates" adaptive receive.
  1172. emsg = ""; // reset
  1173. gotRTNC = true;
  1174.     } else {
  1175. if (wasTimeout()) abortReceive();
  1176. abortPageECMRecv(tif, params, block, fcount, seq, pagedataseen, emsg);
  1177. return (false);
  1178.     }
  1179. }
  1180.     }
  1181.     if (useV34 || gotRTNC) { // V.34 mode or if +FRH:3 in adaptive reception
  1182. if (!gotEOT) {
  1183.     bool gotprimary = false;
  1184.     if (useV34) gotprimary = waitForDCEChannel(false);
  1185.     while (!sendERR && !gotEOT && (gotRTNC || (ctrlFrameRcvd != fxStr::null))) {
  1186. /*
  1187.  * Remote requested control channel retrain, the remote didn't
  1188.  * properly hear our last signal, and/or we got an EOR signal 
  1189.  * after PPR.  So now we have to use a signal from the remote
  1190.  * and then respond appropriately to get us back or stay in sync.
  1191.  * DCS::CFR - PPS::PPR/MCF - EOR::ERR
  1192.  */
  1193. HDLCFrame rtncframe(conf.class1FrameOverhead);
  1194. bool gotrtncframe = false;
  1195. if (useV34) {
  1196.     if (ctrlFrameRcvd != fxStr::null) {
  1197. gotrtncframe = true;
  1198. for (u_int i = 0; i < ctrlFrameRcvd.length(); i++)
  1199.     rtncframe.put(frameRev[ctrlFrameRcvd[i] & 0xFF]);
  1200. traceHDLCFrame("-->", rtncframe);
  1201.     } else
  1202. gotrtncframe = recvFrame(rtncframe, FCF_RCVR, conf.t2Timer);
  1203. } else {
  1204.     gotrtncframe = recvFrame(rtncframe, FCF_RCVR, conf.t2Timer, true);
  1205. }
  1206. if (gotrtncframe) {
  1207.     traceFCF("RECV recv", rtncframe.getFCF());
  1208.     switch (rtncframe.getFCF()) {
  1209. case FCF_PPS:
  1210.     if (rtncframe.getLength() > 5) {
  1211. u_int fc = frameRev[rtncframe[6]] + 1;
  1212. if ((fc == 256 || fc == 1) && !dataseen) fc = 0; // distinguish 0 from 1 and 256
  1213. traceFCF("RECV recv", rtncframe.getFCF2());
  1214. protoTrace("RECV received %u frames of block %u of page %u", 
  1215.     fc, frameRev[rtncframe[5]]+1, frameRev[rtncframe[4]]+1);
  1216. switch (rtncframe.getFCF2()) {
  1217.     case 0:  // PPS-NULL
  1218.     case FCF_EOM:
  1219.     case FCF_MPS:
  1220.     case FCF_EOP:
  1221.     case FCF_PRI_EOM:
  1222.     case FCF_PRI_MPS:
  1223.     case FCF_PRI_EOP:
  1224. if (!useV34 && !switchingPause(emsg)) {
  1225.     abortPageECMRecv(tif, params, block, fcount, seq, pagedataseen, emsg);
  1226.     return (false);
  1227. }
  1228. if (frameRev[rtncframe[4]] > prevPage || (frameRev[rtncframe[4]] == prevPage && frameRev[rtncframe[5]] >= prevBlock)) {
  1229.     (void) transmitFrame(FCF_PPR, fxStr(ppr, 32));
  1230.     traceFCF("RECV send", FCF_PPR);
  1231. } else {
  1232.     (void) transmitFrame(FCF_MCF|FCF_RCVR);
  1233.     traceFCF("RECV send", FCF_MCF);
  1234. }
  1235. break;
  1236. }
  1237.     }
  1238.     break;
  1239. case FCF_EOR:
  1240.     if (rtncframe.getLength() > 5) {
  1241. traceFCF("RECV recv", rtncframe.getFCF2());
  1242. switch (rtncframe.getFCF2()) {
  1243.     case 0:  // PPS-NULL
  1244.     case FCF_EOM:
  1245.     case FCF_MPS:
  1246.     case FCF_EOP:
  1247.     case FCF_PRI_EOM:
  1248.     case FCF_PRI_MPS:
  1249.     case FCF_PRI_EOP:
  1250. if (fcount) {
  1251.     /*
  1252.      * The block hasn't been written to disk.
  1253.      * This is expected when the sender sends
  1254.      * EOR after our PPR (e.g. after the 4th).
  1255.      */
  1256.     blockgood = true;
  1257.     signalRcvd = rtncframe.getFCF2();
  1258.     if (signalRcvd) lastblock = true;
  1259.     sendERR = true;
  1260. } else {
  1261.     if (!useV34 && !switchingPause(emsg)) {
  1262. abortPageECMRecv(tif, params, block, fcount, seq, pagedataseen, emsg);
  1263. return (false);
  1264.     }
  1265.     (void) transmitFrame(FCF_ERR|FCF_RCVR);
  1266.     traceFCF("RECV send", FCF_ERR);
  1267. }
  1268. break;
  1269. }
  1270.     }
  1271.     break;
  1272. case FCF_CTC:
  1273.     {
  1274. u_int dcs; // possible bits 1-16 of DCS in FIF
  1275. if (useV34) {
  1276.     // T.30 F.3.4.5 Note 1 does not permit CTC in V.34-fax
  1277.     emsg = "Received invalid CTC signal in V.34-Fax. {E113}";
  1278.     abortPageECMRecv(tif, params, block, fcount, seq, pagedataseen, emsg);
  1279.     return (false);
  1280. }
  1281. /*
  1282.  * See the other comments about T.30 A.1.3.  Some senders
  1283.  * are habitually wrong in sending CTC at incorrect moments.
  1284.  */
  1285. // use 16-bit FIF to alter speed, curcap
  1286. dcs = rtncframe[3] | (rtncframe[4]<<8);
  1287. curcap = findSRCapability(dcs&DCS_SIGRATE, recvCaps);
  1288. processNewCapabilityUsage();
  1289. // requisite pause before sending response (CTR)
  1290. if (!switchingPause(emsg)) {
  1291.     abortPageECMRecv(tif, params, block, fcount, seq, pagedataseen, emsg);
  1292.     return (false);
  1293. }
  1294. (void) transmitFrame(FCF_CTR|FCF_RCVR);
  1295. traceFCF("RECV send", FCF_CTR);
  1296. dolongtrain = true;
  1297. pprcnt = 0;
  1298. break;
  1299.     }
  1300. case FCF_CRP:
  1301.     // command repeat... just repeat whatever we last sent
  1302.     if (!useV34 && !switchingPause(emsg)) {
  1303. abortPageECMRecv(tif, params, block, fcount, seq, pagedataseen, emsg);
  1304. return (false);
  1305.     }
  1306.     transmitFrame(signalSent);
  1307.     traceFCF("RECV send", (u_char) signalSent[2]);
  1308.     break;
  1309. case FCF_DCN:
  1310.     emsg = "COMREC received DCN (sender abort) {E108}";
  1311.     gotEOT = true;
  1312.     recvdDCN = true;
  1313.     continue;
  1314. case FCF_MCF:
  1315. case FCF_CFR:
  1316. case FCF_CTR:
  1317.     if ((rtncframe[2] & 0x80) == FCF_RCVR) {
  1318. /*
  1319.  * Echo on the channel may be so lagged that we're hearing 
  1320.  * ourselves.  Ignore it.  Try again.
  1321.  */
  1322. break;
  1323.     }
  1324.     /* intentional pass-through */
  1325. default:
  1326.     // The message is not ECM-specific: fall out of ECM receive, and let
  1327.     // the earlier message-handling routines try to cope with the signal.
  1328.     signalRcvd = rtncframe.getFCF();
  1329.     messageReceived = true;
  1330.     abortPageECMRecv(tif, params, block, fcount, seq, pagedataseen, emsg);
  1331.     if (getRecvEOLCount() == 0) {
  1332. prevPage--; // counteract the forthcoming increment
  1333. return (true);
  1334.     } else {
  1335. emsg = "COMREC invalid response received {E110}"; // plain ol' error
  1336. return (false);
  1337.     }
  1338.     }
  1339.     if (!sendERR) { // as long as we're not trying to send the ERR signal (set above)
  1340.         if (useV34) gotprimary = waitForDCEChannel(false);
  1341. else {
  1342.     gotRTNC = false;
  1343.     if (!raiseRecvCarrier(dolongtrain, emsg) && !gotRTNC) {
  1344. if (wasTimeout()) {
  1345.     abortReceive(); // return to command mode
  1346.     setTimeout(false);
  1347. }
  1348. long wait = BIT(curcap->br) & BR_ALL ? 273066 / (curcap->br+1) : conf.t2Timer;
  1349. if (lastResponse != AT_NOCARRIER && atCmd(rhCmd, AT_CONNECT, wait)) { // wait longer
  1350.     // simulate adaptive receive
  1351.     emsg = ""; // clear the failure
  1352.     gotRTNC = true;
  1353. } else {
  1354.     if (wasTimeout()) abortReceive();
  1355.     abortPageECMRecv(tif, params, block, fcount, seq, pagedataseen, emsg);
  1356.     return (false);
  1357. }
  1358.     } else gotprimary = true;
  1359. }
  1360.     }
  1361. } else {
  1362.     gotprimary = false;
  1363.     if (!useV34) {
  1364. if (wasTimeout()) {
  1365.     abortReceive();
  1366.     break;
  1367. }
  1368. if (lastResponse == AT_NOCARRIER || lastResponse == AT_ERROR ||
  1369.     !atCmd(rhCmd, AT_CONNECT, conf.t1Timer)) break;
  1370.     }
  1371. }
  1372.     }
  1373.     if (!gotprimary && !sendERR) {
  1374. if (emsg == "") {
  1375.     if (useV34) emsg = "Failed to properly open V.34 primary channel. {E114}";
  1376.     else emsg = "Failed to properly detect high-speed data carrier. {E112}";
  1377. }
  1378. protoTrace(emsg);
  1379. abortPageECMRecv(tif, params, block, fcount, seq, pagedataseen, emsg);
  1380. return (false);
  1381.     }
  1382. }
  1383. if (gotEOT) { // intentionally not an else of the previous if
  1384.     if (useV34 && emsg == "") emsg = "Received premature V.34 termination. {E115}";
  1385.     protoTrace(emsg);
  1386.     abortPageECMRecv(tif, params, block, fcount, seq, pagedataseen, emsg);
  1387.     return (false);
  1388. }
  1389.     }
  1390.     /*
  1391.      * Buffering and flow control must be done after AT+FRM=n.
  1392.      */
  1393.     setInputBuffering(true);
  1394.     if (flowControl == FLOW_XONXOFF)
  1395. (void) setXONXOFF(FLOW_NONE, FLOW_XONXOFF, ACT_FLUSH);
  1396.     gotoPhaseD = false;
  1397.     if (!sendERR && (useV34 || syncECMFrame())) { // no synchronization needed w/V.34-fax
  1398. time_t start = Sys::now();
  1399. do {
  1400.     frame.reset();
  1401.     if (recvECMFrame(frame)) {
  1402. if (frame[2] == 0x60) { // FCF is FCD
  1403.     dataseen = true;
  1404.     pagedataseen = true;
  1405.     rcpcnt = 0; // reset RCP counter
  1406.     fnum = frameRev[frame[3]]; // T.4 A.3.6.1 says LSB2MSB
  1407.     protoTrace("RECV received frame number %u", fnum);
  1408.     if (frame.checkCRC()) {
  1409. // store received frame in block at position fnum (A+C+FCF+Frame No.=4 bytes)
  1410. for (u_int i = 0; i < frameSize; i++) {
  1411.     if (frame.getLength() - 6 > i) // (A+C+FCF+Frame No.+FCS=6 bytes)
  1412. block[fnum*frameSize+i] = frameRev[frame[i+4]]; // LSB2MSB
  1413. }
  1414. if (fcount < (fnum + 1)) fcount = fnum + 1;
  1415. // valid frame, set the corresponding bit in ppr to 0
  1416. u_int pprpos, pprval;
  1417. for (pprpos = 0, pprval = fnum; pprval >= 8; pprval -= 8) pprpos++;
  1418. if (ppr[pprpos] & frameRev[1 << pprval]) ppr[pprpos] ^= frameRev[1 << pprval];
  1419.     } else {
  1420. protoTrace("RECV frame FCS check failed");
  1421.     }
  1422. } else if (frame[2] == 0x61 && frame.checkCRC()) { // FCF is RCP
  1423.     rcpcnt++;
  1424. } else {
  1425.     dataseen = true;
  1426.     protoTrace("HDLC frame with bad FCF %#x", frame[2]);
  1427. }
  1428.     } else {
  1429. dataseen = true; // assume that garbage was meant to be data
  1430. if (!useV34) syncECMFrame();
  1431. if (useV34 && (gotEOT || gotCTRL)) rcpcnt = 3;
  1432.     }
  1433.     // some senders don't send the requisite three RCP signals
  1434. } while (rcpcnt == 0 && (unsigned) Sys::now()-start < 5*60); // can't expect 50 ms of flags, some violate T.4 A.3.8
  1435. if (flowControl == FLOW_XONXOFF)
  1436.     (void) setXONXOFF(FLOW_NONE, FLOW_NONE, ACT_DRAIN);
  1437. setInputBuffering(false);
  1438. if (useV34) {
  1439.     if (!gotEOT && !gotCTRL && !waitForDCEChannel(true)) {
  1440. emsg = "Failed to properly open V.34 control channel. {E116}";
  1441. protoTrace(emsg);
  1442. abortPageECMRecv(tif, params, block, fcount, seq, pagedataseen, emsg);
  1443. return (false);
  1444.     }
  1445.     if (gotEOT) {
  1446. emsg = "Received premature V.34 termination. {E115}";
  1447. protoTrace(emsg);
  1448. abortPageECMRecv(tif, params, block, fcount, seq, pagedataseen, emsg);
  1449. return (false);
  1450.     }
  1451. } else {
  1452.     if (!endECMBlock()) { // wait for <DLE><ETX>
  1453. if (wasTimeout()) {
  1454.     abortReceive();
  1455.     emsg = "Timeout waiting for Phase C carrier drop. {E154}";
  1456.     protoTrace(emsg);
  1457.     abortPageECMRecv(tif, params, block, fcount, seq, pagedataseen, emsg);
  1458.     return (false);
  1459. }
  1460.     }
  1461. }
  1462. if (!useV34) {
  1463.     // wait for message carrier to drop
  1464.     time_t nocarrierstart = Sys::now();
  1465.     bool gotnocarrier = false;
  1466.     do {
  1467. gotnocarrier = waitFor(AT_NOCARRIER, 2*1000);
  1468.     } while (!gotnocarrier && lastResponse != AT_EMPTYLINE && Sys::now() < (nocarrierstart + 5));
  1469. }
  1470. bool gotpps = false;
  1471. HDLCFrame ppsframe(conf.class1FrameOverhead);
  1472. u_short recvFrameCount = 0;
  1473. do {
  1474.     /*
  1475.      * It is possible that the high-speed carrier drop was
  1476.      * detected in error or that some line noise caused it but
  1477.      * that the sender has not disconnected.  It is possible
  1478.      * then, that T2 will not be long enough to receive the
  1479.      * partial-page signal because the sender is still transmitting
  1480.      * high-speed data.  So we calculate the wait for 80KB (the 
  1481.      * ECM block plus some wriggle-room) at the current bitrate.
  1482.      */
  1483.     u_int br = useV34 ? primaryV34Rate : curcap->br + 1;
  1484.     long wait = br >= 1 && br <= 15 ? 273066 / br : conf.t2Timer;
  1485.     gotpps = recvFrame(ppsframe, FCF_RCVR, wait); // wait longer
  1486. } while (!gotpps && gotCONNECT && !wasTimeout() && !gotEOT && ++recvFrameCount < 5);
  1487. if (gotpps) {
  1488.     traceFCF("RECV recv", ppsframe.getFCF());
  1489.     if (ppsframe.getFCF() == FCF_PPS) {
  1490. // sender may violate T.30-A.4.3 and send another signal (i.e. DCN)
  1491. traceFCF("RECV recv", ppsframe.getFCF2());
  1492.     }
  1493.     switch (ppsframe.getFCF()) {
  1494. /*
  1495.  * PPS is the only valid signal, Figure A.8/T.30; however, some
  1496.  * senders don't handle T.30 A.1.3 ("When PPR is received four
  1497.  * times for the same block...") properly (possibly because T.30
  1498.  * A.4.1 isn't clear about the "per-block" requirement), and so
  1499.  * it is possible for us to get CTC or EOR here (if the modem
  1500.  * quickly reported NO CARRIER when we went looking for the
  1501.  * non-existent high-speed carrier and the sender is persistent).
  1502.  *
  1503.  * CRP is a bizarre signal to get instead of PPS, but some
  1504.  * senders repeatedly transmit this instead of PPS.  So to
  1505.  * handle it as best as possible we interpret the signal as
  1506.  * meaning PPS-NULL (full block) unless there was no data seen
  1507.  * (in which case PPS-MPS is assumed) in order to prevent 
  1508.  * any data loss, and we let the sender cope with it from there.
  1509.  */
  1510. case FCF_PPS:
  1511. case FCF_CRP:
  1512.     {
  1513. u_int fc = ppsframe.getFCF() == FCF_CRP ? 256 : frameRev[ppsframe[6]] + 1;
  1514. if ((fc == 256 || fc == 1) && !dataseen) fc = 0; // distinguish 0 from 1 and 256
  1515. if (fcount < fc) fcount = fc;
  1516. if (ppsframe.getFCF() == FCF_CRP) {
  1517.     if (fc) ppsframe[3] = 0x00; // FCF2 = NULL
  1518.     else ppsframe[3] = FCF_MPS;
  1519.     protoTrace("RECV unexpected CRP - assume %u frames of block %u of page %u", 
  1520. fc, prevBlock + 1, prevPage + 1);
  1521. } else {
  1522.     protoTrace("RECV received %u frames of block %u of page %u", 
  1523. fc, frameRev[ppsframe[5]]+1, frameRev[ppsframe[4]]+1);
  1524. }
  1525. blockgood = true;
  1526. /*
  1527.  * The sender may send no frames.  This will happen for at least three
  1528.  * reasons.
  1529.  *
  1530.  * 1) If we previously received data from this block and responded
  1531.  * with PPR but the sender is done retransmitting frames as the sender
  1532.  * thinks that our PPR signal did not indicate any frame that the 
  1533.  * sender transmitted.  This should only happen with the last frame
  1534.  * of a block due to counting errors.  So, in the case where we received
  1535.  * no frames from the sender we ignore the last frame in the block when
  1536.  * checking.
  1537.  *
  1538.  * 2) The sender feeds paper into a scanner during the initial
  1539.  * synchronization and it expected another page but didn't get it 
  1540.  * (e.g. paper feed problem).  We respond with a full PPR in hopes that
  1541.  * the sender knows what they're doing by sending PPS instead of DCN.
  1542.  * The sender can recover by sending data with the block retransmission.
  1543.  *
  1544.  * 3) The sender sent only one frame but for some reason we did not see
  1545.  * any data, and so the frame-count in the PPS signal ended up getting
  1546.  * interpreted as a zero.  Only in the case that the frame happens to be
  1547.  * the last frame in a block and we're dealing with MH, MR, or MMR data 
  1548.  * we will send MCF (to accomodate #1), and so this frame will then be 
  1549.  * lost.  This should be rare and have little impact on actual image data
  1550.  * loss when it does occur.  This approach cannot be followed with JPEG
  1551.  * and JBIG data formats or when the signal is PPS-NULL.
  1552.  */
  1553. if (fcount) {
  1554.     u_int fbad = 0;
  1555.     for (u_int i = 0; i <= (fcount - ((fc || params.df > DF_2DMMR || ppsframe.getFCF() == 0) ? 1 : 2)); i++) {
  1556. u_int pprpos, pprval;
  1557. for (pprpos = 0, pprval = i; pprval >= 8; pprval -= 8) pprpos++;
  1558. if (ppr[pprpos] & frameRev[1 << pprval]) {
  1559.     blockgood = false;
  1560.     fbad++;
  1561. }
  1562.     }
  1563.     if (fcount && ! blockgood) protoTrace("Block incomplete: %d frames (%d%%) corrupt or missing", fbad, ((fbad*100)/fcount));
  1564.     if (frameRev[ppsframe[4]] < prevPage || (frameRev[ppsframe[4]] == prevPage && frameRev[ppsframe[5]] < prevBlock))
  1565. blockgood = false; // we already confirmed this block receipt... (see below)
  1566. } else {
  1567.     blockgood = false; // MCF only if we have data
  1568. }
  1570. // requisite pause before sending response (PPR/MCF)
  1571. if (!blockgood && !useV34 && !switchingPause(emsg)) {
  1572.     abortPageECMRecv(tif, params, block, fcount, seq, pagedataseen, emsg);
  1573.     return (false);
  1574. }
  1575.     }
  1576.     /* ... pass through ... */
  1577. case FCF_CTC:
  1578. case FCF_EOR:
  1579.     if (! blockgood) {
  1580. if ((ppsframe.getFCF() == FCF_CTC || ppsframe.getFCF() == FCF_EOR) &&
  1581.      (!useV34 || !conf.class1PersistentECM)) { // only if we can make use of the signal
  1582.     signalRcvd = ppsframe.getFCF();
  1583.     pprcnt = 4;
  1584. }
  1585. if (signalRcvd == 0) {
  1586.     if (frameRev[ppsframe[4]] > prevPage || (frameRev[ppsframe[4]] == prevPage && frameRev[ppsframe[5]] >= prevBlock)) {
  1587. // inform the remote that one or more frames were invalid
  1588. transmitFrame(FCF_PPR, fxStr(ppr, 32));
  1589. traceFCF("RECV send", FCF_PPR);
  1590. pprcnt++;
  1591. if (pprcnt > 4) pprcnt = 4; // could've been 4 before increment
  1592.     } else {
  1593. /*
  1594.  * The silly sender already sent us this block and we already confirmed it.
  1595.  * Just confirm it again, but let's behave as if we sent a full PPR without
  1596.  * incrementing pprcnt.
  1597.  */
  1598. (void) transmitFrame(FCF_MCF|FCF_RCVR);
  1599. traceFCF("RECV send", FCF_MCF);
  1600. for (u_int i = 0; i < 32; i++) ppr[i] = 0xff; // ppr defaults to all 1's, T.4 A.4.4
  1601.     }
  1602. }
  1603. if (pprcnt == 4 && (!useV34 || !conf.class1PersistentECM)) {
  1604.     HDLCFrame rtnframe(conf.class1FrameOverhead);
  1605.     if (signalRcvd == 0) {
  1606. // expect sender to send CTC/EOR after every fourth PPR, not just the fourth
  1607. protoTrace("RECV sent fourth PPR");
  1608.     } else {
  1609. // we already got the signal
  1610. rtnframe.put(ppsframe, ppsframe.getLength());
  1611.     }
  1612.     pprcnt = 0;
  1613.     if (signalRcvd != 0 || recvFrame(rtnframe, FCF_RCVR, conf.t2Timer)) {
  1614. bool gotrtnframe = true;
  1615. if (signalRcvd == 0) traceFCF("RECV recv", rtnframe.getFCF());
  1616. else signalRcvd = 0; // reset it, we're in-sync now
  1617. recvFrameCount = 0;
  1618. lastResponse = AT_NOTHING;
  1619. while (rtnframe.getFCF() == FCF_PPS && !gotEOT && recvFrameCount < 5 && gotrtnframe) {
  1620.     // we sent PPR, but got PPS again...
  1621.     if (!useV34 && !switchingPause(emsg)) {
  1622. abortPageECMRecv(tif, params, block, fcount, seq, pagedataseen, emsg);
  1623. return (false);
  1624.     }
  1625.     transmitFrame(FCF_PPR, fxStr(ppr, 32));
  1626.     traceFCF("RECV send", FCF_PPR);
  1627.     gotrtnframe = recvFrame(rtnframe, FCF_RCVR, conf.t2Timer);
  1628.     if (gotrtnframe)
  1629. traceFCF("RECV recv", rtnframe.getFCF());
  1630.     recvFrameCount++;
  1631. }
  1632. u_int dcs; // possible bits 1-16 of DCS in FIF
  1633. switch (rtnframe.getFCF()) {
  1634.     case FCF_CTC:
  1635. if (useV34) {
  1636.     // T.30 F.3.4.5 Note 1 does not permit CTC in V.34-fax
  1637.     emsg = "Received invalid CTC signal in V.34-Fax. {E113}";
  1638.     abortPageECMRecv(tif, params, block, fcount, seq, pagedataseen, emsg);
  1639.     return (false);
  1640. }
  1641. // use 16-bit FIF to alter speed, curcap
  1642. dcs = rtnframe[3] | (rtnframe[4]<<8);
  1643. curcap = findSRCapability(dcs&DCS_SIGRATE, recvCaps);
  1644. processNewCapabilityUsage();
  1645. // requisite pause before sending response (CTR)
  1646. if (!switchingPause(emsg)) {
  1647.     abortPageECMRecv(tif, params, block, fcount, seq, pagedataseen, emsg);
  1648.     return (false);
  1649. }
  1650. (void) transmitFrame(FCF_CTR|FCF_RCVR);
  1651. traceFCF("RECV send", FCF_CTR);
  1652. dolongtrain = true;
  1653. break;
  1654.     case FCF_EOR:
  1655. traceFCF("RECV recv", rtnframe.getFCF2());
  1656. /*
  1657.  * It may be wise to disconnect here if MMR is being
  1658.  * used because there will surely be image data loss.
  1659.  * However, since the sender knows what the extent of
  1660.  * the data loss will be, we'll naively assume that
  1661.  * the sender knows what it's doing, and we'll
  1662.  * proceed as instructed by it.
  1663.  */
  1664. blockgood = true;
  1665. switch (rtnframe.getFCF2()) {
  1666.     case 0:
  1667. // EOR-NULL partial page boundary
  1668. break;
  1669.     case FCF_EOM:
  1670.     case FCF_MPS:
  1671.     case FCF_EOP:
  1672.     case FCF_PRI_EOM:
  1673.     case FCF_PRI_MPS:
  1674.     case FCF_PRI_EOP:
  1675. lastblock = true;
  1676. signalRcvd = rtnframe.getFCF2();
  1677. break;
  1678.     default:
  1679. emsg = "COMREC invalid response to repeated PPR received {E117}";
  1680. abortPageECMRecv(tif, params, block, fcount, seq, pagedataseen, emsg);
  1681. return (false);
  1682. }
  1683. sendERR = true; // do it later
  1684. break;
  1685.     case FCF_DCN:
  1686. emsg = "COMREC received DCN (sender abort) {E108}";
  1687. gotEOT = true;
  1688. recvdDCN = true;  
  1689.     default:
  1690. if (emsg == "") emsg = "COMREC invalid response to repeated PPR received {E117}";
  1691. abortPageECMRecv(tif, params, block, fcount, seq, pagedataseen, emsg);
  1692. return (false);
  1693. }
  1694.     } else {
  1695. emsg = "T.30 T2 timeout, expected signal not received {E118}";
  1696. abortPageECMRecv(tif, params, block, fcount, seq, pagedataseen, emsg);
  1697. return (false);
  1698.     }
  1699. }
  1700.     }
  1701.     if (signalRcvd == 0) { // don't overwrite EOR settings
  1702. switch (ppsframe.getFCF2()) {
  1703.     case 0:
  1704. // PPS-NULL partial page boundary
  1705. break;
  1706.     case FCF_EOM:
  1707.     case FCF_MPS:
  1708.     case FCF_EOP:
  1709.     case FCF_PRI_EOM:
  1710.     case FCF_PRI_MPS:
  1711.     case FCF_PRI_EOP:
  1712. lastblock = true;
  1713. signalRcvd = ppsframe.getFCF2();
  1714. break;
  1715.     default:
  1716. if (blockgood) {
  1717.     emsg = "COMREC invalid partial-page signal received {E119}";
  1718.     abortPageECMRecv(tif, params, block, fcount, seq, pagedataseen, emsg);
  1719.     return (false);
  1720. }
  1721. /*
  1722.  * If the sender signalled PPS-<??> (where the FCF2 is meaningless) 
  1723.  * and if the block isn't good then we already signalled back PPR... 
  1724.  * which is appropriate despite whatever the strange FCF2 was supposed
  1725.  * to mean, and hopefully it will not re-use it on the next go-around.
  1726.  */
  1727. break;
  1728. }
  1729.     }
  1730.     break;
  1731. case FCF_DCN:
  1732.     emsg = "COMREC received DCN (sender abort) {E108}";
  1733.     gotEOT = true;
  1734.     recvdDCN = true;
  1735.     abortPageECMRecv(tif, params, block, fcount, seq, pagedataseen, emsg);
  1736.     return (false);
  1737. default:
  1738.     // The message is not ECM-specific: fall out of ECM receive, and let
  1739.     // the earlier message-handling routines try to cope with the signal.
  1740.     signalRcvd = ppsframe.getFCF();
  1741.     messageReceived = true;
  1742.     abortPageECMRecv(tif, params, block, fcount, seq, pagedataseen, emsg);
  1743.     if (getRecvEOLCount() == 0) {
  1744.  prevPage--; // counteract the forthcoming increment
  1745. return (true);
  1746.     } else {
  1747. emsg = "COMREC invalid response received {E110}"; // plain ol' error
  1748. return (false);
  1749.     }
  1750.     }
  1751. } else {
  1752.     emsg = "T.30 T2 timeout, expected signal not received {E118}";
  1753.     abortPageECMRecv(tif, params, block, fcount, seq, pagedataseen, emsg);
  1754.     return (false);
  1755. }
  1756.     } else {
  1757. if (wasTimeout()) {
  1758.     abortReceive();
  1759.     if (!useV34) {
  1760. // must now await V.21 signalling
  1761. long wait = BIT(curcap->br) & BR_ALL ? 273066 / (curcap->br+1) : conf.t2Timer;
  1762. gotRTNC = atCmd(rhCmd, AT_CONNECT, wait);
  1763. gotoPhaseD = gotRTNC;
  1764. if (!gotRTNC) syncattempts = 21;
  1765.     }
  1766. }
  1767. if (syncattempts++ > 20) {
  1768.     emsg = "Cannot synchronize ECM frame reception. {E120}";
  1769.     abortPageECMRecv(tif, params, block, fcount, seq, true, emsg);
  1770.     return(false);
  1771. }
  1772.     }
  1773. } while (! blockgood);
  1775. u_int cc = fcount * frameSize;
  1776. if (lastblock) {
  1777.     // trim zero padding
  1778.     while (cc > 0 && block[cc - 1] == 0) cc--;
  1779. }
  1780. // write the block to file
  1781. if (lastblock) seq |= 2; // seq code for the last block
  1783. /*
  1784.  * On servers where disk or CPU may be bottlenecked or stressed,
  1785.  * the writeECMData call can lag.  The strategy, then, is
  1786.  * to employ RNR/RR flow-control in order to grant writeECMData
  1787.  * sufficient time to complete.   
  1788. */
  1789. int fcfd[2]; // flow control file descriptors for the pipe
  1790. pid_t fcpid = -1; // flow control process id for the child
  1791. if (pipe(fcfd) >= 0) {
  1792.     fcpid = fork();
  1793.     char tbuf[1]; // trigger signal
  1794.     tbuf[0] = 0xFF;
  1795.     time_t rrstart = Sys::now();
  1796.     switch (fcpid) {
  1797. case -1: // error
  1798.     protoTrace("Protocol flow control unavailable due to fork error.");
  1799.     writeECMData(tif, block, cc, params, seq, emsg);
  1800.     Sys::close(fcfd[0]);
  1801.     Sys::close(fcfd[1]);
  1802.     break;
  1803. case 0: // child
  1804.     Sys::close(fcfd[1]);
  1805.     do {
  1806. fd_set rfds;
  1807. FD_ZERO(&rfds);
  1808. FD_SET(fcfd[0], &rfds);
  1809. struct timeval tv;
  1810. tv.tv_sec = 1; // 1000 ms should be safe
  1811. tv.tv_usec = 0;
  1812. #if CONFIG_BADSELECTPROTO
  1813. if (!select(fcfd[0]+1, (int*) &rfds, NULL, NULL, &tv)) {
  1814. #else
  1815. if (!select(fcfd[0]+1, &rfds, NULL, NULL, &tv)) {
  1816. #endif
  1817.     bool gotresponse = true;
  1818.     u_short rnrcnt = 0;
  1819.     do {
  1820. if (!useV34) (void) switchingPause(emsg);
  1821. if (emsg != "") break;
  1822. (void) transmitFrame(FCF_RNR|FCF_RCVR);
  1823. traceFCF("RECV send", FCF_RNR);
  1824. HDLCFrame rrframe(conf.class1FrameOverhead);
  1825. gotresponse = recvFrame(rrframe, FCF_RCVR, conf.t2Timer);
  1826. if (gotresponse) {
  1827.     traceFCF("RECV recv", rrframe.getFCF());
  1828.     if (rrframe.getFCF() == FCF_DCN) {
  1829. protoTrace("RECV recv DCN");
  1830. emsg = "COMREC received DCN (sender abort) {E108}";
  1831. gotEOT = true;
  1832. recvdDCN = true;
  1833.     } else if (params.ec != EC_DISABLE && rrframe.getFCF() != FCF_RR) {
  1834. protoTrace("Ignoring invalid response to RNR.");
  1835.     }
  1836. }
  1837.     } while (!recvdDCN && !gotEOT && !gotresponse && ++rnrcnt < 2 && Sys::now()-rrstart < 60);
  1838.     if (!gotresponse) emsg = "No response to RNR repeated 3 times. {E109}";
  1839. } else tbuf[0] = 0; // parent finished writeECMData
  1840.     } while (!gotEOT && !recvdDCN && tbuf[0] != 0 && Sys::now()-rrstart < 60);
  1841.     Sys::read(fcfd[0], NULL, 1);
  1842.     _exit(0);
  1843. default: // parent
  1844.     Sys::close(fcfd[0]);
  1845.     writeECMData(tif, block, cc, params, seq, emsg);
  1846.     Sys::write(fcfd[1], tbuf, 1);
  1847.     (void) Sys::waitpid(fcpid);
  1848.     Sys::close(fcfd[1]);
  1849.     break;
  1850.     }
  1851. } else {
  1852.     protoTrace("Protocol flow control unavailable due to pipe error.");
  1853.     writeECMData(tif, block, cc, params, seq, emsg);
  1854. }
  1855. seq = 0; // seq code for in-between blocks
  1857. if (!lastblock) {
  1858.     // confirm block received as good
  1859.     if (!useV34) (void) switchingPause(emsg);
  1860.     (void) transmitFrame((sendERR ? FCF_ERR : FCF_MCF)|FCF_RCVR);
  1861.     traceFCF("RECV send", sendERR ? FCF_ERR : FCF_MCF);
  1862. }
  1863. prevBlock++;
  1864.     } while (! lastblock);
  1866.     free(block);
  1867.     recvEndPage(tif, params);
  1869.     if (getRecvEOLCount() == 0) {
  1870. // Just because image data blocks are received properly doesn't guarantee that
  1871. // those blocks actually contain image data.  If the decoder finds no image
  1872. // data at all we send DCN instead of MCF in hopes of a retransmission.
  1873. emsg = "ECM page received containing no image data. {E121}";
  1874. return (false);
  1875.     }
  1876.     return (true);    // signalRcvd is set, full page is received...
  1877. }
  1879. /*
  1880.  * Receive Phase C data w/ or w/o copy quality checking.
  1881.  */
  1882. bool
  1883. Class1Modem::recvPageData(TIFF* tif, fxStr& emsg)
  1884. {
  1885.     /*
  1886.      * T.30-A ECM mode requires a substantially different protocol than non-ECM faxes.
  1887.      */
  1888.     if (params.ec != EC_DISABLE) {
  1889. if (!recvPageECMData(tif, params, emsg)) {
  1890.     /*
  1891.      * The previous page experienced some kind of error.  Falsify
  1892.      * some event settings in order to cope with the error gracefully.
  1893.      */
  1894.     signalRcvd = FCF_EOP;
  1895.     messageReceived = true;
  1896.     if (prevPage)
  1897. recvEndPage(tif, params);
  1898. }
  1899. TIFFSetField(tif, TIFFTAG_IMAGELENGTH, getRecvEOLCount());
  1900. return (true); // no RTN with ECM
  1901.     } else {
  1902. (void) recvPageDLEData(tif, checkQuality(), params, emsg);
  1903. TIFFSetField(tif, TIFFTAG_IMAGELENGTH, getRecvEOLCount());
  1904. TIFFSetField(tif, TIFFTAG_CLEANFAXDATA, getRecvBadLineCount() ?
  1905.     CLEANFAXDATA_REGENERATED : CLEANFAXDATA_CLEAN);
  1906. if (getRecvBadLineCount()) {
  1907.     TIFFSetField(tif, TIFFTAG_BADFAXLINES, getRecvBadLineCount());
  1908.     TIFFSetField(tif, TIFFTAG_CONSECUTIVEBADFAXLINES,
  1909. getRecvConsecutiveBadLineCount());
  1910. }
  1911. return (isQualityOK(params));
  1912.     }
  1913. }
  1915. /*
  1916.  * Complete a receive session.
  1917.  */
  1918. bool
  1919. Class1Modem::recvEnd(FaxSetup* setupinfo, fxStr& emsg)
  1920. {
  1921.     if (setupinfo) {
  1922. /*
  1923.  * Update FaxMachine info...
  1924.  */
  1925. setupinfo->senderSkipsV29 = senderSkipsV29;
  1926. setupinfo->senderHasV17Trouble = senderHasV17Trouble;
  1927.     }
  1928.     if (!recvdDCN && !gotEOT) {
  1929. u_int t1 = howmany(conf.t1Timer, 1000); // T1 timer in seconds
  1930. time_t start = Sys::now();
  1931. /*
  1932.  * Wait for DCN and retransmit ack of EOP if needed.
  1933.  */
  1934. HDLCFrame frame(conf.class1FrameOverhead);
  1935. do {
  1936.     gotRTNC = false;
  1937.     if (recvFrame(frame, FCF_RCVR, conf.t2Timer)) {
  1938. traceFCF("RECV recv", frame.getFCF());
  1939. switch (frame.getFCF()) {
  1940. case FCF_PPS:
  1941. case FCF_EOP:
  1942. case FCF_CRP:
  1943.     if (!useV34) (void) switchingPause(emsg);
  1944.     (void) transmitFrame(FCF_MCF|FCF_RCVR);
  1945.     traceFCF("RECV send", FCF_MCF);
  1946.     break;
  1947. case FCF_DCN:
  1948.     recvdDCN = true;
  1949.     break;
  1950. default:
  1951.     if (!useV34) (void) switchingPause(emsg);
  1952.     transmitFrame(FCF_DCN|FCF_RCVR);
  1953.     recvdDCN = true;
  1954.     break;
  1955. }
  1956.     } else if (gotRTNC) {
  1957. (void) transmitFrame(FCF_MCF|FCF_RCVR);
  1958. traceFCF("RECV send", FCF_MCF);
  1959.     } else if (!wasTimeout() && lastResponse != AT_FCERROR && lastResponse != AT_FRH3) {
  1960. /*
  1961.  * Beware of unexpected responses from the modem.  If
  1962.  * we lose carrier, then we can loop here if we accept
  1963.  * null responses, or the like.
  1964.  */
  1965. break;
  1966.     }
  1967. } while ((unsigned) Sys::now()-start < t1 && (!frame.isOK() || !recvdDCN));
  1968.     }
  1969.     setInputBuffering(true);
  1970.     return (true);
  1971. }
  1973. /*
  1974.  * Abort an active receive session.
  1975.  */
  1976. void
  1977. Class1Modem::recvAbort()
  1978. {
  1979.     if (!recvdDCN && !gotEOT) {
  1980. fxStr emsg;
  1981. if (!useV34) switchingPause(emsg);
  1982. transmitFrame(FCF_DCN|FCF_RCVR);
  1983.     }
  1984.     recvdDCN = true; // don't hang around in recvEnd
  1985. }