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.
895 lines
27 KiB
895 lines
27 KiB
/*****************************************************************************
|
|
*
|
|
* $Workfile: InptChkr.cpp $
|
|
*
|
|
* Copyright (C) 1997 Hewlett-Packard Company.
|
|
* Copyright (c) 1997 Microsoft Corporation.
|
|
* All rights reserved.
|
|
*
|
|
* 11311 Chinden Blvd.
|
|
* Boise, Idaho 83714
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#include "precomp.h"
|
|
#include "TCPMonUI.h"
|
|
#include "UIMgr.h"
|
|
#include "InptChkr.h"
|
|
#include "Resource.h"
|
|
#include "IPAddr.h"
|
|
#include "HostName.h"
|
|
|
|
//
|
|
// FUNCTION: CInputChecker constructor
|
|
//
|
|
// PURPOSE: initialize a CInputChecker class
|
|
//
|
|
CInputChecker::CInputChecker()
|
|
{
|
|
m_bLinked = FALSE;
|
|
m_InputStorageStringAddress[0] = '\0';
|
|
m_InputStorageStringPortNumber[0] = '\0';
|
|
m_InputStorageStringDeviceIndex[0] = '\0';
|
|
m_InputStorageStringQueueName[0] = '\0';
|
|
|
|
} // constructor
|
|
|
|
|
|
//
|
|
// FUNCTION: CInputChecker destructor
|
|
//
|
|
// PURPOSE: deinitialize a CInputChecker class
|
|
//
|
|
CInputChecker::~CInputChecker()
|
|
{
|
|
} // destructor
|
|
|
|
|
|
//
|
|
// FUNCTION: OnUpdatePortName(idEditCtrl, hwndEditCtrl)
|
|
//
|
|
// PURPOSE: to handle EN_UPDATE message when the edit control is the Port Name input.
|
|
//
|
|
void CInputChecker::OnUpdatePortName(int idEditCtrl, HWND hwndEditCtrl)
|
|
{
|
|
// the edit control for Port Name had text changed in it.
|
|
BOOL bModified = static_cast<BOOL> (SendMessage(hwndEditCtrl, EM_GETMODIFY, 0,0));
|
|
if(bModified)
|
|
{
|
|
TCHAR tcsAddr[MAX_ADDRESS_LENGTH] = NULLSTR;
|
|
TCHAR tcsLastValidAddr[MAX_ADDRESS_LENGTH] = NULLSTR;
|
|
GetWindowText(hwndEditCtrl, tcsAddr, MAX_ADDRESS_LENGTH);
|
|
|
|
if(! IsValidPortNameInput(tcsAddr,
|
|
tcsLastValidAddr,
|
|
SIZEOF_IN_CHAR(tcsLastValidAddr)))
|
|
{
|
|
// the port name that was entered is not valid so beep and set the text
|
|
// back to the last valid entry. This test for validity does not
|
|
// include testing for the right length just proper character set.
|
|
MessageBeep((UINT)-1);
|
|
DWORD dwSel = Edit_GetSel(hwndEditCtrl);
|
|
SetWindowText(hwndEditCtrl, tcsLastValidAddr);
|
|
Edit_SetSel(hwndEditCtrl, LOWORD(dwSel) - 1, HIWORD(dwSel) - 1);
|
|
}
|
|
|
|
m_bLinked = FALSE;
|
|
}
|
|
|
|
} // OnUpdatePortName
|
|
|
|
|
|
//
|
|
// FUNCTION: OnUpdatePortNumber(idEditCtrl, hwndEditCtrl)
|
|
//
|
|
// PURPOSE: to handle EN_UPDATE message when the edit control is the Port Number input.
|
|
//
|
|
void CInputChecker::OnUpdatePortNumber(int idEditCtrl, HWND hwndEditCtrl)
|
|
{
|
|
// the edit control for Port Number had text changed in it.
|
|
TCHAR tcsPortNum[MAX_PORTNUM_STRING_LENGTH] = NULLSTR;
|
|
TCHAR tcsLastValidPortNum[MAX_PORTNUM_STRING_LENGTH] = NULLSTR;
|
|
GetWindowText(hwndEditCtrl, tcsPortNum, MAX_PORTNUM_STRING_LENGTH);
|
|
|
|
if(! IsValidPortNumberInput(tcsPortNum,
|
|
tcsLastValidPortNum,
|
|
SIZEOF_IN_CHAR(tcsLastValidPortNum)))
|
|
{
|
|
// the port number that was entered is not valid so beep and set the text
|
|
// back to the last valid entry. This test for validity does not
|
|
// include testing for the right length just proper character set.
|
|
MessageBeep((UINT)-1);
|
|
DWORD dwSel = Edit_GetSel(hwndEditCtrl);
|
|
SetWindowText(hwndEditCtrl, tcsLastValidPortNum);
|
|
Edit_SetSel(hwndEditCtrl, LOWORD(dwSel) - 1, HIWORD(dwSel) - 1);
|
|
}
|
|
|
|
} // OnUpdatePortNumber
|
|
|
|
|
|
//
|
|
// FUNCTION: OnUpdateDeviceIndex(idEditCtrl, hwndEditCtrl)
|
|
//
|
|
// PURPOSE: to handle EN_UPDATE message when the edit control is the Device Index input.
|
|
//
|
|
void CInputChecker::OnUpdateDeviceIndex(int idEditCtrl, HWND hwndEditCtrl)
|
|
{
|
|
// the edit control for Port Number had text changed in it.
|
|
TCHAR tcsDeviceIndex[MAX_SNMP_DEVICENUM_STRING_LENGTH] = NULLSTR;
|
|
TCHAR tcsLastValidDeviceIndex[MAX_SNMP_DEVICENUM_STRING_LENGTH] = NULLSTR;
|
|
GetWindowText(hwndEditCtrl, tcsDeviceIndex, MAX_SNMP_DEVICENUM_STRING_LENGTH);
|
|
|
|
if(! IsValidDeviceIndexInput(tcsDeviceIndex,
|
|
tcsLastValidDeviceIndex,
|
|
SIZEOF_IN_CHAR(tcsLastValidDeviceIndex)))
|
|
{
|
|
// the device index that was entered is not valid so beep and set the
|
|
// text back to the last valid entry. This test for validity does not
|
|
// include testing for the right length just proper character set.
|
|
MessageBeep((UINT)-1);
|
|
DWORD dwSel = Edit_GetSel(hwndEditCtrl);
|
|
SetWindowText(hwndEditCtrl, tcsLastValidDeviceIndex);
|
|
Edit_SetSel(hwndEditCtrl, LOWORD(dwSel) - 1, HIWORD(dwSel) - 1);
|
|
}
|
|
|
|
} // OnUpdateDeviceIndex
|
|
|
|
|
|
|
|
//
|
|
// FUNCTION: OnUpdateAddress(idEditCtrl, hwndEditCtrl)
|
|
//
|
|
// PURPOSE: to handle EN_UPDATE message when the edit control is the Address input.
|
|
//
|
|
void CInputChecker::OnUpdateAddress(HWND hDlg, int idEditCtrl, HWND hwndEditCtrl, LPTSTR psztServerName)
|
|
{
|
|
// the edit control for IP Address or Device Name had text changed in it.
|
|
TCHAR tcsAddr[MAX_ADDRESS_LENGTH] = NULLSTR;
|
|
TCHAR tcsLastValidAddr[MAX_ADDRESS_LENGTH] = NULLSTR;
|
|
GetWindowText(hwndEditCtrl, tcsAddr, MAX_ADDRESS_LENGTH);
|
|
|
|
BOOL bValid = IsValidAddressInput(tcsAddr,
|
|
tcsLastValidAddr,
|
|
SIZEOF_IN_CHAR(tcsLastValidAddr));
|
|
if(! bValid)
|
|
{
|
|
// the address that was entered is not valid so beep and set the text
|
|
// back to the last valid entry. This test for validity does not
|
|
// include testing for the right length just proper character set.
|
|
MessageBeep((UINT)-1);
|
|
DWORD dwSel = Edit_GetSel(hwndEditCtrl);
|
|
SetWindowText(hwndEditCtrl, tcsLastValidAddr);
|
|
Edit_SetSel(hwndEditCtrl, LOWORD(dwSel) - 1, HIWORD(dwSel) - 1);
|
|
}
|
|
else // The address is valid.
|
|
{
|
|
if(m_bLinked)
|
|
{
|
|
MakePortName(tcsAddr, COUNTOF (tcsAddr));
|
|
SetWindowText(GetDlgItem(hDlg, IDC_EDIT_PORT_NAME), tcsAddr);
|
|
}
|
|
}
|
|
|
|
} // OnUpdateAddress
|
|
|
|
|
|
//
|
|
// FUNCTION: OnUpdateQueueName(idEditCtrl, hwndEditCtrl)
|
|
//
|
|
// PURPOSE: to handle EN_UPDATE message when the edit control is the QueueName input.
|
|
//
|
|
void CInputChecker::OnUpdateQueueName(int idEditCtrl, HWND hwndEditCtrl)
|
|
{
|
|
// the edit control for QueueName had text changed in it.
|
|
TCHAR tcsQueueName[MAX_QUEUENAME_LEN] = NULLSTR;
|
|
TCHAR tcsLastValidQueueName[MAX_QUEUENAME_LEN] = NULLSTR;
|
|
GetWindowText(hwndEditCtrl, tcsQueueName, MAX_QUEUENAME_LEN);
|
|
|
|
if(! IsValidQueueNameInput(tcsQueueName,
|
|
tcsLastValidQueueName,
|
|
SIZEOF_IN_CHAR(tcsLastValidQueueName)))
|
|
{
|
|
// the device index that was entered is not valid so beep and set the
|
|
// text back to the last valid entry. This test for validity does not
|
|
// include testing for the right length just proper character set.
|
|
MessageBeep((UINT)-1);
|
|
DWORD dwSel = Edit_GetSel(hwndEditCtrl);
|
|
SetWindowText(hwndEditCtrl, tcsLastValidQueueName);
|
|
Edit_SetSel(hwndEditCtrl, LOWORD(dwSel) - 1, HIWORD(dwSel) - 1);
|
|
}
|
|
|
|
} // OnUpdateQueueName
|
|
|
|
|
|
//
|
|
// FUNCTION: IsValidPortNameInput(TCHAR ptcsAddressInput[MAX_ADDRESS_LENGTH], TCHAR *ptcsReturnLastValid)
|
|
//
|
|
// PURPOSE: IsValidPortNameInput is used for validation while the user is typing.
|
|
//
|
|
// Arguments: ptcsAddressInput is the user input.
|
|
// ptcsReturnLastValid is the last valid user input
|
|
// from the last time this function was called.
|
|
// CRtnValSize size in chars ( or wide chars) of the destination
|
|
// buffer.
|
|
//
|
|
// Return Value: Returns TRUE if the input is valid. FALSE otherwise, with ptcsReturnLastValid set.
|
|
//
|
|
// Comments: Any input is valid until I hear otherwise.
|
|
//
|
|
BOOL CInputChecker::IsValidPortNameInput(TCHAR *ptcsAddressInput,
|
|
TCHAR *ptcsReturnLastValid,
|
|
DWORD CRtnValSize)
|
|
{
|
|
DWORD dwLen = 0;
|
|
BOOL bValid = FALSE;
|
|
|
|
//
|
|
// Valid port name is non-blank and does not include ,
|
|
//
|
|
if ( ptcsAddressInput ) {
|
|
|
|
while ( ptcsAddressInput[dwLen] != TEXT('\0') &&
|
|
ptcsAddressInput[dwLen] != TEXT(',') )
|
|
++dwLen;
|
|
|
|
bValid = dwLen && ptcsAddressInput[dwLen] != TEXT(',');
|
|
}
|
|
|
|
if ( CRtnValSize ) {
|
|
|
|
if ( dwLen + 1 > CRtnValSize )
|
|
dwLen = CRtnValSize - 1;
|
|
|
|
lstrcpyn(ptcsReturnLastValid, ptcsAddressInput ? ptcsAddressInput : L"", dwLen+1);
|
|
}
|
|
|
|
return bValid;
|
|
} // IsValidPortNameInput
|
|
|
|
|
|
//
|
|
// FUNCTION: IsValidCommunityNameInput(TCHAR ptcsCommunityNameInput[MAX_SNMP_COMMUNITY_STR_LEN], TCHAR *ptcsReturnLastValid)
|
|
//
|
|
// PURPOSE: IsValidCommunityNameInput is used for validation while the user is typing.
|
|
//
|
|
// Arguments: ptcsCommunityNameInput is the user input.
|
|
// ptcsReturnLastValid is the last valid user input
|
|
// from the last time this function was called.
|
|
// CRtnValSize size in chars ( or wide chars) of the destination
|
|
// buffer.
|
|
//
|
|
// Return Value: Returns TRUE if the input is valid. FALSE otherwise, with ptcsReturnLastValid set.
|
|
//
|
|
// Comments: Any input is valid until I hear otherwise.
|
|
//
|
|
BOOL CInputChecker::IsValidCommunityNameInput(TCHAR *ptcsCommunityNameInput,
|
|
TCHAR *ptcsReturnLastValid,
|
|
DWORD CRtnValSize)
|
|
{
|
|
return TRUE;
|
|
|
|
} // IsValidCommunityNameInput
|
|
|
|
|
|
//
|
|
// FUNCTION: IsValidPortNumberInput(TCHAR ptcsAddressInput[MAX_ADDRESS_LENGTH], TCHAR *ptcsReturnLastValid)
|
|
//
|
|
// PURPOSE: IsValidPortNumberInput is used for validation while the user is typing.
|
|
//
|
|
// Arguments: ptcsAddressInput is the user input.
|
|
// ptcsReturnLastValid is the last valid user input
|
|
// from the last time this function was called.
|
|
// CRtnValSize size in chars ( or wide chars) of the destination
|
|
// buffer.
|
|
//
|
|
// Return Value: Returns TRUE if the input is valid. FALSE otherwise, with ptcsReturnLastValid set.
|
|
//
|
|
// Comments: The input is valid if it contains only digit characters.
|
|
//
|
|
BOOL CInputChecker::IsValidPortNumberInput(TCHAR *ptcsPortNumInput,
|
|
TCHAR *ptcsReturnLastValid,
|
|
DWORD CRtnValSize)
|
|
{
|
|
BOOL bIsValid = TRUE;
|
|
TCHAR *charPtr = NULL;
|
|
TCHAR ptcsString[MAX_PORTNUM_STRING_LENGTH] = NULLSTR;
|
|
|
|
lstrcpyn(ptcsString, ptcsPortNumInput, MAX_PORTNUM_STRING_LENGTH );
|
|
bIsValid = (_tcslen(ptcsString) <= MAX_PORTNUM_STRING_LENGTH);
|
|
|
|
for (charPtr = ptcsString; bIsValid && *charPtr; charPtr++)
|
|
{
|
|
switch (*charPtr)
|
|
{
|
|
case (TCHAR)'0':
|
|
case (TCHAR)'1':
|
|
case (TCHAR)'2':
|
|
case (TCHAR)'3':
|
|
case (TCHAR)'4':
|
|
case (TCHAR)'5':
|
|
case (TCHAR)'6':
|
|
case (TCHAR)'7':
|
|
case (TCHAR)'8':
|
|
case (TCHAR)'9':
|
|
bIsValid = TRUE;
|
|
break;
|
|
|
|
default:
|
|
bIsValid = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!bIsValid)
|
|
{
|
|
if(ptcsReturnLastValid != NULL)
|
|
{
|
|
lstrcpyn(ptcsReturnLastValid,
|
|
m_InputStorageStringPortNumber,
|
|
CRtnValSize);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
lstrcpyn(m_InputStorageStringPortNumber,
|
|
ptcsString,
|
|
MAX_ADDRESS_LENGTH);
|
|
}
|
|
return(bIsValid);
|
|
|
|
} // IsValidPortNumberInput
|
|
|
|
|
|
//
|
|
// FUNCTION: IsValidDeviceIndexInput(TCHAR ptcsAddressInput[MAX_ADDRESS_LENGTH], TCHAR *ptcsReturnLastValid)
|
|
//
|
|
// PURPOSE: IsValidDeviceIndexInput is used for validation while the user is typing.
|
|
//
|
|
// Arguments: ptcsAddressInput is the user input.
|
|
// ptcsReturnLastValid is the last valid user input
|
|
// from the last time this function was called.
|
|
// CRtnValSize size in chars ( or wide chars) of the destination
|
|
// buffer.
|
|
//
|
|
// Return Value: Returns TRUE if the input is valid. FALSE otherwise, with ptcsReturnLastValid set.
|
|
//
|
|
// Comments: The input is valid if it contains only digit characters.
|
|
//
|
|
BOOL CInputChecker::IsValidDeviceIndexInput(TCHAR *ptcsDeviceIndexInput,
|
|
TCHAR *ptcsReturnLastValid,
|
|
DWORD CRtnValSize)
|
|
{
|
|
BOOL bIsValid = TRUE;
|
|
TCHAR *charPtr = NULL;
|
|
TCHAR ptcsString[MAX_SNMP_DEVICENUM_STRING_LENGTH] = NULLSTR;
|
|
|
|
lstrcpyn(ptcsString,
|
|
ptcsDeviceIndexInput,
|
|
MAX_SNMP_DEVICENUM_STRING_LENGTH);
|
|
bIsValid = (_tcslen(ptcsString) <= MAX_SNMP_DEVICENUM_STRING_LENGTH);
|
|
|
|
for (charPtr = ptcsString; bIsValid && *charPtr; charPtr++)
|
|
{
|
|
switch (*charPtr)
|
|
{
|
|
case (TCHAR)'0':
|
|
case (TCHAR)'1':
|
|
case (TCHAR)'2':
|
|
case (TCHAR)'3':
|
|
case (TCHAR)'4':
|
|
case (TCHAR)'5':
|
|
case (TCHAR)'6':
|
|
case (TCHAR)'7':
|
|
case (TCHAR)'8':
|
|
case (TCHAR)'9':
|
|
bIsValid = TRUE;
|
|
break;
|
|
|
|
default:
|
|
bIsValid = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!bIsValid)
|
|
{
|
|
if(ptcsReturnLastValid != NULL)
|
|
{
|
|
lstrcpyn(ptcsReturnLastValid,
|
|
m_InputStorageStringDeviceIndex,
|
|
CRtnValSize);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
lstrcpyn(m_InputStorageStringDeviceIndex,
|
|
ptcsString,
|
|
MAX_SNMP_DEVICENUM_STRING_LENGTH);
|
|
}
|
|
return(bIsValid);
|
|
|
|
} // IsValidDeviceIndexInput
|
|
|
|
|
|
//
|
|
// FUNCTION: IsValidAddressInput(TCHAR ptcsAddressInput[MAX_ADDRESS_LENGTH], TCHAR *ptcsReturnLastValid)
|
|
//
|
|
// PURPOSE: IsValidAddressInput is used for validation while the user is typing.
|
|
//
|
|
// Arguments: ptcsAddressInput is the user input.
|
|
// ptcsReturnLastValid is the last valid user input
|
|
// from the last time this function was called.
|
|
// CRtnValSize size in chars ( or wide chars) of the destination
|
|
// buffer.
|
|
//
|
|
// Return Value: Returns TRUE if the input is valid. FALSE otherwise.
|
|
//
|
|
// Comments: The input is valid if it contains characters that are either valid for
|
|
// an IP Address or a Host Name or both.
|
|
//
|
|
BOOL CInputChecker::IsValidAddressInput(TCHAR *ptcsAddressInput,
|
|
TCHAR *ptcsReturnLastValid,
|
|
DWORD CRtnValSize)
|
|
{
|
|
TCHAR *charPtr = NULL;
|
|
TCHAR ptcsString[MAX_ADDRESS_LENGTH] = NULLSTR;
|
|
BOOL bIsValid = FALSE;
|
|
|
|
lstrcpyn(ptcsString, ptcsAddressInput, MAX_ADDRESS_LENGTH);
|
|
|
|
bIsValid = (_tcslen(ptcsString) <= MAX_ADDRESS_LENGTH);
|
|
for (charPtr = ptcsString; bIsValid && *charPtr; charPtr++)
|
|
{
|
|
switch (*charPtr)
|
|
{
|
|
case (TCHAR)' ':
|
|
case (TCHAR)'"':
|
|
case (TCHAR)'&':
|
|
case (TCHAR)'*':
|
|
case (TCHAR)'(':
|
|
case (TCHAR)')':
|
|
case (TCHAR)'+':
|
|
case (TCHAR)',':
|
|
case (TCHAR)'/':
|
|
case (TCHAR)':':
|
|
case (TCHAR)';':
|
|
case (TCHAR)'<':
|
|
case (TCHAR)'=':
|
|
case (TCHAR)'>':
|
|
case (TCHAR)'?':
|
|
case (TCHAR)'[':
|
|
case (TCHAR)'\\':
|
|
case (TCHAR)']':
|
|
case (TCHAR)'|':
|
|
case (TCHAR)'~':
|
|
case (TCHAR)'@':
|
|
case (TCHAR)'#':
|
|
case (TCHAR)'$':
|
|
case (TCHAR)'%':
|
|
case (TCHAR)'^':
|
|
case (TCHAR)'!':
|
|
// other invalid character cases here
|
|
bIsValid = FALSE;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
if (!bIsValid)
|
|
{
|
|
if(ptcsReturnLastValid != NULL)
|
|
{
|
|
lstrcpyn(ptcsReturnLastValid,
|
|
m_InputStorageStringAddress,
|
|
CRtnValSize);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
lstrcpyn(m_InputStorageStringAddress,
|
|
ptcsString,
|
|
MAX_ADDRESS_LENGTH);
|
|
}
|
|
return(bIsValid);
|
|
|
|
} // IsValidAddressInput
|
|
|
|
|
|
|
|
//
|
|
// FUNCTION: IsValidQueueNameInput(TCHAR ptcsAddressInput[MAX_QUEUENAME_LEN], TCHAR *ptcsReturnLastValid)
|
|
//
|
|
// PURPOSE: IsValidQueueNameInput is used for validation while the user is typing.
|
|
//
|
|
// Arguments: ptcsQueueNameInput is the user input.
|
|
// ptcsReturnLastValid is the last valid user input
|
|
// from the last time this function was called.
|
|
// CRtnValSize size in chars ( or wide chars) of the destination
|
|
// buffer.
|
|
//
|
|
// Return Value: Returns TRUE if the input is valid. FALSE otherwise.
|
|
//
|
|
// Comments: The name is limited to 14 characters and must consist entirely of the
|
|
// characters A-Z, a-z, 0-9, and _ (underscore).
|
|
//
|
|
BOOL CInputChecker::IsValidQueueNameInput(TCHAR *ptcsQueueNameInput,
|
|
TCHAR *ptcsReturnLastValid,
|
|
DWORD CRtnValSize)
|
|
{
|
|
BOOL bIsValid = TRUE;
|
|
TCHAR *charPtr = NULL;
|
|
TCHAR ptcsString[MAX_QUEUENAME_LEN] = NULLSTR;
|
|
|
|
lstrcpyn(ptcsString, ptcsQueueNameInput, MAX_QUEUENAME_LEN );
|
|
bIsValid = (_tcslen(ptcsString) <= MAX_QUEUENAME_LEN);
|
|
|
|
for (charPtr = ptcsString; bIsValid && *charPtr; charPtr++)
|
|
{
|
|
switch (*charPtr)
|
|
{
|
|
|
|
case (TCHAR)' ':
|
|
case (TCHAR)'"':
|
|
case (TCHAR)'&':
|
|
case (TCHAR)'*':
|
|
case (TCHAR)'(':
|
|
case (TCHAR)')':
|
|
case (TCHAR)'+':
|
|
case (TCHAR)',':
|
|
case (TCHAR)'/':
|
|
case (TCHAR)':':
|
|
case (TCHAR)';':
|
|
case (TCHAR)'<':
|
|
case (TCHAR)'=':
|
|
case (TCHAR)'>':
|
|
case (TCHAR)'?':
|
|
case (TCHAR)'[':
|
|
case (TCHAR)'\\':
|
|
case (TCHAR)']':
|
|
case (TCHAR)'|':
|
|
case (TCHAR)'~':
|
|
case (TCHAR)'@':
|
|
case (TCHAR)'#':
|
|
case (TCHAR)'$':
|
|
case (TCHAR)'%':
|
|
case (TCHAR)'^':
|
|
case (TCHAR)'!':
|
|
bIsValid = FALSE;
|
|
break;
|
|
|
|
default:
|
|
bIsValid = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!bIsValid)
|
|
{
|
|
if(ptcsReturnLastValid != NULL)
|
|
{
|
|
lstrcpyn(ptcsReturnLastValid,
|
|
m_InputStorageStringQueueName,
|
|
CRtnValSize);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
lstrcpyn(m_InputStorageStringQueueName,
|
|
ptcsString,
|
|
MAX_QUEUENAME_LEN);
|
|
}
|
|
return(bIsValid);
|
|
|
|
} // IsValidQueueNameInput
|
|
|
|
|
|
//
|
|
// FUNCTION: MakePortName(TCHAR *strAddr)
|
|
//
|
|
// PURPOSE: To return a string that will be a unique port
|
|
// name when the port is added.
|
|
//
|
|
void CInputChecker::MakePortName(TCHAR *strAddr, size_t cchAddr)
|
|
{
|
|
_ASSERTE(m_bLinked == TRUE);
|
|
|
|
if(GetAddressType(strAddr) == IPAddress)
|
|
{
|
|
// The address is an IP address
|
|
TCHAR NameString[10] = NULLSTR;
|
|
|
|
if (LoadString(g_hInstance, IDS_STRING_NAME_IP, NameString, COUNTOF (NameString)))
|
|
{
|
|
TCHAR szTemp[MAX_ADDRESS_LENGTH+1] = NULLSTR;
|
|
HRESULT hr =
|
|
StringCchPrintf (szTemp, COUNTOF (szTemp),
|
|
TEXT( "%s%.*s" ),
|
|
NameString,
|
|
MAX_ADDRESS_LENGTH - _tcslen(NameString),
|
|
strAddr);
|
|
|
|
if (SUCCEEDED (hr))
|
|
{
|
|
StringCchCopy (
|
|
strAddr,
|
|
cchAddr,
|
|
szTemp
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
} // MakePortName
|
|
|
|
|
|
//
|
|
// FUNCTION: PortNumberIsLegal(TCHAR *ptcsPortNumber)
|
|
//
|
|
// PURPOSE: To determine if the PortNum passed in in the parameter ptcsAddress
|
|
// is legal.
|
|
//
|
|
BOOL CInputChecker::PortNumberIsLegal(TCHAR *ptcsPortNumber)
|
|
{
|
|
if(IsValidPortNumberInput(ptcsPortNumber, NULL, 0) &&
|
|
_tcslen(ptcsPortNumber) >= 1 &&
|
|
_tcslen(ptcsPortNumber) <= MAX_PORTNUM_STRING_LENGTH)
|
|
{
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
|
|
} // PortNumberIsLegal
|
|
|
|
|
|
//
|
|
// FUNCTION: CommunityNameIsLegal(TCHAR *ptcsCommunityName)
|
|
//
|
|
// PURPOSE: To determine if the Community Name passed in in the parameter ptcsAddress
|
|
// is legal.
|
|
//
|
|
BOOL CInputChecker::CommunityNameIsLegal(TCHAR *ptcsCommunityName)
|
|
{
|
|
if(IsValidCommunityNameInput(ptcsCommunityName) &&
|
|
_tcslen(ptcsCommunityName) >= 1 &&
|
|
_tcslen(ptcsCommunityName) <= MAX_SNMP_COMMUNITY_STR_LEN)
|
|
{
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
|
|
} // CommunityNameIsLegal
|
|
|
|
|
|
//
|
|
// FUNCTION: QueueNameIsLegal(TCHAR *ptcsQueueName)
|
|
//
|
|
// PURPOSE: To determine if the PortNum passed in in the parameter ptcsAddress
|
|
// is legal.
|
|
//
|
|
BOOL CInputChecker::QueueNameIsLegal(TCHAR *ptcsQueueName)
|
|
{
|
|
if(IsValidQueueNameInput(ptcsQueueName) &&
|
|
_tcslen(ptcsQueueName) >= 1 &&
|
|
_tcslen(ptcsQueueName) <= MAX_QUEUENAME_LEN)
|
|
{
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
|
|
} // QueueNameIsLegal
|
|
|
|
//
|
|
// FUNCTION: GetAddressType(TCHAR *ptcsAddress)
|
|
//
|
|
// PURPOSE: To determine if the address passed in in the parameter ptcsAddress
|
|
// is an ip address or a host name.
|
|
//
|
|
AddressType CInputChecker::GetAddressType(TCHAR *ptcsAddress)
|
|
{
|
|
// determine if we are dealing with a name or an ip address
|
|
// if it's an IP Address it will start with a number, otherwise
|
|
// it will start with a letter or other character.
|
|
|
|
if( ptcsAddress[0] == '0' ||
|
|
ptcsAddress[0] == '1' ||
|
|
ptcsAddress[0] == '2' ||
|
|
ptcsAddress[0] == '3' ||
|
|
ptcsAddress[0] == '4' ||
|
|
ptcsAddress[0] == '5' ||
|
|
ptcsAddress[0] == '6' ||
|
|
ptcsAddress[0] == '7' ||
|
|
ptcsAddress[0] == '8' ||
|
|
ptcsAddress[0] == '9')
|
|
{
|
|
CIPAddress IPAddr;
|
|
if (IPAddr.IsValid(ptcsAddress))
|
|
return(IPAddress);
|
|
else
|
|
return (HostName);
|
|
}
|
|
else
|
|
{
|
|
return(HostName);
|
|
}
|
|
|
|
} // GetAddressType
|
|
|
|
//
|
|
// FUNCTION: AddressIsLegal(TCHAR *ptcsAddress)
|
|
//
|
|
// PURPOSE: To determine if the address passed in in the parameter ptcsAddress
|
|
// is legal -- That is not too short and either a legal ip address or
|
|
// a legal host name.
|
|
//
|
|
BOOL CInputChecker::AddressIsLegal(TCHAR *ptcsAddress)
|
|
{
|
|
BOOL bLegalAddress = TRUE;
|
|
|
|
// determine if the input is at least 2 characters long.
|
|
if((_tcslen(ptcsAddress) > 1))
|
|
{
|
|
if( GetAddressType(ptcsAddress) == IPAddress )
|
|
{
|
|
CIPAddress IPAddr;
|
|
bLegalAddress = IPAddr.IsValid(ptcsAddress);
|
|
}
|
|
else
|
|
{
|
|
CHostName HostName(ptcsAddress);
|
|
bLegalAddress = HostName.IsValid();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bLegalAddress = FALSE;
|
|
}
|
|
|
|
return bLegalAddress;
|
|
|
|
} // AddressIsLegal
|
|
|
|
|
|
//
|
|
// FUNCTION: PortNameIsLegal(TCHAR *ptcsPortName)
|
|
//
|
|
// PURPOSE: To determine if the PortName passed in in the parameter ptcsPortName
|
|
// is legal
|
|
//
|
|
// Return Value: True if the port name is legal. False if it is not.
|
|
//
|
|
// Parameters: ptcsPortName - the name of the port to check for legality.
|
|
//
|
|
BOOL CInputChecker::PortNameIsLegal(TCHAR *ptcsPortName)
|
|
{
|
|
DWORD dwLen;
|
|
|
|
dwLen = ptcsPortName && *ptcsPortName ? _tcslen(ptcsPortName) : 0;
|
|
|
|
//
|
|
// Remove trailing spaces
|
|
//
|
|
while ( dwLen && ptcsPortName[dwLen-1] == ' ' )
|
|
--dwLen;
|
|
|
|
if ( dwLen == 0 )
|
|
return FALSE;
|
|
|
|
ptcsPortName[dwLen] = TEXT('\0');
|
|
|
|
for ( ; *ptcsPortName ; ++ptcsPortName )
|
|
if ( *ptcsPortName == TEXT(',') ||
|
|
*ptcsPortName == TEXT('\\') ||
|
|
*ptcsPortName == TEXT('/') )
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
} // PortNameIsLegal
|
|
|
|
|
|
//
|
|
// FUNCTION: SNMPDevIndexIsLegal(TCHAR *ptcsPortName)
|
|
//
|
|
// PURPOSE: To determine if the SNMPDevIndex passed in in the parameter psztSNMPDevIndex
|
|
// is legal
|
|
//
|
|
// Return Value: True if the index is legal. False if it is not.
|
|
//
|
|
// Parameters: psztSNMPDevIndex - the device index to check for legality.
|
|
//
|
|
BOOL CInputChecker::SNMPDevIndexIsLegal(TCHAR *psztSNMPDevIndex)
|
|
{
|
|
if((! IsValidDeviceIndexInput(psztSNMPDevIndex)) ||
|
|
(_tcslen(psztSNMPDevIndex) < 1))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
|
|
} // SNMPDevIndexIsLegal
|
|
|
|
|
|
//
|
|
// FUNCTION: PortNameIsUnique(TCHAR *ptcsPortName)
|
|
//
|
|
// PURPOSE: To determine if the PortName passed in in the parameter ptcsPortName
|
|
// is Unique.
|
|
//
|
|
// Return Value: True if the port does not exist. False if it does.
|
|
//
|
|
// Parameters: psztPortName - the name of the port to check for prior existance.
|
|
//
|
|
// Note: The spooler must be running on the system in order for this function
|
|
// to work properly.
|
|
//
|
|
BOOL CInputChecker::PortNameIsUnique(TCHAR *ptcsPortName, LPTSTR psztServerName)
|
|
{
|
|
return(! PortExists(ptcsPortName, psztServerName));
|
|
|
|
} // PortNameIsUnique
|
|
|
|
|
|
//
|
|
// FUNCTION: PortExists()
|
|
//
|
|
// PURPOSE: Enumerate ports and search for the given port name
|
|
//
|
|
// Return Value: True if the port exists. False if it does not.
|
|
//
|
|
// Parameters: psztPortName - the name of the port to check for existance.
|
|
// psztServerName - The Name of the server to check on.
|
|
//
|
|
// Note: The spooler must be running on the system in order for this function
|
|
// to work properly.
|
|
//
|
|
BOOL CInputChecker::PortExists(LPTSTR psztPortName, LPTSTR psztServerName)
|
|
{
|
|
BOOL Exists = FALSE;
|
|
|
|
PORT_INFO_1 *pi1 = NULL;
|
|
DWORD pcbNeeded = 0;
|
|
DWORD pcReturned = 0;
|
|
BOOL res = EnumPorts((psztServerName[0] == '\0') ? NULL : psztServerName,
|
|
1, // specifies type of port info structure
|
|
(LPBYTE)pi1, // pointer to buffer to receive array of port info. structures
|
|
0, // specifies size, in bytes, of buffer
|
|
&pcbNeeded, // pointer to number of bytes stored into buffer (or required buffer size)
|
|
&pcReturned // pointer to number of PORT_INFO_*. structures stored into buffer
|
|
);
|
|
|
|
DWORD err = GetLastError();
|
|
if(res == 0 && ERROR_INSUFFICIENT_BUFFER == err)
|
|
{
|
|
pi1 = (PORT_INFO_1 *) malloc(pcbNeeded);
|
|
if(pi1 == NULL)
|
|
{
|
|
pcbNeeded = 0;
|
|
}
|
|
|
|
res = EnumPorts((psztServerName[0] == '\0') ? NULL : psztServerName,
|
|
1,
|
|
(LPBYTE)pi1,
|
|
pcbNeeded,
|
|
&pcbNeeded,
|
|
&pcReturned);
|
|
|
|
for(DWORD i=0;i<pcReturned; i++)
|
|
{
|
|
if(0 == _tcsicmp(pi1[i].pName, psztPortName))
|
|
{
|
|
Exists = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if(pi1 != NULL)
|
|
{
|
|
free(pi1);
|
|
pi1 = NULL;
|
|
}
|
|
|
|
return(Exists);
|
|
|
|
} // PortExists
|