//////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 1999 Microsoft Corporation
//
// Module Name:
//
// utils.c
//
// Abstract:
//
// utils functions
//
// Revision History:
//
// Thierry Perraut 04/07/1999
//
//////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include <netsh.h>
#include "aaaamontr.h"
#include "strdefs.h"
#include "rmstring.h"
#include "aaaamon.h"
#include "context.h"
#include <rtutils.h>
#include "utils.h"
#include "base64tool.h"
const WCHAR c_szCurrentBuildNumber[] = L"CurrentBuildNumber";
const WCHAR c_szWinVersionPath[] =
L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion";
const WCHAR c_szAssignFmt[] = L"%s = %s";
const WCHAR pszAAAAEngineParamStub[] =
L"SYSTEM\\CurrentControlSet\\Services\\AAAAEngine\\Parameters\\";
AAAA_ALLOC_FN RutlAlloc;
AAAA_DWORDDUP_FN RutlDwordDup;
AAAA_CREATE_DUMP_FILE_FN RutlCreateDumpFile;
AAAA_CLOSE_DUMP_FILE_FN RutlCloseDumpFile;
AAAA_ASSIGN_FROM_TOKENS_FN RutlAssignmentFromTokens;
AAAA_STRDUP_FN RutlStrDup;
AAAA_FREE_FN RutlFree;
AAAA_GET_OS_VERSION_FN RutlGetOsVersion;
AAAA_GET_TAG_TOKEN_FN RutlGetTagToken;
AAAA_IS_HELP_TOKEN_FN RutlIsHelpToken;
//////////////////////////////////////////////////////////////////////////////
// RutlGetTagToken
//
// Routine Description:
//
// Identifies each argument based on its tag. It assumes that each argument
// has a tag. It also removes tag= from each argument.
//
// Arguments:
//
// ppwcArguments - The argument array. Each argument has tag=value form
// dwCurrentIndex - ppwcArguments[dwCurrentIndex] is first arg.
// dwArgCount - ppwcArguments[dwArgCount - 1] is last arg.
// pttTagToken - Array of tag token ids that are allowed in the args
// dwNumTags - Size of pttTagToken
// pdwOut - Array identifying the type of each argument.
//
// Return Value:
//
// NO_ERROR, ERROR_INVALID_PARAMETER, ERROR_INVALID_OPTION_TAG
//
//////////////////////////////////////////////////////////////////////////////
DWORD
WINAPI
RutlGetTagToken(
IN HANDLE hModule,
IN PWCHAR *ppwcArguments,
IN DWORD dwCurrentIndex,
IN DWORD dwArgCount,
IN PTAG_TYPE pttTagToken,
IN DWORD dwNumTags,
OUT PDWORD pdwOut
)
{
PWCHAR pwcTag,pwcTagVal,pwszArg = NULL;
//
// This function assumes that every argument has a tag
// It goes ahead and removes the tag.
//
for ( DWORD i = dwCurrentIndex; i < dwArgCount; ++i )
{
DWORD len = wcslen(ppwcArguments[i]);
if ( !len )
{
//
// something wrong with arg
//
pdwOut[i] = static_cast<DWORD> (-1);
continue;
}
pwszArg = static_cast<unsigned short *>(RutlAlloc(
(len + 1) * sizeof(WCHAR),
FALSE));
if ( !pwszArg )
{
DisplayError(NULL, ERROR_NOT_ENOUGH_MEMORY);
return ERROR_NOT_ENOUGH_MEMORY;
}
wcscpy(pwszArg, ppwcArguments[i]);
pwcTag = wcstok(pwszArg, NETSH_ARG_DELIMITER);
//
// Got the first part
// Now if next call returns NULL then there was no tag
//
pwcTagVal = wcstok((PWCHAR)NULL, NETSH_ARG_DELIMITER);
if ( !pwcTagVal )
{
DisplayMessage(g_hModule,
ERROR_NO_TAG,
ppwcArguments[i]);
RutlFree(pwszArg);
return ERROR_INVALID_PARAMETER;
}
//
// Got the tag. Now try to match it
//
BOOL bFound = FALSE;
pdwOut[i - dwCurrentIndex] = (DWORD) -1;
for ( DWORD j = 0; j < dwNumTags; ++j )
{
if ( MatchToken(pwcTag, pttTagToken[j].pwszTag) )
{
//
// Tag matched
//
bFound = TRUE;
pdwOut[i - dwCurrentIndex] = j;
break;
}
}
if ( bFound )
{
//
// Remove tag from the argument
//
wcscpy(ppwcArguments[i], pwcTagVal);
}
else
{
DisplayError(NULL,
ERROR_INVALID_OPTION_TAG,
pwcTag);
RutlFree(pwszArg);
return ERROR_INVALID_OPTION_TAG;
}
RutlFree(pwszArg);
}
return NO_ERROR;
}
//////////////////////////////////////////////////////////////////////////////
// RutlCreateDumpFile
//////////////////////////////////////////////////////////////////////////////
DWORD
WINAPI
RutlCreateDumpFile(
IN PWCHAR pwszName,
OUT PHANDLE phFile
)
{
HANDLE hFile;
*phFile = NULL;
// Create/open the file
hFile = CreateFileW(pwszName,
GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_DELETE,
NULL,
OPEN_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
NULL);
if ( hFile == INVALID_HANDLE_VALUE )
{
return GetLastError();
}
// Go to the end of the file
SetFilePointer(hFile, 0, NULL, FILE_END);
*phFile = hFile;
return NO_ERROR;
}
//////////////////////////////////////////////////////////////////////////////
// RutlCloseDumpFile
//////////////////////////////////////////////////////////////////////////////
VOID
WINAPI
RutlCloseDumpFile(HANDLE hFile)
{
CloseHandle(hFile);
}
//////////////////////////////////////////////////////////////////////////////
//
// RutlAlloc
//
// Returns an allocated block of memory conditionally
// zeroed of the given size.
//
//////////////////////////////////////////////////////////////////////////////
PVOID
WINAPI
RutlAlloc(
IN DWORD dwBytes,
IN BOOL bZero
)
{
DWORD dwFlags = 0;
if ( bZero )
{
dwFlags |= HEAP_ZERO_MEMORY;
}
return HeapAlloc(GetProcessHeap(), dwFlags, dwBytes);
}
//////////////////////////////////////////////////////////////////////////////
//
// RutlFree
//
// Conditionally free's a pointer if it is non-null
//
//////////////////////////////////////////////////////////////////////////////
VOID
WINAPI
RutlFree(
IN PVOID pvData
)
{
HeapFree(GetProcessHeap(), 0, pvData);
}
//////////////////////////////////////////////////////////////////////////////
//
// RutlStrDup
//
// Uses RutlAlloc to copy a string
//
//////////////////////////////////////////////////////////////////////////////
PWCHAR
WINAPI
RutlStrDup(
IN PWCHAR pwszSrc
)
{
PWCHAR pszRet = NULL;
DWORD dwLen;
if (( !pwszSrc ) || ((dwLen = wcslen(pwszSrc)) == 0))
{
return NULL;
}
pszRet = static_cast<PWCHAR>(RutlAlloc((dwLen + 1) * sizeof(WCHAR),FALSE));
if ( pszRet )
{
wcscpy(pszRet, pwszSrc);
}
return pszRet;
}
//////////////////////////////////////////////////////////////////////////////
// RutlDwordDup
//
// Uses RutlAlloc to copy a dword
//
//////////////////////////////////////////////////////////////////////////////
LPDWORD
WINAPI
RutlDwordDup(
IN DWORD dwSrc
)
{
LPDWORD lpdwRet = NULL;
lpdwRet = static_cast<LPDWORD>(RutlAlloc(sizeof(DWORD), FALSE));
if ( lpdwRet )
{
*lpdwRet = dwSrc;
}
return lpdwRet;
}
//////////////////////////////////////////////////////////////////////////////
//
// RutlGetOsVersion
//
// Returns the build number of operating system
//
//////////////////////////////////////////////////////////////////////////////
DWORD
WINAPI
RutlGetOsVersion(
IN PWCHAR pwszRouter,
OUT LPDWORD lpdwVersion)
{
DWORD dwErr, dwType = REG_SZ, dwLength;
HKEY hkMachine = NULL, hkVersion = NULL;
WCHAR pszBuildNumber[64];
PWCHAR pszMachine = pwszRouter;
//
// Validate and initialize
//
if ( !lpdwVersion )
{
return ERROR_INVALID_PARAMETER;
}
*lpdwVersion = FALSE;
do
{
//
// Connect to the remote server
//
dwErr = RegConnectRegistry(
pszMachine,
HKEY_LOCAL_MACHINE,
&hkMachine);
if ( dwErr != ERROR_SUCCESS )
{
break;
}
//
// Open the windows version key
//
dwErr = RegOpenKeyEx(
hkMachine,
c_szWinVersionPath,
0,
KEY_QUERY_VALUE,
&hkVersion
);
if ( dwErr != NO_ERROR )
{
break;
}
//
// Read in the current version key
//
dwLength = sizeof(pszBuildNumber);
dwErr = RegQueryValueEx (
hkVersion,
c_szCurrentBuildNumber,
NULL,
&dwType,
(BYTE*)pszBuildNumber,
&dwLength
);
if ( dwErr != NO_ERROR )
{
break;
}
*lpdwVersion = static_cast<DWORD>(wcstol(pszBuildNumber, NULL, 10));
} while (FALSE);
// Cleanup
if ( hkVersion )
{
RegCloseKey( hkVersion );
}
if ( hkMachine )
{
RegCloseKey( hkMachine );
}
return dwErr;
}
//////////////////////////////////////////////////////////////////////////////
//
// RutlParseOptions
//
// Routine Description:
//
// Based on an array of tag types returns which options are
// included in the given command line.
//
// Arguments:
//
// ppwcArguments - Argument array
// dwCurrentIndex - ppwcArguments[dwCurrentIndex] is the first arg
// dwArgCount - ppwcArguments[dwArgCount - 1] is the last arg
//
// Return Value:
//
// NO_ERROR
//
//////////////////////////////////////////////////////////////////////////////
DWORD
WINAPI
RutlParseOptions(
IN PWCHAR* ppwcArguments,
IN DWORD dwCurrentIndex,
IN DWORD dwArgCount,
IN DWORD dwNumArgs,
IN TAG_TYPE* rgTags,
IN DWORD dwTagCount,
OUT LPDWORD* ppdwTagTypes
)
{
LPDWORD pdwTagType;
DWORD i, dwErr = NO_ERROR;
// If there are no arguments, there's nothing to to
//
if ( !dwNumArgs )
{
return NO_ERROR;
}
// Set up the table of present options
pdwTagType = static_cast<LPDWORD>(RutlAlloc(
dwArgCount * sizeof(DWORD),
TRUE
));
if( !pdwTagType )
{
DisplayError(NULL, ERROR_NOT_ENOUGH_MEMORY);
return ERROR_NOT_ENOUGH_MEMORY;
}
do {
//
// The argument has a tag. Assume all of them have tags
//
if( wcsstr(ppwcArguments[dwCurrentIndex], NETSH_ARG_DELIMITER) )
{
dwErr = RutlGetTagToken(
g_hModule,
ppwcArguments,
dwCurrentIndex,
dwArgCount,
rgTags,
dwTagCount,
pdwTagType);
if( dwErr != NO_ERROR )
{
if( dwErr == ERROR_INVALID_OPTION_TAG )
{
dwErr = ERROR_INVALID_SYNTAX;
break;
}
}
}
else
{
//
// No tags - all args must be in order
//
for( i = 0; i < dwNumArgs; ++i )
{
pdwTagType[i] = i;
}
}
} while (FALSE);
// Cleanup
{
if ( dwErr == NO_ERROR )
{
*ppdwTagTypes = pdwTagType;
}
else
{
RutlFree(pdwTagType);
}
}
return dwErr;
}
//////////////////////////////////////////////////////////////////////////////
//
// RutlIsHelpToken
//
//////////////////////////////////////////////////////////////////////////////
BOOL
WINAPI
RutlIsHelpToken(PWCHAR pwszToken)
{
if( MatchToken(pwszToken, CMD_AAAA_HELP1) )
{
return TRUE;
}
if( MatchToken(pwszToken, CMD_AAAA_HELP2) )
{
return TRUE;
}
return FALSE;
}
//////////////////////////////////////////////////////////////////////////////
//
// RutlAssignmentFromTokens
//
//////////////////////////////////////////////////////////////////////////////
PWCHAR
WINAPI
RutlAssignmentFromTokens(
IN HINSTANCE hModule,
IN PWCHAR pwszToken,
IN PWCHAR pszString
)
{
PWCHAR pszRet = NULL, pszCmd = NULL;
DWORD dwErr = NO_ERROR, dwSize;
do
{
pszCmd = pwszToken;
// Compute the string lenghth needed
//
dwSize = wcslen(pszString) +
wcslen(pszCmd) +
wcslen(c_szAssignFmt) +
1;
dwSize *= sizeof(WCHAR);
// Allocate the return value
pszRet = (PWCHAR) RutlAlloc(dwSize, FALSE);
if (pszRet == NULL)
{
dwErr = ERROR_NOT_ENOUGH_MEMORY;
break;
}
// Copy in the command assignment
_snwprintf(
pszRet,
dwSize,
c_szAssignFmt,
pszCmd,
pszString
);
} while ( FALSE );
// Cleanup
{
if ( dwErr != NO_ERROR )
{
if ( pszRet )
{
RutlFree(pszRet);
}
pszRet = NULL;
}
}
return pszRet;
}
//////////////////////////////////////////////////////////////////////////////
//
// RutlRegReadDword
//
//////////////////////////////////////////////////////////////////////////////
DWORD
RutlRegReadDword(
IN HKEY hKey,
IN PWCHAR pszValName,
OUT LPDWORD lpdwValue
)
{
DWORD dwSize = sizeof(DWORD), dwType = REG_DWORD, dwErr;
dwErr = RegQueryValueExW(
hKey,
pszValName,
NULL,
&dwType,
(LPBYTE)lpdwValue,
&dwSize);
if ( dwErr == ERROR_FILE_NOT_FOUND )
{
dwErr = NO_ERROR;
}
return dwErr;
}
//////////////////////////////////////////////////////////////////////////////
//
// RutlRegReadString
//
//////////////////////////////////////////////////////////////////////////////
DWORD
RutlRegReadString(
IN HKEY hKey,
IN PWCHAR pszValName,
OUT PWCHAR* ppszValue
)
{
DWORD dwErr = NO_ERROR, dwSize = 0;
*ppszValue = NULL;
// Findout how big the buffer should be
//
dwErr = RegQueryValueExW(
hKey,
pszValName,
NULL,
NULL,
NULL,
&dwSize);
if ( dwErr == ERROR_FILE_NOT_FOUND )
{
return NO_ERROR;
}
if ( dwErr != ERROR_SUCCESS )
{
return dwErr;
}
// Allocate the string
//
*ppszValue = (PWCHAR) RutlAlloc(dwSize, TRUE);
if ( ! *ppszValue )
{
return ERROR_NOT_ENOUGH_MEMORY;
}
// Read the value in and return
//
dwErr = RegQueryValueExW(
hKey,
pszValName,
NULL,
NULL,
(LPBYTE)*ppszValue,
&dwSize);
return dwErr;
}
//////////////////////////////////////////////////////////////////////////////
//
// RutlRegReadString
//
//////////////////////////////////////////////////////////////////////////////
DWORD
RutlRegWriteDword(
IN HKEY hKey,
IN PWCHAR pszValName,
IN DWORD dwValue
)
{
return RegSetValueExW(
hKey,
pszValName,
0,
REG_DWORD,
(LPBYTE)&dwValue,
sizeof(DWORD));
}
//////////////////////////////////////////////////////////////////////////////
//
// RutlRegWriteString
//
//////////////////////////////////////////////////////////////////////////////
DWORD
RutlRegWriteString(
IN HKEY hKey,
IN PWCHAR pszValName,
IN PWCHAR pszValue
)
{
return RegSetValueExW(
hKey,
pszValName,
0,
REG_SZ,
(LPBYTE)pszValue,
(wcslen(pszValue) + 1) * sizeof(WCHAR));
}
//////////////////////////////////////////////////////////////////////////////
//RutlParse
//
// Generic parse
//
//////////////////////////////////////////////////////////////////////////////
DWORD
RutlParse(
IN PWCHAR* ppwcArguments,
IN DWORD dwCurrentIndex,
IN DWORD dwArgCount,
IN BOOL* pbDone,
OUT AAAAMON_CMD_ARG* pAaaaArgs,
IN DWORD dwAaaaArgCount
)
{
DWORD i, dwNumArgs, dwErr, dwLevel = 0;
LPDWORD pdwTagType = NULL;
TAG_TYPE* pTags = NULL;
AAAAMON_CMD_ARG* pArg = NULL;
if ( !dwAaaaArgCount )
{
return ERROR_INVALID_PARAMETER;
}
do
{
// Initialize
dwNumArgs = dwArgCount - dwCurrentIndex;
// Generate a list of the tags
//
pTags = (TAG_TYPE*)
RutlAlloc(dwAaaaArgCount * sizeof(TAG_TYPE), TRUE);
if ( !pTags )
{
dwErr = ERROR_NOT_ENOUGH_MEMORY;
break;
}
for ( i = 0; i < dwAaaaArgCount; ++i )
{
CopyMemory(&pTags[i], &pAaaaArgs[i].rgTag, sizeof(TAG_TYPE));
}
// Get the list of present options
//
dwErr = RutlParseOptions(
ppwcArguments,
dwCurrentIndex,
dwArgCount,
dwNumArgs,
pTags,
dwAaaaArgCount,
&pdwTagType);
if ( dwErr != NO_ERROR )
{
break;
}
// Copy the tag info back
//
for ( i = 0; i < dwAaaaArgCount; ++i )
{
CopyMemory(&pAaaaArgs[i].rgTag, &pTags[i], sizeof(TAG_TYPE));
}
for( i = 0; i < dwNumArgs; ++i )
{
// Validate the current argument
//
if ( pdwTagType[i] >= dwAaaaArgCount )
{
i = dwNumArgs;
dwErr = ERROR_INVALID_SYNTAX;
break;
}
pArg = &pAaaaArgs[pdwTagType[i]];
// Get the value of the argument
//
switch ( pArg->dwType )
{
case AAAAMONTR_CMD_TYPE_STRING:
{
pArg->Val.pszValue =
RutlStrDup(ppwcArguments[i + dwCurrentIndex]);
break;
}
case AAAAMONTR_CMD_TYPE_ENUM:
{
dwErr = MatchEnumTag(g_hModule,
ppwcArguments[i + dwCurrentIndex],
pArg->dwEnumCount,
pArg->rgEnums,
&(pArg->Val.dwValue));
if(dwErr != NO_ERROR)
{
RutlDispTokenErrMsg(
g_hModule,
EMSG_BAD_OPTION_VALUE,
pArg->rgTag.pwszTag,
ppwcArguments[i + dwCurrentIndex]);
i = dwNumArgs;
dwErr = ERROR_INVALID_PARAMETER;
}
break;
}
}
if ( dwErr != NO_ERROR )
{
break;
}
// Mark the argument as present if needed
//
if ( pArg->rgTag.bPresent )
{
dwErr = ERROR_TAG_ALREADY_PRESENT;
i = dwNumArgs;
break;
}
pArg->rgTag.bPresent = TRUE;
}
if( dwErr != NO_ERROR )
{
break;
}
// Make sure that all of the required parameters have
// been included.
//
for ( i = 0; i < dwAaaaArgCount; ++i )
{
if ( (pAaaaArgs[i].rgTag.dwRequired & NS_REQ_PRESENT)
&& !pAaaaArgs[i].rgTag.bPresent )
{
DisplayMessage(g_hModule, EMSG_CANT_FIND_EOPT);
dwErr = ERROR_INVALID_SYNTAX;
break;
}
}
if ( dwErr != NO_ERROR )
{
break;
}
} while (FALSE);
// Cleanup
{
if ( pTags )
{
RutlFree(pTags);
}
if ( pdwTagType )
{
RutlFree(pdwTagType);
}
}
return dwErr;
}
//////////////////////////////////////////////////////////////////////////////
// RefreshIASService
//
// Send a control 128 (refresh)to IAS
//
//////////////////////////////////////////////////////////////////////////////
HRESULT RefreshIASService()
{
SC_HANDLE hManager = OpenSCManager(
NULL,
SERVICES_ACTIVE_DATABASE,
SC_MANAGER_CONNECT |
SC_MANAGER_ENUMERATE_SERVICE |
SC_MANAGER_QUERY_LOCK_STATUS
);
if ( !hManager )
{
return E_FAIL;
}
SC_HANDLE hService = OpenServiceW(
hManager,
L"IAS",
SERVICE_USER_DEFINED_CONTROL |
SERVICE_QUERY_STATUS
);
if ( !hService )
{
CloseServiceHandle(hManager);
return E_FAIL;
}
SERVICE_STATUS ServiceStatus;
BOOL bResultOk = QueryServiceStatus(
hService,
&ServiceStatus
);
HRESULT hres;
if ( bResultOk )
{
if ( (SERVICE_STOPPED == ServiceStatus.dwCurrentState) ||
(SERVICE_STOP_PENDING == ServiceStatus.dwCurrentState))
{
//////////////////////////////////////////////////
// service not running = nothing to do to refresh
//////////////////////////////////////////////////
hres = S_OK;
}
else
{
/////////////////////////////////////////////////////
// the service is running thus send the refresh code
/////////////////////////////////////////////////////
BOOL bControlOk = ControlService(
hService,
128,
&ServiceStatus
);
if ( bControlOk == FALSE )
{
hres = E_FAIL;
}
else
{
hres = S_OK;
}
}
}
else
{
hres = E_FAIL;
}
//////////
// clean
//////////
CloseServiceHandle(hService);
CloseServiceHandle(hManager);
// hres is always defined here.
return hres;
}