windows-xp/Source/XPSP1/NT/printscan/fax/provider/t30/main/ecm.c

/***************************************************************************
 Name     :     ECM.C
 Comment  :     Contains the ECM T30 routines
 Revision Log
 Date     Name  Description
 -------- ----- ---------------------------------------------------------
***************************************************************************/


#include "prep.h"

#include "efaxcb.h"
#include "t30.h"
#include "hdlc.h"
#include "debug.h"

///RSL
#include "glbproto.h"


#define         faxTlog(m)              DEBUGMSG(ZONE_ECM, m)
#define         FILEID                  FILEID_ECM

typedef enum
{
        ECMRECVOK_OK,
        ECMRECVOK_BADFR,
        ECMRECVOK_ABORT
}
ECMRECVOK;

/****************** begin prototypes from ecm.c *****************/
IFR RNR_RRLoop(PThrdGlbl pTG);
IFR CTC_RespRecvd(PThrdGlbl pTG, USHORT uBaud);
BOOL Recv_NotReadyLoop(PThrdGlbl pTG, IFR ifrFirst, IFR ifrLast);
BOOL FillInFrames(PThrdGlbl pTG, USHORT N, LONG sBufSize, USHORT uDataSize);
ECMRECVOK ECMRecvOK(PThrdGlbl pTG);
/***************** end of prototypes from ecm.c *****************/



BYTE RCP[3] = { 0xFF, 0x03, 0x86 };






ET30ACTION      ECMPhaseC(PThrdGlbl pTG, BOOL fReTx)
{
        USHORT          uFrameNum, uFramesSent, uLim;
        SWORD           swRet;
        ULONG           lTotalLen=0;
        LPBYTE          lpPPRMask;
        LPBUFFER        lpbf=0;
        USHORT          uMod;

        /******** Transmitter ECM Phase C. Fig A-7/T.30 (sheet 1) ********/

/***
        switch(action = Params.lpfnWhatNext(pTG, eventSTARTSEND))
        {
          case actionCONTINUE:  break;
          case actionDCN:
          case actionHANGUP:    return action;
          case actionERROR:             return action;  // goto PhaseLoop & exit
          default:                              return BadAction(action);
        }
***/

        pTG->ECM.uFrameSize = ProtGetECMFrameSize(pTG);
        BG_CHK(pTG->ECM.uFrameSize==6 || pTG->ECM.uFrameSize==8);

        // already done in WhatNext
        // uSize = (1 << pTG->ECM.uFrameSize);
        // ICommSetSendMode(TRUE, uSize+ECM_EXTRA, uSize, TRUE);

        if(fReTx)
        {
                lpPPRMask = ProtGetRetransmitMask(pTG);
        }
        else
        {
                pTG->ECM.uPPRCount = 0;

                if(pTG->ECM.fEndOfPage)
                {
                        pTG->ECM.SendPageCount++;
                        pTG->ECM.SendBlockCount = 1;
                        pTG->ECM.dwPageSize=0;

                        faxTlog((SZMOD "Waiting for Startpage in ECM at 0x%08lx\r\n", GetTickCount()));
                        DEBUGSTMT(IFProcProfile((HTASK)(-1), TRUE));

                        // Callback to open file to send. Doesn't return any data
                        if((swRet=GetSendBuf(pTG, 0, SEND_STARTPAGE)) != SEND_OK)
                        {
                                ERRMSG((SZMOD "<<ERROR>> Nonzero return %d from SendProc at Start Page\r\n", swRet));
                                // return actionDCN;
                                return actionERROR;
                        }

                        DEBUGSTMT(IFProcProfile((HTASK)(-1), FALSE));
                        faxTlog((SZMOD "Got Startpage in ECM at 0x%08lx\r\n", GetTickCount()));
                }
                else
                {
                        pTG->ECM.SendBlockCount++;

                        faxTlog((SZMOD "Waiting for Startblock in ECM at 0x%08lx\r\n", GetTickCount()));
                        DEBUGSTMT(IFProcProfile((HTASK)(-1), TRUE));

                        // Callback to open file to send. Doesn't return any data
                        if((swRet=GetSendBuf(pTG, 0, SEND_STARTBLOCK)) != SEND_OK)
                        {
                                ERRMSG((SZMOD "<<ERROR>> Nonzero return %d from SendProc at Start Page\r\n", swRet));
                                // return actionDCN;
                                return actionERROR;
                        }

                        DEBUGSTMT(IFProcProfile((HTASK)(-1), FALSE));
                        faxTlog((SZMOD "Got Startblock in ECM at 0x%08lx\r\n", GetTickCount()));
                }
        }

        faxTlog((SZMOD "Starting ECM Partial Page SEND.......P=%d B=%d ReTx=%d\r\n",
                        pTG->ECM.SendPageCount, pTG->ECM.SendBlockCount, fReTx));
        if(fReTx)
                ICommStatus(pTG, T30STATS_RESEND_ECM, pTG->ECM.SendPageCount, 0, pTG->ECM.SendBlockCount);

        uMod = ProtGetSendMod(pTG);
        if(uMod >= V17_START && !pTG->ECM.fSentCTC) uMod |= ST_FLAG;
        pTG->ECM.fSentCTC = FALSE;

        // here we should use a small timeout (100ms?) and if it fails,
        // should go back to sending the previous V21 frame (which could be DCS
        // or MPS or whatever, which is why it gets complicated & we havn't
        // done it!). Meanwhile use a long timeout, ignore return value
        // and send anyway.

        if(!ModemRecvSilence(pTG, pTG->Params.hModem, RECV_PHASEC_PAUSE, LONG_RECVSILENCE_TIMEOUT))
        {
                ERRMSG((SZMOD "<<ERROR>> ECM Pix RecvSilence(%d, %d) FAILED!!!\r\n", RECV_PHASEC_PAUSE, LONG_RECVSILENCE_TIMEOUT));
        }

        if(!ModemSendMode(pTG, pTG->Params.hModem, uMod, TRUE, ifrECMPIX))
        {
                ERRMSG((SZMOD "<<ERROR>> ModemSendMode failed in Tx ECM PhaseC\r\n"));
                ICommFailureCode(pTG, T30FAILSE_SENDMODE_PHASEC);
                BG_CHK(FALSE);
                return actionERROR;
        }

#ifdef IFAX
        BroadcastMessage(pTG, IF_PSIFAX_DATAMODE, (PSIFAX_SEND|PSIFAX_ECM|(fReTx ? PSIFAX_RESEND : 0)), (uMod & (~ST_FLAG)));
#endif
        faxTlog((SZMOD "SENDING ECM Page Data.....\r\n"));
        FComCriticalNeg(pTG, FALSE);

        uLim = (fReTx ? pTG->ECM.SendFrameCount : 256);
        BG_CHK(uLim);
        BG_CHK(lpbf == 0);

        for(uFrameNum=0, uFramesSent=0, lTotalLen=0, swRet=0; uFrameNum<uLim; uFrameNum++)
        {
                if(!fReTx || (lpPPRMask[uFrameNum/8] & (1 << (uFrameNum%8))))
                {
                        BG_CHK(uFrameNum < 256 && pTG->ECM.uFrameSize <=8);  // shift below won't ovf 16 bits
                        BG_CHK(lpbf == 0);
                        swRet = GetSendBuf(pTG, &lpbf, (fReTx ? ((SLONG)(uFrameNum << pTG->ECM.uFrameSize)) : SEND_SEQ));

                        if(swRet == SEND_ERROR)
                        {
                                ERRMSG((SZMOD "<<ERROR>> Error return from SendProc in ECM retransmit\r\n"));
                                BG_CHK(lpbf == 0);
                                // return actionDCN;    // goto NodeC;
                                return actionERROR;
                        }
                        else if(swRet == SEND_EOF)
                        {
                                BG_CHK(lpbf == 0);
                                if(!fReTx)
                                        break;
                                else
                                {
                                        BG_CHK(FALSE);
                                        ICommFailureCode(pTG, T30FAILSE_PHASEC_RETX_EOF);
                                        return actionDCN;
                                }
                        }
                        BG_CHK(swRet == SEND_OK);

                        BG_CHK(lpbf);
                        BG_CHK(lpbf->lpbBegBuf+4 == lpbf->lpbBegData);

                        lpbf->lpbBegBuf[0] = 0xFF;
                        lpbf->lpbBegBuf[1] = 0x03;
                        lpbf->lpbBegBuf[2] = 0x06;
                        lpbf->lpbBegBuf[3] = (BYTE) uFrameNum;
                        lpbf->lpbBegData -= 4;
                        lpbf->wLengthData += 4;

                        lTotalLen += lpbf->wLengthData;

                        if(!ModemSendMem(pTG, pTG->Params.hModem, lpbf->lpbBegData, lpbf->wLengthData, SEND_ENDFRAME))
                        {
                                ERRMSG((SZMOD "<<ERROR>> DataWrite Timeout in ECM Phase C\r\n"));
                                ICommFailureCode(pTG, T30FAILSE_MODEMSEND_PHASEC);
                                BG_CHK(FALSE);
                                return actionERROR;             // goto error;
                        }

                        // faxTlog((SZMOD "Freeing 0x%08lx in ECM\r\n", lpbf));
                        if(!MyFreeBuf(pTG, lpbf))
                        {
                                ERRMSG((SZMOD "<<ERROR>> FReeBuf failed in ECM Phase C\r\n"));
                                ICommFailureCode(pTG, T30FAILSE_FREEBUF_PHASEC);
                                BG_CHK(FALSE);
                                return actionERROR;             // goto error;
                        }
                        lpbf = 0;
                        uFramesSent++;
                }
        }

        if( !ModemSendMem(pTG, pTG->Params.hModem, RCP, 3, SEND_ENDFRAME) ||
                !ModemSendMem(pTG, pTG->Params.hModem, RCP, 3, SEND_ENDFRAME) ||
                !ModemSendMem(pTG, pTG->Params.hModem, RCP, 3, SEND_ENDFRAME|SEND_FINAL))
        {
                ERRMSG((SZMOD "<<ERROR>> DataWrite Timeout on RCPs\r\n"));
                ICommFailureCode(pTG, T30FAILSE_MODEMSEND_ENDPHASEC);
                BG_CHK(FALSE);
                return actionERROR;             // goto error;
        }
/***
        if(!ModemDrain())
                return FALSE;
***/

        FComCriticalNeg(pTG, TRUE);

        faxTlog((SZMOD "Page Send Done.....len=(%ld, 0x%08x)\r\n", lTotalLen, lTotalLen));
        pTG->ECM.FramesSent = uFramesSent;

        if(!fReTx)
        {
                BG_CHK(lTotalLen>=(ULONG)uFramesSent*4);
                pTG->ECM.dwPageSize+= (lTotalLen-uFramesSent*4); // 4-bytes of framing data
                pTG->ECM.SendFrameCount = uFrameNum;

                switch(GetSendBuf(pTG, 0, SEND_QUERYENDPAGE))
                {
                case SEND_OK:   pTG->ECM.fEndOfPage = FALSE; break;
                case SEND_EOF:  pTG->ECM.fEndOfPage = TRUE;  break;
                default:                ERRMSG((SZMOD "<<ERROR>> Got SEND_ERROR from GetSendBuf at end of page\r\n"));
                                                return actionERROR;
                }
        }
        if(!pTG->ECM.FramesSent)
        {
                ERRMSG((SZMOD "<<ERROR>> Sent 0 frames--Bad PPR recvd or bad send file\r\n"));
                ICommFailureCode(pTG, T30FAILSE_BADPPR);
                return actionERROR;
        }

        pTG->T30.fSendAfterSend = TRUE;      // ECM PhaseC/PIX--PPS-X
        return actionGONODE_V;
}












