1826 lines
57 KiB
C
1826 lines
57 KiB
C
/***************************************************************************
|
|
Name : DDI.C
|
|
|
|
Copyright (c) Microsoft Corp. 1991 1992 1993
|
|
|
|
Revision Log
|
|
Num Date Name Description
|
|
--- -------- ---------- -----------------------------------------------
|
|
***************************************************************************/
|
|
|
|
#pragma warning(disable:4100) // unreferenced formal param
|
|
|
|
#include "prep.h"
|
|
|
|
#include "mmsystem.h"
|
|
#include "comdevi.h"
|
|
#include "class1.h"
|
|
// #include "modem.h"
|
|
#include "debug.h"
|
|
#include "decoder.h"
|
|
|
|
///RSL
|
|
#include "glbproto.h"
|
|
|
|
|
|
#define faxTlog(m) DEBUGMSG(ZONE_DDI, m)
|
|
#define faxT2log(m) DEBUGMSG(ZONE_FRAMES, m)
|
|
#define FILEID FILEID_DDI
|
|
|
|
/* Converts a the T30 code for a speed to the Class1 code
|
|
* Generates V.17 with Long Training.
|
|
* Add 1 to V.17 codes to get teh Short-train version
|
|
*/
|
|
BYTE T30toC1[16] =
|
|
{
|
|
/* V27_2400 0 */ 24,
|
|
/* V29_9600 1 */ 96,
|
|
/* V27_4800 2 */ 48,
|
|
/* V29_7200 3 */ 72,
|
|
/* V33_14400 4 */ 145, // 144, // V33==V17_long_train FTM=144 is illegal
|
|
0,
|
|
/* V33_12000 6 */ 121, // 120, // V33==V17_long_train FTM=120 is illegal
|
|
/* V21 squeezed in */ 3,
|
|
/* V17_14400 8 */ 145,
|
|
/* V17_9600 9 */ 97,
|
|
/* V17_12000 10 */ 121,
|
|
/* V17_7200 11 */ 73,
|
|
0,
|
|
0,
|
|
0,
|
|
0
|
|
};
|
|
|
|
|
|
|
|
int T30toSpeed[16] =
|
|
{
|
|
/* V27_2400 0 */ 2400,
|
|
/* V29_9600 1 */ 9600,
|
|
/* V27_4800 2 */ 4800,
|
|
/* V29_7200 3 */ 7200,
|
|
/* V33_14400 4 */ 14400, // 144, // V33==V17_long_train FTM=144 is illegal
|
|
0,
|
|
/* V33_12000 6 */ 12000, // 120, // V33==V17_long_train FTM=120 is illegal
|
|
/* V21 squeezed in */ 300,
|
|
/* V17_14400 8 */ 14400,
|
|
/* V17_9600 9 */ 9600,
|
|
/* V17_12000 10 */ 12000,
|
|
/* V17_7200 11 */ 7200,
|
|
0,
|
|
0,
|
|
0,
|
|
0
|
|
};
|
|
|
|
// used only for checking
|
|
|
|
static BYTE SpeedtoCap[16] =
|
|
{
|
|
/* V27_2400 0 */ 0,
|
|
/* V29_9600 1 */ V29, // 1
|
|
/* V27_4800 2 */ V27, // 2
|
|
/* V29_7200 3 */ V29, // 1
|
|
/* V33_14400 4 */ V33, // 4
|
|
0,
|
|
/* V33_12000 6 */ V33, // 4
|
|
/* V21 squeezed in */ 0,
|
|
/* V17_14400 8 */ V17, // 8
|
|
/* V17_9600 9 */ V17, // 8
|
|
/* V17_12000 10 */ V17, // 8
|
|
/* V17_7200 11 */ V17, // 8
|
|
0,
|
|
0,
|
|
0,
|
|
0
|
|
};
|
|
|
|
|
|
CBSZ cbszFTH3 = "AT+FTH=3\r";
|
|
CBSZ cbszFRH3 = "AT+FRH=3\r";
|
|
|
|
CBSZ cbszFRS = "AT+FRS=%d\r";
|
|
CBSZ cbszFTS = "AT+FTS=%d\r";
|
|
CBSZ cbszFTM = "AT+FTM=%d\r";
|
|
CBSZ cbszFRM = "AT+FRM=%d\r";
|
|
|
|
#ifdef MDRV
|
|
CBSZ cbszOK, cbszCONNECT, cbszNOCARRIER, cbszERROR, cbszFCERROR;
|
|
#else //MDRV
|
|
|
|
// echo off, verbose response, no auto answer, hangup on DTR drop
|
|
// 30 seconds timer on connect, speaker always off, speaker volume=0
|
|
// busy&dialtone detect enabled
|
|
extern CBSZ cbszOK ;
|
|
extern CBSZ cbszCONNECT ;
|
|
extern CBSZ cbszNOCARRIER ;
|
|
extern CBSZ cbszERROR ;
|
|
extern CBSZ cbszFCERROR ;
|
|
|
|
#endif //MDRV
|
|
|
|
|
|
|
|
#define ST_MASK (0x8 | ST_FLAG) // 8 selects V17 only. 16 selects ST flag
|
|
|
|
/******************** Global Vars *********/
|
|
BYTE bDLEETX[3] = { DLE, ETX, 0 };
|
|
BYTE bDLEETXOK[9] = { DLE, ETX, '\r', '\n', 'O', 'K', '\r', '\n', 0 };
|
|
/******************** Global Vars *********/
|
|
|
|
|
|
|
|
|
|
/****************** begin prototypes from ddi.c *****************/
|
|
void iModemParamsReset(PThrdGlbl pTG);
|
|
void iModemInitGlobals(PThrdGlbl pTG);
|
|
|
|
// If defined, iModemRecvFrame retries FTH until timeout,
|
|
// if it receiving a null frame followed by ERROR or NO_CARRIER.
|
|
//#define USR_HACK
|
|
|
|
#ifdef USR_HACK
|
|
USHORT iModemFRHorM(PThrdGlbl pTG, ULONG ulTimeout);
|
|
#endif // USR_HACK
|
|
|
|
/****************** begin prototypes from ddi.c *****************/
|
|
|
|
|
|
#ifndef MDRV
|
|
|
|
#ifdef DEBUG
|
|
DBGPARAM dpCurSettings = {
|
|
"Modem Driver", 0x0000, {
|
|
"DDI", "Frames", "", "",
|
|
"Class0", "", "", "",
|
|
"", "", "SW Framing", "SW Framing Hi"
|
|
"Debug", "", "", "" },
|
|
// 0x00000FFF
|
|
// 0x00000001
|
|
// 0x0000000F0
|
|
// 0x00000400 // too much for 14400 ECM
|
|
// 0x00000F01
|
|
0x00000000
|
|
// 0xFFFFFFFF
|
|
};
|
|
#endif
|
|
|
|
|
|
#define szMODULENAME "awcl1_32"
|
|
|
|
|
|
#endif //MDRV
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void iModemInitGlobals(PThrdGlbl pTG)
|
|
{
|
|
|
|
_fmemset(&pTG->Class1Modem, 0, sizeof(CLASS1_MODEM));
|
|
_fmemset(&pTG->Class1Status, 0, sizeof(CLASS1_STATUS));
|
|
|
|
pTG->Class1Modem.eRecvFCS = RECV_FCS_NO;
|
|
|
|
#if 0 /// RSL #ifndef MDDI
|
|
{
|
|
LPCMDTAB lpCmdTab = iModemGetCmdTabPtr(pTG);
|
|
pTG->Class1Modem.eRecvFCS = RECV_FCS_DUNNO;
|
|
if (lpCmdTab)
|
|
{
|
|
if (lpCmdTab->dwFlags&fMDMSP_C1_FCS_NO)
|
|
pTG->Class1Modem.eRecvFCS = RECV_FCS_NO;
|
|
else if (lpCmdTab->dwFlags&fMDMSP_C1_FCS_YES_BAD)
|
|
pTG->Class1Modem.eRecvFCS = RECV_FCS_NOCHK;
|
|
}
|
|
}
|
|
#endif //!MDDI
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void iModemParamsReset(PThrdGlbl pTG)
|
|
{
|
|
_fmemset(&pTG->ModemParams, 0 , sizeof(pTG->ModemParams));
|
|
|
|
pTG->ModemParams.uSize = sizeof(pTG->ModemParams);
|
|
pTG->ModemParams.Class = FAXCLASS1;
|
|
|
|
// Don't use this. Need differnet number of flags according to speed
|
|
// pTG->ModemParams.PreambleFlags = 400; // 200ms @ 14400bps
|
|
pTG->ModemParams.InterframeFlags = 3; // random. one or two may do!
|
|
// pTG->ModemParams.InterframeFlags = 10; // too much!
|
|
|
|
// must be **less* than 50, so need a
|
|
// different length for each speed
|
|
// pTG->ModemParams.ClosingFlags = 50;
|
|
// pTG->ModemParams.fCEDOff = 0;
|
|
// pTG->ModemParams.fCNGOff = 0;
|
|
// pTG->ModemParams.InactivityTimer = 0;
|
|
|
|
// pTG->ModemParams.cbLineMin = 0;
|
|
// pTG->ModemParams.hJob = 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// added for CLASS0
|
|
BOOL ModemSetParams(PThrdGlbl pTG, USHORT uModem, LPMODEMPARAMS lpParams)
|
|
{
|
|
BG_CHK((uModem==1||uModem==5) && lpParams->uSize >= sizeof(MODEMPARAMS));
|
|
|
|
if(lpParams->Class && lpParams->Class != (-1))
|
|
{
|
|
#ifdef CL0
|
|
BG_CHK(lpParams->Class == FAXCLASS1 || lpParams->Class == FAXCLASS0);
|
|
#else //CL0
|
|
BG_CHK(lpParams->Class == FAXCLASS1);
|
|
#endif //CL0
|
|
|
|
pTG->ModemParams.Class = lpParams->Class;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
USHORT NCUDial(PThrdGlbl pTG, HLINE hLine, LPSTR szPhoneNum)
|
|
{
|
|
USHORT uRet;
|
|
|
|
D_PrintDDI("NCUDial", (USHORT)hLine, 0);
|
|
IF_BG_CHK(hLine==HLINE_2);
|
|
IF_BG_CHK(pTG->DDI.uComPort && pTG->DDI.fModemOpen && pTG->DDI.fLineInUse && pTG->DDI.fNCUModemLinked);
|
|
|
|
iModemInitGlobals(pTG);
|
|
|
|
#ifndef CL0
|
|
pTG->ModemParams.Class = FAXCLASS1;
|
|
#endif
|
|
|
|
if((uRet = iModemDial(pTG, szPhoneNum, pTG->ModemParams.Class)) == CONNECT_OK)
|
|
pTG->Class1Modem.ModemMode = FRH;
|
|
|
|
return uRet;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
USHORT NCULink(PThrdGlbl pTG, HLINE hLine, HMODEM hModem, USHORT uHandset, USHORT uFlags)
|
|
{
|
|
USHORT uRet;
|
|
|
|
D_PrintDDI("NCULink", (USHORT)hLine, (USHORT)hModem);
|
|
D_PrintDDI("NCULink", uHandset, uFlags);
|
|
IF_BG_CHK(hLine==HLINE_2);
|
|
IF_BG_CHK(pTG->DDI.uComPort && pTG->DDI.fModemOpen && pTG->DDI.fLineInUse);
|
|
|
|
switch(uFlags & NCULINK_MODEMASK)
|
|
{
|
|
case NCULINK_HANGUP:
|
|
if(iModemHangup(pTG))
|
|
{
|
|
MDDISTMT(pTG->pTG->DDI.fNCUModemLinked = FALSE);
|
|
uRet = CONNECT_OK;
|
|
}
|
|
else
|
|
uRet = CONNECT_ERROR;
|
|
break;
|
|
|
|
case NCULINK_TX:
|
|
MDDISTMT(pTG->DDI.fNCUModemLinked = TRUE);
|
|
uRet = CONNECT_OK;
|
|
break;
|
|
case NCULINK_RX:
|
|
iModemInitGlobals(pTG);
|
|
|
|
# ifdef MDDI
|
|
pTG->ModemParams.Class = FAXCLASS1;
|
|
# endif //MDDI
|
|
|
|
pTG->ModemParams.Class = FAXCLASS1; //RSL
|
|
if((uRet = iModemAnswer(pTG, (uFlags & NCULINK_IMMEDIATE), pTG->ModemParams.Class)) == CONNECT_OK)
|
|
{
|
|
MDDISTMT(pTG->DDI.fNCUModemLinked = TRUE);
|
|
pTG->Class1Modem.ModemMode = FTH;
|
|
}
|
|
break;
|
|
|
|
case NCULINK_OFFHOOK:
|
|
// fall through. Can't handle yet
|
|
default: BG_CHK(FALSE);
|
|
uRet = CONNECT_ERROR;
|
|
break;
|
|
}
|
|
//done:
|
|
MDDISTMT((MyDebugPrint(pTG, LOG_ALL, "NCULink: uRet=%d Linked=%d\r\n", uRet, pTG->DDI.fNCUModemLinked)));
|
|
return uRet;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// dangerous. May get 2 OKs, may get one. Generally avoid
|
|
// CBSZ cbszATAT = "AT\rAT\r";
|
|
CBSZ cbszAT1 = "AT\r";
|
|
|
|
BOOL iModemSyncEx(PThrdGlbl pTG, HMODEM hModem, ULONG ulTimeout, DWORD dwFlags);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
BOOL ModemSync(PThrdGlbl pTG, HMODEM hModem, ULONG ulTimeout)
|
|
{
|
|
return iModemSyncEx(pTG, hModem, ulTimeout, 0);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#ifndef MDDI
|
|
BOOL ModemSyncEx(PThrdGlbl pTG, HMODEM hModem, ULONG ulTimeout, DWORD dwFlags)
|
|
{
|
|
return iModemSyncEx(pTG, hModem, ulTimeout, dwFlags);
|
|
}
|
|
#endif // !MDDI
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
BOOL iModemSyncEx(PThrdGlbl pTG, HMODEM hModem, ULONG ulTimeout, DWORD dwFlags)
|
|
{
|
|
IF_BG_CHK(hModem==HMODEM_3 && pTG->DDI.uComPort && pTG->DDI.fModemOpen && pTG->DDI.fLineInUse && pTG->DDI.fNCUModemLinked);
|
|
faxIFlog(("In ModemSync fModemOpen=%d fLineInUse=%d\r\n", pTG->DDI.fModemOpen, pTG->DDI.fLineInUse));
|
|
|
|
///// Do cleanup of global state //////
|
|
FComOutFilterClose(pTG);
|
|
FComOverlappedIO(pTG, FALSE);
|
|
SWFramingSendSetup(pTG, FALSE);
|
|
SWFramingRecvSetup(pTG, FALSE);
|
|
FComXon(pTG, FALSE);
|
|
EndMode(pTG);
|
|
///// Do cleanup of global state //////
|
|
|
|
#ifdef CL0
|
|
if(pTG->ModemParams.Class == FAXCLASS0)
|
|
return TRUE;
|
|
#endif //CL0
|
|
|
|
{
|
|
LPCMDTAB lpCmdTab = iModemGetCmdTabPtr(pTG);
|
|
if (
|
|
#ifndef MDDI
|
|
(dwFlags & fMDMSYNC_DCN) &&
|
|
#endif //MDDI
|
|
pTG->Class1Modem.ModemMode == COMMAND
|
|
&& lpCmdTab
|
|
&& (lpCmdTab->dwFlags&fMDMSP_C1_NO_SYNC_IF_CMD) )
|
|
{
|
|
ERRMSG((SZMOD "<<WARNING>> ModemSync: NOT Syching modem (MSPEC)\r\n"));
|
|
#ifdef WIN32
|
|
Sleep(100); // +++ 4/12 JosephJ -- try to elim this -- it's juse
|
|
#endif // WIN32
|
|
// that we used to always issue an AT here, which
|
|
// we now don't, so I issue a 100ms delay here instead.
|
|
// MOST probably unnessary. The AT was issued by
|
|
// accident on 4/94 -- as a side effect of
|
|
// a change in T.30 code -- when ModemSync was
|
|
// called just before a normal dosconnect. Unfortunately
|
|
// we discovered in 4/95, 2 weeks before code freeze,
|
|
// that the AT&T DataPort express (TT14), didn't
|
|
// like this AT.
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
return (iModemPauseDialog(pTG, (LPSTR)cbszAT1, sizeof(cbszAT1)-1, ulTimeout, cbszOK)==1);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Does nothing in this driver
|
|
BOOL ModemFlush(PThrdGlbl pTG, HMODEM hModem)
|
|
{
|
|
D_PrintDDI("ModemFlush", (USHORT)hModem, 0);
|
|
IF_BG_CHK(hModem==HMODEM_3 && pTG->DDI.uComPort && pTG->DDI.fModemOpen && pTG->DDI.fLineInUse && pTG->DDI.fNCUModemLinked);
|
|
return TRUE;
|
|
}
|
|
|
|
// #if (PAGE_PREAMBLE_DIV != 0)
|
|
|
|
// length of TCF = 1.5 * bpscode * 100 / 8 == 75 * bpscode / 4
|
|
USHORT TCFLen[16] =
|
|
{
|
|
/* V27_2400 0 */ 450,
|
|
/* V29_9600 1 */ 1800,
|
|
/* V27_4800 2 */ 900,
|
|
/* V29_7200 3 */ 1350,
|
|
/* V33_14400 4 */ 2700,
|
|
0,
|
|
/* V33_12000 6 */ 2250,
|
|
0,
|
|
/* V17_14400 8 */ 2700,
|
|
/* V17_9600 9 */ 1800,
|
|
/* V17_12000 10 */ 2250,
|
|
/* V17_7200 11 */ 1350,
|
|
0,
|
|
0,
|
|
0,
|
|
0
|
|
};
|
|
|
|
|
|
#define min(x,y) (((x) < (y)) ? (x) : (y))
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void SendZeros1(PThrdGlbl pTG, USHORT uCount)
|
|
{
|
|
#define ZERO_BUFSIZE 256
|
|
BYTE bZero[ZERO_BUFSIZE];
|
|
short i; // must be signed
|
|
|
|
_fmemset(bZero, 0, ZERO_BUFSIZE);
|
|
for(i=uCount; i>0; i -= ZERO_BUFSIZE)
|
|
{
|
|
// no need to stuff. They're all zeros!
|
|
FComDirectAsyncWrite(pTG, bZero, (UWORD)(min((UWORD)i, (UWORD)ZERO_BUFSIZE)));
|
|
}
|
|
TRACE((SZMOD "Sent %d zeros\r\n", uCount));
|
|
}
|
|
// #endif //PAGE_PREAMBLE_DIV != 0
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
BOOL ModemSendMode(PThrdGlbl pTG, HMODEM hModem, USHORT uMod, BOOL fHDLC, USHORT ifrHint)
|
|
{
|
|
#ifdef CL0
|
|
if(pTG->ModemParams.Class == FAXCLASS0)
|
|
return Class0ModemSendMode(pTG, hModem, fHDLC);
|
|
#endif //CL0
|
|
|
|
BG_CHK(ifrHint && ifrHint < ifrEND);
|
|
IF_BG_CHK(hModem==HMODEM_3 && pTG->DDI.uComPort && pTG->DDI.fModemOpen && pTG->DDI.fLineInUse && pTG->DDI.fNCUModemLinked);
|
|
|
|
pTG->Class1Modem.CurMod = T30toC1[uMod & 0xF];
|
|
|
|
pTG->CurrentCommSpeed = T30toSpeed[uMod & 0xF];
|
|
|
|
BG_CHK(pTG->Class1Modem.CurMod);
|
|
|
|
if((uMod & ST_MASK) == ST_MASK) // mask selects V.17 and ST bits
|
|
pTG->Class1Modem.CurMod++;
|
|
// BG_CHK((pTG->Class1Modem.CurMod>24 && ModemCaps.uSendSpeeds!=V27_V29_V33_V17) ?
|
|
// (SpeedtoCap[uMod & 0xF] & ModemCaps.uSendSpeeds) : 1);
|
|
|
|
(MyDebugPrint(pTG, LOG_ALL, "In ModemSendMode uMod=%d CurMod=%d fHDLC=%d\r\n", uMod, pTG->Class1Modem.CurMod, fHDLC));
|
|
|
|
if(uMod == V21_300)
|
|
{
|
|
BG_CHK(pTG->Class1Modem.CurMod == 3);
|
|
_fstrcpy(pTG->Class1Modem.bCmdBuf, (LPSTR)cbszFTH3);
|
|
pTG->Class1Modem.uCmdLen = sizeof(cbszFTH3)-1;
|
|
pTG->Class1Modem.fHDLC = TRUE;
|
|
FComXon(pTG, FALSE); // for safety. _May_ be critical
|
|
}
|
|
else
|
|
{
|
|
pTG->Class1Modem.uCmdLen = (USHORT)wsprintf(pTG->Class1Modem.bCmdBuf, cbszFTM, pTG->Class1Modem.CurMod);
|
|
pTG->Class1Modem.fHDLC = FALSE;
|
|
FComXon(pTG, TRUE); // critical!! Start of PhaseC
|
|
// no harm doing it here(i.e before issuing +FTM)
|
|
|
|
if(fHDLC)
|
|
{
|
|
if(!SWFramingSendSetup(pTG, TRUE))
|
|
{
|
|
BG_CHK(FALSE);
|
|
goto error2;
|
|
}
|
|
}
|
|
}
|
|
FComOutFilterInit(pTG); // _not_ used for 300bps HDLC
|
|
// but here just in case
|
|
|
|
// want to do all the work _before_ issuing command
|
|
|
|
pTG->Class1Modem.DriverMode = SEND;
|
|
pTG->Class1Status.ifrHint = ifrHint; // need this before ModemDialog
|
|
|
|
if(pTG->Class1Modem.ModemMode == FTH)
|
|
{
|
|
// already in send mode. This happens on Answer only
|
|
BG_CHK(fHDLC && uMod==V21_300);
|
|
BG_CHK(pTG->Class1Modem.CurMod==3 && pTG->Class1Modem.fHDLC == TRUE);
|
|
return TRUE;
|
|
}
|
|
|
|
#define STARTSENDMODE_TIMEOUT 5000 // Random Timeout
|
|
|
|
//// Try to cut down delay between getting CONNECT and writing the
|
|
// first 00s (else modems can quit because of underrun).
|
|
// Can do this by not sleeping in this. Only in fatal
|
|
// cases will it lock up for too long (max 5secs). In those cases
|
|
// the call is trashed too.
|
|
|
|
FComCritical(pTG, TRUE); // start Crit in ModemSendMode
|
|
|
|
if(!iModemNoPauseDialog(pTG, (LPB)pTG->Class1Modem.bCmdBuf, pTG->Class1Modem.uCmdLen, STARTSENDMODE_TIMEOUT, cbszCONNECT))
|
|
{
|
|
FComCritical(pTG, FALSE); // end Crit in ModemSendMode
|
|
goto error;
|
|
}
|
|
|
|
// can't set this earlier. We'll trash previous value
|
|
pTG->Class1Modem.ModemMode = ((uMod==V21_300) ? FTH : FTM);
|
|
|
|
// Turn OFF overlapped I/O if in V.21 else ON
|
|
FComOverlappedIO(pTG, uMod != V21_300);
|
|
|
|
if(pTG->Class1Modem.fSendSWFraming) // set in SWFramingSendSetup
|
|
{
|
|
SWFramingSendPreamble(pTG, pTG->Class1Modem.CurMod);
|
|
}
|
|
#if (PAGE_PREAMBLE_DIV != 0)
|
|
else if(pTG->Class1Modem.ModemMode == FTM)
|
|
{
|
|
// don't send 00s if ECM
|
|
BG_CHK(ifrHint==ifrPIX_MH || ifrHint==ifrPIX_MR || ifrHint==ifrTCF);
|
|
BG_CHK(PAGE_PREAMBLE_DIV);
|
|
SendZeros1(pTG, (USHORT)(TCFLen[uMod & 0x0F] / PAGE_PREAMBLE_DIV));
|
|
}
|
|
#else
|
|
else if(ifrHint==ifrPIX_MH || ifrHint==ifrPIX_MR)
|
|
{
|
|
// even if MDDI is on need to send some 00s otherwise
|
|
// some modems underrun and hangup
|
|
SendZeros1(pTG, TCFLen[uMod & 0x0F] / 2);
|
|
}
|
|
#endif
|
|
|
|
// FComDrain(-,FALSE) causes fcom to write out any internally-
|
|
// maintained buffers, but not to drain the comm-driver buffers.
|
|
FComDrain(pTG, TRUE,FALSE);
|
|
|
|
|
|
FComCritical(pTG, FALSE); // end Crit in ModemSendMode
|
|
|
|
TRACE((SZMOD "Starting Send at %d\r\n", pTG->Class1Modem.CurMod));
|
|
return TRUE;
|
|
|
|
error:
|
|
FComOutFilterClose(pTG);
|
|
FComOverlappedIO(pTG, FALSE);
|
|
SWFramingSendSetup(pTG, FALSE);
|
|
error2:
|
|
FComXon(pTG, FALSE); // important. Cleanup on error
|
|
EndMode(pTG);
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
BOOL iModemDrain(PThrdGlbl pTG)
|
|
{
|
|
(MyDebugPrint(pTG, LOG_ALL, "Entering iModemDrain\r\n"));
|
|
|
|
if(!FComDrain(pTG, TRUE, TRUE))
|
|
return FALSE;
|
|
|
|
// Must turn XON/XOFF off immediately *after* drain, but before we
|
|
// send the next AT command, since recieved frames have 0x13 or
|
|
// even 0x11 in them!! MUST GO AFTER the getOK ---- See BELOW!!!!
|
|
|
|
// increase this---see bug number 495. Must be big enough for
|
|
// COM_OUTBUFSIZE to safely drain at 2400bps(300bytes/sec = 0.3bytes/ms)
|
|
// let's say (COM_OUTBUFSIZE * 10 / 3) == (COM_OUTBUFSIZE * 4)
|
|
// can be quite long, because on failure we just barf anyway
|
|
|
|
#ifdef CL0
|
|
if(pTG->ModemParams.Class == FAXCLASS0)
|
|
return TRUE;
|
|
#endif //CL0
|
|
|
|
#define POSTPAGEOK_TIMEOUT (10000L + (((ULONG)COM_OUTBUFSIZE) << 2))
|
|
|
|
// Here we were looking for OK only, but some modems (UK Cray Quantun eg)
|
|
// give me an ERROR after sending TCF or a page (at speeds < 9600) even
|
|
// though the page was sent OK. So we were timing out here. Instead look
|
|
// for ERROR (and NO CARRIER too--just in case!), and accept those as OK
|
|
// No point returning ERROR from here, since we just abort. We can't/don't
|
|
// recover from send errors
|
|
// if(!iModemResp1(POSTPAGEOK_TIMEOUT, cbszOK))
|
|
|
|
if(iModemResp3(pTG, POSTPAGEOK_TIMEOUT, cbszOK, cbszERROR, cbszNOCARRIER) == 0)
|
|
return FALSE;
|
|
|
|
// Must change FlowControl State *after* getting OK because in Windows
|
|
// this call takes 500 ms & resets chips, blows away data etc.
|
|
// So do this *only* when you *know* both RX & TX are empty.
|
|
// check this in all usages of this function
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL iModemSendData(PThrdGlbl pTG, LPB lpb, USHORT uCount, USHORT uFlags)
|
|
{
|
|
BG_CHK((uFlags & SEND_ENDFRAME) == 0);
|
|
BG_CHK(lpb);
|
|
BG_CHK(!pTG->Class1Modem.fSendSWFraming);
|
|
|
|
// if(uFlags & SEND_STUFF)
|
|
{
|
|
// always DLE-stuff here. Sometimes zero-stuff
|
|
|
|
(MyDebugPrint(pTG, LOG_ALL, "In ModemSendData calling FComFilterAsyncWrite at %ld \n", GetTickCount() ) );
|
|
|
|
if(!FComFilterAsyncWrite(pTG, lpb, uCount, FILTER_DLEZERO))
|
|
goto error;
|
|
}
|
|
/*******
|
|
else
|
|
{
|
|
if(!FComDirectAsyncWrite(pTG, lpb, uCount))
|
|
goto error;
|
|
}
|
|
*******/
|
|
|
|
if(uFlags & SEND_FINAL)
|
|
{
|
|
(MyDebugPrint(pTG, LOG_ALL, "In ModemSendData calling FComDIRECTAsyncWrite at %ld \n", GetTickCount() ) );
|
|
|
|
// if(!FComDirectAsyncWrite(bDLEETXCR, 3))
|
|
if(!FComDirectAsyncWrite(pTG, bDLEETX, 2))
|
|
goto error;
|
|
|
|
if(!iModemDrain(pTG))
|
|
goto error;
|
|
|
|
FComOutFilterClose(pTG);
|
|
FComOverlappedIO(pTG, FALSE);
|
|
FComXon(pTG, FALSE); // critical. End of PhaseC
|
|
// must come after Drain
|
|
EndMode(pTG);
|
|
}
|
|
return TRUE;
|
|
|
|
error:
|
|
FComXon(pTG, FALSE); // critical. End of PhaseC (error)
|
|
FComFlush(pTG); // clean out the bad stuff if we got an error
|
|
FComOutFilterClose(pTG);
|
|
FComOverlappedIO(pTG, FALSE);
|
|
EndMode(pTG);
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
BOOL iModemSendFrame(PThrdGlbl pTG, LPB lpb, USHORT uCount, USHORT uFlags)
|
|
{
|
|
UWORD uwResp=0;
|
|
|
|
(MyDebugPrint(pTG, LOG_ALL, "Entering iModemSendFrame\r\n"));
|
|
|
|
BG_CHK(uFlags & SEND_ENDFRAME);
|
|
BG_CHK(lpb && uCount);
|
|
BG_CHK(!pTG->Class1Modem.fSendSWFraming);
|
|
|
|
// always DLE-stuff here. Never zero-stuff
|
|
// This is only called for 300bps HDLC
|
|
BG_CHK(pTG->Class1Modem.fHDLC && pTG->Class1Modem.CurMod == 3);
|
|
|
|
if(pTG->Class1Modem.ModemMode != FTH) // Special case on just answering!!
|
|
{
|
|
#define FTH_TIMEOUT 5000 // Random Timeout
|
|
if(!iModemNoPauseDialog(pTG, (LPB)pTG->Class1Modem.bCmdBuf, pTG->Class1Modem.uCmdLen, FTH_TIMEOUT, cbszCONNECT))
|
|
goto error;
|
|
}
|
|
|
|
// if(uFlags & SEND_STUFF)
|
|
{
|
|
// always DLE-stuff here. Never zero-stuff
|
|
if(!FComFilterAsyncWrite(pTG, lpb, uCount, FILTER_DLEONLY))
|
|
goto error;
|
|
}
|
|
/***
|
|
else
|
|
{
|
|
if(!FComDirectAsyncWrite(pTG, lpb, uCount))
|
|
goto error;
|
|
}
|
|
***/
|
|
|
|
|
|
// if(uFlags & SEND_STUFF)
|
|
{
|
|
// SyncWrite call Drain here which we should not need
|
|
// as we are immediately waiting for a response
|
|
// if(!FComDirectSyncWrite(bDLEETX, 2))
|
|
// goto error;
|
|
|
|
if(!FComDirectAsyncWrite(pTG, bDLEETX, 2))
|
|
goto error;
|
|
}
|
|
|
|
// 2000 is too short because PPRs can be 32+7 bytes long and
|
|
// preamble is 1 sec, so set this to 3000
|
|
// 3000 is too short because NSFs and CSIs can be arbitrarily long
|
|
// MAXFRAMESIZE is defined in et30type.h. 30ms/byte at 300bps
|
|
// async (I think V.21 is syn though), so use N*30+1000+slack
|
|
|
|
#define WRITEFRAMERESP_TIMEOUT (1000+30*MAXFRAMESIZE+500)
|
|
if(!(uwResp = iModemResp2(pTG, WRITEFRAMERESP_TIMEOUT, cbszOK, cbszCONNECT)))
|
|
goto error;
|
|
pTG->Class1Modem.ModemMode = ((uwResp == 2) ? FTH : COMMAND);
|
|
|
|
|
|
if(uFlags & SEND_FINAL)
|
|
{
|
|
FComOutFilterClose(pTG);
|
|
FComOverlappedIO(pTG, FALSE);
|
|
// FComXon(FALSE); // at 300bps. no Xon-Xoff in use
|
|
|
|
// in some weird cases (Practical Peripherals PM14400FXMT) we get
|
|
// CONNECT<cr><lf>OK, but we get the CONNECT here. Should we
|
|
// just set pTG->Class1Modem.ModemMode=COMMAND?? (EndMode does that)
|
|
// Happens on PP 144FXSA also. Ignore it & just set mode to COMMAND
|
|
// BG_CHK(pTG->Class1Modem.ModemMode == COMMAND);
|
|
EndMode(pTG);
|
|
}
|
|
// ST_FRAMES(TRACE((SZMOD "FRAME SENT-->\r\n")); D_PrintFrame(lpb, uCount));
|
|
return TRUE;
|
|
|
|
error:
|
|
FComOutFilterClose(pTG);
|
|
FComOverlappedIO(pTG, FALSE);
|
|
FComXon(pTG, FALSE); // just for safety. cleanup on error
|
|
EndMode(pTG);
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
BOOL ModemSendMem(PThrdGlbl pTG, HMODEM hModem, LPBYTE lpb, USHORT uCount, USHORT uFlags)
|
|
{
|
|
#ifdef CL0
|
|
if(pTG->ModemParams.Class == FAXCLASS0)
|
|
return Class0ModemSendMem(pTG, hModem, lpb, uCount, uFlags);
|
|
#endif //CL0
|
|
|
|
IF_BG_CHK(hModem==HMODEM_3 && pTG->DDI.uComPort && pTG->DDI.fModemOpen && pTG->DDI.fLineInUse && pTG->DDI.fNCUModemLinked);
|
|
BG_CHK(pTG->Class1Modem.CurMod);
|
|
BG_CHK(lpb);
|
|
(MyDebugPrint(pTG, LOG_ALL, "In ModemSendMem lpb=%08lx uCount=%d wFlags=%04x\r\n", lpb, uCount, uFlags));
|
|
|
|
if(pTG->Class1Modem.DriverMode != SEND)
|
|
{
|
|
BG_CHK(FALSE);
|
|
return FALSE;
|
|
}
|
|
|
|
if(pTG->Class1Modem.fSendSWFraming)
|
|
return SWFramingSendFrame(pTG, lpb, uCount, uFlags);
|
|
else if(pTG->Class1Modem.fHDLC)
|
|
return iModemSendFrame(pTG, lpb, uCount, uFlags);
|
|
else
|
|
return iModemSendData(pTG, lpb, uCount, uFlags);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void TwiddleThumbs(ULONG ulTime);
|
|
|
|
#ifndef MDRV
|
|
void TwiddleThumbs(ULONG ulTime)
|
|
{
|
|
MY_TWIDDLETHUMBS(ulTime);
|
|
}
|
|
#endif //MDRV
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
BOOL ModemSendSilence(PThrdGlbl pTG, HMODEM hModem, USHORT uMillisecs, ULONG ulTimeout)
|
|
{
|
|
//USHORT uTemp;
|
|
|
|
IF_BG_CHK(hModem==HMODEM_3 && pTG->DDI.uComPort && pTG->DDI.fModemOpen && pTG->DDI.fLineInUse && pTG->DDI.fNCUModemLinked);
|
|
(MyDebugPrint(pTG, LOG_ALL, "Before ModemSendSilence uMillsecs=%d ulTimeout=%ld at %ld\r\n",
|
|
uMillisecs, ulTimeout, GetTickCount() ));
|
|
|
|
#ifdef CL0
|
|
if(pTG->ModemParams.Class == FAXCLASS0)
|
|
return TRUE;
|
|
#endif //CL0
|
|
|
|
// we're so slow it seems we don't need to and should not do this
|
|
// I measured teh dealy due to this (FTS=10) to be about 500ms,
|
|
// all of it on our side (dunno why?) except exactly the 100ms
|
|
// by the modem. If we really want to insert teh delay we should
|
|
// use TwiddleThumbs
|
|
// Can't just return here, because we do _need_ the delay between
|
|
// send DCS and send TCF so that receiver is not overwhelmed
|
|
// return TRUE;
|
|
|
|
// use TwiddleThumbs
|
|
TwiddleThumbs(uMillisecs);
|
|
|
|
(MyDebugPrint(pTG, LOG_ALL, "After ModemSendSilence at %ld\r\n", GetTickCount() ));
|
|
|
|
|
|
return TRUE;
|
|
|
|
// uTemp = wsprintf(pTG->Class1Modem.bCmdBuf, cbszFTS, uMillisecs/10);
|
|
// return (iModemNoPauseDialog((LPB)pTG->Class1Modem.bCmdBuf, uTemp, ulTimeout, cbszOK) == 1);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
BOOL ModemRecvSilence(PThrdGlbl pTG, HMODEM hModem, USHORT uMillisecs, ULONG ulTimeout)
|
|
{
|
|
// USHORT uTemp;
|
|
// CBPSTR cbpstr;
|
|
|
|
D_PrintDDI("RecvSilence", (USHORT)hModem, uMillisecs);
|
|
IF_BG_CHK(hModem==HMODEM_3 && pTG->DDI.uComPort && pTG->DDI.fModemOpen && pTG->DDI.fLineInUse && pTG->DDI.fNCUModemLinked);
|
|
(MyDebugPrint(pTG, LOG_ALL, "Before ModemRecvSilence uMillsecs=%d ulTimeout=%ld at %ld \r\n",
|
|
uMillisecs, ulTimeout, GetTickCount() ));
|
|
|
|
#ifdef CL0
|
|
if(pTG->ModemParams.Class == FAXCLASS0)
|
|
return TRUE;
|
|
#endif //CL0
|
|
|
|
// can't use AT+FRS -- see above for why. Basically, we take so long
|
|
// sending the command and getting teh reply etc, that we can't use
|
|
// it accurately. So use TwiddleThumbs.
|
|
|
|
TwiddleThumbs(uMillisecs);
|
|
|
|
(MyDebugPrint(pTG, LOG_ALL, "After ModemRecvSilence at %ld \r\n", GetTickCount() ));
|
|
|
|
return TRUE;
|
|
|
|
// uTemp = wsprintf(pTG->Class1Modem.bCmdBuf, cbpstr, uMillisecs/10);
|
|
// return (iModemNoPauseDialog((LPB)pTG->Class1Modem.bCmdBuf, uTemp, ulTimeout, cbszOK)==1);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#define MINRECVMODETIMEOUT 500
|
|
#define RECVMODEPAUSE 200
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
USHORT ModemRecvMode(PThrdGlbl pTG, HMODEM hModem, USHORT uMod, BOOL fHDLC, ULONG ulTimeout, USHORT ifrHint)
|
|
{
|
|
USHORT uRet;
|
|
ULONG ulBefore, ulAfter, ulDelta;
|
|
|
|
#ifdef CL0
|
|
if(pTG->ModemParams.Class == FAXCLASS0)
|
|
return Class0ModemRecvMode(pTG, hModem, fHDLC, ulTimeout);
|
|
#endif //CL0
|
|
|
|
// Here we should watch for a different modulation scheme from what we expect.
|
|
// Modems are supposed to return a +FCERROR code to indicate this condition,
|
|
// but I have not seen it from any modem yet, so we just scan for ERROR
|
|
// (this will catch +FCERROR too since iiModemDialog does not expect whole
|
|
// words or anything like that!), and treat both the same.
|
|
|
|
pTG->Class1Modem.CurMod = T30toC1[uMod & 0xF];
|
|
|
|
pTG->CurrentCommSpeed = T30toSpeed[uMod & 0xF];
|
|
|
|
BG_CHK(pTG->Class1Modem.CurMod);
|
|
if((uMod & ST_MASK) == ST_MASK) // mask selects V.17 and ST bits
|
|
pTG->Class1Modem.CurMod++;
|
|
|
|
if(uMod == V21_300)
|
|
{
|
|
BG_CHK(fHDLC && pTG->Class1Modem.CurMod==3);
|
|
_fstrcpy(pTG->Class1Modem.bCmdBuf, (LPSTR)cbszFRH3);
|
|
pTG->Class1Modem.uCmdLen = sizeof(cbszFRH3)-1;
|
|
}
|
|
else
|
|
{
|
|
pTG->Class1Modem.uCmdLen = (USHORT)wsprintf(pTG->Class1Modem.bCmdBuf, cbszFRM, pTG->Class1Modem.CurMod);
|
|
}
|
|
|
|
pTG->Class1Status.ifrHint = ifrHint; // need this before ModemDialog
|
|
|
|
if(pTG->Class1Modem.ModemMode == FRH)
|
|
{
|
|
// already in receive mode. This happens upon Dial only
|
|
BG_CHK(fHDLC && uMod==V21_300);
|
|
BG_CHK(pTG->Class1Modem.CurMod == 3);
|
|
|
|
pTG->Class1Modem.fHDLC = TRUE;
|
|
pTG->Class1Modem.DriverMode = RECV;
|
|
pTG->Class1Modem.fRecvNotStarted = TRUE; // fNoFlags = FALSE;
|
|
// pTG->Class1Modem.sRecvBufSize = sBufSize;
|
|
FComInFilterInit(pTG);
|
|
return RECV_OK;
|
|
}
|
|
|
|
|
|
#ifdef WIN32
|
|
// On Win32, we have a problem going into 2400baud recv.
|
|
// +++ remember to put this into iModemFRHorM when that code is enabled.
|
|
if (pTG->Class1Modem.CurMod==24) TwiddleThumbs(80);
|
|
#endif // WIN32
|
|
|
|
#ifdef USR_HACK
|
|
uRet = iModemFRHorM(pTG, ulTimeout);
|
|
#else // !USR_HACK (iModemFRHorM contains the following code..)
|
|
retry:
|
|
|
|
ulBefore=GetTickCount();
|
|
// Don't look for NO CARRIER. Want it to retry until FRM timeout on NO CARRIER
|
|
// ----This is changed. See below----
|
|
uRet = iModemNoPauseDialog3(pTG, pTG->Class1Modem.bCmdBuf, pTG->Class1Modem.uCmdLen, ulTimeout, cbszCONNECT, cbszFCERROR, cbszNOCARRIER);
|
|
// uRet = iModemNoPauseDialog2(pTG->Class1Modem.bCmdBuf, pTG->Class1Modem.uCmdLen, ulTimeout, cbszCONNECT, cbszFCERROR);
|
|
ulAfter=GetTickCount();
|
|
|
|
if(uRet==2 || uRet==3) // uRet==FCERROR or uRet==NOCARRIER
|
|
{
|
|
ulDelta = (ulAfter >= ulBefore) ? (ulAfter - ulBefore) : (0xFFFFFFFFL - ulBefore) + ulAfter;
|
|
|
|
if(ulTimeout < (ulDelta + MINRECVMODETIMEOUT))
|
|
{
|
|
ERRMSG((SZMOD "<<WARNING>> Giving up on RecvMode. uRet=%d ulTimeout=%ld\r\n", uRet, ulTimeout));
|
|
}
|
|
else
|
|
{
|
|
ulTimeout -= (ulAfter-ulBefore);
|
|
|
|
// need this pause for NO CARRIER for USR modems. See bug#1516
|
|
// for the RC229DP, dunno if it's reqd because I dunno why theyre
|
|
// giving the FCERROR. Don't want to miss the carrier so currently
|
|
// don't pause. (Maybe we can achieve same effect by simply taking
|
|
// FCERROR out of the response list above--but that won't work for
|
|
// NOCARRIER because we _need_ teh pause. iiModemDialog is too fast)
|
|
if(uRet == 3)
|
|
TwiddleThumbs(RECVMODEPAUSE);
|
|
BG_CHK(ulTimeout >= MINRECVMODETIMEOUT);
|
|
|
|
goto retry;
|
|
}
|
|
}
|
|
#endif // !USR_HACK
|
|
|
|
(MyDebugPrint(pTG, LOG_ALL, "Ex ModemRecvMode uMod=%d CurMod=%d fHDLC=%d ulTimeout=%ld: Got=%d\r\n", uMod, pTG->Class1Modem.CurMod, fHDLC, ulTimeout, uRet));
|
|
if(uRet != 1)
|
|
{
|
|
EndMode(pTG);
|
|
if(uRet == 2)
|
|
{
|
|
ERRMSG((SZMOD "<<WARNING>> RecvMode:: Got FCERROR after %ldms\r\n", ulAfter-ulBefore));
|
|
return RECV_WRONGMODE; // need to return quickly
|
|
}
|
|
else
|
|
{
|
|
BG_CHK(uRet == 0);
|
|
ERRMSG((SZMOD "<<WARNING>> RecvMode:: Got Timeout after %ldms\r\n", ulAfter-ulBefore));
|
|
return RECV_TIMEOUT;
|
|
}
|
|
}
|
|
|
|
BG_CHK(ifrHint && ifrHint < ifrEND);
|
|
IF_BG_CHK(hModem==HMODEM_3 && pTG->DDI.uComPort && pTG->DDI.fModemOpen && pTG->DDI.fLineInUse && pTG->DDI.fNCUModemLinked);
|
|
BG_CHK(pTG->Class1Modem.CurMod);
|
|
// BG_CHK((pTG->Class1Modem.CurMod>24 && ModemCaps.uRecvSpeeds!=V27_V29_V33_V17) ?
|
|
// (SpeedtoCap[uMod & 0xF] & ModemCaps.uRecvSpeeds) : 1);
|
|
|
|
if(uMod==V21_300)
|
|
{
|
|
pTG->Class1Modem.ModemMode = FRH;
|
|
pTG->Class1Modem.fHDLC = TRUE;
|
|
}
|
|
else
|
|
{
|
|
pTG->Class1Modem.ModemMode = FRM;
|
|
pTG->Class1Modem.fHDLC = FALSE;
|
|
if(fHDLC)
|
|
{
|
|
if(!SWFramingRecvSetup(pTG, TRUE))
|
|
{
|
|
BG_CHK(FALSE);
|
|
EndMode(pTG);
|
|
return RECV_ERROR;
|
|
}
|
|
}
|
|
}
|
|
// pTG->Class1Modem.sRecvBufSize = sBufSize;
|
|
pTG->Class1Modem.DriverMode = RECV;
|
|
pTG->Class1Modem.fRecvNotStarted = TRUE; // fNoFlags = FALSE;
|
|
FComInFilterInit(pTG);
|
|
TRACE((SZMOD "Starting Recv at %d\r\n", pTG->Class1Modem.CurMod));
|
|
return RECV_OK;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef CL0
|
|
void ModemEndRecv(PThrdGlbl pTG, HMODEM hModem)
|
|
{
|
|
#ifdef CL0
|
|
if(pTG->ModemParams.Class == FAXCLASS0)
|
|
Class0ModemEndRecv(pTG, hModem);
|
|
#endif //CL0
|
|
}
|
|
#endif //CL0
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
USHORT iModemRecvData(PThrdGlbl pTG, LPB lpb, USHORT cbMax, ULONG ulTimeout, USHORT far* lpcbRecv)
|
|
{
|
|
SWORD swEOF;
|
|
USHORT uRet;
|
|
|
|
BG_CHK(pTG->Class1Modem.ModemMode == FRM);
|
|
BG_CHK(lpb && cbMax && lpcbRecv);
|
|
BG_CHK(!pTG->Class1Modem.fRecvSWFraming);
|
|
|
|
startTimeOut(pTG, &(pTG->Class1Modem.toRecv), ulTimeout);
|
|
// 4th arg must be FALSE for Class1
|
|
*lpcbRecv = FComFilterReadBuf(pTG, lpb, cbMax, &(pTG->Class1Modem.toRecv), FALSE, &swEOF);
|
|
if(swEOF == -1)
|
|
{
|
|
// we got a DLE-ETX _not_ followed by OK or NO CARRIER. So now
|
|
// we have to decide whether to (a) declare end of page (swEOF=1)
|
|
// or (b) ignore it & assume page continues on (swEOF=0).
|
|
//
|
|
// The problem is that some modems produce spurious EOL during a page
|
|
// I believe this happens due a momentary loss of carrier that they
|
|
// recover from. For example IFAX sending to the ATI 19200. In those
|
|
// cases we want to do (b). The opposite problem is that we'll run
|
|
// into a modem whose normal response is other than OK or NO CARRIER.
|
|
// Then we want to do (a) because otherwise we'll _never_ work with
|
|
// that modem.
|
|
//
|
|
// So we have to either do (a) always, or have an INI setting that
|
|
// can force (a), which could be set thru the AWMODEM.INF file. But
|
|
// we also want to do (b) if possible because otehrwise we'll not be
|
|
// able to recieve from weak or flaky modems or machines or whatever
|
|
//
|
|
// Snowball does (b). I believe best soln is an INI setting, with (b)
|
|
// as default
|
|
|
|
// option (a)
|
|
// ERRMSG((SZMOD "<<WARNING>> Got arbitrary DLE-ETX. Assuming END OF PAGE!!!\r\n"));
|
|
// swEOF = 1;
|
|
|
|
// option (b)
|
|
ERRMSG((SZMOD "<<WARNING>> Got arbitrary DLE-ETX. Ignoring\r\n"));
|
|
swEOF = 0;
|
|
}
|
|
BG_CHK(swEOF == 0 || swEOF == 1 || swEOF == -2 || swEOF == -3);
|
|
|
|
switch(swEOF)
|
|
{
|
|
case 1: uRet = RECV_EOF; break;
|
|
case 0: return RECV_OK;
|
|
default: BG_CHK(FALSE); // fall through
|
|
case -2: uRet = RECV_ERROR; break;
|
|
case -3: uRet = RECV_TIMEOUT; break;
|
|
}
|
|
|
|
EndMode(pTG);
|
|
return uRet;
|
|
}
|
|
|
|
|
|
const static BYTE LFCRETXDLE[4] = { LF, CR, ETX, DLE };
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
USHORT iModemRecvFrame(PThrdGlbl pTG, LPB lpb, USHORT cbMax, ULONG ulTimeout, USHORT far* lpcbRecv)
|
|
{
|
|
SWORD swRead, swRet;
|
|
USHORT i;
|
|
BOOL fRestarted=0;
|
|
USHORT uRet;
|
|
BOOL fGotGoodCRC = 0; // see comment-block below
|
|
|
|
/** Sometimes modems give use ERROR even when thr frame is good.
|
|
Happens a lot from Thought to PP144MT on CFR. So we check
|
|
the CRC. If the CRc was good and everything else looks good
|
|
_except_ the "ERROR" response from teh modem then return
|
|
RECV_OK, not RECV_BADFRAME.
|
|
This should fix BUG#1218
|
|
**/
|
|
|
|
BG_CHK(lpb && cbMax && lpcbRecv);
|
|
restart:
|
|
*lpcbRecv=0;
|
|
if(pTG->Class1Modem.ModemMode!= FRH)
|
|
{
|
|
#ifdef USR_HACK
|
|
swRet = iModemFRHorM(pTG, ulTimeout);
|
|
#else // !USR_HACK
|
|
swRet=iModemNoPauseDialog2(pTG, (LPB)pTG->Class1Modem.bCmdBuf, pTG->Class1Modem.uCmdLen, ulTimeout, cbszCONNECT, cbszNOCARRIER);
|
|
#endif // !USR_HACK
|
|
if(swRet==2||swRet==3)
|
|
{
|
|
(MyDebugPrint(pTG, LOG_ALL, "Got NO CARRIER from FRH=3\r\n"));
|
|
EndMode(pTG);
|
|
return RECV_EOF;
|
|
}
|
|
else if(swRet != 1)
|
|
{
|
|
ERRMSG((SZMOD "<<WARNING>> Can't get CONNECT from FRH=3\r\n"));
|
|
EndMode(pTG);
|
|
return RECV_TIMEOUT; // may not need this, since we never got flags??
|
|
// actually we dont know what the heck we got!!
|
|
}
|
|
}
|
|
|
|
|
|
pTG->Class1Modem.fRecvNotStarted = FALSE; // fNoFlags = FALSE;
|
|
|
|
/*** Got CONNECT (i.e. flags). Now try to get a frame ***/
|
|
|
|
/****************************************************************
|
|
* Using 3 secs here is a misinterpretation of the T30 CommandReceived?
|
|
* flowchart. WE want to wait here until we get something or until T2
|
|
* or T4 timeout. It would have been best if we started T2 ot T4 on
|
|
* entry into the search routine (t30.c), but starting it here is good
|
|
* enough.
|
|
* Using this 3secs timeout fails when Genoa simulates a bad frame
|
|
* because Zoom PKT modem gives us a whole raft of bad frames for one
|
|
* bad PPS-EOP and then gives a CONNECT that we timeout below exactly
|
|
* as the sender's T4 timeout expires and he re-sends the PPS-EOP
|
|
* so we miss all of them.
|
|
* Alternately, we could timeout here on 2sec & retry. But that's risky
|
|
* If less than 2sec then we'll timeout on modems that give connect
|
|
* first flag, then 2sec elapse before CR-LF (1sec preamble & 1sec for
|
|
* long frames, e.g. PPR!)
|
|
****************************************************************/
|
|
|
|
// #define TIMEOUT_3SECS 3000L
|
|
// startTimeOut(&(pTG->Class1Modem.toRecv), TIMEOUT_3SECS);
|
|
|
|
startTimeOut(pTG, &(pTG->Class1Modem.toRecv), ulTimeout);
|
|
swRead = FComFilterReadLine(pTG, lpb, cbMax, &(pTG->Class1Modem.toRecv));
|
|
|
|
pTG->Class1Modem.ModemMode = COMMAND;
|
|
// may change this to FRH if we get CONNECT later.
|
|
// but set it here just in case we short circuit out due to errors
|
|
|
|
|
|
if(swRead<=0)
|
|
{
|
|
// Timeout
|
|
ERRMSG((SZMOD "<<WARNING>> Can't get frame after connect. Got-->\r\n"));
|
|
D_HexPrint(lpb, (WORD)-swRead);
|
|
EndMode(pTG);
|
|
*lpcbRecv = -swRead;
|
|
return RECV_ERROR; // goto error;
|
|
}
|
|
|
|
faxT2log(("FRAME>>> \r\n"));
|
|
ST_FRAMES(D_HexPrint(lpb, swRead));
|
|
|
|
|
|
for(i=0, swRead--; i<4 && swRead>=0; i++, swRead--)
|
|
{
|
|
if(lpb[swRead] != LFCRETXDLE[i])
|
|
break;
|
|
}
|
|
// exits when swRead is pointing to last non-noise char
|
|
// or swRead == -1
|
|
// incr by 1 to give actual non-noise data size.
|
|
// (size = ptr to last byte + 1!)
|
|
swRead++;
|
|
|
|
|
|
// Hack for AT&T AK144 modem that doesn't send us the CRC
|
|
// only lop off last 2 bytes IFF the frame is >= 5 bytes long
|
|
// that will leave us at least the FF 03/13 FCF
|
|
// if(i==4 && swRead>=2) // i.e. found all of DLE-ETX_CR-LF
|
|
|
|
// 09/25/95 This code was changed to never lop of the CRC.
|
|
// All of the routines except NSxtoBC can figure out the correct length,
|
|
// and that way if the modem doesn't pass on the CRC, we no longer
|
|
// lop off the data.
|
|
// NSxtoBC has been changed to expect the CRC.
|
|
|
|
// we really want this CRC-checking in the MDDI case too
|
|
// #ifdef MDDI
|
|
// if(i==4 && swRead>=5) // i.e. found all of DLE-ETX_CR-LF
|
|
// {
|
|
// swRead -= 2; // get rid of CRC
|
|
// uRet = RECV_OK;
|
|
// }
|
|
// #else //MDDI
|
|
if(i==4) // i.e. found all of DLE-ETX_CR-LF
|
|
{
|
|
// Determine if the frame has the CRC or not..
|
|
// (AT&T and NEC modems don't have them)
|
|
if (pTG->Class1Modem.eRecvFCS != RECV_FCS_NO)
|
|
{
|
|
if (swRead > 2)
|
|
{
|
|
|
|
#ifdef PORTABLE_CODE
|
|
WORD wCRCgot = *(UNALIGNED WORD FAR*)(lpb+swRead-2); // +++alignment
|
|
#else
|
|
WORD wCRCgot = *(LPWORD)(lpb+swRead-2); // +++alignment
|
|
#endif
|
|
WORD wCRCcalc;
|
|
|
|
// Elliot bug 1811: TI PCMCIA modem TI1411 sends control byte twice
|
|
// instead of address (0xff) followed by control.
|
|
// So we correct for that here...
|
|
if (lpb[0]==lpb[1] && (*lpb==0x3 || *lpb==0x13))
|
|
{
|
|
ERRMSG((SZMOD
|
|
"<<WARNING>> V.21 w/ wrong address:%04x.\r\n"
|
|
"\t\tZapping 1st byte with 0xff.\r\n",
|
|
(unsigned)*lpb));
|
|
*lpb = 0xff;
|
|
}
|
|
|
|
wCRCcalc = CalcCRC(pTG, lpb, (USHORT) (swRead-2));
|
|
if (wCRCgot==wCRCcalc)
|
|
{
|
|
// swRead -=2;
|
|
fGotGoodCRC = TRUE;
|
|
}
|
|
else
|
|
{
|
|
#define MUNGECRC(crc) MAKEWORD(LOBYTE(crc),\
|
|
(HIBYTE(crc)<<2)|(LOBYTE(crc)>>6))
|
|
ERRMSG((SZMOD
|
|
"<<WARNING>> V.21 CRC mismatch. Got 0x%04x."
|
|
" Want 0x%04x\r\n",
|
|
(unsigned) wCRCgot, (unsigned) wCRCcalc ));
|
|
// MC1411, MH9611 hack...
|
|
if (wCRCgot == MUNGECRC(wCRCcalc))
|
|
{
|
|
ERRMSG((SZMOD
|
|
"<<WARNING>> mutant V.21 CRC:%04x\r\n",
|
|
MUNGECRC(wCRCcalc)));
|
|
// swRead -=2;
|
|
fGotGoodCRC = TRUE;
|
|
}
|
|
// Elliot bug 2659: PP PM288MT II V.34 adds a flag (0x7e) to the END
|
|
// Of every V.21 flag it receives! So we check for this special case.
|
|
else if (swRead>3 && *(lpb+swRead-1)==0x7e)
|
|
{
|
|
ERRMSG((SZMOD
|
|
"<<WARNING>> Last byte == 0x7e\r\n"));
|
|
|
|
#ifdef PORTABLE_CODE
|
|
wCRCgot = *(UNALIGNED WORD FAR*)(lpb+swRead-3);
|
|
#else
|
|
wCRCgot = *(LPWORD)(lpb+swRead-3);
|
|
#endif
|
|
wCRCcalc = CalcCRC(pTG, lpb, (USHORT) (swRead-3));
|
|
ERRMSG((SZMOD
|
|
"<<WARNING>> Final flag? New Calc:%04x;Got=%04x\r\n",
|
|
(unsigned) wCRCcalc,
|
|
(unsigned) wCRCgot));
|
|
if (wCRCgot==wCRCcalc)
|
|
{
|
|
// swRead -=3;
|
|
swRead--;
|
|
fGotGoodCRC = TRUE;
|
|
}
|
|
}
|
|
else if (pTG->Class1Modem.eRecvFCS == RECV_FCS_NOCHK)
|
|
{
|
|
ERRMSG((SZMOD
|
|
"<<WARNING>> ASSUMING BAD V.21 CRC\r\n"));
|
|
// swRead -=2;
|
|
}
|
|
else
|
|
{
|
|
ERRMSG((SZMOD
|
|
"<<WARNING>> no/bad V.21 CRC\r\n"));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
uRet = RECV_OK;
|
|
}
|
|
// #endif //MDDI
|
|
else
|
|
{
|
|
ERRMSG((SZMOD "<<WARNING>> Frame doesn't end in dle-etx-cr-lf\r\n"));
|
|
// leave tast two bytes in. We don't *know* it's a CRC, since
|
|
// frame ending was non-standard
|
|
uRet = RECV_BADFRAME;
|
|
}
|
|
*lpcbRecv = swRead;
|
|
|
|
// check if it is the NULL frame (i.e. DLE-ETX-CR-LF) first.
|
|
// (check is: swRead==0 and uRet==RECV_OK (see above))
|
|
// if so AND if we get OK or CONNECT or ERROR below then ignore
|
|
// it completely. The Thought modem and the PP144MT generate
|
|
// this poor situation! Keep a flag to avoid a possible
|
|
// endless loop
|
|
|
|
// broaden this so that we Restart on either a dle-etx-cr-lf
|
|
// NULL frame or a simple cr-lf NULL frame. But then we need
|
|
// to return an ERROR (not BADFRAME) after restarting once,
|
|
// otheriwse there is an infinite loop with T30 calling us
|
|
// again and again (see bug#834)
|
|
|
|
// chnage yet again. This takes too long, and were trying to tackle
|
|
// a specific bug (the PP144MT) bug here, so let's retsrat only
|
|
// on dle-etx-cr-lf (not just cr-lf), and in teh latter case
|
|
// return a response according to what we get
|
|
|
|
|
|
BG_CHK(uRet==RECV_OK || uRet==RECV_BADFRAME);
|
|
|
|
/*** Got Frame. Now try to get OK or ERROR. Timeout=0! ***/
|
|
|
|
switch(swRet = iModemResp4(pTG, 0, cbszOK, cbszCONNECT, cbszNOCARRIER, cbszERROR))
|
|
{
|
|
case 2: pTG->Class1Modem.ModemMode = FRH;
|
|
// fall through and do exactly like OK!!
|
|
case 1: // ModemMode already == COMMAND
|
|
if(swRead<=0 && uRet==RECV_OK && !fRestarted)
|
|
{
|
|
ERRMSG((SZMOD "<<WARNING>> Got %d after frame. RESTARTING\r\n", swRet));
|
|
fRestarted = 1;
|
|
goto restart;
|
|
}
|
|
//uRet already set
|
|
break;
|
|
|
|
case 3: // NO CARRIER. If got null-frame or no frame return
|
|
// RECV_EOF. Otherwise if got OK frame then return RECV_OK
|
|
// and return frame as usual. Next time around it'll get a
|
|
// NO CARRIER again (hopefully) or timeout. On a bad frame
|
|
// we can return RECV_EOF, but this will get into trouble if
|
|
// the recv is not actually done. Or return BADFRAME, and hope
|
|
// for a NO CARRIER again next time. But next time we may get a
|
|
// timeout. ModemMode is always set to COMMAND (already)
|
|
ERRMSG((SZMOD "<<WARNING>> Got NO CARRIER after frame. swRead=%d uRet=%d\r\n", swRead, uRet));
|
|
if(swRead <= 0)
|
|
uRet = RECV_EOF;
|
|
// else uRet is already BADFRAME or OK
|
|
break;
|
|
|
|
// this is bad!!
|
|
// alternately:
|
|
// if(swRead<=0 || uRet==RECV_BADFRAME)
|
|
// {
|
|
// uRet = RECV_EOF;
|
|
// *lpcbRecv = 0; // must return 0 bytes with RECV_EOF
|
|
// }
|
|
|
|
case 4: // ERROR
|
|
if(swRead<=0)
|
|
{
|
|
// got no frame
|
|
if(uRet==RECV_OK && !fRestarted)
|
|
{
|
|
// if we got dle-etx-cr-lf for first time
|
|
ERRMSG((SZMOD "<<WARNING>> Got ERROR after frame. RESTARTING\r\n"));
|
|
fRestarted = 1;
|
|
#ifdef USR_HACK
|
|
TwiddleThumbs(RECVMODEPAUSE);
|
|
#endif //USR_HACK
|
|
goto restart;
|
|
}
|
|
else
|
|
uRet = RECV_ERROR;
|
|
}
|
|
else
|
|
{
|
|
// if everything was OK until we got the "ERROR" response from
|
|
// the modem and we got a good CRC then treat it as "OK"
|
|
// This should fix BUG#1218
|
|
if(uRet==RECV_OK && fGotGoodCRC)
|
|
uRet = RECV_OK;
|
|
else
|
|
uRet = RECV_BADFRAME;
|
|
}
|
|
|
|
ERRMSG((SZMOD "<<WARNING>> Got ERROR after frame. swRead=%d uRet=%d\r\n", swRead, uRet));
|
|
break;
|
|
|
|
case 0: // timeout
|
|
ERRMSG((SZMOD "<<WARNING>> Got TIMEOUT after frame. swRead=%d uRet=%d\r\n", swRead, uRet));
|
|
// if everything was OK until we got the timeout from
|
|
// the modem and we got a good CRC then treat it as "OK"
|
|
// This should fix BUG#1218
|
|
if(uRet==RECV_OK && fGotGoodCRC)
|
|
uRet = RECV_OK;
|
|
else
|
|
uRet = RECV_BADFRAME;
|
|
break;
|
|
}
|
|
return uRet;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
USHORT ModemRecvMem(PThrdGlbl pTG, HMODEM hModem, LPBYTE lpb, USHORT cbMax, ULONG ulTimeout, USHORT far* lpcbRecv)
|
|
{
|
|
USHORT uRet;
|
|
|
|
#ifdef CL0
|
|
if(pTG->ModemParams.Class == FAXCLASS0)
|
|
return Class0ModemRecvMem(pTG, hModem, lpb, cbMax, ulTimeout, lpcbRecv);
|
|
#endif //CL0
|
|
|
|
IF_BG_CHK((WORD)hModem==3 && pTG->DDI.uComPort && pTG->DDI.fModemOpen && pTG->DDI.fLineInUse && pTG->DDI.fNCUModemLinked);
|
|
BG_CHK(pTG->Class1Modem.CurMod);
|
|
BG_CHK(lpb && cbMax && lpcbRecv);
|
|
(MyDebugPrint(pTG, LOG_ALL, "In ModemRecvMem lpb=%08lx cbMax=%d ulTimeout=%ld\r\n", lpb, cbMax, ulTimeout));
|
|
|
|
if(pTG->Class1Modem.DriverMode != RECV)
|
|
{
|
|
BG_CHK(FALSE);
|
|
return RECV_ERROR; // see bug#1492
|
|
}
|
|
*lpcbRecv=0;
|
|
|
|
if(pTG->Class1Modem.fRecvSWFraming)
|
|
uRet = SWFramingRecvFrame(pTG, lpb, cbMax, ulTimeout, lpcbRecv);
|
|
else if(pTG->Class1Modem.fHDLC)
|
|
uRet = iModemRecvFrame(pTG, lpb, cbMax, ulTimeout, lpcbRecv);
|
|
else
|
|
uRet = iModemRecvData(pTG, lpb, cbMax, ulTimeout, lpcbRecv);
|
|
|
|
(MyDebugPrint(pTG, LOG_ALL, "Ex ModemRecvMem lpbf=%08lx uCount=%d uRet=%d\r\n", lpb, *lpcbRecv, uRet));
|
|
return uRet;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef USR_HACK
|
|
USHORT iModemFRHorM(PThrdGlbl pTG, ULONG ulTimeout)
|
|
{
|
|
ULONG ulBefore, ulAfter, ulDelta;
|
|
USHORT uRet;
|
|
|
|
retry:
|
|
|
|
ulBefore=GetTickCount();
|
|
|
|
// Don't look for NO CARRIER. Want it to retry until FRM timeout on NO CARRIER
|
|
// ----This is changed. See below----
|
|
uRet = iModemNoPauseDialog3(pTG, pTG->Class1Modem.bCmdBuf, pTG->Class1Modem.uCmdLen, ulTimeout, cbszCONNECT, cbszFCERROR, cbszNOCARRIER);
|
|
// uRet = iModemNoPauseDialog2(pTG, pTG->Class1Modem.bCmdBuf, pTG->Class1Modem.uCmdLen, ulTimeout, cbszCONNECT, cbszFCERROR);
|
|
ulAfter=GetTickCount();
|
|
|
|
if(uRet==2 || uRet==3) // uRet==FCERROR or uRet==NOCARRIER
|
|
{
|
|
ulDelta = (ulAfter >= ulBefore) ? (ulAfter - ulBefore) : (0xFFFFFFFFL - ulBefore) + ulAfter;
|
|
|
|
if(ulTimeout < (ulDelta + MINRECVMODETIMEOUT))
|
|
{
|
|
ERRMSG((SZMOD "<<WARNING>> Giving up on RecvMode. uRet=%d ulTimeout=%ld\r\n", uRet, ulTimeout));
|
|
}
|
|
else
|
|
{
|
|
ulTimeout -= (ulAfter-ulBefore);
|
|
|
|
// need this pause for NO CARRIER for USR modems. See bug#1516
|
|
// for the RC229DP, dunno if it's reqd because I dunno why theyre
|
|
// giving the FCERROR. Don't want to miss the carrier so currently
|
|
// don't pause. (Maybe we can achieve same effect by simply taking
|
|
// FCERROR out of the response list above--but that won't work for
|
|
// NOCARRIER because we _need_ teh pause. iiModemDialog is too fast)
|
|
if(uRet == 3)
|
|
TwiddleThumbs(RECVMODEPAUSE);
|
|
BG_CHK(ulTimeout >= MINRECVMODETIMEOUT);
|
|
|
|
goto retry;
|
|
}
|
|
}
|
|
|
|
return uRet;
|
|
}
|
|
#endif // USR_HACK
|