/* modem.c */
/*---------------------------------------------------------------------------*/
/* This file is part of PSFax/2. */
/* */
/* Written By: Gary L. Hennigan */
/* */
/* This code can modified as much as you like provided you follow the */
/* guidelines as described in the file install.doc which you should have */
/* received with this file. If you did not please notify the author for a */
/* copy of this file via Internet email. The address is: */
/* ghenniga@NMSU.Edu */
/*---------------------------------------------------------------------------*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "psfax2.h"
#define DevIOCtl DosDevIOCtl32
/**Global variables defined in psfax2.c **/
extern char cGlobResp[];
ULONG ulTemp; /* Used by various functions in modem.c */
USHORT usTemp;
void vFlushIO( HFILE );
unsigned char swap_bits( unsigned char );
USHORT usSetTTYTime( HFILE, DCBINFO *, int );
int iGetResp( HFILE, DCBINFO *, char *, int, int, char * );
/****************************************************************************/
/*************************Used for simplifying*******************************/
/*************************IOCtl function calls*******************************/
/****************************************************************************/
USHORT DosDevIOCtl32(PVOID pData, USHORT cbData, PVOID pParms, USHORT cbParms,
USHORT usFunction, USHORT usCategory, HFILE hDevice)
{
ULONG ulParmLengthInOut = cbParms, ulDataLengthInOut = cbData;
return (USHORT)DosDevIOCtl(hDevice, usCategory, usFunction,
pParms, cbParms, &ulParmLengthInOut,
pData, cbData, &ulDataLengthInOut);
}
/****************************************************************************/
/***************************Open the COM Port********************************/
/****************************************************************************/
ULONG ulOpenPort(char *cPort, HFILE *hTTY)
{
return DosOpen(cPort, hTTY, &ulTemp, 0L, 0, FILE_OPEN,
OPEN_ACCESS_READWRITE | OPEN_SHARE_DENYREADWRITE |
OPEN_FLAGS_FAIL_ON_ERROR, 0L);
}
/****************************************************************************/
/**********************Get the current port settings*************************/
/****************************************************************************/
int iPortGetSet(HFILE hTTY, DCBINFO *dcbCom)
{
usTemp = DevIOCtl(dcbCom,sizeof(*dcbCom),NULL,0,
ASYNC_GETDCBINFO, IOCTL_ASYNC, hTTY);
if(usTemp != 0)
return 1;
return 0;
}
/****************************************************************************/
/**************************Initialize the Port*******************************/
/****************************************************************************/
int iPortInit(HFILE hTTY, DCBINFO *dcbCom)
{
MODEMSTATUS ms;
UINT data;
/*-------------------------------End Declarations---------------------------*/
/**Set XON/XOFF flow control. **/
dcbCom->fbCtlHndShake = MODE_DTR_CONTROL;
dcbCom->fbFlowReplace &= ~(MODE_AUTO_RECEIVE | MODE_AUTO_TRANSMIT |
MODE_RTS_CONTROL | MODE_RTS_HANDSHAKE);
dcbCom->fbFlowReplace |= (MODE_AUTO_RECEIVE | MODE_AUTO_TRANSMIT |
MODE_RTS_CONTROL);
ms.fbModemOn = RTS_ON;
ms.fbModemOff = 255;
usTemp = DevIOCtl(NULL,0,dcbCom,sizeof(*dcbCom),ASYNC_SETDCBINFO,
IOCTL_ASYNC, hTTY);
if(usTemp != 0)
return -1;
usTemp = DevIOCtl(&data,sizeof(data),&ms,sizeof(ms),
ASYNC_SETMODEMCTRL,IOCTL_ASYNC,hTTY);
if(usTemp != 0)
return -1;
return 0;
}
/****************************************************************************/
/**************************Initialize the Modem******************************/
/****************************************************************************/
int iModemInit(HFILE hTTY, DCBINFO *dcbCom)
{
char cBuff[256];
int iCnt=0;
/*-------------------------------End Declarations---------------------------*/
strcpy(cBuff,"ATZ\r"); /* Use the default profile of the modem. */
DosWrite(hTTY, cBuff, strlen(cBuff), &ulTemp);
if(iGetResp(hTTY, dcbCom, cBuff, 10*sizeof(char), 3, NULL) <= 0 ||
!strstr(cBuff,"OK\r") )
return 1;
strcpy(cBuff,"AT&K4V0Q0E0L2M1W2S0=0S2=255S12=255 +FCLASS=2\r");
DosWrite(hTTY, cBuff, strlen(cBuff), &ulTemp);
if(iGetResp(hTTY, dcbCom, cBuff, strlen(cBuff)+2*sizeof(char),
2, NULL) <= 0 || !strstr(cBuff,"0\r"))
return 1;
strcpy(cBuff,"ATS7=120 +FCR=1\r");
DosWrite(hTTY, cBuff, strlen(cBuff), &ulTemp); sleep(1);
if(iGetResp(hTTY, dcbCom, cBuff, 2*sizeof(char), 2, NULL) <= 0 ||
!strstr(cBuff,"0\r"))
return 1;
strcpy(cBuff,"AT+FDCC=1,3\r");
DosWrite(hTTY, cBuff, strlen(cBuff), &ulTemp); sleep(1);
if(iGetResp(hTTY, dcbCom, cBuff, 2*sizeof(char), 2, NULL) <= 0 ||
!strstr(cBuff,"0\r"))
return 1;
strcpy(cBuff,"AT+FBOR=0\r");
DosWrite(hTTY, cBuff, strlen(cBuff), &ulTemp); sleep(1);
if(iGetResp(hTTY, dcbCom, cBuff, 2*sizeof(char), 2, NULL) <= 0 ||
!strstr(cBuff,"0\r"))
return 1;
/**Flush all the I/O, set the timeout for reads, and see if the modem **/
/**is responding properly. **/
vFlushIO(hTTY);
usSetTTYTime(hTTY, dcbCom, 2);
strcpy(cBuff, "AT\r");
do
{
DosWrite(hTTY, cBuff, strlen(cBuff), &ulTemp);
iCnt++;
DosRead(hTTY, cBuff, 2, &ulTemp);
}
while(ulTemp == 0 && iCnt <= MAXTIMEOUTS);
if(ulTemp == 0 && iCnt >= MAXTIMEOUTS)return 1;
if(strncmp(cBuff,"0\r",2) != 0)
{
printf("Bad modem response while attempting to sync!\n");
return 1;
}
return 0;
}
/****************************************************************************/
/****************************Dial the Phone**********************************/
/****************************************************************************/
int iModemDial( HFILE hTTY, char *cPhoneNum, DCBINFO *dcbCom, int iWait )
{
int iRedial;
char cBuff[256];
/*-------------------------------End Declarations---------------------------*/
strcpy(cBuff,"ATD");
strcat(cBuff,cPhoneNum);
strcat(cBuff,"\r");
DosWrite(hTTY, cBuff, strlen(cBuff), &ulTemp); sleep(1);
if(iGetResp(hTTY, dcbCom, cBuff, 2, iWait, NULL) <= 0)
{
cBuff[0] = 0x1b;
cBuff[1] = 0x00;
DosWrite(hTTY, cBuff, strlen(cBuff), &ulTemp); sleep(2);
vFlushIO(hTTY);
return DIAL_NOANSWER;
}
if( cBuff[0] )
{
switch(cBuff[0])
{
case '3':
iRedial = DIAL_NOCARRIER;
vFlushIO(hTTY);
return iRedial;
case '6':
iRedial = DIAL_NODIALTONE;
vFlushIO(hTTY);
return iRedial;
case '7':
iRedial = DIAL_BUSY;
vFlushIO(hTTY);
return iRedial;
case '8':
iRedial = DIAL_NOANSWER;
vFlushIO(hTTY);
return iRedial;
default:
iRedial = 0;
break;
}
}
else
{
vFlushIO(hTTY);
return DIAL_NOANSWER;
}
/**Make sure the remote responds with a connection indication. **/
if(iGetResp(hTTY, dcbCom, &cBuff[2], 8, -20, "+FCON\r") <= 0)
{
printf("Incorrect response \"%s\" received...\n",cBuff);
vFlushIO(hTTY);
return DIAL_UNKNOWN;
}
else
strcpy(cGlobResp,cBuff);
puts("Fax connection established!");
return iRedial;
}
/****************************************************************************/
/*******************Initialize the fax-fax connection************************/
/****************************************************************************/
int iFaxInit(HFILE hTTY, DCBINFO *dcbCom, int df, int vr, int wd, int ln)
{
char cBuff[256];
/*-------------------------------End Declarations---------------------------*/
/**Make sure the remote responded correctly. **/
if(iGetResp(hTTY, dcbCom, cBuff, 50, -15, "0\r") <= 0)
{
puts("Remote fax is not responding....");
return 1;
}
/**Set transmission parameters. **/
sprintf(cBuff,"AT+FDT=%d,%d,%d,%d\r", df, vr, wd, ln);
vFlushIO(hTTY);
DosWrite(hTTY, cBuff, strlen(cBuff), &ulTemp); sleep(1);
/**Make sure the remote responds with a CONNECT. **/
if(iGetResp(hTTY, dcbCom, cBuff, 50, -15, "1\r") <= 0)
{
puts("Remote fax is not responding....");
return 1;
}
vFlushIO(hTTY);
return 0;
}
/****************************************************************************/
/*********************Send a page via the Fax/Modem**************************/
/****************************************************************************/
int iFaxSendPage(HFILE hTTY, DCBINFO *dcbCom, FILE *fStream, int iLast)
{
unsigned char cBuff[SENDCHUNK], cBuff2[2*SENDCHUNK];
int iNumRead, iNumWrite, i1, iPPRCode;
/*-------------------------------End Declarations---------------------------*/
iNumRead = fread(cBuff, sizeof(char), SENDCHUNK, fStream);
usSetTTYTime(hTTY, dcbCom, -15);
while(iNumRead > 0)
{
iNumWrite = 0;
/** Swap the bits and pad DLE characters. **/
for(i1=0; i1 < iNumRead; i1++)
{
cBuff2[iNumWrite] = swap_bits(cBuff[i1]);
if(cBuff2[iNumWrite++] == DLE)
cBuff2[iNumWrite++] = DLE;
}
/** Write the stuff out to the modem. **/
DosWrite(hTTY, cBuff2, iNumWrite, &ulTemp);
/** Check for a response, if any, from the modem. **/
DosRead(hTTY, cBuff, sizeof(cBuff), &ulTemp);
if(ulTemp != 0)
{
for(i1=0; i1 < ulTemp; i1++)
{
if((cBuff[i1] & 0x7f) == CAN)
{
printf("Remote has canceled transmission!\n");
sprintf(cBuff,"%c%c",DLE,ETX);
DosWrite(hTTY, cBuff, 2*sizeof(char), &ulTemp);
return -1;
}
}
}
iNumRead = fread(cBuff, sizeof(char), SENDCHUNK, fStream);
}
sprintf(cBuff,"%c%c",DLE,ETX);
DosWrite(hTTY, cBuff, 2*sizeof(char), &ulTemp);
i1 = iGetResp(hTTY, dcbCom, cBuff, 2, -15, "0\r");
if(i1 <= 0)
{
puts("Incorrect response from remote to end-of-page message!\n");
return -1;
}
switch(iLast)
{
case PEND_ANOTHER:
strcpy(cBuff,"AT+FET=0\r");
DosWrite(hTTY, cBuff, strlen(cBuff), &ulTemp);
break;
case PEND_ENDTRAN:
strcpy(cBuff,"AT+FET=2\r");
DosWrite(hTTY, cBuff, strlen(cBuff), &ulTemp);
break;
}
/**Get the post-page response. **/
if(iGetResp(hTTY, dcbCom, cBuff, 20, -10, "0\r") <= 0)
{
puts("No post-page response from remote!");
return -1;
}
if(iLast == PEND_ANOTHER)
DosWrite(hTTY, "AT+FDT\r", sizeof("AT+FDT\r"), &ulTemp);
strtok(&cBuff[8],"\r");
i1 = sscanf(&cBuff[8], "%d", &iPPRCode);
if(i1 <= 0)
{
puts("Incorrect post-page response from remote!");
return -1;
}
if(iLast == PEND_ANOTHER)
{
if(iGetResp(hTTY, dcbCom, cBuff, 2, -10, "1\r") <= 0)
{
puts("Unable to continue transmission!");
return -1;
}
}
else
{
if(iGetResp(hTTY, dcbCom, cBuff, 2, -15, "0\r") <= 0)
{
puts("Failed to properly end transmission!");
return -1;
}
}
return iPPRCode;
}
/****************************************************************************/
/************Tell the remote to intterrupt the transmission******************/
/****************************************************************************/
int iFaxInterrupt(HFILE hTTY, DCBINFO *dcbCom)
{
char cBuff[20];
/*-------------------------------End Declarations---------------------------*/
strcpy(cBuff,"AT+FK\r");
DosWrite(hTTY, cBuff, strlen(cBuff), &ulTemp);
return 0;
}
/****************************************************************************/
/**************************Close the COM Port********************************/
/****************************************************************************/
ULONG ulClosePort(HFILE hTTY)
{
return DosClose(hTTY);
}
/****************************************************************************/
/********************Read the response from the modem************************/
/****************************************************************************/
int iGetResp( HFILE hTTY, DCBINFO *dcbCom, char *cBuff, int iExpSize,
int iTimeout, char *cSearch )
{
int iStart=0, iCnt=0;
/**Initialize the buffer. **/
cBuff[0] = '\000';
/**Set the desired timeout for this read. **/
usSetTTYTime(hTTY, dcbCom, iTimeout);
/**Read the response. **/
if(!cSearch)
{
DosRead(hTTY, cBuff, iExpSize, &ulTemp);
cBuff[ulTemp] = '\000'; /* For string manipulation functions. */
iStart = ulTemp;
}
else
{
do
{
DosRead(hTTY, &cBuff[iStart], iExpSize, &ulTemp);
iStart += ulTemp;
cBuff[iStart] = '\000';
iCnt++;
}
while(!strstr(cBuff,cSearch) && iCnt <= MAXTIMEOUTS);
}
if(iCnt > MAXTIMEOUTS)
return -1;
return iStart;
}
/****************************************************************************/
/***********************Set the read timeout on******************************/
/******************************the COM port**********************************/
/****************************************************************************/
USHORT usSetTTYTime(HFILE hTTY, DCBINFO *dcbCom, int iTime)
{
if(iTime >= 0)
iTime *= 100;
else
iTime *= -1;
dcbCom->usReadTimeout = iTime;
return (DevIOCtl(NULL,0,dcbCom,sizeof(*dcbCom),ASYNC_SETDCBINFO,
IOCTL_ASYNC, hTTY));
}
/****************************************************************************/
/*************************Flush all pending I/O******************************/
/****************************************************************************/
void vFlushIO(HFILE hTTY)
{
UINT data;
char parm=0;
/*-------------------------------End Declarations---------------------------*/
DevIOCtl(&data,sizeof(data),&parm,sizeof(parm),
DEV_FLUSHINPUT, IOCTL_GENERAL, hTTY);
DevIOCtl(&data,sizeof(data),&parm,sizeof(parm),
DEV_FLUSHOUTPUT, IOCTL_GENERAL, hTTY);
}
/****************************************************************************/
/************************Builds table to swap the****************************/
/******************low order 4 bits with the high order**********************/
/****************************************************************************/
static void init_swaptable(unsigned char *swaptable)
{
int i, j;
/*-------------------------------End Declarations---------------------------*/
for (i = 0; i < 256; i++) {
j = ( ((i & 0x01) << 7) |
((i & 0x02) << 5) |
((i & 0x04) << 3) |
((i & 0x08) << 1) |
((i & 0x10) >> 1) |
((i & 0x20) >> 3) |
((i & 0x40) >> 5) |
((i & 0x80) >> 7) );
swaptable[i] = j;
}
}
/****************************************************************************/
/********************Reverses the low order 4 bits of a byte*****************/
/****************************************************************************/
unsigned char swap_bits(unsigned char c)
{
static unsigned char swaptable[256];
static int swaptable_init = FALSE;
/*-------------------------------End Declarations---------------------------*/
if (!swaptable_init) {
init_swaptable(swaptable);
swaptable_init = TRUE;
}
return(swaptable[c]);
}