ET30ACTION      ECMPhaseD(PThrdGlbl pTG)
{
        USHORT          uTryCount, i;
        ET30ACTION      action;
        BYTE            bPPSfif[3];
        LPBYTE          lpPPR;

        /******** Transmitter ECM Phase D. Fig A-8 to A-17/T.30 ********/

        if(!pTG->ECM.fEndOfPage)
        {
                pTG->T30.ifrSend = ifrPPS_NULL;
        }
        else
        {
                switch(action = pTG->Params.lpfnWhatNext(pTG, eventPOSTPAGE))
                {
                        case actionSENDMPS:     pTG->T30.ifrSend = ifrPPS_MPS; break;
                        case actionSENDEOM:     pTG->T30.ifrSend = ifrPPS_EOM; break;
                        case actionSENDEOP:     pTG->T30.ifrSend = ifrPPS_EOP; break;
#ifdef PRI
                        case actionSENDPRIMPS:  pTG->T30.ifrSend = ifrPPS_PRI_MPS; break;
                        case actionSENDPRIEOM:  pTG->T30.ifrSend = ifrPPS_PRI_EOM; break;
                        case actionSENDPRIEOP:  pTG->T30.ifrSend = ifrPPS_PRI_EOP; break;
#endif
                        case actionERROR:       return action;  // goto PhaseLoop & exit
                default:                        return BadAction(pTG, action);
                }
        }

        bPPSfif[0] = pTG->ECM.SendPageCount-1;
        bPPSfif[1] = pTG->ECM.SendBlockCount-1;
        BG_CHK(pTG->ECM.FramesSent && pTG->ECM.FramesSent<=256);
        // bPPSfif[2] = pTG->ECM.SendFrameCount-1;           // don't know which one..!!
        bPPSfif[2] = pTG->ECM.FramesSent-1;                  // this one! For sure

        for(uTryCount=0 ;;)
        {
                SendSingleFrame(pTG, pTG->T30.ifrSend, bPPSfif, 3, 1);

        echoretry:
                pTG->T30.ifrResp = GetResponse(pTG, ifrPPSresponse);
                // if we hear our own frame, try to recv again. DONT retransmit!
                if(pTG->T30.ifrResp==pTG->T30.ifrSend) { ECHOMSG(pTG->T30.ifrResp); goto echoretry; }

                if(pTG->T30.ifrResp != ifrNULL && pTG->T30.ifrResp != ifrBAD)
                        break;

                if(++uTryCount >= 3)
                {
                        ERRMSG((SZMOD "<<ERROR>> ECM 3 PostPages, No reply\r\n"));
                        ICommFailureCode(pTG, T30FAILSE_3POSTPAGE_NOREPLY);
                        return actionDCN;
                }
        }

        switch(pTG->T30.ifrResp)
        {
          case ifrBAD:
          case ifrNULL: BG_CHK(FALSE);  // should never get here
                                        ICommFailureCode(pTG, T30FAILSE_BUG2);
                                        return actionERROR;     // in case they do :-)

          case ifrDCN:  ERRMSG((SZMOD "<<ERROR>> Got ifrDCN from GetResponse after sending post-page command\r\n"));
                                        ICommFailureCode(pTG, T30FAILSE_POSTPAGE_DCN);
                                        return actionHANGUP;
          case ifrPPR:  faxTlog((SZMOD "PPR (P=%d B=%d F=%d) Received: ", pTG->ECM.SendPageCount-1, pTG->ECM.SendBlockCount-1, pTG->ECM.FramesSent-1));
                                        lpPPR = ProtGetRetransmitMask(pTG);
#ifdef DEBUG
                                        for(i=0; i<32; i++)
                                                faxTlog((" %02x", lpPPR[i]));
                                        faxTlog(("]\r\n"));
#endif //DEBUG


                                        if(++pTG->ECM.uPPRCount >= 4)
                                                goto FourthPPR;
                                        return actionGONODE_ECMRETRANSMIT;

          case ifrRNR:  if((pTG->T30.ifrResp=RNR_RRLoop(pTG)) == ifrDCN)
                                        {
                                                ERRMSG((SZMOD "<<ERROR>> RR_RNR loop failed\r\n"));
                                                // ICommFailureCode already called in RR_RNRLoop()
                                                return actionDCN;
                                        }
                                        faxTlog((SZMOD "Got %d from RNR\r\n", pTG->T30.ifrResp));
                                        break;
        }

        switch(pTG->T30.ifrResp)
        {
          case ifrPIP:
          case ifrPIN:
#                                       ifdef PRI
                                                        return GONODE_E;
#                                       else
                                                        ERRMSG((SZMOD "<<WARNING>> Procedure interrupts not supported\r\n"));
                                                        // return actionERROR;
                                                        // fallthru and treat like MCF
                                                        pTG->T30.ifrResp = ifrMCF;
#                                       endif

          case ifrMCF:
                                        {
                                                WORD wSize = (WORD) (pTG->ECM.dwPageSize>>10); //Units are KB
                                                ICommStatus(pTG, T30STATS_CONFIRM_ECM,
                                                        (USHORT) LOBYTE(wSize),
                                                        (USHORT) HIBYTE(wSize),
                                                        (USHORT)(pTG->ECM.SendPageCount&0xff));
                                                ERRMSG((SZMOD "Sending T30STATS_CONFIRM_pTG->ECM. wSize=%u\r\n",
                                                                        (unsigned) wSize));

                                        }
          action=pTG->Params.lpfnWhatNext(pTG, eventGOT_ECM_PPS_RESP,
                                                                (UWORD)pTG->T30.ifrResp, (LPVOID)((DWORD)pTG->T30.ifrSend));
                                        if(pTG->T30.ifrSend==ifrPPS_EOP && pTG->T30.ifrResp==ifrMCF && action==actionDCN)
                                        {
                                                ICommFailureCode(pTG, T30FAILSE_SUCCESS);
                                                return actionDCN_SUCCESS;
                                        }
                                        else
                                                return action;

          default:              ERRMSG((SZMOD "<<ERROR>> Got UNKNOWN from GetResponse after sending post-page command\r\n"));
                                        ICommFailureCode(pTG, T30FAILSE_POSTPAGE_UNKNOWN);
                                        return actionDCN;
        }

FourthPPR:
        action = pTG->Params.lpfnWhatNext(pTG, event4THPPR, (WORD)pTG->ECM.SendFrameCount, (DWORD)pTG->ECM.FramesSent);
        switch(action)
        {
          case actionGONODE_ECMRETRANSMIT:
                        if(CTC_RespRecvd(pTG, ProtGetSendMod(pTG)) == ifrCTR)
                        {
                                pTG->ECM.uPPRCount = 0;
                                pTG->ECM.fSentCTC = TRUE;
                                return actionGONODE_ECMRETRANSMIT;
                        }
                        else
                        {
                                ERRMSG((SZMOD "<<ERROR>> CTC-CTR failed\r\n"));
                                // ICommFailureCode already called in CTC_RespRecvd(pTG)
                                return actionDCN;
                        }

          case actionSENDEOR_EOP:
          case actionDCN:
          case actionERROR:
                        return action;
          default:
                        return BadAction(pTG, action);
                        // none of the EOR stuff
                        // return actionDCN;
        }
}











