archive
/
windows-xp
mirror of https://github.com/tongzx/nt5src
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Source code of Windows XP (NT5)
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.
6 Commits
1 Branch
0 Tags
3.8 GiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
windows-xp/Source/XPSP1/NT/termsrv/admtools/utildll/utildll.c

4138 lines
126 KiB
Raw Permalink Blame History

// Copyright (c) 1998-1999 Microsoft Corporation
/*******************************************************************************
*
* utildll.c
*
* UTILDLL multi-user utility support functions
*
*
*******************************************************************************/
/*
* include files
*/
#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
#include <ntddkbd.h>
#include <ntddmou.h>
#include <ntcsrsrv.h>
#include <ntlsa.h>
#include <ntsam.h>
#include <windows.h>
#include <stdlib.h>
#include <stdio.h>
#include <nb30.h>
#include <tapi.h>
#include <raserror.h>
#include <lmerr.h>
#include <lmcons.h>
#include <lmaccess.h>
#include <lmserver.h>
#include <lmwksta.h>
#include <lmremutl.h>
#include <lmapibuf.h>
#define INITGUID
#include "objbase.h"
#include "initguid.h"
//#include "basetyps.h"
#include "devguid.h"
#include "setupapi.h"
#include <winsta.h>
#include <utildll.h>
#include "..\inc\utilsub.h"
#include "..\inc\ansiuni.h"
#include "resource.h"
/*
* Hydrix helpers function internal defines
*/
#define INITIAL_ENUMERATION_COUNT 16
#define REGISTRY_NETCARDS TEXT("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\NetworkCards")
#define REGISTRY_TITLE TEXT("Title")
#define REGISTRY_SERVICE_NAME TEXT("ServiceName")
#define REGISTRY_HIDDEN TEXT("Hidden")
#define REGISTRY_ROUTE TEXT("Route")
#define REGISTRY_NETBLINKAGE TEXT("SYSTEM\\CurrentControlSet\\Services\\NetBIOS\\Linkage")
#define REGISTRY_NETBLINKAGE_LANAMAP TEXT("LanaMap")
#define REGISTRY_SERVICES TEXT("SYSTEM\\CurrentControlSet\\Services")
#define REGISTRY_DISPLAY_NAME TEXT("DisplayName")
/*
* TAPI defines.
*/
#define LOW_MAJOR_VERSION 0x0001
#define LOW_MINOR_VERSION 0x0003
#define HIGH_MAJOR_VERSION 0x0002
#define HIGH_MINOR_VERSION 0x0000
#define LOW_VERSION ((LOW_MAJOR_VERSION << 16) | LOW_MINOR_VERSION)
#define HIGH_VERSION ((HIGH_MAJOR_VERSION << 16) | HIGH_MINOR_VERSION)
/*=============================================================================
== Local Functions Defined
=============================================================================*/
BOOL CheckForComDevice( LPTSTR );
int NetBiosLanaEnum( LANA_ENUM * pLanaEnum );
DWORD EnumerateTapiPorts( PPDPARAMS pPdParams, ULONG Count, ULONG **ppEntries );
VOID CALLBACK DummyTapiCallback(HANDLE, DWORD, DWORD, DWORD, DWORD, DWORD);
BOOL GetAssociatedPortName(char *szKeyName, WCHAR *wszPortName);
BOOL _UserInGroup( LPWSTR pwszUsername, LPWSTR pwszDomain, LPWSTR pwszGroup );
/*******************************************************************************
*
* StandardErrorMessage - Hydrix helper function
*
* Output an error message with optional additional arguments like the
* ErrorMessagexxx routines. Additionally, a standard error line will
* also be output containing the error code and error message associated
* with that code.
*
* ENTRY:
* pszAppName (input)
* Application name for error message box title.
* hwndApp (input)
* Owner window for error message box.
* hinstApp (input)
* Instance handle of application.
* LogonId (input)
* Optional WinStation LogonId for querying special error strings
* from WinStation via WinStationGetInformation API. If this value
* is LOGONID_NONE then no special error message code checking will
* be done.
* nId (input)
* System message code to get standard error string for.
* nErrorResourceID (input)
* Resource ID of the format string to use in the error message.
* ... (input)
* Optional additional arguments to be used with format string.
*
* EXIT:
*
******************************************************************************/
void WINAPI
StandardErrorMessage( LPCTSTR pszAppName,
HWND hwndApp,
HINSTANCE hinstApp,
ULONG LogonId,
UINT nId,
int nErrorMessageLength,
int nArgumentListLength,
int nErrorResourceID, ...)
{
TCHAR* szClientErrorMessage = NULL;
TCHAR* szClientResourceString = NULL;
TCHAR* szError = NULL;
TCHAR* szFormattedErrorMessage = NULL;
TCHAR* szMessage = NULL;
TCHAR szStandardErrorMessage[STANDARD_ERROR_TEXT_LENGTH + 1];
va_list args;
va_start( args, nErrorResourceID );
szClientErrorMessage = (TCHAR*)malloc((nErrorMessageLength + 1) * sizeof(TCHAR));
if (szClientErrorMessage)
{
LoadString( hinstApp, nErrorResourceID, szClientErrorMessage, nErrorMessageLength );
szClientResourceString = (TCHAR*)malloc((wcslen(szClientErrorMessage) + nArgumentListLength + 1) * sizeof(TCHAR));
if (szClientResourceString != NULL)
{
wvsprintf( szClientResourceString, szClientErrorMessage, args );
LoadString( GetModuleHandle( UTILDLL_NAME ),
IDS_STANDARD_ERROR_FORMAT, szStandardErrorMessage, STANDARD_ERROR_TEXT_LENGTH );
szError = GetSystemMessage( LogonId, nId);
if (szError != NULL)
{
szFormattedErrorMessage = (TCHAR*)malloc((wcslen(szStandardErrorMessage) + 10 + wcslen(szError) + 1) * sizeof(TCHAR));
if (szFormattedErrorMessage != NULL)
{
wsprintf( szFormattedErrorMessage, szStandardErrorMessage, nId, szError);
//lstrcpy(sz1, pszAppName);
szMessage = (TCHAR*)malloc((wcslen(szClientResourceString) + wcslen(szFormattedErrorMessage) + 1) * sizeof(TCHAR));
if (szMessage != NULL)
{
wcscpy(szMessage, szClientResourceString);
wcscat(szMessage, szFormattedErrorMessage);
MessageBox( hwndApp, szMessage, pszAppName, MB_OK | MB_ICONEXCLAMATION );
free(szMessage);
}
free(szFormattedErrorMessage);
}
free (szError);
}
free(szClientResourceString);
}
free (szClientErrorMessage);
}
va_end(args);
} // end StandardErrorMessage
/*******************************************************************************
*
* GetSystemMessageA - Hydrix helper function (ANSI stub)
*
* Return the string associated with the specified system message.
*
* ENTRY:
* (refer to GetSystemMessageW)
* EXIT:
* (refer to GetSystemMessageW)
* If cannot allocate temporary UNICODE buffer to call GetSystemMessageW
* with, the ntents of chBuffer will be set to the "(no error text
* available)" string.
*
******************************************************************************/
LPSTR WINAPI
GetSystemMessageA( ULONG LogonId,
UINT nId
/*LPSTR chBuffer,
int cbBuffSize*/ )
{
LPWSTR uBuffer = NULL;
LPSTR aBuffer = NULL;
int length;
//Call the GetSystemMessageW function
uBuffer = GetSystemMessageW(LogonId, nId);
if (uBuffer == NULL)
{
//If no message was returned from the GetSystemMessageW
//function just return a generic error message
aBuffer = malloc((NO_ERROR_TEXT_LENGTH + 1) * sizeof(char));
if (aBuffer == NULL)
return NULL;
length = LoadStringA( GetModuleHandle( UTILDLL_NAME ),
IDS_NO_ERROR_TEXT_AVAILABLE,
aBuffer, NO_ERROR_TEXT_LENGTH );
ASSERT(length);
}
else
{
length = wcslen(uBuffer) + 1;
//Convert the result into ANSI in caller supplied buffer.
aBuffer = malloc(length * sizeof(char));
if (aBuffer != NULL)
WideCharToMultiByte(CP_ACP, 0, uBuffer, length - 1, aBuffer, length, 0, 0);
//Free the temporary buffer.
free (uBuffer);
}
//Return message.
return(aBuffer);
} // end GetSystemMessageA
/*******************************************************************************
*
* GetSystemMessageW - Hydrix helper function (UNICODE version)
*
* Return the string associated with the specified system message.
*
* ENTRY:
* LogonId (input)
* Optional WinStation LogonId for querying special error strings
* from WinStation via WinStationGetInformation API. If this value
* is LOGONID_NONE then no special error message code checking will
* be done.
* nId (input)
* System message code to get string for.
* chBuffer (input)
* Points to buffer to fill with system message string.
* cbBuffSize (input)
* Maximum number of characters that can be placed in chBuffer.
*
* EXIT:
* Returns chBuffer. Contents of chBuffer will always be set; to
* the "(no error text available)" string if error.
*
* Note: the total length of chBuffer (including terminating NULL) will
* not exceed the size of the internal temporary buffer (Buffer).
*
******************************************************************************/
//NA 3/9/01 IMPORTANT: Behavior has changed. Instead of expecting a buffer long
//enough to accomodate the message, it now allocates the memory dynamically, so
//it's up to the calling procedure to deallocate it.
LPWSTR WINAPI
GetSystemMessageW( ULONG LogonId,
UINT nId
/*LPWSTR chBuffer,
int cbBuffSize*/ )
{
LPWSTR chBuffer = NULL;
WCHAR StackBuffer[512];
WCHAR* SpecialBuffer = NULL;
WCHAR* Buffer = NULL;
BOOL bSpecialCitrixError = FALSE;
HINSTANCE cxerror = LoadLibraryW(L"cxerror.dll");
int length = 0;
StackBuffer[0]=0;
//If we have a valid LogonId passed in, determine if the error
//is a special code requiring that the specific error string be
//queried from the WinStation.
if ( LogonId != LOGONID_NONE )
{
switch ( nId )
{
case ERROR_CTX_TD_ERROR:
length = LoadStringW( GetModuleHandle( UTILDLL_NAME ),
IDS_NO_ADDITIONAL_ERROR_INFO,
StackBuffer,
sizeof(StackBuffer)/sizeof(WCHAR) );
ASSERT(length);
SpecialBuffer = malloc((length + 1) * sizeof(WCHAR));
if (SpecialBuffer != NULL)
{
wcscpy(SpecialBuffer, StackBuffer);
bSpecialCitrixError = TRUE;
}
break;
default:
break;
}
}
//See if this is a Citrix error message first...
if ( !cxerror ||
!FormatMessageW( FORMAT_MESSAGE_IGNORE_INSERTS |
FORMAT_MESSAGE_MAX_WIDTH_MASK |
FORMAT_MESSAGE_FROM_HMODULE |
FORMAT_MESSAGE_ALLOCATE_BUFFER,
(LPCVOID)cxerror,
nId,
0,
(LPWSTR)&Buffer,
0,
NULL ) )
{
//It's not a Citrix error message; fetch system message.
if ( !FormatMessageW( FORMAT_MESSAGE_IGNORE_INSERTS |
FORMAT_MESSAGE_MAX_WIDTH_MASK |
FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_ALLOCATE_BUFFER,
NULL,
nId,
0,
(LPWSTR)&Buffer,
0,
NULL ) )
{
//It's not a system message; don't know what the message is...
length = LoadStringW( GetModuleHandle( UTILDLL_NAME ),
IDS_NO_ERROR_TEXT_AVAILABLE,
StackBuffer,
sizeof(StackBuffer)/sizeof(WCHAR) );
ASSERT(length);
Buffer = LocalAlloc(0,(length + 1) * sizeof(WCHAR));
if (Buffer == NULL)
{
if (SpecialBuffer != NULL)
free (SpecialBuffer);
return NULL;
}
wcscpy(Buffer, StackBuffer);
}
}
if ( cxerror )
FreeLibrary(cxerror);
length = wcslen(Buffer);
if ( bSpecialCitrixError )
length += wcslen(SpecialBuffer) + 2;
chBuffer = malloc((length + 1) * sizeof(WCHAR));
if (chBuffer != NULL)
{
wcscpy(chBuffer, Buffer);
//If we fetched a special Citrix error string, tack it onto the end
//of whatever we've buffered already.
if ( bSpecialCitrixError )
{
lstrcatW(chBuffer, L" ");
lstrcatW(chBuffer, SpecialBuffer);
}
}
if (Buffer != NULL)
LocalFree (Buffer);
if (( bSpecialCitrixError ) && (SpecialBuffer != NULL))
free (SpecialBuffer);
return(chBuffer);
} // end GetSystemMessageW
/*******************************************************************************
*
* WinEnumerateDevices - Hydrix helper function
*
* Perform PD device enumeration for the specified PD.
*
* ENTRY:
* hWnd (input)
* Parent window for error message, if needed.
* pPdConfig (input)
* Points to PDCONFIG3 structure of the PD.
* pEntries (output)
* Points to variable to return number of devices that were enumerated.
* bInSetup (input)
* TRUE if we're operating in Setup; FALSE otherwise.
*
* EXIT:
* (PPDPARAMS) Points to the PDPARAMS array containing the enumeration
* results if sucessful. The caller must perform a LocalFree
* of this array when done. NULL if error; error set for
* GetLastError();
* If the returned error code is anything other than
* ERROR_NOT_ENOUGH_MEMORY, the caller can assume that none of the
* requested devices were available to be enumerated.
*
******************************************************************************/
typedef BOOL (WINAPI * PPDENUMERATE)( PPDCONFIG3, PULONG, PPDPARAMS, PULONG, BOOL );
PPDPARAMS WINAPI
WinEnumerateDevices( HWND hWnd,
PPDCONFIG3 pPdConfig,
PULONG pEntries,
BOOL bInSetup )
{
PPDENUMERATE pPdEnumerate;
ULONG ByteCount;
DWORD Error;
int i;
PPDPARAMS pPdParams = NULL;
/*
* Enumerate according to class.
*/
switch ( pPdConfig->Data.SdClass ) {
case SdAsync:
pPdEnumerate = AsyncDeviceEnumerate;
break;
case SdNetwork:
if ( pPdConfig->Data.PdFlag & PD_LANA ) {
/*
* This is a LANA based network PD (ie, NetBIOS). Perform
* NetBIOS enumerate.
*/
pPdEnumerate = NetBIOSDeviceEnumerate;
}
else {
/*
* This is a physical lan adapter based network (TCP/IP,
* IPX, SPX, etc). Enumerate based on the associated network
* protocol service name.
*/
pPdEnumerate = NetworkDeviceEnumerate;
}
break;
default:
return(NULL);
}
/*
* Call enumerate in loop till we hit enough buffer entries to handle
* a complete enumeration. NOTE: some enumeration routines will return
* the necessary ByteCount on 'insufficient buffer' status; others won't.
*/
for ( ByteCount = 0, i = INITIAL_ENUMERATION_COUNT; ; i *= 2 ) {
if ( pPdParams != NULL )
LocalFree(pPdParams);
pPdParams = (PPDPARAMS)LocalAlloc(
LPTR,
ByteCount ?
ByteCount :
(ByteCount = sizeof(PDPARAMS) * i) );
if ( pPdParams == NULL ) {
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
goto OutOfMemory;
}
/*
* Perform enumeration and break loop if successful.
*/
if ( (*pPdEnumerate)( pPdConfig,
pEntries,
pPdParams,
&ByteCount,
bInSetup ) )
break;
/*
* If we received any other error other than 'insufficient buffer',
* quit (quietly).
*/
if ( (Error = GetLastError()) != ERROR_INSUFFICIENT_BUFFER )
goto BadEnumerate;
}
/*
* Success: return the PDPARAMS pointer.
*/
return(pPdParams);
/*==============================================================================
* Error returns
*============================================================================*/
BadEnumerate:
LocalFree(pPdParams);
OutOfMemory:
return(NULL);
} // end WinEnumerateDevices
/*******************************************************************************
*
* NetworkDeviceEnumerate - Hydrix helper function
*
* Returns a list of Lan Adapter indexes of network cards bound to the the
* specified protocol. The Lan Adapter is returned in the LanAdapter field
* of each PDPARAMS array. A LanAdapter value of 0 indicates 'any configured
* network card'. Indexes >=1 indicate 1-based index into the specific
* protocol's "servicename"\Linkage\Route registry entry to specify the
* particular network card.
*
* ENTRY:
* pPdConfig (input)
* Points to PDCONFIG3 structure of the PD.
* pEntries (output)
* When the function finishes successfully, the variable pointed to
* by the pEntries parameter contains the number of entries actually
* returned.
* pPdParams (output)
* Points to the buffer to receive the enumeration results, which are
* returned as an array of PDPARAMS structures.
* pByteCount (input/output)
* Points to a variable that specifies the size, in bytes, of the
* pPdParams parameter. If the buffer is too small to receive all the
* entries, on output this variable receives the required size of the
* buffer.
* bInSetup (input)
* TRUE if we're operating in Setup; FALSE otherwise.
*
* EXIT:
* TRUE: enumeration was sucessful; FALSE otherwise.
*
* The error code can be retrieved via GetLastError(), and are the
* following possible values:
* ERROR_INSUFFICIENT_BUFFER
* enumeration failed because of an insufficient pPdParams
* buffer size to contain all devices
* ERROR_DEV_NOT_EXIST
* The specified network's service was not found, indicating that
* the protocol was not configured. This error code can be
* interpreted as 'no devices are configured for the xxx protocol'
* for reporting purposes.
* ERROR_xxxx
* Registry error code.
*
******************************************************************************/
BOOL WINAPI
NetworkDeviceEnumerate( PPDCONFIG3 pPdConfig,
PULONG pEntries,
PPDPARAMS pPdParams,
PULONG pByteCount,
BOOL bInSetup )
{
ULONG i, Count;
LPTSTR szRoute, szRouteStr;
LONG Status;
DWORD ValueSize, Type;
TCHAR szKey[256];
HKEY Handle;
/*
* Get maximum number of LanAdapter indexes that can be returned.
*/
Count = *pByteCount / sizeof(PDPARAMS);
/*
* Form key for service name associated with this PD and fetch
* the Linkage\Route strings.
*/
_snwprintf( szKey, sizeof(szKey)/sizeof(TCHAR),
TEXT("%s\\%s\\Linkage"), REGISTRY_SERVICES,
pPdConfig->ServiceName );
if ( (Status = RegOpenKeyEx( HKEY_LOCAL_MACHINE, szKey, 0, KEY_READ, &Handle ))
!= ERROR_SUCCESS ) {
Status = ERROR_DEV_NOT_EXIST;
goto BadRegistryOpen;
}
/*
* Alloc and read in the linkage route multi-string.
*/
if ( ((Status = RegQueryValueEx( Handle, REGISTRY_ROUTE,
NULL, &Type,
NULL, &ValueSize ))
!= ERROR_SUCCESS) || (Type != REG_MULTI_SZ) )
goto BadQuery1;
if ( !(szRoute = (LPTSTR)LocalAlloc(LPTR, ValueSize)) ) {
Status = ERROR_NOT_ENOUGH_MEMORY;
goto BadAlloc;
}
if ( ((Status = RegQueryValueEx( Handle, REGISTRY_ROUTE,
NULL, &Type,
(LPBYTE)szRoute, &ValueSize ))
!= ERROR_SUCCESS) )
goto BadQuery2;
/*
* Close the registry key handle and count the route strings to obtain
* the number of entries to report in the enumeration.
*/
RegCloseKey(Handle);
for ( i = 1, szRouteStr = szRoute; lstrlen(szRouteStr); i++ )
szRouteStr += (lstrlen(szRouteStr) + 1);
LocalFree(szRoute);
/*
* If we don't have enough PDPARAMS structures to report all of the
* LanAdapter indexes, return error.
*/
if ( i > Count ) {
Status = ERROR_INSUFFICIENT_BUFFER;
*pByteCount = (i * sizeof(PDPARAMS));
goto BadBufferSize;
}
/*
* Set the LanAdapter fields of the first 'i' PDPARAMS structures to
* the indexes (0-based), set total number of entries, and return success.
*/
for ( Count = 0, *pEntries = i; Count < i; pPdParams++, Count++ )
pPdParams->Network.LanAdapter = (LONG)Count;
return(TRUE);
/*==============================================================================
* Error returns
*============================================================================*/
BadQuery2:
LocalFree(szRoute);
BadAlloc:
BadQuery1:
RegCloseKey(Handle);
BadBufferSize:
BadRegistryOpen:
SetLastError(Status);
return(FALSE);
} // end NetworkDeviceEnumerate
/*******************************************************************************
*
* QueryCurrentWinStation - Hydrix helper function
*
* Query the currently logged-on WinStation information.
*
* ENTRY:
* pWSName (output)
* Points to string to place current WinStation name.
* pUserName (output)
* Points to string to place current User name.
* pLogonId (output)
* Points to ULONG to place current LogonId.
* pFlags (output)
* Points to ULONG to place current WinStation's flags.
*
* EXIT:
* (BOOL) TRUE if the user's current WinStation information was queried
* sucessfully; FALSE otherwise. The error code is set for
* GetLastError() to retrieve.
*
******************************************************************************/
BOOL WINAPI
QueryCurrentWinStation( PWINSTATIONNAME pWSName,
LPTSTR pUserName,
PULONG pLogonId,
PULONG pFlags )
{
ULONG Flags = 0;
WINSTATIONINFORMATION WSInfo;
#ifdef WINSTA
ULONG ReturnLength;
#endif // WINSTA
#ifdef WINSTA
/*
* Fetch the WinStation's basic information.
*/
if ( !WinStationQueryInformation( SERVERNAME_CURRENT,
LOGONID_CURRENT,
WinStationInformation,
&WSInfo,
sizeof(WSInfo),
&ReturnLength ) )
goto BadQuery;
/*
* Check for shadow capability if WinStation is connected. If the
* WinStation is not connected, we can't shadow.
*/
if ( WSInfo.ConnectState != State_Disconnected ) {
WDCONFIG WdConfig;
/*
* Query Wd config stuff.
*/
if ( !WinStationQueryInformation( SERVERNAME_CURRENT,
LOGONID_CURRENT,
WinStationWd,
&WdConfig,
sizeof(WdConfig),
&ReturnLength ) )
goto BadQuery;
/*
* Set WinStation's Wd flags.
*/
Flags = WdConfig.WdFlag;
}
#else
lstrcpy(WSInfo.WinStationName, TEXT("console"));
lstrcpy(WSInfo.UserName, TEXT("bonzo"));
WSInfo.LogonId = 0;
#endif // WINSTA
/*
* Set WinStation information into caller's variables, and return success.
*/
lstrcpy( pWSName, WSInfo.WinStationName );
lstrlwr(pWSName);
lstrcpy( pUserName, WSInfo.UserName );
lstrlwr(pUserName);
*pLogonId = WSInfo.LogonId;
*pFlags = Flags;
return(TRUE);
/*==============================================================================
* Error returns
*============================================================================*/
#ifdef WINSTA
BadQuery:
#endif // WINSTA
return(FALSE);
} // end QueryCurrentWinStation
/*******************************************************************************
*
* RegGetNetworkDeviceName - Hydrix helper function
*
* Obtain the network device name associated with the given WinStation PD.
*
* ENTRY:
* hServer (input)
* Handle to Hydrix Server
* pPdConfig (input)
* Points to the PDCONFIG3 structure for the WinStation's PD.
* pPdParams (input)
* Points to the PDPARAMS structure for the WinStation's PD.
* szDeviceName (output)
* Points to buffer to return the network device name.
* nDeviceName (input)
* Specifies the maxmum number of characters that can be stored in
* szDeviceName.
*
* EXIT:
* No return. Will always place a string representation of
* pPdParams->Network.LanAdapter along with an appropriate error string
* in pDeviceName if the network device name could not be read from the
* registry.
*
******************************************************************************/
typedef struct _LANAMAP {
BYTE enabled;
BYTE lana;
} LANAMAP, *PLANAMAP;
LONG WINAPI
RegGetNetworkDeviceName( HANDLE hServer,
PPDCONFIG3 pPdConfig,
PPDPARAMS pPdParams,
LPTSTR szDeviceName,
int nDeviceName )
{
int i, length;
LPTSTR szRoute, szRouteStr, p;
LONG Status = ERROR_SUCCESS;
DWORD ValueSize, Type;
TCHAR szKey[256];
HKEY Handle;
HKEY hkey_local_machine;
PLANAMAP pLanaMap, pLana;
if ( hServer == NULL)
hkey_local_machine = HKEY_LOCAL_MACHINE;
else
hkey_local_machine = hServer;
/*
* Check for NetBIOS (PD_LANA) mapping or other mapping.
*/
if ( !(pPdConfig->Data.PdFlag & PD_LANA) ) {
LPTSTR szRoute, szRouteStr;
/*
* Non-LANA mapping. If the LanAdapter is 0, treat this as the
* special 'all configured network cards' value and return that
* string as the device name.
*/
if ( pPdParams->Network.LanAdapter == 0 ) {
TCHAR szString[256];
length = LoadString( GetModuleHandle( UTILDLL_NAME ),
IDS_ALL_LAN_ADAPTERS, szString, 256 );
ASSERT(length);
lstrncpy(szDeviceName, szString, nDeviceName);
szDeviceName[nDeviceName-1] = TEXT('\0');
return Status;
}
/*
* Form key for service name associated with this PD and fetch
* the Linkage\Route strings.
*/
_snwprintf( szKey, sizeof(szKey)/sizeof(TCHAR),
TEXT("%s\\%s\\Linkage"), REGISTRY_SERVICES,
pPdConfig->ServiceName );
if ( (Status = RegOpenKeyEx( hkey_local_machine, szKey, 0,
KEY_READ, &Handle ))
!= ERROR_SUCCESS )
goto Error;
/*
* Alloc and read in the linkage route multi-string.
*/
if ( ((Status = RegQueryValueEx( Handle, REGISTRY_ROUTE,
NULL, &Type,
NULL, &ValueSize ))
!= ERROR_SUCCESS) || (Type != REG_MULTI_SZ) )
goto Error;
if ( !(szRoute = (LPTSTR)LocalAlloc(LPTR, ValueSize)) ) {
Status = ERROR_NOT_ENOUGH_MEMORY;
goto Error;
}
if ( ((Status = RegQueryValueEx( Handle, REGISTRY_ROUTE,
NULL, &Type,
(LPBYTE)szRoute, &ValueSize ))
!= ERROR_SUCCESS) ) {
LocalFree(szRoute);
goto Error;
}
/*
* Close the registry key handle and point to the route string
* associated with this LanAdapter index.
*/
RegCloseKey(Handle);
for ( i = 1, szRouteStr = szRoute;
i < pPdParams->Network.LanAdapter; i++ ) {
szRouteStr += (lstrlen(szRouteStr) + 1);
if ( !lstrlen(szRouteStr) ) {
/*
* Error: Index past end of route multi-string.
*/
LocalFree(szRoute);
Status = ERROR_DEV_NOT_EXIST;
goto Error;
}
}
/*
* Isolate the service string representing the lowest binding
* in the route and convert it to its display name.
*/
*(p = (szRouteStr + lstrlen(szRouteStr) - 1)) = TEXT('\0');
for ( ; *p != TEXT('\"'); p-- );
p++;
if ( (Status = RegGetNetworkServiceName( hServer, p, szDeviceName, nDeviceName ))
!= ERROR_SUCCESS ) {
LocalFree(szRoute);
goto Error;
}
/*
* Clean up and return.
*/
LocalFree(szRoute);
return Status;
}
else {
/*
* NetBIOS LANA #: see which LanaMap entry corresponds to the specified
* Lan Adapter.
*/
if ( (Status = RegOpenKeyEx( hkey_local_machine, REGISTRY_NETBLINKAGE, 0,
KEY_READ, &Handle ))
!= ERROR_SUCCESS )
goto Error;
/*
* Alloc and read the LanaMap
*/
if ( ((Status = RegQueryValueEx( Handle, REGISTRY_NETBLINKAGE_LANAMAP,
NULL, &Type,
NULL, &ValueSize))
!= ERROR_SUCCESS) || (Type != REG_BINARY) ) {
RegCloseKey(Handle);
goto Error;
}
if ( !(pLanaMap = (PLANAMAP)LocalAlloc(LPTR, ValueSize)) ) {
Status = ERROR_NOT_ENOUGH_MEMORY;
goto Error;
}
if ( (Status = RegQueryValueEx( Handle, REGISTRY_NETBLINKAGE_LANAMAP,
NULL, &Type,
(LPBYTE)pLanaMap, &ValueSize))
!= ERROR_SUCCESS ) {
LocalFree(pLanaMap);
RegCloseKey(Handle);
goto Error;
}
/*
* Loop through LanaMap to check for match with the specified Lan
* Adapter #.
*/
for ( pLana = pLanaMap, i = 0;
i < (int)(ValueSize / sizeof(LANAMAP));
i++, pLana++ ) {
if ( pLana->lana == (BYTE)(pPdParams->Network.LanAdapter) ) {
TCHAR szHighestBinding[256], szLowestBinding[256];
LocalFree(pLanaMap);
/*
* Match found. Alloc and fetch the Route multi-string
*/
if ( ((Status = RegQueryValueEx( Handle,
REGISTRY_ROUTE,
NULL, &Type,
NULL, &ValueSize))
!= ERROR_SUCCESS) || (Type != REG_MULTI_SZ) ) {
RegCloseKey(Handle);
goto Error;
}
if ( !(szRoute = (LPTSTR)LocalAlloc(LPTR, ValueSize)) ) {
Status = ERROR_NOT_ENOUGH_MEMORY;
goto Error;
}
if ( (Status = RegQueryValueEx( Handle,
REGISTRY_ROUTE,
NULL, &Type,
(LPBYTE)szRoute, &ValueSize))
!= ERROR_SUCCESS ) {
LocalFree(szRoute);
RegCloseKey(Handle);
goto Error;
}
/*
* Free the registry key handle and make a local copy of the
* 'i'th multi string, which is the binding route for this lana.
*/
RegCloseKey(Handle);
for ( szRouteStr = szRoute; i > 0; i-- )
szRouteStr += (lstrlen(szRouteStr) + 1);
lstrncpy(szDeviceName, szRouteStr, nDeviceName);
szDeviceName[nDeviceName-1] = TEXT('\0');
LocalFree(szRoute);
/*
* Isolate the service string representing the highest binding
* in the route and convert it to its display name.
*/
szRouteStr = szDeviceName + 1; // skip first "
for ( p = szRouteStr; *p && *p != TEXT('\"'); p++ );
if ( !(*p) )
goto Error;
*p = TEXT('\0');
if ( (Status = RegGetNetworkServiceName(
hServer,
szRouteStr,
szHighestBinding,
sizeof(szHighestBinding)/sizeof(TCHAR) ))
!= ERROR_SUCCESS )
goto Error;
/*
* Isolate the service string representing the lowest binding
* in the route and convert it to its display name.
*/
if ( !(*(szRouteStr = p+1)) ) {
*szLowestBinding = TEXT('\0');
}
else {
*(p = (szRouteStr + lstrlen(szRouteStr) - 1)) = TEXT('\0');
for ( ; *p != TEXT('\"'); p-- );
p++;
if ( (Status = RegGetNetworkServiceName(
hServer,
p,
szLowestBinding,
sizeof(szLowestBinding)/sizeof(TCHAR) ))
!= ERROR_SUCCESS )
goto Error;
}
/*
* Build the complete name string.
*/
_snwprintf( szDeviceName, nDeviceName, TEXT("%s => %s"),
szHighestBinding, szLowestBinding );
/*
* Return.
*/
return ERROR_SUCCESS;
}
}
/*
* No match found.
*/
LocalFree(pLanaMap);
RegCloseKey(Handle);
goto Error;
}
/*==============================================================================
* Error returns
*============================================================================*/
Error:
{
TCHAR sz1[256], sz2[1024];
int length;
length = LoadString( GetModuleHandle( UTILDLL_NAME ),
(pPdConfig->Data.PdFlag & PD_LANA) ?
IDP_ERROR_REGLANA :
IDP_ERROR_REGNETCARD,
sz1, 256 );
wsprintf( sz2, sz1, pPdParams->Network.LanAdapter, Status );
lstrncpy(szDeviceName, sz2, nDeviceName);
szDeviceName[nDeviceName-1] = TEXT('\0');
}
return Status;
} // end RegGetNetworkDeviceName
/*******************************************************************************
*
* RegGetNetworkServiceName - Hydrix helper function
*
* Obtain the display name associated with a given network service name.
* If the service is a reference to a physical network card, will return
* the title of the card as obtained from the LOCAL_MACHINE\Software\
* Microsoft\Windows NT\NetworkCards registry.
*
* ENTRY:
* hServer (input)
* Handle of the Hydrix Server
* szServiceKey (input)
* Key string into the LOCAL_MACHINE\System\CurrentControlSet\Services
* registry.
* szServiceName (output)
* Points to buffer to return the service's display name.
* nServiceName (input)
* Specifies the maxmum number of characters that can be stored in
* szServiceName.
*
* EXIT:
* ERROR_SUCCESS if a service name was sucessfully found and returned;
* error code otherwise.
*
* NOTE: If the service name is for an entry in the NetworkCards resistry
* and the entry is flagged as 'hidden', the service name will be
* blank. This will flag caller's logic to ignore the entry.
*
******************************************************************************/
LONG WINAPI
RegGetNetworkServiceName( HANDLE hServer,
LPTSTR szServiceKey,
LPTSTR szServiceName,
int nServiceName )
{
LONG Status;
DWORD ValueSize, Type, dwValue;
TCHAR szKey[256];
LPTSTR szTemp;
HKEY Handle;
HKEY hkey_local_machine;
if (hServer == NULL)
hkey_local_machine = HKEY_LOCAL_MACHINE;
else
hkey_local_machine = hServer;
lstrnprintf( szKey, sizeof(szKey)/sizeof(TCHAR),
TEXT("%s\\%s"), REGISTRY_SERVICES, szServiceKey );
if ( (Status = RegOpenKeyEx( hkey_local_machine,
szKey, 0,
KEY_READ, &Handle ))
!= ERROR_SUCCESS )
return(Status);
/*
* Alloc and read in the service's DisplayName value (if there).
*/
if ( ((Status = RegQueryValueEx( Handle, REGISTRY_DISPLAY_NAME,
NULL, &Type,
NULL, &ValueSize ))
!= ERROR_SUCCESS) || (Type != REG_SZ) ) {
HKEY Subkey;
FILETIME KeyTime;
DWORD i;
/*
* The service doesn't have a DisplayName associated with it (it's a
* Network Card's service name). Traverse the NetworkCards registry
* entries and find the entry associated with this service name
* (if it exists).
*/
RegCloseKey(Handle);
if ( (Status = RegOpenKeyEx( hkey_local_machine,
REGISTRY_NETCARDS, 0,
KEY_READ, &Handle ))
!= ERROR_SUCCESS )
return(Status);
for ( i = 0, ValueSize = sizeof(szKey)/sizeof(TCHAR) ;
RegEnumKeyEx( Handle, i, szKey, &ValueSize,
NULL, NULL, NULL, &KeyTime ) == ERROR_SUCCESS ;
i++, ValueSize = sizeof(szKey)/sizeof(TCHAR) ) {
/*
* Open the Network Card's registry.
*/
if ( (Status = RegOpenKeyEx( Handle,
szKey, 0,
KEY_READ, &Subkey ))
!= ERROR_SUCCESS ) {
RegCloseKey(Handle);
return(Status);
}
/*
* Alloc and fetch the card's service name. Continue net card
* enumeration if service name not found.
*/
if ( ((Status = RegQueryValueEx( Subkey,
REGISTRY_SERVICE_NAME,
NULL, &Type,
NULL, &ValueSize))
!= ERROR_SUCCESS) || (Type != REG_SZ) ) {
RegCloseKey(Subkey);
continue;
}
szTemp = (LPTSTR)LocalAlloc(LPTR, ValueSize);
if(NULL == szTemp)
{
RegCloseKey(Subkey);
RegCloseKey(Handle);
return ERROR_NOT_ENOUGH_MEMORY;
}
if ( (Status = RegQueryValueEx( Subkey,
REGISTRY_SERVICE_NAME,
NULL, &Type,
(LPBYTE)szTemp, &ValueSize))
!= ERROR_SUCCESS ) {
LocalFree(szTemp);
RegCloseKey(Subkey);
continue;
}
/*
* If the current Network Card's service name matches the service
* name that we're looking for, fetch the card's title.
*/
if ( !lstrcmpi(szServiceKey, szTemp) ) {
LocalFree(szTemp);
ValueSize = sizeof(dwValue);
if ( (RegQueryValueEx( Subkey, REGISTRY_HIDDEN,
NULL, &Type,
(LPBYTE)&dwValue, &ValueSize )
== ERROR_SUCCESS) &&
(Type == REG_DWORD) &&
(dwValue == 1) ) {
/*
* Entry is hidden: return empty title.
*/
*szServiceName = TEXT('\0');
}
else {
/*
* Entry is not hidden: Alloc for the card's title.
*/
if ( ((Status = RegQueryValueEx( Subkey,
REGISTRY_TITLE,
NULL, &Type,
NULL, &ValueSize))
!= ERROR_SUCCESS) || (Type != REG_SZ) ) {
RegCloseKey(Subkey);
RegCloseKey(Handle);
return(Status);
}
szTemp = (LPTSTR)LocalAlloc(LPTR, ValueSize);
if(NULL == szTemp)
{
RegCloseKey(Subkey);
RegCloseKey(Handle);
return ERROR_NOT_ENOUGH_MEMORY;
}
/*
* Fetch the title.
*/
if ( (Status = RegQueryValueEx( Subkey,
REGISTRY_TITLE,
NULL, &Type,
(LPBYTE)szTemp, &ValueSize))
!= ERROR_SUCCESS ) {
LocalFree(szTemp);
RegCloseKey(Subkey);
RegCloseKey(Handle);
return(Status);
}
/*
* Copy the card's title.
*/
lstrncpy(szServiceName, szTemp, nServiceName);
szServiceName[nServiceName-1] = TEXT('\0');
LocalFree(szTemp);
}
/*
* Clean up and return success.
*/
RegCloseKey(Subkey);
RegCloseKey(Handle);
return(ERROR_SUCCESS);
}
else {
/*
* This is not the Network Card that we're looking for. Close
* it's registry key, free the service name buffer, and continue
* enumeration loop.
*/
LocalFree(szTemp);
RegCloseKey(Subkey);
}
}
/*
* Network Card not found with service name matching the one supplied.
* Close NetworkCards registry key and return failure,
*/
RegCloseKey(Handle);
return(ERROR_DEV_NOT_EXIST);
}
else {
szTemp = (LPTSTR)LocalAlloc(LPTR, ValueSize);
if(NULL == szTemp)
{
RegCloseKey(Handle);
return ERROR_NOT_ENOUGH_MEMORY;
}
if ( ((Status = RegQueryValueEx( Handle, REGISTRY_DISPLAY_NAME,
NULL, &Type,
(LPBYTE)szTemp, &ValueSize ))
== ERROR_SUCCESS) )
lstrncpy(szServiceName, szTemp, nServiceName);
szServiceName[nServiceName-1] = TEXT('\0');
LocalFree(szTemp);
RegCloseKey(Handle);
return(Status);
}
} // end RegGetNetworkServiceName
/*******************************************************************************
*
* AsyncDeviceEnumerate - Hydrix helper function
*
* Returns a list of async device names. This will return both 'COM' devices
* and TAPI configured modems.
*
* ENTRY:
* pPdConfig (input)
* Points to PDCONFIG3 structure of the PD.
* pEntries (output)
* When the function finishes successfully, the variable pointed to
* by the pEntries parameter contains the number of entries actually
* returned.
* pPdParams (output)
* Points to the buffer to receive the enumeration results, which are
* returned as an array of PDPARAMS structures.
* pByteCount (input/output)
* Points to a variable that specifies the size, in bytes, of the
* pPdParams parameter. If the buffer is too small to receive all the
* entries, on output this variable is set to 0 (caller should double
* the input buffer and try again).
* bInSetup (input)
* TRUE if we're operating in Setup; FALSE otherwise.
* EXIT:
* TRUE: enumeration was sucessful; FALSE otherwise.
*
* The error code can be retrieved via GetLastError(), and are the
* following possible values:
* ERROR_NOT_ENOUGH_MEMORY
* not enough memory to allocate working buffer(s)
* ERROR_INSUFFICIENT_BUFFER
* enumeration failed because of an insufficient pPdParams
* buffer size to contain all devices
* ERROR_DEV_NOT_EXIST
* the QueryDosDevice call failed. This error code can be
* interpreted as 'no async devices are configured' for reporting
* purposes.
*
******************************************************************************/
#define MAX_QUERY_BUFFER (1024*16)
BOOL WINAPI
AsyncDeviceEnumerate( PPDCONFIG3 pPdConfig,
PULONG pEntries,
PPDPARAMS pPdParams,
PULONG pByteCount,
BOOL bInSetup )
{
DWORD Error = ERROR_SUCCESS;
ULONG Count;
HKEY hRoot = NULL;
DWORD BufSize, NameSize, Type, Index, SaveBufSize, SaveNameSize;
LONG Result = 0;
LONG nDosDevice = 0;
LPTSTR pBuffer = NULL, pBufferEnd = NULL;
LPTSTR pNameBuffer = NULL, pName;
BOOLEAN bRetVal = FALSE;
/*
* Get maximum number of names that can be returned
*/
Count = *pByteCount / sizeof(PDPARAMS);
*pByteCount = 0;
*pEntries = 0;
/*
* Allocate buffer
*/
SaveBufSize = MAX_QUERY_BUFFER;
SaveNameSize = MAX_QUERY_BUFFER;
BufSize = SaveBufSize;
NameSize = SaveNameSize;
if ( !(pBuffer = (LPTSTR)LocalAlloc(LPTR, BufSize * sizeof(TCHAR))) ) {
Error = ERROR_NOT_ENOUGH_MEMORY;
goto Cleanup;
}
if ( !(pNameBuffer = (LPTSTR)LocalAlloc(LPTR, NameSize)) ) {
Error = ERROR_NOT_ENOUGH_MEMORY;
goto Cleanup;
}
/*
* If we're in Setup, obtain devices from the SERIALCOMM section in
* LOCAL MACHINE registry, since the serial device driver(s) are most
* likely not running. Otherwise, we'll query all DosDevices and
* return those that are COM devices and are not currently in use.
*/
if ( bInSetup ) {
Result = RegOpenKeyEx( HKEY_LOCAL_MACHINE,
TEXT("HARDWARE\\DEVICEMAP\\SERIALCOMM"),
0, // Reserved
KEY_ENUMERATE_SUB_KEYS|KEY_QUERY_VALUE,
&hRoot );
if ( Result != ERROR_SUCCESS ) {
//
// This is usually the result of having no ports, so the key
// SERIALCOMM does not exist.
//
goto Cleanup;
}
for ( Index=0; ; Index++ ) {
// Each enumerate stomps on our buffer sizes
BufSize = SaveBufSize;
NameSize = SaveNameSize;
Result = RegEnumValue( hRoot,
Index,
pBuffer,
&BufSize,
NULL, // Reserved
&Type,
(LPBYTE)pNameBuffer,
&NameSize );
if ( Result == ERROR_INSUFFICIENT_BUFFER ) {
// Reallocate the buffer
LocalFree( pBuffer );
pBuffer = (LPTSTR)LocalAlloc(LPTR, BufSize * sizeof(TCHAR));
if ( pBuffer == NULL ) {
// Try and reallocate next key
SaveBufSize = BufSize = 0;
continue;
}
else {
SaveBufSize = BufSize;
}
// Reallocate the name buffer
LocalFree( pNameBuffer );
pNameBuffer = (LPTSTR)LocalAlloc(LPTR, NameSize);
if ( pNameBuffer == NULL ) {
// Try and reallocate next key
SaveNameSize = NameSize = 0;
continue;
}
else {
SaveNameSize = NameSize;
}
Result = RegEnumValue( hRoot,
Index,
pBuffer,
&BufSize,
NULL, // Reserved
&Type,
(LPBYTE)pNameBuffer,
&NameSize );
}
// We are done
if ( Result == ERROR_NO_MORE_ITEMS ) {
bRetVal = TRUE;
Result = 0;
goto Cleanup;
}
if ( Result != ERROR_SUCCESS ) {
goto Cleanup;
}
if ( Count > 0 ) {
if ( Type != REG_SZ ) {
continue;
}
pPdParams->SdClass = SdAsync;
lstrcpy( pPdParams->Async.DeviceName, pNameBuffer );
pPdParams++;
Count--;
(*pEntries)++;
}
else {
Error = ERROR_INSUFFICIENT_BUFFER;
goto Cleanup;
}
}
}
else { // not in Setup
/*
* Get complete device list
*/
nDosDevice = QueryDosDevice( NULL, pBuffer, MAX_QUERY_BUFFER );
if ( !nDosDevice)
{
Error = ERROR_DEV_NOT_EXIST;
goto Cleanup;
}
/*
* Find each device name in list
*/
pName = pBuffer;
pBufferEnd = pBuffer + nDosDevice;
while ( *pName && (pName < pBufferEnd) ) {
if ( CheckForComDevice( pName ) ) {
if ( Count > 0 ) {
pPdParams->SdClass = SdAsync;
lstrcpy( pPdParams->Async.DeviceName, pName );
pPdParams++;
Count--;
(*pEntries)++;
}
else {
Error = ERROR_INSUFFICIENT_BUFFER;
goto Cleanup;
}
}
pName += (lstrlen(pName) + 1);
}
bRetVal = TRUE; // sucessful enumeration
}
Cleanup:
/*
* If no errors yet, perform TAPI device enumeration.
*/
if ( bRetVal ) {
if ( (Error = EnumerateTapiPorts( pPdParams,
Count,
&pEntries ))
!= ERROR_SUCCESS ) {
bRetVal = FALSE;
}
}
if ( pBuffer ) {
LocalFree( pBuffer );
}
if ( pNameBuffer ) {
LocalFree( pNameBuffer );
}
if ( hRoot ) {
CloseHandle( hRoot );
}
SetLastError(Error);
return(bRetVal);
} // AsyncDeviceEnumerate
/*******************************************************************************
*
* NetBIOSDeviceEnumerate - Hydrix helper function
*
* Returns a list of NetBIOS lana adapter numbers.
*
* ENTRY:
* pPdConfig (input)
* Points to PDCONFIG3 structure of the PD.
* pEntries (output)
* When the function finishes successfully, the variable pointed to
* by the pEntries parameter contains the number of entries actually
* returned.
* pPdParams (output)
* Points to the buffer to receive the enumeration results, which are
* returned as an array of PDPARAMS structures.
* pByteCount (input/output)
* Points to a variable that specifies the size, in bytes, of the
* pPdParams parameter. If the buffer is too small to receive all the
* entries, on output this variable receives the required size of the
* buffer.
* bInSetup (input)
* TRUE if we're operating in Setup; FALSE otherwise.
*
* EXIT:
* TRUE: enumeration was sucessful; FALSE otherwise.
*
* The error code can be retrieved via GetLastError(), and are the
* following possible values:
* v ERROR_INSUFFICIENT_BUFFER
* enumeration failed because of an insufficient pPdParams
* buffer size to contain all devices
* ERROR_DEV_NOT_EXIST
* the NetBiosLanaEnum call failed. This error code can be
* interpreted as 'no netbios devices are configured' for reporting
* purposes.
*
******************************************************************************/
BOOL WINAPI
NetBIOSDeviceEnumerate( PPDCONFIG3 pPdConfig,
PULONG pEntries,
PPDPARAMS pPdParams,
PULONG pByteCount,
BOOL bInSetup )
{
LANA_ENUM LanaEnum;
NTSTATUS Status;
int i;
/*
* Issue netbios enum command
*/
if ( Status = NetBiosLanaEnum( &LanaEnum ) ) {
SetLastError(ERROR_DEV_NOT_EXIST);
return(FALSE);
}
/*
* Make sure user's buffer is big enough
*/
if ( LanaEnum.length > (*pByteCount / sizeof(PDPARAMS)) ) {
*pByteCount = LanaEnum.length * sizeof(PDPARAMS);
SetLastError(ERROR_INSUFFICIENT_BUFFER);
return(FALSE);
}
/*
* Return number of entries
*/
*pEntries = (ULONG) LanaEnum.length;
/*
* Return lana numbers
*/
for ( i=0; i < (int)LanaEnum.length; i++, pPdParams++ ) {
pPdParams->SdClass = SdNetwork;
pPdParams->Network.LanAdapter = LanaEnum.lana[i];
}
return(TRUE);
} // NetBIOSDeviceEnumerate
/*******************************************************************************
*
* FormDecoratedAsyncDeviceName - Hydrix helper function
*
* Format a decorated async device name if a modem is defined.
*
* ENTRY:
* pDeviceName (output)
* Points to buffer that will contain the decorated name (or undecorated
* name if no modem).
* pPdParams (input)
* Points to the ASYNCCONFIG structure to be used in forming the
* decorated name.
*
* EXIT:
*
******************************************************************************/
void WINAPI
FormDecoratedAsyncDeviceName( LPTSTR pDeviceName,
PASYNCCONFIG pAsyncConfig )
{
if ( *(pAsyncConfig->ModemName) )
wsprintf( pDeviceName, TEXT("%s - %s"),
pAsyncConfig->DeviceName,
pAsyncConfig->ModemName );
else
lstrcpy( pDeviceName,
pAsyncConfig->DeviceName );
} // end FormDecoratedAsyncDeviceName
/*******************************************************************************
*
* ParseDecoratedAsyncDeviceName - Hydrix helper function
*
* Given a decorated async device name, form it's component device and
* modem name portions.
*
* ENTRY:
* pDeviceName (input)
* Points to buffer that contain the decorated async device name.
* pAsyncConfig (output)
* Points to the ASYNCCONFIG structure to save the device (in
* ->DeviceName) and modem (in ->ModemName).
* EXIT:
*
******************************************************************************/
void WINAPI
ParseDecoratedAsyncDeviceName( LPCTSTR pDeviceName,
PASYNCCONFIG pAsyncConfig )
{
int i;
/*
* Form DeviceName portion up to the first blank.
*/
for ( i=0; *pDeviceName && (*pDeviceName != TEXT(' ')); i++ )
(pAsyncConfig->DeviceName)[i] = *pDeviceName++;
(pAsyncConfig->DeviceName)[i] = TEXT('\0');
/*
* Skip the ' - ' decoration (to the next space).
*/
if ( *pDeviceName ) {
for ( pDeviceName++;
*pDeviceName && (*pDeviceName != TEXT(' '));
pDeviceName++ );
}
/*
* Form the ModemName from the remainder of the string.
*/
i = 0;
if ( *pDeviceName ) {
for ( pDeviceName++; *pDeviceName ; i++ )
(pAsyncConfig->ModemName)[i] = *pDeviceName++;
}
(pAsyncConfig->ModemName)[i] = TEXT('\0');
} // end ParseDecoratedAsyncDeviceName
/*******************************************************************************
*
* SetupAsyncCdConfig - Hydrix helper function
*
* Given a properly configured ASYNCCONFIG structure, set up a given
* CDCONFIG structure.
*
* ENTRY:
* pAsyncConfig (input)
* Points properly configured ASYNCCONFIG structure.
* pCdConfig (output)
* Points to the CDCONFIG structure to setup.
* EXIT:
*
******************************************************************************/
void WINAPI
SetupAsyncCdConfig( PASYNCCONFIG pAsyncConfig,
PCDCONFIG pCdConfig )
{
memset(pCdConfig, 0, sizeof(CDCONFIG));
if ( *(pAsyncConfig->ModemName) ) {
pCdConfig->CdClass = CdModem;
lstrcpy( pCdConfig->CdName, TEXT("cdmodem") );
lstrcpy( pCdConfig->CdDLL, TEXT("cdmodem.dll") );
}
} // end SetupAsyncCdConfig
/*******************************************************************************
*
* InstallModem - Hydrix helper function
*
* Install UNIMODEM modem(s).
*
* ENTRY:
* hwndOwner
* Window handle that owns the installation dialog.
* EXIT:
* TRUE: installation completed; FALSE: error or user canceled.
*
* If an error, the error code can be retrieved via GetLastError().
*
******************************************************************************/
BOOL WINAPI
InstallModem( HWND hwndOwner )
{
HDEVINFO hdi;
BOOL bStatus = FALSE;
HCURSOR hcur = SetCursor(LoadCursor(NULL, IDC_WAIT));
/*
* Create a modem DeviceInfoSet
*/
if ( (hdi = SetupDiCreateDeviceInfoList( (LPGUID)&GUID_DEVCLASS_MODEM,
hwndOwner )) ) {
SP_INSTALLWIZARD_DATA iwd;
/*
* Initialize the InstallWizardData
*/
memset(&iwd, 0, sizeof(iwd));
iwd.ClassInstallHeader.cbSize = sizeof(SP_CLASSINSTALL_HEADER);
iwd.ClassInstallHeader.InstallFunction = DIF_INSTALLWIZARD;
iwd.hwndWizardDlg = hwndOwner;
/*
* Set the InstallWizardData as the ClassInstallParams
*/
if ( SetupDiSetClassInstallParams( hdi,
NULL,
(PSP_CLASSINSTALL_HEADER)&iwd,
sizeof(iwd)) ) {
/*
* Call the class installer to invoke the installation
* wizard.
*/
SetCursor(hcur);
hcur = NULL;
if ( SetupDiCallClassInstaller( DIF_INSTALLWIZARD,
hdi,
NULL) ) {
/*
* Success. The wizard was invoked and finished.
*/
SetupDiCallClassInstaller( DIF_DESTROYWIZARDDATA,
hdi,
NULL );
bStatus = TRUE;
}
}
/*
* Clean up
*/
SetupDiDestroyDeviceInfoList( hdi );
}
if (hcur)
SetCursor(hcur);
return(bStatus);
} // end InstallModem
/*******************************************************************************
*
* ConfigureModem - Hydrix helper function
*
* Configure the specified UNIMODEM modem.
*
* ENTRY:
* pModemName
* Name of UNIMODEM modem to configure.
* hwndOwner
* Window handle that owns the configuration dialog.
* EXIT:
* TRUE: configuration was sucessful; FALSE otherwise.
*
* The error code can be retrieved via GetLastError().
*
******************************************************************************/
BOOL WINAPI
ConfigureModem( LPCTSTR pModemName,
HWND hwndOwner )
{
BOOL bStatus = FALSE;
COMMCONFIG ccDummy;
COMMCONFIG * pcc;
DWORD dwSize;
HCURSOR hcur = SetCursor(LoadCursor(NULL, IDC_WAIT));
ccDummy.dwProviderSubType = PST_MODEM;
dwSize = sizeof(COMMCONFIG);
GetDefaultCommConfig(pModemName, &ccDummy, &dwSize);
pcc = (COMMCONFIG *)LocalAlloc(LPTR, (UINT)dwSize);
if ( pcc ) {
pcc->dwProviderSubType = PST_MODEM;
if ( GetDefaultCommConfig(pModemName, pcc, &dwSize) ) {
COMMCONFIG *pccOld = (COMMCONFIG *)LocalAlloc(LPTR, (UINT)dwSize);
if ( pccOld ) {
memcpy(pccOld, pcc, dwSize);
}
SetCursor(hcur);
hcur = NULL;
bStatus = TRUE;
if ( CommConfigDialog(pModemName, hwndOwner, pcc) ) {
if ( !SetDefaultCommConfig(pModemName, pcc, dwSize) )
bStatus = FALSE;
}
LocalFree((HLOCAL)pcc);
}
}
else
{
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
}
if (hcur)
SetCursor(hcur);
return(bStatus);
} // end ConfigureModem
///////////////////////////////////////////////////////////////////////////////
// Static Helper Functions
/***************************************************************************
*
* InitServerLock
*
* Since we do not require the user to call an initialize function,
* we must initialize our critical section in a thread safe manner.
*
* The problem is, a critical section is needed to guard against multiple
* threads trying to init the critical section at the same time.
*
* The solution that Nt uses, in which RtlInitializeCriticalSection itself
* uses, is to wait on a kernel supported process wide Mutant before proceding.
* This Mutant almost works by itself, but RtlInitializeCriticalSection does
* not wait on it until after trashing the semaphore count. So we wait on
* it ourselves, since it can be acquired recursively.
*
***************************************************************************/
typedef struct SERVERVERSION {
struct SERVERVERSION * pNext;
char ServerNameA[MAX_BR_NAME+1];
USHORT ServerVersion;
} SERVERVERSION, *PSERVERVERSION;
BOOLEAN G_fLockInited = FALSE;
PSERVERVERSION G_pServerList = NULL;
RTL_CRITICAL_SECTION G_ServerLock;
NTSTATUS
InitServerLock()
{
NTSTATUS status = STATUS_SUCCESS;
RtlEnterCriticalSection((PRTL_CRITICAL_SECTION)NtCurrentPeb()->LoaderLock);
/*
* Make sure another thread did not beat us here
*/
if ( !G_fLockInited ) {
status = RtlInitializeCriticalSection( &G_ServerLock );
if (status == STATUS_SUCCESS) {
G_fLockInited = TRUE;
}
}
RtlLeaveCriticalSection((PRTL_CRITICAL_SECTION)NtCurrentPeb()->LoaderLock);
return status;
}
/*******************************************************************************
*
* CheckForComDevice - local helper function
*
* check if device name is a serial com device
*
* ENTRY:
* pName (input)
* device name
*
* EXIT:
* TRUE - serial device
* FALSE - not a serial device
*
******************************************************************************/
static BOOL
CheckForComDevice( LPTSTR pName )
{
FILE_FS_DEVICE_INFORMATION DeviceInformation;
IO_STATUS_BLOCK IoStatus;
HANDLE Handle;
DEVICENAME Name;
NTSTATUS Status;
if ( (lstrlen(pName) == 2 && pName[1] == TEXT(':')) ||
!lstrcmpi(pName, TEXT("aux")) ||
!lstrnicmp(pName, TEXT("lpt"), 3) ||
!lstrnicmp(pName, TEXT("prn"), 3) ||
!lstrnicmp(pName, TEXT("display"), 7) ||
!lstrnicmp(pName, TEXT("$VDMLPT"), 7))
return(FALSE);
lstrcpy( Name, TEXT("\\\\.\\") );
lstrcat( Name, pName );
try
{
Handle = CreateFile( Name,
GENERIC_READ | GENERIC_WRITE,
0, // exclusive access
NULL, // no security attr
OPEN_EXISTING, // must exist
0,
NULL // no template
);
}
__except (1)
{
if ( Handle != INVALID_HANDLE_VALUE )
{
CloseHandle( Handle );
Handle = INVALID_HANDLE_VALUE;
}
}
if ( Handle == INVALID_HANDLE_VALUE )
return(FALSE);
Status = NtQueryVolumeInformationFile( (HANDLE) Handle,
&IoStatus,
&DeviceInformation,
sizeof(DeviceInformation),
FileFsDeviceInformation );
CloseHandle( Handle );
if ( (Status != STATUS_SUCCESS) ||
(DeviceInformation.DeviceType != FILE_DEVICE_SERIAL_PORT) )
return(FALSE);
return(TRUE);
} // end CheckForComDevice
/*******************************************************************************
*
* NetBiosLanaEnum - local helper function
*
* enumerate lana numbers
*
* ENTRY:
* pLanaEnum (input)
* pointer to receive LAN_ENUM structure
* EXIT:
* NO_ERROR - succesful
*
******************************************************************************/
typedef struct _LANA_MAP {
BOOLEAN Enum;
UCHAR Lana;
} LANA_MAP, *PLANA_MAP;
static int
NetBiosLanaEnum( LANA_ENUM * pLanaEnum )
{
int ProviderCount;
void * pProviderNames = NULL;
PLANA_MAP pLanaMap = NULL;
HKEY netbiosKey = NULL;
ULONG providerListLength;
ULONG lanaMapLength;
ULONG type;
int i;
LPTSTR currentProviderName;
int rc;
//
// Read the registry for information on all Netbios providers,
// including Lana numbers, protocol numbers, and provider device
// names. First, open the Netbios key in the registry.
//
rc = RegOpenKeyEx( HKEY_LOCAL_MACHINE, REGISTRY_NETBLINKAGE, 0,
MAXIMUM_ALLOWED, &netbiosKey );
if ( rc != NO_ERROR ) {
goto error_exit;
}
//
// Determine the size of the provider names. We need this so
// that we can allocate enough memory to hold it.
//
providerListLength = 0;
rc = RegQueryValueEx(
netbiosKey,
TEXT("Bind"),
NULL,
&type,
NULL,
&providerListLength
);
if ( rc != ERROR_MORE_DATA && rc != NO_ERROR ) {
goto error_exit;
}
//
// Allocate enough memory to hold the mapping.
//
if ( (pProviderNames = LocalAlloc(LPTR,providerListLength)) == NULL ) {
rc = ERROR_NOT_ENOUGH_MEMORY;
goto error_exit;
}
//
// Get the list of transports from the registry.
//
rc = RegQueryValueEx(
netbiosKey,
TEXT("Bind"),
NULL,
&type,
(PVOID)pProviderNames,
&providerListLength
);
if ( rc != NO_ERROR ) {
goto error_exit;
}
//
// Determine the size of the Lana map. We need this so that we
// can allocate enough memory to hold it.
//
providerListLength = 0;
rc = RegQueryValueEx(
netbiosKey,
TEXT("LanaMap"),
NULL,
&type,
NULL,
&lanaMapLength
);
if ( rc != ERROR_MORE_DATA && rc != NO_ERROR ) {
goto error_exit;
}
//
// Allocate enough memory to hold the Lana map.
//
if ( (pLanaMap = LocalAlloc(LPTR,lanaMapLength)) == NULL ) {
rc = ERROR_NOT_ENOUGH_MEMORY;
goto error_exit;
}
//
// Get the list of transports from the registry.
//
rc = RegQueryValueEx(
netbiosKey,
TEXT("LanaMap"),
NULL,
&type,
(PVOID)pLanaMap,
&lanaMapLength
);
if ( rc != NO_ERROR ) {
goto error_exit;
}
//
// Determine the number of Netbios providers loaded on the system.
//
ProviderCount = (int) (lanaMapLength / sizeof(LANA_MAP));
//
// Fill in the lana array
//
pLanaEnum->length = 0;
for ( currentProviderName = pProviderNames, i = 0;
*currentProviderName != UNICODE_NULL && i < ProviderCount;
currentProviderName += lstrlen( currentProviderName ) + 1, i++ ) {
if ( pLanaMap[i].Enum &&
lstrstr( currentProviderName, TEXT("Nbf_") ) ) {
pLanaEnum->lana[ pLanaEnum->length++ ] = pLanaMap[i].Lana;
}
}
error_exit:
if ( netbiosKey != NULL )
RegCloseKey( netbiosKey );
if ( pProviderNames != NULL )
LocalFree( pProviderNames );
if ( pLanaMap != NULL )
LocalFree( pLanaMap );
return( rc );
}
//
// NOTE: Butchd 9-26-96
// all of this following TAPI-related code is from various
// \nt\private\net\ras\src\ui\setup\src\ files
//
/******************************************************************************
*
* EnumerateTapiPorts - local helper function
*
* Determine all TAPI configured modems.
*
* ENTRY
* pPdParams (output)
* Points to array of PDPARAMS structures to save enumerated TAPI
* modems into.
* Count (input)
* Specifies number of entries in the pPdParams array.
* ppEntries (input/output)
* Points to pointer to variable containing the existing number of
* PDPARAMS entries already stored at addresses prior to pPdParams.
* The referenced variable will be incremented by the number of
* TAPI modems found and stored in the pPdParams array.
* EXIT
* Returns ERROR_SUCCESS if successful, error code if not.
*
*****************************************************************************/
DWORD
EnumerateTapiPorts( PPDPARAMS pPdParams,
ULONG Count,
ULONG **ppEntries )
{
LINEINITIALIZEEXPARAMS params;
LINEDEVCAPS *linedevcaps ;
LINEEXTENSIONID extensionid ;
HLINEAPP TapiLine = (HLINEAPP)0;
DWORD NegotiatedApiVersion ;
DWORD NegotiatedExtVersion = 0;
WORD i;
DWORD lines = 0 ;
BYTE buffer[1000] ;
CHAR szregkey[512];
WCHAR wszDeviceName[DEVICENAME_LENGTH+1];
WCHAR wszModemName[DEVICENAME_LENGTH+1];
CHAR szModemName[DEVICENAME_LENGTH+1];
LONG lerr;
DWORD Status = ERROR_TAPI_CONFIGURATION;
DWORD dwApiVersion = HIGH_VERSION;
BOOL fSuccess = FALSE;
ULONG RASIsUsingPort = 0;
HKEY CurKey, CurKey2;
DWORD KeyCount=0, KeySize, CurSize, DataType;
TCHAR szSubKey[255], CurRASDev[1024], szMainKey[255], *pCurRASDev;
/*
* Un-comment / edit the following line if time needed to allow newly
* added modem to appear in TAPI's enumeration list.
*/
// Sleep(4000L);
/*
* Initialize TAPI.
*/
memset(&params, 0, sizeof(params));
params.dwTotalSize = sizeof(params);
params.dwOptions = LINEINITIALIZEEXOPTION_USEEVENT;
if ( lerr = lineInitializeExA( &TapiLine,
GetModuleHandle( UTILDLL_NAME ),
(LINECALLBACK)DummyTapiCallback,
NULL,
&lines,
&dwApiVersion,
&params ) )
goto error;
/*
* Get configured TAPI modems on all lines.
*/
for ( i = 0; i < lines; i++ ) {
if ( lineNegotiateAPIVersion( TapiLine, i,
LOW_VERSION, HIGH_VERSION,
&NegotiatedApiVersion,
&extensionid ) ) {
continue ;
}
memset( buffer, 0, sizeof(buffer) );
linedevcaps = (LINEDEVCAPS *)buffer;
linedevcaps->dwTotalSize = sizeof(buffer);
/*
* Get this line's dev caps (ANSI).
*/
if ( lineGetDevCapsA( TapiLine, i,
NegotiatedApiVersion,
NegotiatedExtVersion,
linedevcaps ) ) {
continue ;
}
/*
li * Only process modems.
*/
if ( linedevcaps->dwMediaModes & LINEMEDIAMODE_DATAMODEM ) {
/*
* The linedevcaps stuff is in ASCII.
*/
DWORD j;
char *temp;
/*
* Convert all nulls in the device class string to non nulls.
*/
for ( j = 0, temp = (char *)((BYTE *)linedevcaps+linedevcaps->dwDeviceClassesOffset);
j < linedevcaps->dwDeviceClassesSize;
j++, temp++ ) {
if ( *temp == '\0' )
*temp = ' ';
}
/*
* Select only those devices that have comm/datamodem as a
* device class.
*/
if ( strstr( (char*)((BYTE *)linedevcaps+linedevcaps->dwDeviceClassesOffset),
"comm/datamodem" ) == NULL ) {
continue;
}
/*
* Fetch modem name (line name).
*/
strncpy( szModemName,
(char *)((BYTE *)linedevcaps+linedevcaps->dwLineNameOffset),
DEVICENAME_LENGTH );
szModemName[DEVICENAME_LENGTH] = '\0';
MultiByteToWideChar(CP_ACP, 0, szModemName, -1, wszModemName, DEVICENAME_LENGTH + 1);
/*
* The registry key name where the modem specific information is
* stored is at dwDevSpecificOffset + 2 * DWORDS
*
* The device specifc string is not unicode so copy that as
* an ansii string
*/
strncpy( szregkey,
(char *)linedevcaps+linedevcaps->dwDevSpecificOffset+(2*sizeof(DWORD)),
linedevcaps->dwDevSpecificSize );
szregkey[linedevcaps->dwDevSpecificSize] = '\0';
if ( !GetAssociatedPortName( szregkey, wszDeviceName ) ) {
goto error;
}
/*
* If RAS is installed and is using the port configured with this
* modem, we will return the modem, but the Parity field will be
* set to 1, indicating that RAS is using the port. This is done
* so that WinCfg (or other caller) can filter out the raw port
* (device name) as well as the TAPI modem from the list.
*/
RASIsUsingPort = 0;
//See if the RAS Key even exists
if (RegOpenKeyEx( HKEY_LOCAL_MACHINE, TEXT("SOFTWARE\\Microsoft\\RAS\\TAPI DEVICES"), 0, KEY_ALL_ACCESS, &CurKey) == ERROR_SUCCESS) {
KeySize = sizeof(szSubKey) / sizeof( TCHAR );
KeyCount = 0;
while (RegEnumKeyEx( CurKey,
KeyCount++,
szSubKey,
&KeySize,
NULL,
NULL,
NULL,
NULL
) != ERROR_NO_MORE_ITEMS) {
wcscpy(szMainKey,TEXT("SOFTWARE\\Microsoft\\RAS\\TAPI DEVICES"));
wcscat(szMainKey,TEXT("\\"));
wcscat(szMainKey,szSubKey);
if (RegOpenKeyEx( HKEY_LOCAL_MACHINE, szMainKey, 0, KEY_ALL_ACCESS, &CurKey2) == ERROR_SUCCESS) {
CurSize = sizeof(CurRASDev);
if (RegQueryValueEx(
CurKey2,
TEXT("Address"),
NULL,
&DataType,
(LPBYTE)CurRASDev,
&CurSize
) == ERROR_SUCCESS) {
for ( pCurRASDev = CurRASDev;
*pCurRASDev && !RASIsUsingPort; ) {
if ( lstrcmpi(pCurRASDev, wszDeviceName) == 0 )
RASIsUsingPort = 1;
else
pCurRASDev += (wcslen(pCurRASDev) + 1);
}
}
RegCloseKey(CurKey2);
}
KeySize = sizeof(szSubKey) / sizeof( TCHAR );
}
RegCloseKey(CurKey);
}
/*
* Save DeviceName and ModemName to PDPARAMS
* structure and bump counts. Also, set the BaudRate
* element to the TAPI line index so that the caller can
* determine the most recently added line, and set the Parity
* field to 0 if RAS is not using the line, 1 if RAS is
* using the line (so caller can filter properly).
*/
if ( Count > 0 ) {
pPdParams->SdClass = SdAsync;
lstrcpy( pPdParams->Async.DeviceName, wszDeviceName );
lstrcpy( pPdParams->Async.ModemName, wszModemName );
pPdParams->Async.BaudRate = (ULONG)i;
pPdParams->Async.Parity = RASIsUsingPort;
pPdParams++;
Count--;
(**ppEntries)++;
}
else {
Status = ERROR_INSUFFICIENT_BUFFER;
goto error;
}
}
}
Status = ERROR_SUCCESS;
error:
if ( TapiLine )
lineShutdown(TapiLine);
return( Status );
} // end EnumerateTapiPorts
/******************************************************************************
*
* DummyTapiCallback - local helper function
*
* A dummy callback routine to satisfy TAPI initialization.
*
* ENTRY
* (see TAPI lineInitialize documentation)
* EXIT
*
*****************************************************************************/
VOID CALLBACK
DummyTapiCallback (HANDLE context, DWORD msg, DWORD instance, DWORD param1, DWORD param2, DWORD param3)
{
} // end DummyTapiCallback
/******************************************************************************
*
* GetAssociatedPortName - local helper function
*
* Determine the 'attached to' (port) for the given modem via it's device
* specific registry key (szKeyName).
*
* ENTRY
* (see TAPI lineInitialize documentation)
* EXIT
*
*****************************************************************************/
#define VALNAME_ATTACHEDTO "AttachedTo"
BOOL
GetAssociatedPortName( char *szKeyName,
WCHAR * wszPortName )
{
HKEY hKeyModem;
DWORD dwType;
DWORD cbValueBuf;
char szPortName[DEVICENAME_LENGTH+1];
if ( RegOpenKeyExA( HKEY_LOCAL_MACHINE,
szKeyName,
0,
KEY_READ,
&hKeyModem ) ) {
return( FALSE );
}
cbValueBuf = sizeof( szPortName );
if ( RegQueryValueExA( hKeyModem,
VALNAME_ATTACHEDTO,
NULL,
&dwType,
(LPBYTE)&szPortName,
&cbValueBuf ) ) {
return ( FALSE );
}
RegCloseKey( hKeyModem );
MultiByteToWideChar(CP_ACP, 0, szPortName, -1, wszPortName, DEVICENAME_LENGTH + 1);
return( TRUE );
} // end GetAssociatedPortName
/*
* Defines and typedefs
*/
typedef struct _userlist {
struct _userlist *pNext;
WCHAR UserName[USERNAME_LENGTH+1];
} USERLIST, *PUSERLIST;
#define MAX_DOMAINANDNAME ((DOMAIN_LENGTH+1+USERNAME_LENGTH+1)*sizeof(WCHAR))
#define MAX_BUFFER (10*MAX_DOMAINANDNAME)
/*
* Local variables
*/
WCHAR *s_pszCompareList = NULL;
WCHAR s_szServer[256];
/*
* Local functions.
*/
WCHAR *_ctxCreateAnonymousUserCompareList();
/*******************************************************************************
*
* InitializeAnonymousUserCompareList - helper routine
*
* Creates a list of all local users who currently belong to the local
* Anonymous group on the specified server, and saves the server name.
*
* ENTRY:
* pszServer (input)
* Name of server to query users for.
*
******************************************************************************/
void WINAPI
InitializeAnonymousUserCompareList( const WCHAR *pszServer )
{
if ( s_pszCompareList )
free( s_pszCompareList );
wcscpy(s_szServer, pszServer);
s_pszCompareList = _ctxCreateAnonymousUserCompareList();
}
/*******************************************************************************
*
* HaveAnonymousUsersChanged - helper routine
*
* Using the saved server name, fetch current list of local users that
* belong to the local Anonymous group and compare with saved list.
*
* ENTRY:
* EXIT:
* On exit, the original compare list is freed and server name cleared.
*
******************************************************************************/
BOOL WINAPI
HaveAnonymousUsersChanged()
{
BOOL bChanged = FALSE;
WCHAR *pszNewCompareList, *pszOldName, *pszNewName;
if ( s_pszCompareList && *s_szServer ) {
if ( pszNewCompareList = _ctxCreateAnonymousUserCompareList() ) {
bChanged = TRUE;
for ( pszOldName = s_pszCompareList, pszNewName = pszNewCompareList;
(*pszOldName != L'\0') && (*pszNewName != L'\0'); ) {
if ( wcscmp(pszOldName, pszNewName) )
break;
pszOldName += (wcslen(pszOldName) + 1);
pszNewName += (wcslen(pszNewName) + 1);
}
if ( (*pszOldName == L'\0') && (*pszNewName == L'\0') )
bChanged = FALSE;
free(pszNewCompareList);
}
}
if ( s_pszCompareList )
free( s_pszCompareList );
s_pszCompareList = NULL;
memset(s_szServer, 0, sizeof(s_szServer));
return(bChanged);
}
/*******************************************************************************
*
* _ctxCreateAnonymousUserCompareList - local routine
*
* Routine to get local anonymous users and place in sorted string list.
*
* ENTRY:
* EXIT:
* pszCompareList - Returns pointer to buffer containing sorted string
* list of local anonymous users, double null terminated.
* NULL if error.
*
******************************************************************************/
WCHAR *
_ctxCreateAnonymousUserCompareList()
{
DWORD EntriesRead, EntriesLeft, ResumeHandle = 0;
NET_API_STATUS rc;
WCHAR DomainAndUsername[256], *pszCompareList = NULL;
DWORD i, TotalCharacters = 0;
LPWSTR p;
PLOCALGROUP_MEMBERS_INFO_3 plgrmi3 = NULL;
PUSERLIST pUserListBase = NULL, pNewUser;
/*
* Loop till all local anonymous users have been retrieved.
*/
do {
/*
* Get first batch
*/
if ( (rc = NetLocalGroupGetMembers( s_szServer,
PSZ_ANONYMOUS,
3,
(LPBYTE *)&plgrmi3,
MAX_BUFFER,
&EntriesRead,
&EntriesLeft,
(PDWORD_PTR)(&ResumeHandle) )) &&
(rc != ERROR_MORE_DATA ) ) {
break;
}
/*
* Process first batch
*/
for ( i = 0; i < EntriesRead; i++ ) {
/*
* Get DOMAIN/USERNAME
*/
wcscpy( DomainAndUsername, plgrmi3[i].lgrmi3_domainandname );
/*
* Check that DOMAIN is actually LOCAL MACHINE NAME
*/
if ( (p = wcsrchr( DomainAndUsername, L'\\' )) != NULL ) {
/*
* Make sure that this user belongs to specified
* server.
*/
*p = L'\0';
if ( _wcsicmp( DomainAndUsername, &s_szServer[2] ) ) {
continue;
}
}
/*
* Allocate list element and insert this username into list.
*/
if ( (pNewUser = (PUSERLIST)malloc(sizeof(USERLIST))) == NULL ) {
rc = ERROR_OUTOFMEMORY;
break;
}
pNewUser->pNext = NULL;
wcscpy(pNewUser->UserName, p+1);
TotalCharacters += wcslen(p+1) + 1;
if ( pUserListBase == NULL ) {
/*
* First item in list.
*/
pUserListBase = pNewUser;
}
else {
PUSERLIST pPrevUserList, pUserList;
pPrevUserList = pUserList = pUserListBase;
for ( ; ; ) {
if ( wcscmp(pNewUser->UserName, pUserList->UserName) < 0 ) {
if ( pPrevUserList == pUserListBase ) {
/*
* Insert at beginning of list.
*/
pUserListBase = pNewUser;
}
else {
/*
* Insert into middle or beginning of list.
*/
pPrevUserList->pNext = pNewUser;
}
/*
* Link to next.
*/
pNewUser->pNext = pUserList;
break;
}
else if ( pUserList->pNext == NULL ) {
/*
* Add to end of list.
*/
pUserList->pNext = pNewUser;
break;
}
pPrevUserList = pUserList;
pUserList = pUserList->pNext;
}
}
}
/*
* Free memory
*/
if ( plgrmi3 != NULL ) {
NetApiBufferFree( plgrmi3 );
}
} while ( rc == ERROR_MORE_DATA );
/*
* Allocate buffer for multi-string compare list if no error so far
* and terminate in case of empty list.
*/
if ( rc == ERROR_SUCCESS ) {
pszCompareList = (WCHAR *)malloc( (++TotalCharacters) * 2 );
if( pszCompareList != NULL )
{
*pszCompareList = L'\0';
}
}
/*
* Traverse and free username list, creating the multi-string compare
* list if buffer is available (no error so far).
*/
if ( pUserListBase ) {
PUSERLIST pUserList = pUserListBase,
pNext = NULL;
WCHAR *pBuffer = pszCompareList;
do {
pNext = pUserList->pNext;
if ( pBuffer ) {
wcscpy(pBuffer, pUserList->UserName);
pBuffer += (wcslen(pBuffer) + 1);
*pBuffer = L'\0'; // auto double-null terminate
}
free(pUserList);
pUserList = pNext;
} while ( pUserList );
}
return(pszCompareList);
}
/*******************************************************************************
*
* GetUserFromSid - Hydrix helper function
*
* Fetch the user name associated with the specified SID.
*
* ENTRY:
* pSid (input)
* Points to SID to match to user name.
* pUserName (output)
* Points to buffer to place the user name into.
* cbUserName (input)
* Specifies the size in bytes of the user name buffer. The returned
* user name will be truncated to fit this buffer (including NUL
* terminator) if necessary.
*
* EXIT:
*
* GetUserFromSid() will always return a user name. If the specified
* SID fails to match to a user name, then the user name "(unknown)" will
* be returned.
*
******************************************************************************/
void WINAPI
GetUserFromSid( PSID pSid,
LPTSTR pUserName,
DWORD cbUserName )
{
TCHAR DomainBuffer[DOMAIN_LENGTH], UserBuffer[USERNAME_LENGTH];
DWORD cbDomainBuffer=sizeof(DomainBuffer), cbUserBuffer=sizeof(UserBuffer),
Error;
LPTSTR pDomainBuffer = NULL, pUserBuffer = NULL;
SID_NAME_USE SidNameUse;
/*
* Fetch user name from SID: try user lookup with a reasonable Domain and
* Sid buffer size first, before resorting to alloc.
*/
if ( !LookupAccountSid( NULL, pSid,
UserBuffer, &cbUserBuffer,
DomainBuffer, &cbDomainBuffer, &SidNameUse ) ) {
if ( ((Error = GetLastError()) == ERROR_INSUFFICIENT_BUFFER) ) {
if ( cbDomainBuffer > sizeof(DomainBuffer) ) {
if ( !(pDomainBuffer =
(LPTSTR)LocalAlloc(
LPTR, cbDomainBuffer * sizeof(TCHAR))) ) {
Error = ERROR_NOT_ENOUGH_MEMORY;
goto BadDomainAlloc;
}
}
if ( cbUserBuffer > sizeof(UserBuffer) ) {
if ( !(pUserBuffer =
(LPTSTR)LocalAlloc(
LPTR, cbUserBuffer * sizeof(TCHAR))) ) {
Error = ERROR_NOT_ENOUGH_MEMORY;
goto BadUserAlloc;
}
}
if ( !LookupAccountSid( NULL, pSid,
pUserBuffer ?
pUserBuffer : UserBuffer,
&cbUserBuffer,
pDomainBuffer ?
pDomainBuffer : DomainBuffer,
&cbDomainBuffer,
&SidNameUse ) ) {
Error = GetLastError();
goto BadLookup;
}
}
else {
goto BadLookup;
}
}
/*
* Copy the user name into the specified buffer, truncating if necessary,
* and make lower case.
*/
lstrncpy( pUserName, pUserBuffer ? pUserBuffer : UserBuffer,
cbUserName - 1 );
pUserName[cbUserName-1] = TEXT('\0');
lstrlwr(pUserName);
/*
* Free our local allocs (if any) and return.
*/
if ( pDomainBuffer )
LocalFree(pDomainBuffer);
if ( pUserBuffer )
LocalFree(pUserBuffer);
return;
/*--------------------------------------
* Error clean-up and return...
*/
BadLookup:
BadUserAlloc:
BadDomainAlloc:
if ( pDomainBuffer )
LocalFree(pDomainBuffer);
if ( pUserBuffer )
LocalFree(pUserBuffer);
LoadString( GetModuleHandle( UTILDLL_NAME ),
IDS_UNKNOWN, pUserName, cbUserName - 1 );
pUserName[cbUserName-1] = TEXT('\0');
return;
} // end GetUserFromSid
/*******************************************************************************
*
* CachedGetUserFromSid - Hydrix helper function
*
* Provides entry point for a direct call to the UTILSUB.LIB
* GetUserNameFromSid, which performs its own caching of usernames.
*
* ENTRY:
* See UTILSUB.LIB GetUserNameFromSid (procutil.c)
* EXIT:
* See UTILSUB.LIB GetUserNameFromSid (procutil.c)
*
******************************************************************************/
void WINAPI
CachedGetUserFromSid( PSID pSid,
PWCHAR pUserName,
PULONG pcbUserName )
{
GetUserNameFromSid( pSid, pUserName, pcbUserName );
} // end CachedGetUserFromSid
/*****************************************************************************
*
* TestUserForAdmin - Hydrix helper function
*
* Returns whether the current thread is running under admin
* security.
*
* ENTRY:
* dom (input)
* TRUE/FALSE - whether we want DOMAIN admin (as compared to local admin)
*
* EXIT:
* TRUE/FALSE - whether user is specified admin
*
****************************************************************************/
BOOL WINAPI
TestUserForAdmin( BOOL dom )
{
BOOL IsMember, IsAnAdmin;
SID_IDENTIFIER_AUTHORITY SystemSidAuthority = SECURITY_NT_AUTHORITY;
PSID AdminSid;
if (RtlAllocateAndInitializeSid(
&SystemSidAuthority,
2,
SECURITY_BUILTIN_DOMAIN_RID,
DOMAIN_ALIAS_RID_ADMINS,
0, 0, 0, 0, 0, 0,
&AdminSid
) != STATUS_SUCCESS)
{
IsAnAdmin = FALSE;
}
else
{
if (!CheckTokenMembership( NULL,
AdminSid,
&IsMember))
{
RtlFreeSid(AdminSid);
IsAnAdmin = FALSE;
}
else
{
RtlFreeSid(AdminSid);
IsAnAdmin = IsMember;
}
}
return IsAnAdmin;
// UNUSED dom;
} // end of TestUserForAdmin
/*****************************************************************************
*
* IsPartOfDomain - Hydrix helper function
*
* Returns whether the current server participates in a domain.
*
* ENTRY:
*
* EXIT:
* TRUE or FALSE
*
****************************************************************************/
BOOL WINAPI
IsPartOfDomain(VOID)
{
NTSTATUS Status;
LSA_HANDLE PolicyHandle;
PPOLICY_ACCOUNT_DOMAIN_INFO DomainInfo;
OBJECT_ATTRIBUTES ObjAttributes;
BOOL IsDomainName = FALSE;
//
// Open a handle to the local security policy. Initialize the
// objects attributes structure first.
//
InitializeObjectAttributes( &ObjAttributes, NULL, 0, NULL, NULL );
Status = LsaOpenPolicy( NULL,
&ObjAttributes,
POLICY_VIEW_LOCAL_INFORMATION,
&PolicyHandle );
if ( !NT_SUCCESS(Status) )
goto done;
//
// Get the name of the primary domain from LSA
//
Status = LsaQueryInformationPolicy( PolicyHandle,
PolicyPrimaryDomainInformation,
(PVOID *)&DomainInfo );
(void) LsaClose( PolicyHandle );
if ( !NT_SUCCESS(Status) )
goto done;
if ( DomainInfo->DomainSid )
IsDomainName = TRUE;
(void) LsaFreeMemory( DomainInfo );
done:
return( IsDomainName );
} // end IsPartOfDomain
/*******************************************************************************
*
* StrSdClass - Hydrix helper function
*
* Returns pointer to string representing the specified SdClass.
*
* ENTRY:
* SdClass (input)
* The SDCLASS to associate with a string.
*
* EXIT:
* (LPCTSTR) Points to string representing the SDCLASS.
*
******************************************************************************/
LPTSTR SdClassStrings[9] = { NULL};
LPCTSTR WINAPI
StrSdClass( SDCLASS SdClass )
{
TCHAR buffer[256];
WORD wID = IDS_UNKNOWN_PROTOCOL;
switch ( SdClass ) {
case SdConsole:
wID = IDS_CONSOLE;
break;
case SdNetwork:
wID = IDS_NETWORK;
break;
case SdAsync:
wID = IDS_ASYNC;
break;
case SdFrame:
wID = IDS_FRAME;
break;
case SdReliable:
wID = IDS_RELIABLE;
break;
case SdCompress:
wID = IDS_COMPRESSION;
break;
case SdEncrypt:
wID = IDS_ENCRYPTION;
break;
case SdTelnet:
wID = IDS_TELNET;
break;
}
// If we haven't loaded the string yet, do it now
if (!SdClassStrings[wID - IDS_CONSOLE]) {
LoadString(GetModuleHandle( UTILDLL_NAME ),
wID, buffer, lengthof(buffer) );
SdClassStrings[wID - IDS_CONSOLE] = LocalAlloc(LPTR, 2*(wcslen(buffer)+1));
if(NULL == SdClassStrings[wID - IDS_CONSOLE])
{
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return NULL;
}
lstrcpy(SdClassStrings[wID - IDS_CONSOLE], buffer);
}
return(SdClassStrings[wID]);
} // end StrSdClass
/*******************************************************************************
*
* StrConnectState - Hydrix helper function
*
* Returns pointer to string representing the specified WinStation
* connection state.
*
* ENTRY:
* ConnectState (input)
* The WinStation connect state to associate with a string.
* bShortString (input)
* If TRUE, returns a short(er) version of the string (if there is
* one); FALSE returns the full spelling.
*
* EXIT:
* (LPCTSTR) Points to string representing the connect state.
*
* Note: The short version of the string may be the same as the long version.
* (i.e. "active") However, there are two string resources in case
* the long version of the string is not short in a language other
* than English.
******************************************************************************/
LPTSTR ConnectStateStrings[21] = { NULL};
LPCTSTR WINAPI
StrConnectState( WINSTATIONSTATECLASS ConnectState,
BOOL bShortString )
{
TCHAR buffer[256];
WORD wID = IDS_UNKNOWN;
switch ( ConnectState ) {
case State_Active:
wID = bShortString ? IDS_SHORT_ACTIVE : IDS_ACTIVE;
break;
case State_Connected:
wID = bShortString ? IDS_SHORT_CONNECTED : IDS_CONNECTED;
break;
case State_ConnectQuery:
wID = bShortString ? IDS_SHORT_CONNECT_QUERY : IDS_CONNECT_QUERY;
break;
case State_Shadow:
wID = bShortString ? IDS_SHORT_SHADOW : IDS_SHADOW;
break;
case State_Disconnected:
wID = bShortString ? IDS_SHORT_DISCONNECTED : IDS_DISCONNECTED;
break;
case State_Idle:
wID = bShortString ? IDS_SHORT_IDLE : IDS_IDLE;
break;
case State_Reset:
wID = bShortString ? IDS_SHORT_RESET : IDS_RESET;
break;
case State_Down:
wID = bShortString ? IDS_SHORT_DOWN : IDS_DOWN;
break;
case State_Init:
wID = bShortString ? IDS_SHORT_INIT : IDS_INIT;
break;
case State_Listen:
wID = bShortString ? IDS_SHORT_LISTEN : IDS_LISTEN;
break;
}
// If we haven't loaded the string yet, do it now
if (!ConnectStateStrings[wID - IDS_ACTIVE]) {
LoadString(GetModuleHandle( UTILDLL_NAME ),
wID, buffer, lengthof(buffer) );
ConnectStateStrings[wID - IDS_ACTIVE] = LocalAlloc(LPTR, 2*(wcslen(buffer)+1));
if(NULL == ConnectStateStrings[wID - IDS_ACTIVE])
{
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return NULL;
}
lstrcpy(ConnectStateStrings[wID - IDS_ACTIVE], buffer);
}
return(ConnectStateStrings[wID - IDS_ACTIVE]);
} // end StrConnectState
/*******************************************************************************
*
* StrProcessState - Hydrix helper function
*
* Returns pointer to string representing the specified process state.
*
* ENTRY:
* State (input)
* The process state to associate with a string.
*
* EXIT:
* (LPCTSTR) Points to string representing the process state.
*
******************************************************************************/
LPTSTR ProcessStateStrings[8] = { NULL};
WORD StateTable[] = {
IDS_INITED,
IDS_READY,
IDS_RUN,
IDS_STANDBY,
IDS_TERMINATE,
IDS_WAIT,
IDS_TRANSIT,
IDS_STATE_DASHES,
IDS_STATE_DASHES,
IDS_STATE_DASHES,
IDS_STATE_DASHES,
IDS_STATE_DASHES
};
LPCTSTR WINAPI
StrProcessState( ULONG State )
{
TCHAR buffer[256];
WORD wID = StateTable[State];
// If we haven't loaded the string yet, do it now
if (!ProcessStateStrings[wID - IDS_INITED]) {
LoadString(GetModuleHandle( UTILDLL_NAME ),
wID, buffer, lengthof(buffer) );
ProcessStateStrings[wID - IDS_INITED] = LocalAlloc(LPTR, 2*(wcslen(buffer)+1));
if(NULL == ProcessStateStrings[wID - IDS_INITED])
{
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return NULL;
}
lstrcpy(ProcessStateStrings[wID - IDS_INITED], buffer);
}
return(ProcessStateStrings[wID - IDS_INITED]);
} // end StrProcessState
/*******************************************************************************
*
* StrSystemWaitReason - Hydrix helper function
*
* Returns pointer to string representing the specified 'system'
* wait reason code.
*
* ENTRY:
* WaitReason (input)
* The system wait reason code to associate with a string.
*
* EXIT:
* (LPCTSTR) Points to string representing the system wait reason.
*
******************************************************************************/
LPTSTR SystemWaitStrings[31] = { NULL};
WORD SystemWaitReason[] = {
IDS_EXECUTIVE, // Executive
IDS_FREE_PAGE, // FreePage
IDS_PAGE_IN, // PageIn
IDS_POOL_ALLOC, // PoolAlloc
IDS_DELAY_EXECUTION, // DelayExecution
IDS_SUSPENDED, // Suspended
IDS_USER_REQUEST, // UserRequest
IDS_EXECUTIVE, // Executive
IDS_FREE_PAGE, // FreePage
IDS_PAGE_IN, // PageIn
IDS_POOL_ALLOC, // PoolAllocation
IDS_DELAY_EXECUTION, // DelayExecution
IDS_SUSPENDED, // Suspended
IDS_USER_REQUEST, // UserRequest
IDS_EVENT_PAIR_HIGH, // EventPairHigh
IDS_EVENT_PAIR_LOW, // EventPairLow
IDS_LPC_RECEIVE, // LpcReceive
IDS_LPC_REPLY, // LpcReply
IDS_VIRTUAL_MEMORY, // VirtualMemory
IDS_PAGE_OUT, // PageOut
IDS_WAIT1,
IDS_WAIT2,
IDS_WAIT3,
IDS_WAIT4,
IDS_WAIT5,
IDS_WAIT6,
IDS_WAIT7,
IDS_WAIT8,
IDS_WAIT9,
IDS_WAIT10
};
LPCTSTR WINAPI
StrSystemWaitReason( ULONG WaitReason )
{
TCHAR buffer[256];
WORD wID = SystemWaitReason[WaitReason];
// If we haven't loaded the string yet, do it now
if (!SystemWaitStrings[wID - IDS_EXECUTIVE]) {
LoadString(GetModuleHandle( UTILDLL_NAME ),
wID, buffer, lengthof(buffer) );
SystemWaitStrings[wID - IDS_EXECUTIVE] = LocalAlloc(LPTR, 2*(wcslen(buffer)+1));
if(NULL == SystemWaitStrings[wID - IDS_EXECUTIVE])
{
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return NULL;
}
wcscpy(SystemWaitStrings[wID - IDS_EXECUTIVE], buffer);
}
return(SystemWaitStrings[wID - IDS_EXECUTIVE]);
} // end StrSystemWaitReason
/*******************************************************************************
*
* StrAsyncConnectState - Hydrix helper function
*
* Returns pointer to string representing the specified async connect state.
*
* ENTRY:
* State (input)
* The async connect state to associate with a string.
*
* EXIT:
* (LPCTSTR) Points to string representing the async connect state.
*
******************************************************************************/
LPTSTR AsyncConnectStateStrings[6] = { NULL };
LPCTSTR WINAPI
StrAsyncConnectState( ASYNCCONNECTCLASS State )
{
TCHAR buffer[256];
WORD wID = State - Connect_CTS;
// If we haven't loaded the string yet, do it now
if (!AsyncConnectStateStrings[wID]) {
LoadString(GetModuleHandle( UTILDLL_NAME ),
wID + IDS_ASYNC_CONNECT_CTS, buffer, lengthof(buffer) );
AsyncConnectStateStrings[wID] = LocalAlloc(LPTR, 2*(wcslen(buffer)+1));
if(NULL == AsyncConnectStateStrings[wID])
{
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return NULL;
}
lstrcpy(AsyncConnectStateStrings[wID], buffer);
}
return(AsyncConnectStateStrings[wID]);
} // end StrProcessState
/*******************************************************************************
*
* GetUnknownString - Hydrix helper function
*
* Returns pointer to the string representing an unknown
* Connect State or DateTimeString (IDS_UNKNOWN)
* This is primarily so that WinAdmin can compare against it
*
* ENTRY:
* None
*
* EXIT:
* (LPCTSTR) Points to string representing the unknown string
*
******************************************************************************/
LPTSTR UnknownString = NULL;
LPCTSTR WINAPI
GetUnknownString()
{
TCHAR buffer[256];
// if we haven't loaded the string yet, do it now
if (!UnknownString) {
LoadString(GetModuleHandle( UTILDLL_NAME ),
IDS_UNKNOWN, buffer, lengthof(buffer) );
UnknownString = LocalAlloc(LPTR, 2*(wcslen(buffer)+1));
if(NULL == UnknownString)
{
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return NULL;
}
lstrcpy(UnknownString, buffer);
}
return(UnknownString);
} // end GetUnknownString
/*******************************************************************************
*
* CalculateElapsedTime - Hydrix helper function
*
* Determines the difference between a specified LARGE_INTEGER time value
* and the current system time, saves this 'elapsed time' into the
* specified ELAPSEDTIME structure.
*
* ENTRY:
* pTime (input)
* Points to LARGE_INTEGER of time for difference calculation.
* pElapsedTime (output)
* Points to ELAPSEDTIME structure to save elapsed time.
*
* EXIT:
*
******************************************************************************/
void WINAPI
CalculateElapsedTime( LARGE_INTEGER *pTime,
ELAPSEDTIME *pElapsedTime )
{
LARGE_INTEGER InputTime;
LARGE_INTEGER CurrentTime;
LARGE_INTEGER DiffTime;
SYSTEMTIME ltime;
ULONG d_time;
/*
* Fetch the current time and zero out the specified ELAPSEDTIME structure.
*/
GetLocalTime( &ltime );
memset( pElapsedTime, 0, sizeof(ELAPSEDTIME) );
if ( (pTime->HighPart == 0 && pTime->LowPart == 0 ) ||
!FileTimeToLocalFileTime( (FILETIME*)pTime, (FILETIME*)&InputTime ) ||
!SystemTimeToFileTime( &ltime, (FILETIME *)&CurrentTime ) )
return;
/*
* Get the number of seconds since specified time.
*/
DiffTime = CalculateDiffTime( InputTime, CurrentTime );
d_time = DiffTime.LowPart;
/*
* Calculate the days, hours, minutes, seconds since specified time.
*/
pElapsedTime->days = (USHORT)(d_time / 86400L); // days since
d_time = d_time % 86400L; // seconds => partial day
pElapsedTime->hours = (USHORT)(d_time / 3600L); // hours since
d_time = d_time % 3600L; // seconds => partial hour
pElapsedTime->minutes = (USHORT)(d_time / 60L); // minutes since
pElapsedTime->seconds = (USHORT)(d_time % 60L); // seconds remaining
} // end CalculateElapsedTime
/*******************************************************************************
*
* CompareElapsedTime - Hydrix helper function
*
* Determines the difference between two ELAPSEDTIME values.
*
* ENTRY:
* pElapsedTime1 (input)
* Points to first ELAPSEDTIME
* pElapsedTime2 (input)
* Points to ELAPSEDTIME structure to save elapsed time.
* bCompareSeconds (input)
* TRUE to include the seconds member in comparison; false otherwise.
*
* EXIT:
* < 1 if first time is less than second time
* 0 if times are the same
* > 1 if first time is greater than second time
*
******************************************************************************/
int WINAPI
CompareElapsedTime( ELAPSEDTIME *pElapsedTime1,
ELAPSEDTIME *pElapsedTime2,
BOOL bCompareSeconds )
{
int result;
if ( !(result = pElapsedTime1->days - pElapsedTime2->days) &&
!(result = pElapsedTime1->hours - pElapsedTime2->hours) &&
!(result = pElapsedTime1->minutes - pElapsedTime2->minutes) &&
(!bCompareSeconds ||
!(result = pElapsedTime1->seconds - pElapsedTime2->seconds) ) )
return(0);
else
return(result);
} // end CompareElapsedTime
/*******************************************************************************
*
* ElapsedTimeString - Hydrix helper function
*
* Converts the specified ELAPSEDTIME into a string of the form
* "ddd+hh:mm:ss" or, optionally "ddd+hh:mm" (suppress seconds).
*
* ENTRY:
* pElapsedTime (input)
* Points to ELAPSEDTIME structure to convert to string.
* bIncludeSeconds (input)
* If TRUE, will include seconds in string; FALSE will exclude.
* pString (output)
* Points to location to store elapsed time string.
* EXIT:
*
******************************************************************************/
void WINAPI
ElapsedTimeString( ELAPSEDTIME *pElapsedTime,
BOOL bIncludeSeconds,
LPTSTR pString )
{
if ( bIncludeSeconds ) {
if ( pElapsedTime->days > 0 )
wsprintf( pString, TEXT("%u+%02u:%02u:%02u"),
pElapsedTime->days,
pElapsedTime->hours,
pElapsedTime->minutes,
pElapsedTime->seconds );
else if ( pElapsedTime->hours > 0 )
wsprintf( pString, TEXT("%u:%02u:%02u"),
pElapsedTime->hours,
pElapsedTime->minutes,
pElapsedTime->seconds );
else if ( pElapsedTime->minutes > 0 )
wsprintf( pString, TEXT("%u:%02u"),
pElapsedTime->minutes,
pElapsedTime->seconds );
else if ( pElapsedTime->seconds > 0 )
wsprintf( pString, TEXT("%u"),
pElapsedTime->seconds );
else
wsprintf( pString, TEXT(".") );
}
else {
if ( pElapsedTime->days > 0 )
wsprintf( pString, TEXT("%u+%02u:%02u"),
pElapsedTime->days,
pElapsedTime->hours,
pElapsedTime->minutes );
else if ( pElapsedTime->hours > 0 )
wsprintf( pString, TEXT("%u:%02u"),
pElapsedTime->hours,
pElapsedTime->minutes );
else if ( pElapsedTime->minutes > 0 )
wsprintf( pString, TEXT("%u"),
pElapsedTime->minutes );
else
wsprintf( pString, TEXT(".") );
}
} // end ElapsedTimeString
/*******************************************************************************
*
* DateTimeString - Hydrix helper function
*
* Converts the specified LARGE_INTEGER time value into a date/time string
* of the form "mm/dd/yy hh:mm".
*
* ENTRY:
* pTime (input)
* Points to LARGE_INTEGER of time to convert to string.
* pString (output)
* Points string to store converted date/time into.
*
* EXIT:
*
******************************************************************************/
void WINAPI
DateTimeString( LARGE_INTEGER *pTime,
LPTSTR pString )
{
FILETIME LocalTime;
SYSTEMTIME stime;
LPTSTR lpTimeStr;
int nLen;
if ( FileTimeToLocalFileTime( (FILETIME *)pTime, &LocalTime ) &&
FileTimeToSystemTime( &LocalTime, &stime ) ) {
//Get Date Format
nLen = GetDateFormat(
LOCALE_USER_DEFAULT,
DATE_SHORTDATE,
&stime,
NULL,
NULL,
0);
lpTimeStr = (LPTSTR) GlobalAlloc(GPTR, (nLen + 1) * sizeof(TCHAR));
if(NULL == lpTimeStr)
{
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
wcscpy(pString, L"");
return;
}
nLen = GetDateFormat(
LOCALE_USER_DEFAULT,
DATE_SHORTDATE,
&stime,
NULL,
lpTimeStr,
nLen);
wcscpy(pString, lpTimeStr);
wcscat(pString, L" ");
GlobalFree(lpTimeStr);
//Get Time Format
nLen = GetTimeFormat(
LOCALE_USER_DEFAULT,
TIME_NOSECONDS,
&stime,
NULL,
NULL,
0);
lpTimeStr = (LPTSTR) GlobalAlloc(GPTR, (nLen + 1) * sizeof(TCHAR));
if(NULL == lpTimeStr)
{
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
wcscpy(pString, L"");
return;
}
nLen = GetTimeFormat(
LOCALE_USER_DEFAULT,
TIME_NOSECONDS,
&stime,
NULL,
lpTimeStr,
nLen);
wcscat(pString, lpTimeStr);
GlobalFree(lpTimeStr);
}
else
LoadString( GetModuleHandle( UTILDLL_NAME ),
IDS_UNKNOWN, pString, lengthof(pString) );
} // end DateTimeString
/*******************************************************************************
*
* CurrentDateTimeString - Hydrix helper function
*
* Converts the current system time into a date/time string of the form
* "mm/dd/yy hh:mm".
*
* ENTRY:
* pString (output)
* Points string to store converted date/time into.
* EXIT:
*
******************************************************************************/
void WINAPI
CurrentDateTimeString( LPTSTR pString )
{
SYSTEMTIME stime;
LPTSTR lpTimeStr;
int nLen;
GetLocalTime(&stime);
//Get DateFormat
nLen = GetDateFormat(
LOCALE_USER_DEFAULT,
DATE_SHORTDATE,
&stime,
NULL,
NULL,
0);
lpTimeStr = (LPTSTR) GlobalAlloc(GPTR, (nLen + 1) * sizeof(TCHAR));
if(NULL == lpTimeStr)
{
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
wcscpy(pString, L"");
return;
}
nLen = GetDateFormat(
LOCALE_USER_DEFAULT,
DATE_SHORTDATE,
&stime,
NULL,
lpTimeStr,
nLen);
wcscpy(pString, lpTimeStr);
wcscat(pString, L" ");
GlobalFree(lpTimeStr);
//Get Time Format
nLen = GetTimeFormat(
LOCALE_USER_DEFAULT,
TIME_NOSECONDS,
&stime,
NULL,
NULL,
0);
lpTimeStr = (LPTSTR) GlobalAlloc(GPTR, (nLen + 1) * sizeof(TCHAR));
if(NULL == lpTimeStr)
{
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
wcscpy(pString, L"");
return;
}
nLen = GetTimeFormat(
LOCALE_USER_DEFAULT,
TIME_NOSECONDS,
&stime,
NULL,
lpTimeStr,
nLen);
wcscat(pString, lpTimeStr);
GlobalFree(lpTimeStr);
} // end CurrentDateTimeString
/*******************************************************************************
*
* CalculateDiffTime - Hydrix helper function
*
* Calculate the time difference between two LARGE_INTEGER time values.
*
* ENTRY:
* FirstTime (input)
* The first (lower) time value.
* SecondTime (input)
* The second (higher) time value.
*
* EXIT:
* LARGE_INTEGER - the time difference
*
******************************************************************************/
LARGE_INTEGER WINAPI
CalculateDiffTime( LARGE_INTEGER FirstTime, LARGE_INTEGER SecondTime )
{
LARGE_INTEGER DiffTime;
DiffTime = RtlLargeIntegerSubtract( SecondTime, FirstTime );
DiffTime = RtlExtendedLargeIntegerDivide( DiffTime, 10000000, NULL );
return(DiffTime);
} // end CalculateDiffTime
/*******************************************************************************
*
* EnumerateMultiUserServers - Hydrix helper function
*
* Enumerate the Hydrix servers on the network by Domain
*
* ENTRY:
* pDomain (input)
* Specifies the domain to enumerate; NULL for current domain.
*
* EXIT:
* (LPTSTR) Points to LocalAlloced buffer containing results of the
* enumeration, in multi-string format, if sucessful; NULL if
* error. The caller must perform a LocalFree of this buffer
* when done. If error (NULL), the error code is set for
* retrieval by GetLastError();
*
******************************************************************************/
LPWSTR WINAPI
EnumerateMultiUserServers( LPWSTR pDomain )
{
PSERVER_INFO_101 pInfo = NULL;
DWORD dwByteCount, dwIndex, TotalEntries;
DWORD AvailCount = 0;
LPWSTR pTemp, pBuffer = NULL;
/*
* Enumerate all WF servers on the specified domain.
*/
if ( NetServerEnum ( NULL,
101,
(LPBYTE *)&pInfo,
(DWORD) -1,
&AvailCount,
&TotalEntries,
SV_TYPE_TERMINALSERVER,
pDomain,
NULL ) ||
!AvailCount )
goto done;
/*
* Traverse list and calculate the total byte count for list of
* servers that will be returned.
*/
for ( dwByteCount = dwIndex = 0; dwIndex < AvailCount; dwIndex++ ) {
dwByteCount += (wcslen(pInfo[dwIndex].sv101_name) + 1) * 2;
}
dwByteCount += 2; // for ending null
/*
* Allocate memory.
*/
if ( (pBuffer = LocalAlloc(LPTR, dwByteCount)) == NULL ) {
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
goto done;
}
/*
* Traverse list again and copy servers to buffer.
*/
for ( pTemp = pBuffer, dwIndex = 0; dwIndex < AvailCount; dwIndex++ ) {
wcscpy(pTemp, pInfo[dwIndex].sv101_name);
pTemp += (wcslen(pInfo[dwIndex].sv101_name) + 1);
}
*pTemp = L'\0'; // ending null
done:
if ( AvailCount && pInfo )
NetApiBufferFree( pInfo );
return(pBuffer);
} // end EnumerateMultiUserServers
/******************************************************************************
*
* _UserInGroup
* Internal function, determines if a user is a member of any of the
* groups passed in
*
* ENTRY:
* pwszUsername (IN) - Username to test group membership of
*
* pwszDomain (IN) - Domain of the user passed in
*
* pwszGroup (IN) - String array of all the allowed groups
*
* EXIT:
* Returns BOOLEAN value if user is a member of one of the groups
* HISTORY:
*
*
*****************************************************************************/
BOOL _UserInGroup( LPWSTR pwszUsername, LPWSTR pwszDomain, LPWSTR pwszGroup )
{
DWORD EntriesRead;
DWORD EntriesLeft;
NET_API_STATUS rc;
PGROUP_USERS_INFO_0 pszGroups;
ULONG i;
PWCHAR pwcUser;
WCHAR szBuf[MAX_PATH];
LPWKSTA_INFO_100 pWorkstationInfo = NULL;
WCHAR szDomainController[50];
#if DBG
DbgPrint( "MSGINA: UserInGroup: look(%S\\%S) group(%S)\n",
pwszDomain, pwszUsername, pwszGroup );
#endif
// This call will return the domain of the computer, not the domain of the user
if (( NetWkstaGetInfo( NULL,
100,
(LPBYTE *)&pWorkstationInfo )) == NERR_Success) {
if( !CtxGetAnyDCName( NULL,
pWorkstationInfo->wki100_langroup,
szDomainController ) ){
NetApiBufferFree((LPVOID)pWorkstationInfo);
return( FALSE );
}
}
else {
return (FALSE);
}
if ( wcscmp( pWorkstationInfo->wki100_langroup, pwszDomain ) != 0 ) {
// user is from a different domain than the machine (trusted domain)
// need to change username to reflect the domain
wcscpy( szBuf, pwszDomain );
wcscat( szBuf, L"\\" );
wcscat( szBuf, pwszUsername );
pwcUser = szBuf;
}
else {
pwcUser = pwszUsername;
}
rc = NetUserGetLocalGroups( szDomainController,
pwcUser,
0, // level
LG_INCLUDE_INDIRECT, // flags
(LPBYTE*)&pszGroups,
MAX_BUFFER,
&EntriesRead,
&EntriesLeft );
if( pWorkstationInfo != NULL )
NetApiBufferFree((LPVOID)pWorkstationInfo);
if ( rc != NERR_Success ) {
return( FALSE );
}
for ( i=0; i < EntriesRead; i++ ) {
if ( wcscmp( pszGroups[i].grui0_name, pwszGroup ) == 0 ) {
NetApiBufferFree( pszGroups );
pszGroups = NULL;
return( TRUE );
}
}
NetApiBufferFree( pszGroups );
pszGroups = NULL;
return(FALSE);
}
/******************************************************************************
*
* CtxGetAnyDCName
* Function to find a any DC of a specified domain. The call
* NetGetAnyDCName does not work as needed in all occasions.
* ie. Trusted domains and the current server being a DC.
*
* ENTRY:
* pServer (IN) - Server on which to run the call (RPC)
*
* pDomain (IN) - Domain you are inquring about, does not need to be
* current domain
*
* pBuffer (OUT) - Pointer to a string containg a DC name, buffer must
* be passed in.
* EXIT:
* BOOL Success
*
* HISTORY:
*
*
*****************************************************************************/
BOOL
CtxGetAnyDCName ( PWCHAR pServer, PWCHAR pDomain, PWCHAR pBuffer )
{
PWCHAR pDomainController = NULL;
PWCHAR pLocalDomainDC = NULL;
SERVER_INFO_101* ServerBuf = NULL;
BOOLEAN rc = TRUE;
BOOLEAN bFoundDC = FALSE;
// This call will return the domain of the computer, not the domain of the user
if (( NetGetAnyDCName(NULL,
pDomain,
(LPBYTE *)&pDomainController)) != NERR_Success) {
//
// NetGetAnyDCName doesn't work in two situations
// 1. If the domain is a trusted domain, it must be run from a DC. So we find our local
// DC and have it run getanydcname for us.
// 2. If we are a DC it will fail. So a second check is made to see
// if in fact we are a DC or not
//
// find a local DC in which to RPC to
if( NetGetAnyDCName( NULL,
NULL,
(LPBYTE *) &pLocalDomainDC ) == NERR_Success ) {
// Make the call as an RPC and pass it the Domain name
if( NetGetAnyDCName( pLocalDomainDC,
pDomain,
(LPBYTE *) &pDomainController ) == NERR_Success){
bFoundDC = TRUE;
}
}
// if it wasn't a trusted domain, maybe we are a domain controller
if( !bFoundDC ) {
if( NetServerGetInfo( NULL,
101,
(LPBYTE*)&ServerBuf ) == NERR_Success ) {
if( ServerBuf->sv101_type & (SV_TYPE_DOMAIN_CTRL | SV_TYPE_DOMAIN_BAKCTRL) ) {
pDomainController = NULL;
}
else {
rc = FALSE;
goto done;
}
}
else {
rc = FALSE;
goto done;
}
}
}
if( pDomainController )
wcscpy( pBuffer, pDomainController);
else
*pBuffer = '\0';
done:
if( pLocalDomainDC )
NetApiBufferFree( pLocalDomainDC );
if( pDomainController )
NetApiBufferFree( pDomainController );
if( ServerBuf )
NetApiBufferFree( ServerBuf );
return( rc );
}