|
|
//****************************************************************************
//
// 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
//*
DWORDBuildMacroXlationTable(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()
//
//*
DWORDDeviceStateMachine(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()
//
//*
DWORDReceiveStateMachine(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()
//
//*
DWORDCheckResponse(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)
//
//*
DWORDModemResponseLen(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.
//
//*
DWORDCommWait(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().
//
//*
BOOLWaitForEcho(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().
//
//*
BOOLWaitForFirstChar(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().
//
//*
BOOLReceiveString(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
//*
DWORDPutInMessage(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
//*
DWORDPortSetStringInfo(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().
//
//*
DWORDResetBPS(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
//*
DWORDCheckBpsMacros(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.
//
//*
UINTFindTableEntry(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.
//
//*
DWORDMapKeyToErrorCode(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);}
|