ET30ACTION      ECMSendEOR_EOP(PThrdGlbl pTG)
{
        // dont set new ICommFailure codes in this function. We have already
        // set the 'too many retries' code

        USHORT          uTryCount;

        for(uTryCount=0 ;;)
        {
                RETAILMSG((SZMOD "<<WARNING>> Sending EOR-EOP\r\n"));

                pTG->T30.ifrSend = ifrEOR_EOP;
                SendEOR_EOP(pTG);

        echoretry:
                pTG->T30.ifrResp = GetResponse(pTG, ifrEORresponse);
                // if we hear our own frame, try to recv again. DONT retransmit!
                if(pTG->T30.ifrResp==pTG->T30.ifrSend) { ECHOMSG(pTG->T30.ifrResp); goto echoretry; }

                if(pTG->T30.ifrResp != ifrNULL && pTG->T30.ifrResp != ifrBAD)
                        break;

                if(++uTryCount >= 3)
                {
                        ERRMSG((SZMOD "<<ERROR>> ECM 3 EORs, No reply\r\n"));
                        return actionDCN;
                }
        }

        switch(pTG->T30.ifrResp)
        {
          case ifrBAD:
          case ifrNULL: BG_CHK(FALSE);  // should never get here
                                        return actionERROR;     // in case they do :-)

          case ifrDCN:  ERRMSG((SZMOD "<<ERROR>> Got ifrDCN from GetResponse after sending EOR\r\n"));
                                        return actionHANGUP;

          case ifrRNR:  RETAILMSG((SZMOD "<<WARNING>> Sent EOR-EOP, got RNR\r\n"));
                                        if((pTG->T30.ifrResp=RNR_RRLoop(pTG)) == ifrDCN)
                                        {
                                                ERRMSG((SZMOD "<<ERROR>> RR_RNR loop failed\r\n"));
                                                // ICommFailureCode already called in RR_RNRLoop(pTG)
                                                return actionDCN;
                                        }
                                        faxTlog((SZMOD "Got %d from RNR\r\n", pTG->T30.ifrResp));
                                        break;
        }

        switch(pTG->T30.ifrResp)
        {
          case ifrERR:  RETAILMSG((SZMOD "<<WARNING>> Sent EOR-EOP. Got ERR. Sending DCN\r\n"));
                                        return actionDCN;
          default:              ERRMSG((SZMOD "<<ERROR>> Got UNKNOWN from GetResponse after sending EOR\r\n"));
                                        return actionDCN;
        }
}



