You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1308 lines
36 KiB
1308 lines
36 KiB
//****************************************************************************
|
|
//
|
|
// Microsoft NT Remote Access Service
|
|
//
|
|
// Copyright (C) 1992-93 Microsft Corporation. All rights reserved.
|
|
//
|
|
// Filename: rasstate.c
|
|
//
|
|
// Revision History
|
|
//
|
|
// Jul 1, 1992 J. Perry Hannah Created
|
|
//
|
|
//
|
|
// Description: This file contains the state machine functions for the
|
|
// RASMXS.DLL and related funcitons.
|
|
//
|
|
//****************************************************************************
|
|
|
|
#include <nt.h> //These first five headers are used by media.h
|
|
#include <ntrtl.h>
|
|
#include <nturtl.h>
|
|
#include <windows.h>
|
|
|
|
#include <string.h>
|
|
#include <malloc.h>
|
|
#include <stdlib.h>
|
|
|
|
|
|
#include <rasman.h>
|
|
#include <raserror.h>
|
|
#include <serial.h>
|
|
#include <rasfile.h>
|
|
#include <media.h>
|
|
#include <mprlog.h>
|
|
#include <rtutils.h>
|
|
|
|
#include <rasmxs.h>
|
|
#include <mxsint.h>
|
|
#include <mxspriv.h>
|
|
#include "mxswrap.h" // inf file wrapper
|
|
|
|
#define STRSAFE_NO_DEPRECATE
|
|
#include <strsafe.h>
|
|
|
|
|
|
|
|
|
|
//* Global Variables *******************************************************
|
|
//
|
|
extern RESPSECTION ResponseSection ; //Shared response section
|
|
|
|
extern PortSetInfo_t PortSetInfo; //API typedef defined in media.h
|
|
|
|
extern BOOL gbLogDeviceDialog; //Indicates logging on if TRUE
|
|
extern HANDLE ghLogFile; //Handle of device log file
|
|
|
|
|
|
|
|
|
|
//* BuildMacroXlationsTable ------------------------------------------------
|
|
//
|
|
// Function: Creates a table of macros and their expansions for use by
|
|
// the RasDevAPIs. Memory is allocated for the table and the
|
|
// pMacros pointer in the device control block points to it.
|
|
// Since this function depends on a valid InfoTable being present
|
|
// CreateInfoTable and CreateAttributes must be called before
|
|
// this function is called.
|
|
//
|
|
// Assumptions: - Parameters in InfoTable are sorted by P_Key.
|
|
// - Both parts of binary macros are present.
|
|
// These assumptions imply that if somename_off is in InfoTable
|
|
// somename_on is also present and is adjacent to somename_off.
|
|
//
|
|
// Returns: SUCCESS
|
|
// ERROR_ALLOCATING_MEMORY
|
|
//*
|
|
|
|
DWORD
|
|
BuildMacroXlationTable(DEVICE_CB *pDevice)
|
|
{
|
|
WORD i, j, k, cMacros;
|
|
DWORD dSize;
|
|
TCHAR szCoreName[MAX_PARAM_KEY_SIZE];
|
|
|
|
RASMAN_DEVICEINFO *pInfo = pDevice->pInfoTable;
|
|
MACROXLATIONTABLE *pMacros;
|
|
|
|
|
|
|
|
// Calucate size and allocate memory
|
|
|
|
cMacros = MacroCount(pInfo, ALL_MACROS);
|
|
dSize = sizeof(MACROXLATIONTABLE) + sizeof(MXT_ENTRY) * (cMacros - 1);
|
|
|
|
GetMem(dSize, (BYTE **) &(pDevice->pMacros));
|
|
if (pDevice->pMacros == NULL)
|
|
return(ERROR_ALLOCATING_MEMORY);
|
|
|
|
|
|
// Copy macro names and pointers to new Macro Translation Table
|
|
|
|
pMacros = pDevice->pMacros;
|
|
pMacros->MXT_NumOfEntries = cMacros;
|
|
|
|
for (i=0, j=0; i < pInfo->DI_NumOfParams; i++)
|
|
{
|
|
if (IsVariable(pInfo->DI_Params[i]))
|
|
;
|
|
|
|
// copy nothing
|
|
|
|
else if (IsBinaryMacro(pInfo->DI_Params[i].P_Key))
|
|
{
|
|
// copy Core Macro Name and pointer to Param
|
|
|
|
GetCoreMacroName(pInfo->DI_Params[i].P_Key, szCoreName);
|
|
strcpy(pMacros->MXT_Entry[j].E_MacroName, szCoreName);
|
|
|
|
|
|
// copy Param ptr for ON macro if enabled, else copy Off Param ptr
|
|
|
|
if (XOR(pInfo->DI_Params[i].P_Attributes & ATTRIB_ENABLED,
|
|
BinarySuffix(pInfo->DI_Params[i].P_Key) == ON_SUFFIX))
|
|
k = i + 1;
|
|
else
|
|
k = i;
|
|
|
|
pMacros->MXT_Entry[j].E_Param = &(pInfo->DI_Params[k]);
|
|
|
|
i++;
|
|
j++;
|
|
}
|
|
else // Is Unary Macro
|
|
{
|
|
// copy Core Macro Name and pointer to Param
|
|
|
|
strcpy(pMacros->MXT_Entry[j].E_MacroName, pInfo->DI_Params[i].P_Key);
|
|
pMacros->MXT_Entry[j].E_Param = &(pInfo->DI_Params[i]);
|
|
j++;
|
|
}
|
|
}
|
|
|
|
return(SUCCESS);
|
|
|
|
///***
|
|
#ifdef DEBUG //Printout Macro Translation Table
|
|
|
|
for(i=0; i<cMacros; i++)
|
|
DebugPrintf(("%32s %s\n", pMacros->MXT_Entry[i].E_MacroName,
|
|
pMacros->MXT_Entry[i].E_Param->P_Value.String.Data));
|
|
|
|
#endif // DEBUG
|
|
//***/
|
|
}
|
|
|
|
|
|
|
|
//* DeviceStateMachine -----------------------------------------------------
|
|
//
|
|
// Function: This is the main state machine used by the DLL to control
|
|
// asynchronous actions (writing and reading to/from devices).
|
|
//
|
|
// Returns: PENDING
|
|
// SUCCESS
|
|
// ERROR_CMD_TOO_LONG from RasDevGetCommand
|
|
// Error return codes from GetLastError()
|
|
//
|
|
//*
|
|
|
|
DWORD
|
|
DeviceStateMachine(DEVICE_CB *pDevice, HANDLE hIOPort)
|
|
{
|
|
DWORD dRC, lpcBytesWritten;
|
|
BOOL fIODone, fEndOfSection = FALSE;
|
|
TCHAR szCmdSuffix[MAX_CMDTYPE_SUFFIX_LEN + 1];
|
|
COMMTIMEOUTS CT;
|
|
|
|
|
|
|
|
while(1)
|
|
{
|
|
//DebugPrintf(("DeviceStateMachine state: %d\n", pDevice->eDevNextAction));
|
|
|
|
switch(pDevice->eDevNextAction)
|
|
{
|
|
|
|
// Send a Command to the device
|
|
|
|
case SEND:
|
|
// Get Command string
|
|
dRC = RasDevGetCommand(pDevice->hInfFile,
|
|
CmdTypeToStr(szCmdSuffix, pDevice->eCmdType),
|
|
pDevice->pMacros,
|
|
pDevice->szCommand,
|
|
&(pDevice->dCmdLen));
|
|
|
|
switch(dRC)
|
|
{
|
|
case SUCCESS:
|
|
|
|
// Check to see if a response is expected
|
|
|
|
pDevice->bResponseExpected =
|
|
RasDevResponseExpected(pDevice->hInfFile, pDevice->eDeviceType);
|
|
|
|
|
|
// Log the Command
|
|
|
|
if (gbLogDeviceDialog)
|
|
LogString(pDevice, "Command to Device:", pDevice->szCommand,
|
|
pDevice->dCmdLen);
|
|
|
|
|
|
// Check for null command with no response expected
|
|
|
|
if (pDevice->dCmdLen == 0 && !pDevice->bResponseExpected)
|
|
{
|
|
// Pause between commands
|
|
|
|
if (CommWait(pDevice, hIOPort, NO_RESPONSE_DELAY))
|
|
return(ERROR_UNEXPECTED_RESPONSE);
|
|
|
|
else if ((dRC = GetLastError()) == ERROR_IO_PENDING)
|
|
{
|
|
pDevice->eDevNextAction = DONE;
|
|
return(PENDING);
|
|
}
|
|
else
|
|
return(dRC);
|
|
}
|
|
|
|
|
|
// Send the command to the Port
|
|
|
|
CT.WriteTotalTimeoutMultiplier = 0;
|
|
CT.WriteTotalTimeoutConstant = TO_WRITE;
|
|
SetCommTimeouts(hIOPort, &CT);
|
|
|
|
fIODone = WriteFile(hIOPort, // Send Cmd string to modem
|
|
pDevice->szCommand,
|
|
pDevice->dCmdLen,
|
|
&lpcBytesWritten,
|
|
(LPOVERLAPPED)&(pDevice->Overlapped));
|
|
|
|
pDevice->eDevNextAction = RECEIVE;
|
|
|
|
if ( ! fIODone)
|
|
{
|
|
if ((dRC = GetLastError()) == ERROR_IO_PENDING)
|
|
return(PENDING);
|
|
|
|
else
|
|
return(dRC);
|
|
}
|
|
|
|
return(PENDING);
|
|
|
|
case ERROR_END_OF_SECTION:
|
|
|
|
fEndOfSection = TRUE;
|
|
pDevice->eDevNextAction = DONE;
|
|
break;
|
|
|
|
default:
|
|
return(dRC);
|
|
}
|
|
break;
|
|
|
|
|
|
// Recieve Response string from device
|
|
|
|
case RECEIVE:
|
|
|
|
dRC = ReceiveStateMachine(pDevice, hIOPort);
|
|
switch(dRC)
|
|
{
|
|
case SUCCESS:
|
|
pDevice->eDevNextAction = DONE;
|
|
pDevice->eRcvState = GETECHO; //Reset Recieve State Machine
|
|
break;
|
|
|
|
case PENDING:
|
|
return(PENDING);
|
|
|
|
default:
|
|
pDevice->eRcvState = GETECHO; //Reset Recieve State Machine
|
|
return(dRC);
|
|
}
|
|
break;
|
|
|
|
|
|
// A Command-Response cycle is complete
|
|
|
|
case DONE:
|
|
|
|
if (fEndOfSection)
|
|
switch(pDevice->eCmdType) //Last cmd of this type is now done
|
|
{
|
|
case CT_INIT:
|
|
pDevice->eCmdType = pDevice->eNextCmdType; //Reset command type
|
|
RasDevResetCommand(pDevice->hInfFile); //Reset INF file ptr
|
|
break;
|
|
|
|
case CT_DIAL:
|
|
case CT_LISTEN:
|
|
if ((dRC = CheckBpsMacros(pDevice)) != SUCCESS)
|
|
return(dRC);
|
|
return(ResetBPS(pDevice));
|
|
|
|
case CT_GENERIC:
|
|
return(SUCCESS);
|
|
}
|
|
|
|
pDevice->eDevNextAction = SEND; //Reset state machine
|
|
break;
|
|
|
|
} /* Switch */
|
|
} /* While */
|
|
} /* DeviceStateMachine */
|
|
|
|
|
|
|
|
//* ReceiveStateMachine ----------------------------------------------------
|
|
//
|
|
// Function: This state machine controls asynchronously reading from the
|
|
// device. First the command echo is read promptly after the
|
|
// command is sent. Then after a delay the the response begins
|
|
// arriving. An asynchronous read with a long time out is done
|
|
// for the first character. Then the rest of the string is read
|
|
// (also asynchronously).
|
|
//
|
|
// Returns: PENDING
|
|
// SUCCESS
|
|
// ERROR_REPEATED_PARTIAL_RESPONSE
|
|
// Error return codes from GetLastError(), RasDevCheckResponse()
|
|
//
|
|
//*
|
|
|
|
DWORD
|
|
ReceiveStateMachine(DEVICE_CB *pDevice, HANDLE hIOPort)
|
|
{
|
|
DWORD dRC;
|
|
BOOL fKeyIsOK;
|
|
TCHAR szKey[MAX_PARAM_KEY_SIZE];
|
|
|
|
|
|
while(1)
|
|
{
|
|
//DebugPrintf(("ReceiveStateMachine state: %d\n", pDevice->eRcvState));
|
|
|
|
switch (pDevice->eRcvState)
|
|
{
|
|
|
|
case GETECHO:
|
|
|
|
// Check if an echo is expected.
|
|
// 1. If there is no command there is no echo.
|
|
// 2. Null modems require that if there is no response there is no echo
|
|
// so we require it for all devices.
|
|
// 3. If the current line of INF file is "NoEcho", there is no echo.
|
|
|
|
if (pDevice->dCmdLen == 0 ||
|
|
!pDevice->bResponseExpected ||
|
|
!RasDevEchoExpected(pDevice->hInfFile))
|
|
{
|
|
pDevice->eRcvState = GETFIRSTCHAR;
|
|
break;
|
|
}
|
|
|
|
|
|
// Clear buffer used for echo and device response, and Reset Event
|
|
|
|
memset(pDevice->szResponse, '\0', sizeof(pDevice->szResponse));
|
|
|
|
ResetEvent(pDevice->hNotifier); //Reset event handle
|
|
|
|
|
|
ConsolePrintf(("WaitForEcho hIOPort: 0x%08lx hNotifier: 0x%08x\n",
|
|
hIOPort, pDevice->hNotifier));
|
|
|
|
// Get Echo
|
|
|
|
if (WaitForEcho(pDevice, hIOPort, pDevice->dCmdLen))
|
|
{
|
|
pDevice->eRcvState = CHECKECHO;
|
|
return(PENDING);
|
|
}
|
|
else if ((dRC = GetLastError()) == ERROR_IO_PENDING)
|
|
{
|
|
pDevice->eRcvState = GETNUMBYTESECHOD;
|
|
return(PENDING);
|
|
}
|
|
else
|
|
return(dRC);
|
|
|
|
break;
|
|
|
|
|
|
case GETNUMBYTESECHOD:
|
|
|
|
if (!GetOverlappedResult(hIOPort,
|
|
(LPOVERLAPPED)&pDevice->Overlapped,
|
|
&pDevice->cbRead,
|
|
!WAITFORCOMPLETION))
|
|
return(GetLastError());
|
|
|
|
pDevice->eRcvState = CHECKECHO; //Set Next state
|
|
break;
|
|
|
|
|
|
case CHECKECHO:
|
|
|
|
// Log the Echo received
|
|
|
|
DebugPrintf(("Echo:%s!\n cbEcohed:%d\n",
|
|
pDevice->szResponse, pDevice->cbRead));
|
|
|
|
if (gbLogDeviceDialog && !pDevice->fPartialResponse)
|
|
LogString(pDevice, "Echo from Device :", pDevice->szResponse,
|
|
pDevice->cbRead);
|
|
|
|
|
|
// Check for echo different from command
|
|
|
|
switch(pDevice->eDeviceType)
|
|
{
|
|
case DT_MODEM:
|
|
if (pDevice->cbRead != pDevice->dCmdLen ||
|
|
_strnicmp(pDevice->szCommand,
|
|
pDevice->szResponse, pDevice->dCmdLen) != 0)
|
|
{
|
|
if (CheckForOverruns(hIOPort))
|
|
return(ERROR_OVERRUN);
|
|
else
|
|
return(ERROR_PORT_OR_DEVICE);
|
|
}
|
|
break;
|
|
|
|
case DT_PAD:
|
|
case DT_SWITCH:
|
|
if (RasDevSubStr(pDevice->szResponse,
|
|
pDevice->cbRead,
|
|
"NO CARRIER",
|
|
strlen("NO CARRIER")))
|
|
|
|
return(ERROR_NO_CARRIER);
|
|
break;
|
|
}
|
|
|
|
|
|
pDevice->eRcvState = GETFIRSTCHAR; //Set Next state
|
|
break;
|
|
|
|
|
|
case GETFIRSTCHAR:
|
|
|
|
// Check if a response is expected
|
|
|
|
if ( ! pDevice->bResponseExpected)
|
|
{
|
|
if ((dRC = PutInMessage(pDevice, "", 0)) != SUCCESS)
|
|
return(dRC);
|
|
|
|
pDevice->cbTotal = 0; //Reset for next response
|
|
return(SUCCESS);
|
|
}
|
|
|
|
|
|
// Save starting point for a receive following an echo
|
|
|
|
if (!pDevice->fPartialResponse)
|
|
{
|
|
(pDevice->cbTotal) += pDevice->cbRead;
|
|
pDevice->pszResponseStart = pDevice->szResponse + pDevice->cbTotal;
|
|
}
|
|
|
|
ResetEvent(pDevice->hNotifier); //Reset event handle
|
|
|
|
if (WaitForFirstChar(pDevice, hIOPort))
|
|
{
|
|
pDevice->eRcvState = GETRECEIVESTR;
|
|
return(PENDING);
|
|
}
|
|
else if ((dRC = GetLastError()) == ERROR_IO_PENDING)
|
|
{
|
|
pDevice->eRcvState = GETNUMBYTESFIRSTCHAR;
|
|
return(PENDING);
|
|
}
|
|
else
|
|
return(dRC);
|
|
|
|
break;
|
|
|
|
|
|
case GETNUMBYTESFIRSTCHAR:
|
|
|
|
DebugPrintf(("After 1st char:%s! cbTotal:%d\n",
|
|
pDevice->szResponse, pDevice->cbTotal));
|
|
|
|
if (!GetOverlappedResult(hIOPort,
|
|
(LPOVERLAPPED)&pDevice->Overlapped,
|
|
&pDevice->cbRead,
|
|
!WAITFORCOMPLETION))
|
|
return(GetLastError());
|
|
|
|
pDevice->eRcvState = GETRECEIVESTR; //Set Next state
|
|
break;
|
|
|
|
|
|
case GETRECEIVESTR:
|
|
|
|
(pDevice->cbTotal)++; //FIRSTCAR always rcvs 1 byte
|
|
|
|
ResetEvent(pDevice->hNotifier); //Reset event handle
|
|
|
|
if (ReceiveString(pDevice, hIOPort))
|
|
{
|
|
pDevice->eRcvState = CHECKRESPONSE;
|
|
return(PENDING);
|
|
}
|
|
else if ((dRC = GetLastError()) == ERROR_IO_PENDING)
|
|
{
|
|
pDevice->eRcvState = GETNUMBYTESRCVD;
|
|
return(PENDING);
|
|
}
|
|
else
|
|
return(dRC);
|
|
|
|
break;
|
|
|
|
|
|
case GETNUMBYTESRCVD:
|
|
|
|
if (!GetOverlappedResult(hIOPort,
|
|
(LPOVERLAPPED)&pDevice->Overlapped,
|
|
&pDevice->cbRead,
|
|
!WAITFORCOMPLETION))
|
|
return(GetLastError());
|
|
|
|
pDevice->eRcvState = CHECKRESPONSE; //Set Next state
|
|
break;
|
|
|
|
|
|
case CHECKRESPONSE:
|
|
|
|
(pDevice->cbTotal) += pDevice->cbRead;
|
|
|
|
|
|
// Always put response string where UI can get it
|
|
|
|
if (pDevice->eDeviceType == DT_MODEM)
|
|
dRC = PutInMessage(pDevice,
|
|
pDevice->pszResponseStart,
|
|
ModemResponseLen(pDevice));
|
|
else
|
|
dRC = PutInMessage(pDevice, pDevice->szResponse, pDevice->cbTotal);
|
|
|
|
if (dRC != SUCCESS)
|
|
return(dRC);
|
|
|
|
|
|
|
|
// Check the response
|
|
|
|
dRC = CheckResponse(pDevice, szKey);
|
|
|
|
|
|
// Log the response received
|
|
|
|
if (gbLogDeviceDialog && dRC != ERROR_PARTIAL_RESPONSE)
|
|
LogString(pDevice,
|
|
"Response from Device:",
|
|
pDevice->pszResponseStart,
|
|
ModemResponseLen(pDevice));
|
|
|
|
switch(dRC)
|
|
{
|
|
case ERROR_UNRECOGNIZED_RESPONSE:
|
|
default: // Other errors
|
|
return(dRC);
|
|
|
|
|
|
case ERROR_PARTIAL_RESPONSE:
|
|
|
|
if (pDevice->fPartialResponse)
|
|
return(ERROR_PARTIAL_RESPONSE_LOOPING);
|
|
|
|
pDevice->fPartialResponse = TRUE;
|
|
pDevice->eRcvState = GETFIRSTCHAR;
|
|
|
|
ConsolePrintf(("Partial Response\n"));
|
|
break;
|
|
|
|
|
|
case SUCCESS: // Response found in INF file
|
|
|
|
pDevice->cbTotal = 0; // Reset for next response
|
|
|
|
fKeyIsOK = !_strnicmp(szKey, MXS_OK_KEY, strlen(MXS_OK_KEY));
|
|
|
|
|
|
// Do we need to loop and get another response from device
|
|
|
|
if (((_stricmp(szKey, LOOP_TXT) == 0) && (pDevice->eCmdType != CT_INIT)) ||
|
|
(fKeyIsOK && pDevice->eCmdType == CT_LISTEN) )
|
|
{
|
|
pDevice->eRcvState = GETFIRSTCHAR;
|
|
break;
|
|
}
|
|
|
|
|
|
// Check if device has error contol on
|
|
|
|
pDevice->bErrorControlOn = _stricmp(szKey, MXS_CONNECT_EC_KEY) == 0;
|
|
|
|
|
|
// Determine return code
|
|
|
|
if (fKeyIsOK)
|
|
if (pDevice->eCmdType == CT_DIAL)
|
|
return(ERROR_PORT_OR_DEVICE);
|
|
else
|
|
return(SUCCESS);
|
|
|
|
if (_strnicmp(szKey, MXS_CONNECT_KEY, strlen(MXS_CONNECT_KEY)) == 0)
|
|
return(SUCCESS);
|
|
|
|
else if (_strnicmp(szKey, MXS_ERROR_KEY, strlen(MXS_ERROR_KEY)) == 0)
|
|
return(MapKeyToErrorCode(szKey));
|
|
|
|
else if (CheckForOverruns(hIOPort))
|
|
return(ERROR_OVERRUN);
|
|
|
|
else
|
|
return(ERROR_UNKNOWN_RESPONSE_KEY);
|
|
}
|
|
break;
|
|
|
|
} /* Switch */
|
|
} /* While */
|
|
} /* ReceiveStateMachine */
|
|
|
|
|
|
|
|
//* CheckResponse ----------------------------------------------------------
|
|
//
|
|
// Function: If DeviceType is Modem this function checks first for a
|
|
// response in that particular modem's section of the INF
|
|
// file and returns if it finds one. If there is no response
|
|
// there, it checks for a response in the Modems Responses
|
|
// section.
|
|
//
|
|
// If DeviceType is not Modem the function checks only in
|
|
// the particular device's section of the INF file.
|
|
//
|
|
// Returns: Error return codes from RasDevCheckResponse()
|
|
//
|
|
//*
|
|
|
|
DWORD
|
|
CheckResponse(DEVICE_CB *pDev, LPTSTR szKey)
|
|
{
|
|
DWORD dRC, dResponseLen;
|
|
|
|
|
|
if (pDev->cbTotal > sizeof(pDev->szResponse))
|
|
return(ERROR_RECV_BUF_FULL);
|
|
|
|
|
|
dResponseLen = ModemResponseLen(pDev);
|
|
|
|
DebugPrintf(("Device Response:%s! cbResponse:%d\n",
|
|
pDev->pszResponseStart, dResponseLen));
|
|
|
|
dRC = RasDevCheckResponse(pDev->hInfFile,
|
|
pDev->pszResponseStart,
|
|
dResponseLen,
|
|
pDev->pMacros,
|
|
szKey);
|
|
|
|
if (pDev->eDeviceType == DT_MODEM &&
|
|
dRC != SUCCESS &&
|
|
dRC != ERROR_PARTIAL_RESPONSE) {
|
|
|
|
// **** Exclusion Begin ****
|
|
WaitForSingleObject(ResponseSection.Mutex, INFINITE) ;
|
|
|
|
dRC = RasDevCheckResponse(ResponseSection.Handle,
|
|
pDev->pszResponseStart,
|
|
dResponseLen,
|
|
pDev->pMacros,
|
|
szKey);
|
|
|
|
// *** Exclusion End ***
|
|
ReleaseMutex(ResponseSection.Mutex);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dRC == ERROR_UNRECOGNIZED_RESPONSE)
|
|
{
|
|
|
|
// Maybe there was no echo.
|
|
// Try again assuming string starts at beginning of buffer.
|
|
|
|
dRC = RasDevCheckResponse(pDev->hInfFile,
|
|
pDev->szResponse,
|
|
pDev->cbTotal,
|
|
pDev->pMacros,
|
|
szKey);
|
|
|
|
if (pDev->eDeviceType == DT_MODEM &&
|
|
dRC != SUCCESS &&
|
|
dRC != ERROR_PARTIAL_RESPONSE) {
|
|
|
|
// **** Exclusion Begin ****
|
|
WaitForSingleObject(ResponseSection.Mutex, INFINITE) ;
|
|
|
|
dRC = RasDevCheckResponse(ResponseSection.Handle,
|
|
pDev->szResponse,
|
|
pDev->cbTotal,
|
|
pDev->pMacros,
|
|
szKey);
|
|
|
|
// *** Exclusion End ***
|
|
ReleaseMutex(ResponseSection.Mutex);
|
|
|
|
}
|
|
}
|
|
|
|
return(dRC);
|
|
}
|
|
|
|
|
|
|
|
//* ModemResponseLen -------------------------------------------------------
|
|
//
|
|
// Function: This function returns the length of the portion of the
|
|
// response in the response buffer which follows the echo.
|
|
//
|
|
// Returns: Total length - (start of response - beginning of buffer)
|
|
//
|
|
//*
|
|
|
|
DWORD
|
|
ModemResponseLen(DEVICE_CB *pDev)
|
|
{
|
|
return(DWORD)(pDev->cbTotal - (pDev->pszResponseStart - pDev->szResponse));
|
|
}
|
|
|
|
|
|
|
|
//* CommWait ---------------------------------------------------------------
|
|
//
|
|
// Function: This function causes an asynchronous delay by reading the
|
|
// com port when no characters are expected. When the ReadFile
|
|
// times out the calling process is signaled via hNotifier.
|
|
//
|
|
// Returns: Values from Win32 api calls.
|
|
//
|
|
//*
|
|
|
|
DWORD
|
|
CommWait(DEVICE_CB *pDevice, HANDLE hIOPort, DWORD dwPause)
|
|
{
|
|
DWORD dwBytesRead;
|
|
TCHAR Buffer[2048];
|
|
COMMTIMEOUTS CT;
|
|
|
|
|
|
CT.ReadIntervalTimeout = 0;
|
|
CT.ReadTotalTimeoutMultiplier = 0;
|
|
CT.ReadTotalTimeoutConstant = dwPause;
|
|
|
|
if ( ! SetCommTimeouts(hIOPort, &CT))
|
|
return(FALSE);
|
|
|
|
|
|
return(ReadFile(hIOPort,
|
|
Buffer,
|
|
sizeof(Buffer),
|
|
&dwBytesRead,
|
|
(LPOVERLAPPED)&pDevice->Overlapped));
|
|
}
|
|
|
|
|
|
|
|
//* WaitForEcho ------------------------------------------------------------
|
|
//
|
|
// Function: This function reads the echo of the command sent to the
|
|
// device. The echo is not used and is simply ignored.
|
|
// Since the length of the echo is the length of the command
|
|
// sent, cbEcho is the size of the command sent.
|
|
//
|
|
// ReadFile is asynchronous (because the port was opened in
|
|
// overlapped mode), and completes when the buffer is full
|
|
// (cbEcho bytes) or after TO_ECHO mS, whichever comes first.
|
|
//
|
|
// Returns: Error return codes from ReadFile(), or GetLastError().
|
|
//
|
|
//*
|
|
|
|
BOOL
|
|
WaitForEcho(DEVICE_CB *pDevice, HANDLE hIOPort, DWORD cbEcho)
|
|
{
|
|
COMMTIMEOUTS CT;
|
|
|
|
|
|
CT.ReadIntervalTimeout = 0;
|
|
CT.ReadTotalTimeoutMultiplier = 0;
|
|
CT.ReadTotalTimeoutConstant = TO_ECHO; // Comm time out = TO_ECHO
|
|
|
|
if ( ! SetCommTimeouts(hIOPort, &CT))
|
|
return(FALSE);
|
|
|
|
if(cbEcho > MAX_RCV_BUF_LEN)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
return(ReadFile(hIOPort,
|
|
pDevice->szResponse,
|
|
cbEcho,
|
|
&pDevice->cbRead,
|
|
(LPOVERLAPPED)&pDevice->Overlapped));
|
|
}
|
|
|
|
|
|
|
|
//* WaitForFirstChar -------------------------------------------------------
|
|
//
|
|
// Function: This function reads the first character received from the
|
|
// device in response to the last command. (This follows the
|
|
// echo of the command.)
|
|
//
|
|
// ReadFile is asynchronous (because the port was opened in
|
|
// overlapped mode), and completes after one character is
|
|
// received, or after CT.ReadToalTimeoutConstant, whichever
|
|
// comes first.
|
|
//
|
|
// Returns: Error return codes from ReadFile(), or GetLastError().
|
|
//
|
|
//*
|
|
|
|
BOOL
|
|
WaitForFirstChar(DEVICE_CB *pDevice, HANDLE hIOPort)
|
|
{
|
|
TCHAR *pszResponse;
|
|
COMMTIMEOUTS CT;
|
|
|
|
|
|
CT.ReadIntervalTimeout = 0;
|
|
CT.ReadTotalTimeoutMultiplier = 0;
|
|
|
|
|
|
if (pDevice->fPartialResponse)
|
|
CT.ReadTotalTimeoutConstant = TO_PARTIALRESPONSE;
|
|
|
|
else if (pDevice->eCmdType == CT_LISTEN)
|
|
CT.ReadTotalTimeoutConstant = 0; //Never timeout for LISTEN
|
|
|
|
else if (pDevice->cbTotal == 0) //Implies no Echo
|
|
CT.ReadTotalTimeoutConstant = TO_FIRSTCHARNOECHO; //Probably not a modem
|
|
|
|
else
|
|
CT.ReadTotalTimeoutConstant = TO_FIRSTCHARAFTERECHO; //Probably a modem
|
|
|
|
|
|
if ( ! SetCommTimeouts(hIOPort, &CT))
|
|
return(FALSE);
|
|
|
|
pszResponse = pDevice->szResponse;
|
|
pszResponse += pDevice->cbTotal;
|
|
|
|
return(ReadFile(hIOPort,
|
|
pszResponse,
|
|
1,
|
|
&pDevice->cbRead,
|
|
(LPOVERLAPPED)&pDevice->Overlapped));
|
|
}
|
|
|
|
|
|
|
|
//* ReceiveString ----------------------------------------------------------
|
|
//
|
|
// Function: This function reads the string received from the device in
|
|
// response to the last command. The first byte of this string
|
|
// has already been received by WaitForFirstChar().
|
|
//
|
|
// ReadFile is asynchronous (because the port was opened in
|
|
// overlapped mode), and times out after a total time of
|
|
// TO_RCV_CONSTANT, or if the time between characters exceeds
|
|
// TO_RCV_INTERVAL.
|
|
//
|
|
// Returns: Error return codes from ReadFile(), or GetLastError().
|
|
//
|
|
//*
|
|
|
|
BOOL
|
|
ReceiveString(DEVICE_CB *pDevice, HANDLE hIOPort)
|
|
{
|
|
TCHAR *pszResponse;
|
|
COMMTIMEOUTS CT;
|
|
|
|
|
|
CT.ReadIntervalTimeout = TO_RCV_INTERVAL;
|
|
CT.ReadTotalTimeoutMultiplier = 0;
|
|
CT.ReadTotalTimeoutConstant = TO_RCV_CONSTANT;
|
|
|
|
if ( ! SetCommTimeouts(hIOPort, &CT))
|
|
return(FALSE);
|
|
|
|
|
|
pszResponse = pDevice->szResponse;
|
|
pszResponse += pDevice->cbTotal;
|
|
|
|
return(ReadFile(hIOPort,
|
|
pszResponse,
|
|
sizeof(pDevice->szResponse) - pDevice->cbTotal,
|
|
&pDevice->cbRead,
|
|
(LPOVERLAPPED)&pDevice->Overlapped));
|
|
}
|
|
|
|
|
|
|
|
//* PutInMessage -----------------------------------------------------------
|
|
//
|
|
// Function: This function finds the message macro in the Macro Translations
|
|
// table, and copies the second parameter, a string, into the
|
|
// message macro's value field.
|
|
//
|
|
// Returns: SUCCESS
|
|
// ERROR_MESSAGE_MACRO_NOT_FOUND
|
|
// Return codes from UpdateparmString
|
|
//*
|
|
|
|
DWORD
|
|
PutInMessage(DEVICE_CB *pDevice, LPTSTR lpszStr, DWORD dwStrLen)
|
|
{
|
|
WORD i;
|
|
MACROXLATIONTABLE *pMacros = pDevice->pMacros;
|
|
|
|
|
|
for (i=0; i<pMacros->MXT_NumOfEntries; i++)
|
|
|
|
if (_stricmp(MXS_MESSAGE_KEY, pMacros->MXT_Entry[i].E_MacroName) == 0)
|
|
break;
|
|
|
|
if (i >= pMacros->MXT_NumOfEntries)
|
|
return(ERROR_MESSAGE_MACRO_NOT_FOUND);
|
|
|
|
return(UpdateParamString(pMacros->MXT_Entry[i].E_Param,
|
|
lpszStr,
|
|
dwStrLen));
|
|
}
|
|
|
|
|
|
|
|
//* PortSetStringInfo -----------------------------------------------------
|
|
//
|
|
// Function: Formats a RASMAN_PORTINFO struct for string data and calls
|
|
// PortSetInfo.
|
|
//
|
|
// Returns: Return codes from PortSetInfo
|
|
//*
|
|
|
|
DWORD
|
|
PortSetStringInfo(HANDLE hIOPort, char *pszKey, char *psStr, DWORD sStrLen)
|
|
{
|
|
BYTE chBuffer[sizeof(RASMAN_PORTINFO) + RAS_MAXLINEBUFLEN];
|
|
RASMAN_PORTINFO *pSetInfo;
|
|
|
|
|
|
pSetInfo = (RASMAN_PORTINFO *)chBuffer;
|
|
pSetInfo->PI_NumOfParams = 1;
|
|
|
|
// strcpy(pSetInfo->PI_Params[0].P_Key, pszKey);
|
|
(VOID) StringCchCopyA(pSetInfo->PI_Params[0].P_Key,
|
|
MAX_PARAM_KEY_SIZE,
|
|
pszKey);
|
|
|
|
pSetInfo->PI_Params[0].P_Type = String;
|
|
pSetInfo->PI_Params[0].P_Attributes = 0;
|
|
pSetInfo->PI_Params[0].P_Value.String.Data =
|
|
(PCHAR)pSetInfo + sizeof(RASMAN_PORTINFO);
|
|
|
|
strncpy(pSetInfo->PI_Params[0].P_Value.String.Data, psStr, sStrLen);
|
|
pSetInfo->PI_Params[0].P_Value.String.Length = sStrLen;
|
|
|
|
PortSetInfo(hIOPort, pSetInfo) ;
|
|
|
|
return(SUCCESS);
|
|
}
|
|
|
|
|
|
|
|
//* ResetBPS --------------------------------------------------------------
|
|
//
|
|
// Function: This function calls the serial dll API, PortSetInfo, and
|
|
// 1. sets the Error Control Flag in the Serial PCB,
|
|
// 2. sets the Hardware Flow Conrol Flag,
|
|
// 3. sets the Carrier BPS rate in the Serial PCB,
|
|
// 4. if the Connect BPS macro is non-null the Port BPS is
|
|
// is set to the macro value, otherwise it is unchanged.
|
|
//
|
|
// See the truth table in the CheckBpsMacros() function notes.
|
|
//
|
|
// Assumptions: ConnectBps and CarrierBps macros are filled in,
|
|
// that is, RasDevCheckResponse has been called successfully.
|
|
//
|
|
// Returns: Error codes from GetLastError().
|
|
//
|
|
//*
|
|
|
|
DWORD
|
|
ResetBPS(DEVICE_CB *pDev)
|
|
{
|
|
UINT i;
|
|
DWORD dwRC;
|
|
TCHAR *pStrData, *pArgs[1];
|
|
BYTE chBuffer[sizeof(RASMAN_PORTINFO) + (MAX_LEN_STR_FROM_NUMBER + 1)];
|
|
|
|
RAS_PARAMS *pParam;
|
|
RASMAN_PORTINFO *pPortInfo;
|
|
RASMAN_DEVICEINFO *pInfoTable = pDev->pInfoTable;
|
|
|
|
|
|
|
|
pPortInfo = (RASMAN_PORTINFO *)chBuffer;
|
|
pParam = pPortInfo->PI_Params;
|
|
pStrData = (PCHAR)pPortInfo + sizeof(RASMAN_PORTINFO);
|
|
|
|
pPortInfo->PI_NumOfParams = 1;
|
|
|
|
|
|
// Make Error Control Flag Entry
|
|
|
|
strcpy(pParam->P_Key, SER_ERRORCONTROLON_KEY);
|
|
pParam->P_Type = Number;
|
|
pParam->P_Attributes = 0;
|
|
pParam->P_Value.Number = pDev->bErrorControlOn;
|
|
|
|
PortSetInfo(pDev->hPort, pPortInfo) ;
|
|
|
|
// Make HwFlowControl Flag Entry
|
|
|
|
strcpy(pParam->P_Key, SER_HDWFLOWCTRLON_KEY);
|
|
pParam->P_Type = Number;
|
|
pParam->P_Attributes = 0;
|
|
|
|
i = FindTableEntry(pInfoTable, MXS_HDWFLOWCONTROL_KEY);
|
|
|
|
if (i == INVALID_INDEX)
|
|
return(ERROR_MACRO_NOT_FOUND);
|
|
|
|
|
|
pParam->P_Value.Number =
|
|
pInfoTable->DI_Params[i].P_Attributes & ATTRIB_ENABLED;
|
|
|
|
PortSetInfo(pDev->hPort, pPortInfo) ;
|
|
|
|
// Make Carrier BPS Entry
|
|
|
|
i = FindTableEntry(pInfoTable, MXS_CARRIERBPS_KEY);
|
|
|
|
if (i == INVALID_INDEX)
|
|
return(ERROR_MACRO_NOT_FOUND);
|
|
|
|
dwRC = PortSetStringInfo(pDev->hPort,
|
|
SER_CARRIERBPS_KEY,
|
|
pInfoTable->DI_Params[i].P_Value.String.Data,
|
|
pInfoTable->DI_Params[i].P_Value.String.Length);
|
|
|
|
if (dwRC != SUCCESS)
|
|
return(dwRC);
|
|
|
|
|
|
|
|
// Make Connect BPS Entry
|
|
|
|
i = FindTableEntry(pInfoTable, MXS_CONNECTBPS_KEY);
|
|
|
|
if (i == INVALID_INDEX)
|
|
return(ERROR_MACRO_NOT_FOUND);
|
|
|
|
dwRC = PortSetStringInfo(pDev->hPort,
|
|
SER_CONNECTBPS_KEY,
|
|
pInfoTable->DI_Params[i].P_Value.String.Data,
|
|
pInfoTable->DI_Params[i].P_Value.String.Length);
|
|
|
|
if (dwRC == ERROR_INVALID_PARAMETER)
|
|
{
|
|
pArgs[0] = pDev->szPortName;
|
|
LogError(ROUTERLOG_UNSUPPORTED_BPS, 1, pArgs, NO_ERROR);
|
|
return(ERROR_UNSUPPORTED_BPS);
|
|
}
|
|
else if (dwRC != SUCCESS)
|
|
return(dwRC);
|
|
|
|
|
|
return(SUCCESS);
|
|
}
|
|
|
|
|
|
|
|
//* CheckBpsMacros ---------------------------------------------------------
|
|
//
|
|
// Function: If the connectbps macro string converts to zero (no connect BPS
|
|
// rate was received from the device, or it was a word, eg, FAST),
|
|
// then the value for the Port BPS saved in the DCB is copied to
|
|
// connectbps.
|
|
//
|
|
// If the carrierbps macro string converts to zero, then the value
|
|
// for the carrierbps is estimated as max(2400, connectbps/4),
|
|
// unless the connectbps <= 2400, in which case carrerbps is set to
|
|
// the value for connectbps.
|
|
//
|
|
// Returns: SUCCESS
|
|
// Return codes from UpdateparmString
|
|
//*
|
|
|
|
DWORD
|
|
CheckBpsMacros(DEVICE_CB *pDev)
|
|
{
|
|
UINT i, j;
|
|
DWORD dwRC, dwConnectBps, dwCarrierBps, dwCarrierBpsEstimate;
|
|
TCHAR szConnectBps[MAX_LEN_STR_FROM_NUMBER];
|
|
TCHAR szCarrierBps[MAX_LEN_STR_FROM_NUMBER];
|
|
RASMAN_DEVICEINFO *pInfoTable = pDev->pInfoTable;
|
|
|
|
|
|
|
|
// Find Carrier BPS rate in InfoTable
|
|
|
|
j = FindTableEntry(pInfoTable, MXS_CONNECTBPS_KEY);
|
|
i = FindTableEntry(pInfoTable, MXS_CARRIERBPS_KEY);
|
|
|
|
if (j == INVALID_INDEX || i == INVALID_INDEX)
|
|
return(ERROR_MACRO_NOT_FOUND);
|
|
|
|
|
|
// Get Connect Bps rate from macro
|
|
|
|
strncpy(szConnectBps,
|
|
pInfoTable->DI_Params[j].P_Value.String.Data,
|
|
pInfoTable->DI_Params[j].P_Value.String.Length);
|
|
|
|
szConnectBps[pInfoTable->DI_Params[j].P_Value.String.Length] = '\0';
|
|
|
|
dwConnectBps = atoi(szConnectBps);
|
|
|
|
|
|
// If Connect BPS macro value is zero copy Port BPS to Connect BPS
|
|
|
|
if (dwConnectBps == 0)
|
|
{
|
|
dwRC = UpdateParamString(&(pInfoTable->DI_Params[j]),
|
|
pDev->szPortBps,
|
|
strlen(pDev->szPortBps));
|
|
if (dwRC != SUCCESS)
|
|
return(dwRC);
|
|
|
|
dwConnectBps = atoi(pDev->szPortBps);
|
|
}
|
|
|
|
|
|
|
|
// Get Carrier Bps rate from macro
|
|
|
|
strncpy(szCarrierBps,
|
|
pInfoTable->DI_Params[i].P_Value.String.Data,
|
|
pInfoTable->DI_Params[i].P_Value.String.Length);
|
|
|
|
szCarrierBps[pInfoTable->DI_Params[i].P_Value.String.Length] = '\0';
|
|
|
|
dwCarrierBps = atoi(szCarrierBps);
|
|
|
|
|
|
// If Carrier BPS macro value is zero estimate Carrier BPS
|
|
|
|
if (dwCarrierBps == 0)
|
|
{
|
|
if (dwConnectBps <= MIN_LINK_SPEED) //2400 bps
|
|
|
|
dwCarrierBpsEstimate = dwConnectBps;
|
|
|
|
else
|
|
{
|
|
UINT k ;
|
|
|
|
k = FindTableEntry(pInfoTable, MXS_HDWFLOWCONTROL_KEY);
|
|
|
|
if (k == INVALID_INDEX)
|
|
return(ERROR_MACRO_NOT_FOUND);
|
|
|
|
|
|
if (pInfoTable->DI_Params[k].P_Attributes & ATTRIB_ENABLED)
|
|
dwCarrierBpsEstimate = dwConnectBps/4 ;
|
|
else
|
|
dwCarrierBpsEstimate = dwConnectBps ;
|
|
|
|
if (dwCarrierBpsEstimate < MIN_LINK_SPEED)
|
|
dwCarrierBpsEstimate = MIN_LINK_SPEED;
|
|
}
|
|
|
|
_itoa(dwCarrierBpsEstimate, szCarrierBps, 10);
|
|
|
|
dwRC = UpdateParamString(&(pInfoTable->DI_Params[i]),
|
|
szCarrierBps,
|
|
strlen(szCarrierBps));
|
|
if (dwRC != SUCCESS)
|
|
return(dwRC);
|
|
}
|
|
|
|
|
|
|
|
// Log BPS Macros
|
|
|
|
if (gbLogDeviceDialog)
|
|
{
|
|
LogString(pDev,
|
|
"Connect BPS:",
|
|
pInfoTable->DI_Params[j].P_Value.String.Data,
|
|
pInfoTable->DI_Params[j].P_Value.String.Length);
|
|
|
|
LogString(pDev,
|
|
"Carrier BPS:",
|
|
pInfoTable->DI_Params[i].P_Value.String.Data,
|
|
pInfoTable->DI_Params[i].P_Value.String.Length);
|
|
}
|
|
|
|
DebugPrintf(("ConnectBps: %s\n", pInfoTable->DI_Params[j].P_Value.String.Data));
|
|
DebugPrintf(("CarrierBps: %s\n", pInfoTable->DI_Params[i].P_Value.String.Data));
|
|
|
|
|
|
return(SUCCESS);
|
|
}
|
|
|
|
|
|
|
|
//* FindTableEntry ---------------------------------------------------------
|
|
//
|
|
// Function: Finds a key in Info Table. This function matches the length
|
|
// up to the lenght of the input parameter (pszKey). If a binary
|
|
// macro name is given without the suffix the first of the two
|
|
// binary macros will be found. If the full binary macro name is
|
|
// given the exact binary macro will be found.
|
|
//
|
|
// Assumptions: The input parameter, pszKey, is
|
|
// 1. a full unary macro name, or
|
|
// 2. a "core" binary macro name, or
|
|
// 3. a full binary macro name.
|
|
//
|
|
// Returns: Index of DI_Params in Info Table.
|
|
//
|
|
//*
|
|
|
|
UINT
|
|
FindTableEntry(RASMAN_DEVICEINFO *pTable, TCHAR *pszKey)
|
|
{
|
|
WORD i;
|
|
|
|
|
|
for (i=0; i<pTable->DI_NumOfParams; i++)
|
|
|
|
if (_strnicmp(pszKey, pTable->DI_Params[i].P_Key, strlen(pszKey)) == 0)
|
|
break;
|
|
|
|
if (i >= pTable->DI_NumOfParams)
|
|
return(INVALID_INDEX);
|
|
|
|
return(i);
|
|
}
|
|
|
|
|
|
|
|
//* MapKeyToErrorCode ------------------------------------------------------
|
|
//
|
|
// Function: Maps the error key from the device.ini file to an error code
|
|
// number to be returned to the UI.
|
|
//
|
|
// Returns: An error code that represents the error returned from the device.
|
|
//
|
|
//*
|
|
|
|
DWORD
|
|
MapKeyToErrorCode(TCHAR *pszKey)
|
|
{
|
|
int i;
|
|
ERROR_ELEM ErrorTable[] = {
|
|
MXS_ERROR_BUSY_KEY , ERROR_LINE_BUSY ,
|
|
MXS_ERROR_NO_ANSWER_KEY , ERROR_NO_ANSWER ,
|
|
MXS_ERROR_VOICE_KEY , ERROR_VOICE_ANSWER ,
|
|
MXS_ERROR_NO_CARRIER_KEY , ERROR_NO_CARRIER ,
|
|
MXS_ERROR_NO_DIALTONE_KEY , ERROR_NO_DIALTONE ,
|
|
MXS_ERROR_DIAGNOSTICS_KEY , ERROR_X25_DIAGNOSTIC
|
|
};
|
|
|
|
for (i=0; i < sizeof(ErrorTable)/sizeof(ERROR_ELEM); i++)
|
|
|
|
if (_stricmp(pszKey, ErrorTable[i].szKey) == 0)
|
|
|
|
return(ErrorTable[i].dwErrorCode);
|
|
|
|
return(ERROR_FROM_DEVICE);
|
|
}
|