// reduce this so that when externally measured it always ends up less
// then the specified max of 65s, so we pass protocol conformance tests
#define T5_TIMEOUT              62000L                  // 60s + 5s












IFR RNR_RRLoop(PThrdGlbl pTG)
{
        /** Flowchart is:- Enter this on getting an RNR. Then start T5,
                send RR, get response (standard ResponseRecvd routine). If
                no response, send RR again. Repeat 3 times. If RNR response
                recvd, send RR again & repeat, until T5 expires, upon which
                send DCN & hangup.

                This routine returns ifrDCN, implying teh caller should
                go to NodeC, or ifrXXX, which is used as the response to be
                analysed further down the chart. Never returns ifrNULL
        **/

        UWORD   i;
        IFR     ifr;

        TstartTimeOut(pTG, &(pTG->ECM.toT5), T5_TIMEOUT);
        do
        {
                for(i=0; i<3; i++)
                {
                        if(!TcheckTimeOut(pTG, &(pTG->ECM.toT5)))
                        {
                                ERRMSG((SZMOD "<<ERROR>> T5 timeout on Sender\r\n"));
                                ICommFailureCode(pTG, T30FAILSE_RR_T5);
                                return ifrDCN;                                  // T5 timed out
                        }

                        SendRR(pTG);

                echoretry:
                        ifr = GetResponse(pTG, ifrRRresponse);
                        // if we hear our own frame, try to recv again. DONT retransmit!
                        if(ifr==ifrRR) { ECHOMSG(ifr); goto echoretry; }

                        if(ifr!=ifrNULL && ifr!=ifrBAD)
                                break;
                        // on ifrNULL (T4 timeout) we resend RR & try again -- 3 times
                }
        }
        while(ifr == ifrRNR);

        // BG_CHK(ifr!=ifrRNR && ifr!=ifrNULL && ifr!=ifrBAD && ifr!=ifrTIMEOUT);
        // can get BAD or NULL here when i=3
        BG_CHK(ifr!=ifrRNR && ifr!=ifrTIMEOUT);

        if(ifr == ifrDCN)
        {
                ERRMSG((SZMOD "<<ERROR>> Got DCN in response to RR\r\n"));
                ICommFailureCode(pTG, T30FAILSE_RR_DCN);
        }

        if(ifr==ifrBAD || ifr==ifrNULL)
        {
                BG_CHK(i==3);
                ERRMSG((SZMOD "<<ERROR>> No response to RR 3 times\r\n"));
                ICommFailureCode(pTG, T30FAILSE_RR_3xT4);
                ifr=ifrDCN;     // same as T5 timeout
        }
        return ifr;             // finally got a non-RNR response
                                        // return ifrDCN or ifrXXXX (not RNR)
}










IFR CTC_RespRecvd(PThrdGlbl pTG, USHORT uBaud)
{
        UWORD   i;
        IFR     ifr = ifrDCN;
        BYTE    bCTCfif[2];

        BG_CHK((uBaud & (~0x0F)) == 0);
        bCTCfif[0] = 0;
        bCTCfif[1] = (uBaud << 2);

        for(i=0; i<3; i++)
        {
                SendCTC (pTG, bCTCfif);

        echoretry:
                ifr = GetResponse(pTG, ifrCTCresponse);
                // if we hear our own frame, try to recv again. DONT retransmit!
                if(ifr==ifrCTC) { ECHOMSG(ifr); goto echoretry; }


                if(ifr!=ifrNULL && ifr!=ifrBAD)
                        break;
                // on ifrNULL (T4 timeout) we resend RR & try again -- 3 times
        }

        if(ifr==ifrNULL || ifr==ifrBAD)
        {
                BG_CHK(i == 3);
                ERRMSG((SZMOD "<<ERROR>> No response to CTC 3 times\r\n"));
                ICommFailureCode(pTG, T30FAILSE_CTC_3xT4);
                ifr = ifrDCN;
        }
        else if(ifr != ifrCTR)
        {
                ERRMSG((SZMOD "<<ERROR>> Bad response CTC\r\n"));
                ICommFailureCode(pTG, T30FAILSE_CTC_UNKNOWN);
        }
        return ifr;             // return ifrDCN or ifrXXXX
}






ET30ACTION      ECMRecvPhaseD ( PThrdGlbl pTG)
{
        DWORD           CurrPPS;
        ET30ACTION      action;

        switch(pTG->T30.ifrCommand)
        {
        case ifrPRI_MPS:
        case ifrPRI_EOM:
        case ifrPRI_EOP:
#                       ifdef PRI
                                return actionGONODE_RECVPRIQ;
#                       else
                                pTG->T30.ifrCommand = pTG->T30.ifrCommand-ifrPRI_MPS+ifrMPS;
                                break;
#                       endif

        case ifrPPS_PRI_MPS:
        case ifrPPS_PRI_EOM:
        case ifrPPS_PRI_EOP:
#                       ifdef PRI
                                goto RecvPPSPRIQ;
#                       else
                                pTG->T30.ifrCommand = pTG->T30.ifrCommand-ifrPPS_PRI_MPS+ifrPPS_MPS;
                                break;
#                       endif

        case ifrEOR_PRI_MPS:
        case ifrEOR_PRI_EOM:
        case ifrEOR_PRI_EOP:
#                       ifdef PRI
                                goto RecvEORPRIQ;
#                       else
                                pTG->T30.ifrCommand = pTG->T30.ifrCommand-ifrEOR_PRI_MPS+ifrEOR_MPS;
                                break;
#                       endif
        }


UsePrevCommand:

        switch(pTG->T30.ifrCommand)
        {
        case ifrCTC:
                                        EnterPageCrit(); //start CTR--PAGE critsection
                                        pTG->ECM.fRecvdCTC = TRUE;
                                        SendCTR(pTG);
                                        ECHOPROTECT(ifrCTR, modeECMRETX);
                                        return actionGONODE_RECVECMRETRANSMIT;
        case ifrPPS_NULL:
        case ifrPPS_MPS:
        case ifrPPS_EOM:
        case ifrPPS_EOP:
                // saved for PPS--RNR--RR--MCF(missed)--RR--MCF sequences
                pTG->ECM.ifrPrevCommand = pTG->T30.ifrCommand;

                //////BugFix 396//////
                CurrPPS = ProtGetPPS(pTG);
                if(pTG->ECM.ifrPrevResponse==ifrMCF && _fmemcmp(pTG->ECM.bPrevPPS, (LPBYTE)(&CurrPPS), 4)==0)
                        goto GoSendMCF;
                _fmemcpy(pTG->ECM.bPrevPPS, (LPBYTE)(&CurrPPS), 4);
                pTG->ECM.ifrPrevResponse = 0;
                //////BugFix 396//////

                switch(ECMRecvOK(pTG))
                {
                default:
                case ECMRECVOK_ABORT:   return actionERROR;
                case ECMRECVOK_OK:              break;
                case ECMRECVOK_BADFR:
                        EnterPageCrit(); //start PPR--PAGE critsection
                        SendPPR(pTG, pTG->ECM.bRecvBadFrameMask);
                        ECHOPROTECT(ifrPPR, modeECMRETX);
                        return actionGONODE_RECVECMRETRANSMIT;
                }

                // now we can mark eop here
                // #ifdef PRI is on, this won't work (e.g. if the guy sends
                // PRI_MPS at end of page, then this needs to be called but it won't.

                if(pTG->T30.ifrCommand != ifrPPS_NULL
                   && !pTG->ECM.fRecvEndOfPage)              // so we won't call this twice
                {
                        // RECV_ENDDOC if PPS_EOP or PPS_EOM
                        PutRecvBuf(pTG, NULL, ((pTG->T30.ifrCommand==ifrPPS_MPS) ? RECV_ENDPAGE : RECV_ENDDOC));
                        // ignore error/abort. We'll catch it soon enough
                        pTG->ECM.fRecvEndOfPage = TRUE;
                }

                if(!Recv_NotReadyLoop(pTG, ifrPPS_FIRST, ifrPPS_LAST))
                {
                        ICommFailureCode(pTG, T30FAILRE_PPS_RNR_LOOP);
                        return actionHANGUP;
                }

                if(pTG->T30.ifrCommand == ifrPPS_NULL)
                {
                        action = actionSENDMCF;
                }
                else switch(action = pTG->Params.lpfnWhatNext(pTG, eventRECVPOSTPAGECMD,(WORD)pTG->T30.ifrCommand))
                {
                  case actionSENDMCF: break;
                  case actionSENDRTN:
                  case actionHANGUP:
                  case actionERROR:
                  default:                        return BadAction(pTG, action);
                }

#ifdef PRI
                if(pTG->T30.ifrCommand != ifrPPS_NULL)
                {
                        if((action = pTG->Params.lpfnWhatNext(pTG, eventQUERYLOCALINT))==actionTRUE)
                        {
                                ECHOPROTECT(ifrPIP, 0);
                                SendPIP(pTG);
                                break;
                        }
                        else if(action == actionERROR)
                                return action;
                }
#endif //PRI

GoSendMCF:
                pTG->ECM.ifrPrevResponse = ifrMCF;
                if(pTG->T30.ifrCommand == ifrPPS_NULL || pTG->T30.ifrCommand == ifrPPS_MPS)
                {
                        EnterPageCrit(); //start ECM MCF--PAGE critsection
                        ECHOPROTECT(ifrMCF, modeECM);
                        SendMCF(pTG);
                        return actionGONODE_RECVPHASEC;
                }
                ECHOPROTECT(ifrMCF, 0);
                SendMCF(pTG);
                if(pTG->T30.ifrCommand==ifrPPS_EOP)
                        return actionNODEF_SUCCESS;
                else
                        break;

        case ifrEOR_NULL:
        case ifrEOR_MPS:
        case ifrEOR_EOM:
        case ifrEOR_EOP:
                // saved for EOR--RNR--RR--ERR(missed)--RR--ERR sequences
                pTG->ECM.ifrPrevCommand = pTG->T30.ifrCommand;

                if(pTG->T30.ifrCommand!=ifrEOR_NULL
                   && !pTG->ECM.fRecvEndOfPage)              // so we won't call this twice
                {
                        // RECV_ENDDOC if EOR_EOP or EOR_EOM
                        PutRecvBuf(pTG, NULL, ((pTG->T30.ifrCommand==ifrEOR_MPS) ? RECV_ENDPAGE : RECV_ENDDOC));
                        // ignore error/abort. We'll catch it soon enough
                        pTG->ECM.fRecvEndOfPage = TRUE;
                }


                if(!Recv_NotReadyLoop(pTG, ifrEOR_FIRST, ifrEOR_LAST))
                {
                        ICommFailureCode(pTG, T30FAILRE_EOR_RNR_LOOP);
                        return actionHANGUP;
                }

#ifdef PRI
                if(pTG->T30.ifrCommand != ifrPPS_NULL)
                {
                        if((action = pTG->Params.lpfnWhatNext(pTG, eventQUERYLOCALINT))==actionTRUE)
                        {
                                ECHOPROTECT(ifrPIN, 0);
                                SendPIN(pTG);
                                break;
                        }
                        else if(action == actionERROR)
                                return action;
                }
#endif //PRI
                if(pTG->T30.ifrCommand == ifrEOR_NULL || pTG->T30.ifrCommand == ifrEOR_MPS)
                {
                        EnterPageCrit(); //start ERR--PAGE critsection
                        ECHOPROTECT(ifrERR, modeECM);
                        SendERR(pTG);
                        return actionGONODE_RECVPHASEC;
                }
                ECHOPROTECT(ifrERR, 0);
                SendERR(pTG);
                break;

        case ifrRR:
                if(pTG->ECM.ifrPrevCommand)
                {
                        pTG->T30.ifrCommand = pTG->ECM.ifrPrevCommand;
                        goto UsePrevCommand;
                }
                else
                {
                        ERRMSG((SZMOD "<<WARNING>> ignoring ERR at weird time\r\n"));
                        break;
                }

        default:
                ERRMSG((SZMOD "<<WARNING>> Random Command frame received=%d\r\n", pTG->T30.ifrCommand));
                break;  // ignore it
        }
        return actionGONODE_F;

#ifdef PRI
RecvPRIPPS:
        switch(ECMRecvOK(pTG))
        {
        default:
        ECMRECVOK_ABORT:        return actionERROR;
        ECMRECVOK_OK:           break;
        ECMRECVOK_BADFR:
                EnterPageCrit(); //start PRI PPR--PAGE critsection
                ECHOPROTECT(ifrPPR, modeECMRETX);
                SendPPR(pTG, pTG->ECM.bRecvBadFrameMask);
                return actionGONODE_RECVECMRETRANSMIT;
        }
RecvPRIEOR:
        switch(action = pTG->Params.lpfnWhatNext(pTG, eventGOTPRIQ, (WORD)pTG->T30.ifrCommand))
        {
          case actionERROR:             break;  // return to PhaseLoop
          case actionHANGUP:    break;
          case actionGONODE_F:  break;
          case actionSENDPIP:   pTG->T30.ifrSend=ifrPIP; return actionGOVOICE;
          case actionSENDPIN:   pTG->T30.ifrSend=ifrPIN; return actionGOVOICE;
          case actionGO_RECVPOSTPAGE:
                        if(pTG->T30.ifrCommand >= ifrPPS_PRI_FIRST && pTG->T30.ifrCommand <= ifrPPS_PRI_LAST)
                        {
                                pTG->T30.ifrCommand = pTG->T30.ifrCommand-ifrPPS_PRI_MPS+ifrPPS_MPS;
                                goto NodeVIIIa;
                        }
                        else if(pTG->T30.ifrCommand >= ifrEOR_PRI_FIRST && pTG->T30.ifrCommand <= ifrEOR_PRI_LAST)
                        {
                                pTG->T30.ifrCommand = pTG->T30.ifrCommand-ifrEOR_PRI_MPS+ifrEOR_MPS;
                                goto NodeIXa;
                        }
                        else
                        {
                                BG_CHK(FALSE);
                        }
        }
        return action;
#endif //PRI
}






BOOL Recv_NotReadyLoop(PThrdGlbl pTG, IFR ifrFirst, IFR ifrLast)
{
        IFR ifrCommand;

        // OBSOLETE:- (??)
        // this is wrong. We should exit only on DCN I think.
        // We should definitely loop again on BAD
        // dunno about TIMEOUT and NULL

        do
        {
                if(ICommRecvBufIsEmpty(pTG))
                        return TRUE;

                // sleep for a while, to give FMTRES etc some CPU cycles to catch
                // up with us. Can sleep just before sending response, since sender
                // waits upto 3 (6?) secs for it.
#ifndef FILET30
                IFProcSleep(1000);
#endif

                SendRNR(pTG);

        echoretry:
                ifrCommand = GetCommand(pTG, ifrRNRcommand);
                // if we hear our own frame, try to recv again. DONT retransmit!
                if(ifrCommand==ifrRNR) { ECHOMSG(ifrCommand); goto echoretry; }
        }
        while(  ifrCommand==ifrNULL || ifrCommand==ifrBAD ||
                        ifrCommand == ifrRR     ||
                        (ifrCommand >= ifrFirst && ifrCommand <= ifrLast) );

        // This means we exit on any valid frame _except_ RR and the PPS-X
        // or EOR-X we were expecting. We also exit on ifrTIMEOUT which is
        // when the GetCommand() times out without getting any CONNECT.
        // Otherwise we'd end up sending an MCF after timing out which
        // Ricoh's protocol tester doesnt like. (Ricoh's bug numbbers B3-0106)

        return FALSE;   // just hangs up after this
}








ECMRECVOK ECMRecvOK(PThrdGlbl pTG)
{
        USHORT N, i;

        N = ProtGetRecvECMFrameCount(pTG);
        // N==actual number of frames, i.e. PPR value+1

        faxTlog((SZMOD "ECMRecvChk %d frames\r\n", N));
        if(!N || N>256)
        {
                BG_CHK(FALSE);
                return ECMRECVOK_ABORT;
        }

        for(i=0; i<N; i++)
        {
                if(pTG->ECM.bRecvBadFrameMask[i/8] & (1 << (i%8)))
                {
                        faxTlog((SZMOD "ECMRecvChk--bad fr=%d\r\n", i));
                        return ECMRECVOK_BADFR;
                }
        }
        return ECMRECVOK_OK;
}








ET30ACTION      ECMRecvPhaseC(PThrdGlbl pTG, BOOL fRetrans)
{
        /******** Receiver ECM Phase C. Fig A-7/T.30 (sheet 1) ********/

        ULONG           lTotalLen=0;
        USHORT          uRet, uFrameNum, uRCPCount, uSize;
        USHORT          uRecvFrame, uMod;
        LPBUFFER        lpbf;
        LPBUFFER        lpbfShort;

        // There is a race between sending the CFR and sending out an
        // +FRM=xx command, so we want to do it ASAP.

        pTG->ECM.uFrameSize = ProtGetRecvECMFrameSize(pTG);
        BG_CHK(pTG->ECM.uFrameSize==6 || pTG->ECM.uFrameSize==8);
        uSize = (1 << pTG->ECM.uFrameSize);

        uMod = ProtGetRecvMod(pTG);
        if(uMod >= V17_START && !pTG->ECM.fRecvdCTC) uMod |= ST_FLAG;

        pTG->T30.sRecvBufSize = MY_ECMBUF_SIZE;

        if((uRet = ModemECMRecvMode(pTG, pTG->Params.hModem, uMod, PHASEC_TIMEOUT)) != RECV_OK)
        {
                ExitPageCrit();
                ERRMSG((SZMOD "<<WARNING>> ECMPhC: RecvMode ret=%d\r\n", uRet));

                if(!fRetrans)
                {
                        // in case we miss the page entirely
                        // and jump into PhaseD directly

                        // init bad frame bitmask to all-bad
                        memset(pTG->ECM.bRecvBadFrameMask, 0xFF, 32);        // all bad
                        // init the status vars for the PPS/EOR--(RR-RNR)*--PPR/MCF loop
                        pTG->ECM.ifrPrevCommand = 0;
                        // reset the FrameInThisBlock count. Reset only on
                        // non-retransmit. Set when first PPS is recvd
                        ProtResetRecvECMFrameCount(pTG);

                        if(pTG->ECM.fRecvEndOfPage)  // as opposed to end-of-block
                                uRet = (USHORT)PutRecvBuf(pTG, NULL, RECV_STARTPAGE);
                        else
                                uRet = (USHORT)PutRecvBuf(pTG, NULL, RECV_STARTBLOCK);

                        pTG->ECM.fRecvEndOfPage = FALSE;
                        if(!uRet)
                        {
                                ERRMSG((SZMOD "<<ERROR>> Got Error from PutRecvBuf at StartPage/Block\r\n"));
                                return actionERROR;
                        }
                        pTG->EchoProtect.modePrevRecv = modeECM;
                }
                else
                        pTG->EchoProtect.modePrevRecv = modeECMRETX;

                // set global flag if we got WRONGMODE
                pTG->EchoProtect.fGotWrongMode = (uRet==RECV_WRONGMODE);

                // elim flush--does no good & wastes 10ms
                // ModemFlush(pTG->Params.hModem);
                return actionGONODE_F;
                // try to get 300bps command instead
        }
        ExitPageCrit();

        // as soon as we get good carrier ZERO the pTG->EchoProtect state
        _fmemset(&pTG->EchoProtect, 0, sizeof(pTG->EchoProtect));

        // reset this flag AFTER we successfully recv LONG_TRAIN. We may get an
        // echo of our last command, go to NodeF, reject the echo and loop back
        // here. In that case we want to retry LONG train, otherwise we always
        // croak after a CTC
        pTG->ECM.fRecvdCTC = FALSE;

#ifdef IFAX
        BroadcastMessage(pTG, IF_PSIFAX_DATAMODE, (PSIFAX_RECV|PSIFAX_ECM|(fRetrans ? PSIFAX_RERECV : 0)), (uMod & (~ST_FLAG)));
#endif
        faxTlog((SZMOD "RECEIVING ECM Page.......\r\n"));
        if(fRetrans)
                ICommStatus(pTG, T30STATR_RERECV_ECM, 0, 0, 0);

        // Turn yielding on *after* entering receive mode safely!
        FComCriticalNeg(pTG, FALSE);

/***
        switch(action = pTG->Params.lpfnWhatNext(eventSTARTRECV))
        {
          case actionCONTINUE:  break;
          case actionDCN:               ERRMSG((SZMOD "<<ERROR>> Got actionDCN from eventSTARTRECV\r\n"));
                                                        return actionDCN;               // goto NodeC;
          case actionHANGUP:    ERRMSG((SZMOD "<<ERROR>> Got actionHANGUP from eventSTARTRECV\r\n"));
                                                        return action;  // goto NodeB;
          case actionERROR:             return action;
          default:                              return BadAction(action);
        }
***/

        if(!fRetrans)
        {
                memset(pTG->ECM.bRecvBadFrameMask, 0xFF, 32);
                ProtResetRecvECMFrameCount(pTG);

                if(pTG->ECM.fRecvEndOfPage)  // as opposed to end-of-block
                        uRet = (USHORT)PutRecvBuf(pTG, NULL, RECV_STARTPAGE);
                else
                        uRet = (USHORT)PutRecvBuf(pTG, NULL, RECV_STARTBLOCK);
                if(!uRet)
                {
                        ERRMSG((SZMOD "<<ERROR>> Got Error from PutRecvBuf at StartPage/Block\r\n"));
                        return actionERROR;
                }
        }
        pTG->ECM.ifrPrevCommand = 0;
        pTG->ECM.fRecvEndOfPage = FALSE;
        pTG->ECM.ifrPrevResponse = 0;


        DEBUGSTMT(if(fRetrans) D_PSIFAXCheckMask(pTG, pTG->ECM.bRecvBadFrameMask));


// make it large, in case of large buffers & slow modems
#define READ_TIMEOUT    25000

        lpbfShort=0;
        for(uFrameNum=0, lpbf=0, lTotalLen=0, uRCPCount=0, uRet=RECV_OK; uRet!=RECV_EOF;)
        {
                if(lpbf)
                {
                        faxTlog((SZMOD "<<WARNING>> ECM RecvPhC: Freeing leftover Buf 0x%08lx inside loop\r\n", lpbf));
                        MyFreeBuf(pTG,  lpbf);        // need to free after bad frames etc
                }

                lpbf = 0;
                uRet=ModemRecvBuf(pTG, pTG->Params.hModem, TRUE, &lpbf, READ_TIMEOUT);

                if(uRet == RECV_BADFRAME)
                {
                        ERRMSG((SZMOD "<<WARNING>> ModemRecvBuf returns BADFRAME\r\n"));
                        continue;
                }
                else if(uRet == RECV_EOF)
                {
                        BG_CHK(lpbf == 0);
                        if(lpbfShort)
                        {
                                lpbf = lpbfShort;
                                lpbfShort = 0;

                                if(fRetrans && ((USHORT)(lpbf->lpbBegData[3])+1 < ProtGetRecvECMFrameCount(pTG)))
                                {
                                        RETAILMSG((SZMOD "<<WARNING>> DISCARDING Short but not-really-terminal FCD frame(N=%d). len=%d. PADDING to %d!!\r\n",  lpbf->lpbBegData[3], lpbf->wLengthData, uSize+4));
                                        IFBufFree(lpbf);
                                        break;
                                }
                                else
                                {
                                        RETAILMSG((SZMOD "<<WARNING>> Short Terminal FCD frame(N=%d). len=%d. PADDING to %d!!\r\n",  lpbf->lpbBegData[3], lpbf->wLengthData, uSize+4));
                                        BG_CHK(lpbf->wLengthBuf >= uSize+4);
                                        _fmemset(lpbf->lpbBegData+lpbf->wLengthData, 0, (uSize+4-lpbf->wLengthData));
                                        lpbf->wLengthData = uSize+4;
                                        goto skipchks;
                                }
                        }
                        else
                                break;
                }
                else if(uRet != RECV_OK)
                {
                        ERRMSG((SZMOD "<<WARNING>> Got %d from RecvBuf in ECMREcvPhaseC\r\n", uRet));
                        break;
                }
                else if(lpbf==0)
                {
                        // sometimes we get RECV_OK with no data. Treat same as bad frame
                        continue;
                }

                BG_CHK(uRet==RECV_OK && lpbf && lpbf->lpbBegData);

                if(uRCPCount >= 3)
                {
                        ERRMSG((SZMOD "<<WARNING>> Got a good frame after %d RCP\r\n", uRCPCount));
                        continue;
                }

                if( lpbf->lpbBegData[0] != 0xFF ||
                        lpbf->lpbBegData[1] != 0x03 ||
                        (lpbf->lpbBegData[2] & 0x7F) != 0x06)
                {
                        ERRMSG((SZMOD "<<ERROR>> Bad frame (N=%d) not caught FCF=%02x!!\r\n", uFrameNum, lpbf->lpbBegData[2]));
                        BG_CHK(FALSE);
                        continue;
                }

                if(lpbf->lpbBegData[2] == 0x86)
                {
                        // got RCP
                        if(lpbf->wLengthData != 3)
                        {
                                ERRMSG((SZMOD "<<ERROR>> Bad RCP frame len=%d\r\n", lpbf->wLengthData));
                                BG_CHK(FALSE);
                                continue;
                        }
                        uRCPCount++;
                        faxTlog((SZMOD "Got %d RCP\r\n", uRCPCount));
#ifdef CL0
                        if(uRCPCount >= 3)
                        {
                                // tell modem that recv is done
                                // but keep calling RecvMem until we get RECV_EOF
                                ModemEndRecv(pTG, pTG->Params.hModem);
                        }
#endif //CL0
                        continue;
                }

                if(lpbfShort)
                {
                        ERRMSG((SZMOD "<<ERROR>> Short FCD frame(N=%d). len=%d DISCARDING\r\n", lpbfShort->lpbBegData[3], lpbfShort->wLengthData));
                        MyFreeBuf(pTG, lpbfShort);
                        lpbfShort = NULL;
                }
                if(lpbf->wLengthData > (uSize+4))
                {
                        ERRMSG((SZMOD "<<ERROR>> FCD frame too long(N=%d %d). len=%d. DISCARDING\r\n", uFrameNum, lpbf->lpbBegData[3], lpbf->wLengthData));
                        continue;
                }
                else if(lpbf->wLengthData < (uSize+4))
                {
                        RETAILMSG((SZMOD "<<WARNING>> Short FCD frame(N=%d %d). len=%d. Storing\r\n", uFrameNum, lpbf->lpbBegData[3], lpbf->wLengthData));
                        BG_CHK(lpbfShort==0);
                        lpbfShort = lpbf;
                        lpbf = NULL;
                        continue;
                }

skipchks:
                BG_CHK(lpbf->lpbBegData[2] == 0x06);
                BG_CHK(lpbf->wLengthData == (uSize+4));

                uRecvFrame = lpbf->lpbBegData[3];
                lpbf->lpbBegData += 4;
                lpbf->wLengthData -= 4;

                if(!fRetrans)
                {
                        if(uFrameNum > uRecvFrame)
                        {
                                ERRMSG((SZMOD "<<ERROR>> Out of order frame. Got %d Looking for %d\r\n", uRecvFrame, uFrameNum));
                                BG_CHK(FALSE);
                                // ignore this frame in non-debug mode
                                continue;
                        }
                        else if(uFrameNum < uRecvFrame)
                        {
                                if(!FillInFrames(pTG, (USHORT)(uRecvFrame-uFrameNum), pTG->T30.sRecvBufSize, uSize))
                                {
                                        ERRMSG((SZMOD "<<ERROR>> Zero return from PutRecvBuf in FillInFrames\r\n"));
                                        return actionERROR;
                                }
                        }
                        lTotalLen += lpbf->wLengthData;
                }
                uFrameNum = uRecvFrame;

                if(!fRetrans || (pTG->ECM.bRecvBadFrameMask[uFrameNum/8] & (1 << (uFrameNum%8))))
                {
                        BG_CHK(uFrameNum < 256 && pTG->ECM.uFrameSize <=8); // shift below wont ovf 16 bits
                        if(!PutRecvBuf(pTG, lpbf, (fRetrans ? ((SLONG)(uFrameNum << pTG->ECM.uFrameSize)) : RECV_SEQ)))
                        {
                                ERRMSG((SZMOD "<<ERROR>> Zero return from PutRecvBuf in page\r\n"));
                                return actionERROR;
                        }
                        pTG->ECM.bRecvBadFrameMask[uFrameNum/8] &= ~(1 << (uFrameNum%8));
                        uFrameNum++;
                        lpbf = 0;
                }
        }


        if(lpbf)
        {
                ERRMSG((SZMOD "<<ERROR>> ECMRecvPhC: Freeing leftover Buf 0x%08lx outside loop\r\n", lpbf));
                MyFreeBuf(pTG, lpbf);        // need to free after bad frames etc
        }

        if(uRet == RECV_EOF)
        {
                FComCriticalNeg(pTG, TRUE);
                // cant mark end of page until we know if end of page or block etc.
                // PutRecvBuf(NULL, RECV_ENDPAGE);              // to mark end of Page
        }
        else
        {
                ERRMSG((SZMOD "<<ERROR>> DataRead Timeout or Error=%d\r\n", uRet));
                BG_CHK(FALSE);
                ICommFailureCode(pTG, T30FAILRE_MODEMRECV_PHASEC);
                return actionERROR;     // goto error;
        }

        faxTlog((SZMOD "ECM Page Recv Done.....len=(%ld, 0x%08x)\r\n", lTotalLen, lTotalLen));
        ECHOPROTECT(0, 0);
        return actionGONODE_F;  // goto NodeF;                  // get post-message command
}









BOOL FillInFrames(PThrdGlbl pTG, USHORT N, LONG sBufSize, USHORT uDataSize)
{
        USHORT i;
        LPBUFFER        lpbf;

        for(i=0; i<N; i++)
        {
#ifdef IFK
                TstartTimeOut(pTG, &pTG->T30.toBuf, WAITFORBUF_TIMEOUT);
                while(!(lpbf = MyAllocBuf(pTG, sBufSize)))
                {
                        if(!TcheckTimeOut(pTG, &pTG->T30.toBuf))
                        {
                                ERRMSG((SZMOD "<<ERROR>> Giving up on BufAlloc in T30-ECM after %ld millisecs\r\n", ((ULONG)WAITFORBUF_TIMEOUT)));
                                BG_CHK(FALSE);
                                return FALSE;
                        }
                        RETAILMSG((SZMOD "<<ERROR>> BufAlloc failed in T30-pTG->ECM. Trying again\r\n"));
                        IFProcSleep(100);
                }
#else
                if(!(lpbf = MyAllocBuf( pTG, sBufSize)))
                        return FALSE;
#endif

                lpbf->wLengthData = uDataSize;

                if(!PutRecvBuf(pTG, lpbf, RECV_SEQBAD))
                {
                        ERRMSG((SZMOD "<<ERROR>> Zero return from PutRecvBuf in page\r\n"));
                        return FALSE;
                }
        }
        return TRUE;
}






#ifdef SWECM

USHORT ModemECMRecvMode(PThrdGlbl pTG, HMODEM h, USHORT uMod, ULONG ulTimeout)
{
        if(!SWECMRecvSetup(pTG, TRUE))
        {
                BG_CHK(FALSE);
                return RECV_ERROR;
        }
        return ModemRecvMode(pTG, h, uMod, FALSE, ulTimeout, ifrPIX_SWECM);
}

#endif //SWECM