/*****************************************************************************
*
* OsUtil.c
*
* Copyright (c) 1996 Microsoft Corporation. All Rights Reserved.
*
* Abstract:
* Various OS dependent utility functions
*
* Contents:
*
* History:
*
* vlads 11/05/1996 created
*****************************************************************************/
/*
#include <windows.h>
#include <windowsx.h>
#include <objbase.h>
#include <regstr.h>
#include <setupapi.h>
#include <cfgmgr32.h>
#include <devguid.h>
#include <stdio.h>
#include <stilog.h>
#include <stiregi.h>
#include <sti.h>
#include <stierr.h>
#include <stiusd.h>
#include "wia.h"
#include "stipriv.h"
#include "stiapi.h"
#include "stirc.h"
#include "debug.h"
*/
#include "sticomm.h"
#define DbgFl DbgFlUtil
BOOL WINAPI
OSUtil_IsPlatformUnicode()
{
OSVERSIONINFOA ver;
BOOL bReturn = FALSE;
ZeroX(ver);
ver.dwOSVersionInfoSize = sizeof(OSVERSIONINFOA);
// Just always call the ANSI function
if(!GetVersionExA(&ver)) {
DebugOutPtszV(DbgFl, TEXT("Unable to determinte platform -- setting flag to ANSI"));
bReturn = FALSE;
}
else {
switch(ver.dwPlatformId) {
case VER_PLATFORM_WIN32_WINDOWS:
bReturn = FALSE;
break;
case VER_PLATFORM_WIN32_NT:
bReturn = TRUE;
break;
default:
bReturn = FALSE;
break;
}
}
// Keep the compiler happy
return bReturn;
} // endproc OSUtil_IsUnicodePlatform
HRESULT WINAPI
OSUtil_GetAnsiString(
LPSTR * ppszAnsi,
LPCWSTR lpszWide
)
{
HRESULT hres;
int cbStrLen;
if (!lpszWide) {
*ppszAnsi = NULL;
return S_OK;
}
// We can use WideToChar to figure out exact resultant width
cbStrLen = 2*(OSUtil_StrLenW(lpszWide)+1);
hres = AllocCbPpv(cbStrLen, ppszAnsi);
if (!*ppszAnsi) {
DebugOutPtszV(DbgFl, TEXT("could not get ansi string -- out of memory"));
return E_OUTOFMEMORY;
}
UToA(*ppszAnsi,cbStrLen,lpszWide);
return S_OK;
} // OSUtil_GetAnsiString
HRESULT WINAPI
OSUtil_GetWideString(
LPWSTR *ppszWide,
LPCSTR pszAnsi
)
{
HRESULT hres;
int cbStrLen;
if (!pszAnsi) {
*ppszWide = NULL;
return S_OK;
}
// We can use WideToChar to figure out exact resultant width
cbStrLen = 2*(lstrlenA(pszAnsi)+1);
hres = AllocCbPpv(cbStrLen, (PPV)ppszWide);
if (!*ppszWide) {
DebugOutPtszV(DbgFl,TEXT("Could not get unicode string -- out of memory"));
return E_OUTOFMEMORY;
}
AToU(*ppszWide,cbStrLen,pszAnsi);
return S_OK;
} // OSUtil_GetWideString
HINSTANCE
OSUtil_LoadLibraryW(
LPCWSTR lpszWFileName
)
{
HINSTANCE hinstRet = NULL;
if (g_NoUnicodePlatform) {
CHAR *pFileNameA = NULL;
if ( SUCCEEDED(OSUtil_GetAnsiString(&pFileNameA,lpszWFileName))) {
hinstRet = LoadLibraryA(pFileNameA);
FreePpv(&pFileNameA);
}
else {
DebugOutPtszV(DbgFl,TEXT("Failed in LoadLibraryW"));
}
}
else {
hinstRet = LoadLibraryW(lpszWFileName);
}
return hinstRet;
} // OSUtil_LoadLibrary
/*
// There seems to be no getproc addressW
FARPROC
WINAPI
OSUtil_GetProcAddress(HMODULE hModule,LPCTSTR lpProcName)
{
#ifndef UNICODE
return GetProcAddress(hModule,lpProcNameW);
#else
FARPROC pProcAddr = NULL;
CHAR *pProcNameA = NULL;
if ( SUCCEEDED(OSUtil_GetAnsiString(&pProcNameA,lpProcName))) {
pProcAddr = GetProcAddress(hModule,pProcNameA);
FreePpv(&pProcNameA);
}
else {
DebugOutPtszV(DbgFl,TEXT("Failed in GetProcAddress "));
}
return pProcAddr;
#endif
} // OSUtil_GetProcAddress
*/
LONG
WINAPI
OSUtil_RegOpenKeyExW(
HKEY hKey,
LPCWSTR lpszKeyStrW,
DWORD dwReserved,
REGSAM samDesired,
PHKEY phkResult)
{
LONG lRet = 0L;
if (g_NoUnicodePlatform) {
CHAR *lpszKeyStrA = NULL;
if ( SUCCEEDED(OSUtil_GetAnsiString(&lpszKeyStrA,lpszKeyStrW))) {
lRet = RegOpenKeyExA(hKey,lpszKeyStrA,dwReserved,samDesired,phkResult);
FreePpv(&lpszKeyStrA);
}
else {
DebugOutPtszV(DbgFl,TEXT("Failed in RegOpenKeyExW"));
lRet = ERROR_INVALID_PARAMETER;
}
}
else {
lRet = RegOpenKeyExW(hKey,lpszKeyStrW,dwReserved,samDesired,phkResult);
}
return (lRet);
}
LONG WINAPI
OSUtil_RegDeleteValueW(
HKEY hKey,
LPWSTR lpszValueNameW
)
{
long lRet = NOERROR;
if (g_NoUnicodePlatform) {
CHAR *lpszValueNameA = NULL;
if ( SUCCEEDED(OSUtil_GetAnsiString(&lpszValueNameA,lpszValueNameW))) {
lRet = RegDeleteValueA(hKey, lpszValueNameA);
FreePpv(&lpszValueNameA);
}
else {
DebugOutPtszV(DbgFl,TEXT("Failed in RegDeleteValueKeyW"));
lRet = ERROR_INVALID_PARAMETER;
}
}
else {
lRet = RegDeleteValueW(hKey, lpszValueNameW);
}
return lRet;
}
LONG
WINAPI
OSUtil_RegCreateKeyExW(
HKEY hKey,
LPWSTR lpszSubKeyW, DWORD dwReserved, LPWSTR lpszClassW,
DWORD dwOptions,
REGSAM samDesired, LPSECURITY_ATTRIBUTES lpSecurityAttributes,
PHKEY phkResult,
LPDWORD lpdwDisposition
)
{
LPSTR lpszSubKeyA = NULL;
LPSTR lpszClassA = NULL;
long lRet = NOERROR;
if (g_NoUnicodePlatform) {
if ( SUCCEEDED(OSUtil_GetAnsiString(&lpszClassA,lpszClassW)) &&
SUCCEEDED(OSUtil_GetAnsiString(&lpszSubKeyA,lpszSubKeyW))) {
lRet = RegCreateKeyExA(hKey, lpszSubKeyA, dwReserved, lpszClassA, dwOptions,
samDesired, lpSecurityAttributes, phkResult, lpdwDisposition);
FreePpv(&lpszSubKeyA);
FreePpv(&lpszClassA);
}
else {
DebugOutPtszV(DbgFl,TEXT("Failed in RegCreateKeyExW"));
lRet = ERROR_INVALID_PARAMETER;
}
}
else {
lRet = RegCreateKeyExW(hKey, lpszSubKeyW, dwReserved, lpszClassW, dwOptions,
samDesired, lpSecurityAttributes, phkResult, lpdwDisposition);
}
return lRet;
}
LONG WINAPI
OSUtil_RegQueryValueExW(
HKEY hKey,
LPCWSTR lpszValueNameW,
DWORD *pdwType,
BYTE* lpData,
DWORD *pcbData,
BOOL fUnicodeCaller // =FALSE
)
{
long lRet = NOERROR;
DWORD cbDataGiven = *pcbData ;
if (g_NoUnicodePlatform || !fUnicodeCaller) {
CHAR *lpszValueNameA = NULL;
if ( SUCCEEDED(OSUtil_GetAnsiString(&lpszValueNameA,lpszValueNameW))) {
lRet = RegQueryValueExA( hKey,
lpszValueNameA,
NULL,
pdwType,
lpData,
pcbData );
FreePpv(&lpszValueNameA);
#if 1
//
// The string came back as ANSI but we need UNICODE. Conversion in place
// is not allowed, so do it with second buffer
//
if ( fUnicodeCaller && (NOERROR == lRet) && (*pdwType == REG_SZ)) {
LPWSTR pwszWideData = NULL;
DWORD dwNewSize = *pcbData * sizeof(WCHAR);
HRESULT hres;
if (cbDataGiven >= dwNewSize ) {
hres = OSUtil_GetWideString(&pwszWideData,lpData);
if (SUCCEEDED(hres) && pwszWideData) {
memcpy(lpData,pwszWideData,dwNewSize);
FreePpv(&pwszWideData);
}
else {
lRet = GetLastError();
}
}
else {
lRet = ERROR_MORE_DATA;
}
*pcbData *= sizeof(WCHAR);
}
#endif
}
else {
DebugOutPtszV(DbgFl,TEXT("Failed in RegDeleteValueKeyW"));
lRet = ERROR_INVALID_PARAMETER;
}
}
else {
lRet = RegQueryValueExW( hKey,
lpszValueNameW,
NULL,
pdwType,
lpData,
pcbData );
}
return lRet;
}
LONG WINAPI
OSUtil_RegSetValueExW(
HKEY hKey,
LPCWSTR lpszValueNameW,
DWORD dwType,
BYTE* lpData,
DWORD cbData,
BOOL fUnicodeCaller // =FALSE
)
{
long lRet = NOERROR;
if (g_NoUnicodePlatform || !fUnicodeCaller) {
CHAR *lpszValueNameA = NULL;
if ( SUCCEEDED(OSUtil_GetAnsiString(&lpszValueNameA,lpszValueNameW))) {
lRet = RegSetValueExA(hKey,
lpszValueNameA,
0,
dwType,
lpData,
cbData);
FreePpv(&lpszValueNameA);
}
else {
DebugOutPtszV(DbgFl,TEXT("Failed in RegDeleteValueKeyW"));
lRet = ERROR_INVALID_PARAMETER;
}
}
else {
lRet = RegSetValueExW( hKey,
(LPVOID)lpszValueNameW,
0,
dwType,
lpData,
cbData);
}
return lRet;
}
DWORD ReadRegistryDwordW( HKEY hkey,
LPCWSTR pszValueNameW,
DWORD dwDefaultValue )
{
DWORD err = NOERROR;
DWORD dwBuffer = 0;
DWORD cbBuffer = sizeof(dwBuffer);
DWORD dwType;
if( hkey != NULL ) {
if (g_NoUnicodePlatform) {
CHAR *pszValueNameA = NULL;
dwType = REG_DWORD;
if ( SUCCEEDED(OSUtil_GetAnsiString(&pszValueNameA,pszValueNameW))) {
err = RegQueryValueExA( hkey,
pszValueNameA,
NULL,
&dwType,
(LPBYTE)&dwBuffer,
&cbBuffer );
FreePpv(&pszValueNameA);
}
else {
DebugOutPtszV(DbgFl,TEXT("Failed in ReadRegistryDwordW "));
err = ERROR_INVALID_PARAMETER;
}
} else {
err = RegQueryValueExW( hkey,
pszValueNameW,
NULL,
&dwType,
(LPBYTE)&dwBuffer,
&cbBuffer );
}
if( ( err == NO_ERROR ) &&
( ( dwType == REG_DWORD ) || ( dwType == REG_BINARY ) )
) {
dwDefaultValue = dwBuffer;
}
}
return dwDefaultValue;
} // ReadRegistryDwordW()
DWORD
WriteRegistryDwordW(
IN HKEY hkey,
IN LPCWSTR pszValueNameW,
IN DWORD dwValue)
{
DWORD err = NOERROR;
if ( hkey == NULL || pszValueNameW == NULL) {
err = ( ERROR_INVALID_PARAMETER);
} else {
if (g_NoUnicodePlatform) {
CHAR *pszValueNameA = NULL;
if ( SUCCEEDED(OSUtil_GetAnsiString(&pszValueNameA,pszValueNameW))) {
err = RegSetValueExA( hkey,pszValueNameA,0,REG_DWORD,(LPBYTE ) &dwValue,sizeof( dwValue));
FreePpv(&pszValueNameA);
}
else {
DebugOutPtszV(DbgFl,TEXT("Failed in ReadRegistryDwordW "));
err = ERROR_INVALID_PARAMETER;
}
}
else {
err = RegSetValueExW( hkey,(LPVOID)pszValueNameW,0,REG_DWORD,(LPBYTE ) &dwValue,sizeof( dwValue));
}
}
return ( err);
} // WriteRegistryDwordW()
DWORD
WriteRegistryStringA(
IN HKEY hkey,
IN LPCSTR pszValueName,
IN LPCSTR pszValue,
IN DWORD cbValue,
IN DWORD fdwType)
{
DWORD err = NOERROR;
if ( hkey == NULL ||
pszValueName == NULL ||
cbValue == 0 ) {
err = ERROR_INVALID_PARAMETER;
} else {
err = RegSetValueExA(
hkey,
pszValueName,
0,
fdwType,
(LPBYTE ) pszValue,
cbValue); // + 1 for null character
}
return ( err);
} // WriteRegistryStringA()
DWORD
WriteRegistryStringW(
IN HKEY hkey,
IN LPCWSTR pszValueNameW,
IN LPCWSTR pszValueW,
IN DWORD cbValue,
IN DWORD fdwType)
{
DWORD err = NOERROR;
DWORD le;
if ( hkey == NULL ||
pszValueNameW == NULL ||
cbValue == 0 ) {
err = ERROR_INVALID_PARAMETER;
} else {
if (g_NoUnicodePlatform) {
err = ERROR_INVALID_PARAMETER;
if ( (fdwType == REG_SZ) || (fdwType == REG_EXPAND_SZ)) {
LPSTR lpszAnsi = NULL;
LPSTR lpszAnsiName = NULL;
if ( SUCCEEDED(OSUtil_GetAnsiString(&lpszAnsi,pszValueW)) &&
SUCCEEDED(OSUtil_GetAnsiString(&lpszAnsiName,pszValueNameW))
) {
err = WriteRegistryStringA(hkey,
lpszAnsiName,
lpszAnsi,
(lstrlenA(lpszAnsi)+1)*sizeof(CHAR),
fdwType);
}
FreePpv(&lpszAnsi);
FreePpv(&lpszAnsiName);
}
else {
ValidateF(FALSE,("Wrong registry value type in WriteRegistryStringW"));
err = ERROR_INVALID_PARAMETER;
}
}
else {
err = RegSetValueExW(
hkey,
pszValueNameW,
0,
fdwType,
(LPBYTE ) pszValueW,
cbValue);
le = GetLastError();
}
}
return ( err);
} // WriteRegistryStringW()
HRESULT
ReadRegistryStringA(
HKEY hkey,
LPCWSTR pszValueNameW,
LPCWSTR pszDefaultValueW,
BOOL fExpand,
LPWSTR * ppwszResult
)
{
WCHAR * pszBuffer1 = NULL;
WCHAR * pszBuffer2 = NULL;
DWORD cbBuffer;
DWORD dwType;
DWORD err = NOERROR;
CHAR *pszValueNameA = NULL;
if (!ppwszResult) {
return STIERR_INVALID_PARAM;
}
*ppwszResult = NULL;
if ( !SUCCEEDED(OSUtil_GetAnsiString(&pszValueNameA,pszValueNameW))) {
return STIERR_INVALID_PARAM;
}
//
// Determine the buffer size.
//
pszBuffer1 = NULL;
pszBuffer2 = NULL;
cbBuffer = 0;
if( hkey == NULL ) {
//
// Pretend the key wasn't found.
//
err = ERROR_FILE_NOT_FOUND;
}
else {
err = RegQueryValueExA( hkey,
pszValueNameA,
NULL,
&dwType,
NULL,
&cbBuffer );
if( ( err == NO_ERROR ) || ( err == ERROR_MORE_DATA ) ) {
if( ( dwType != REG_SZ ) &&
( dwType != REG_MULTI_SZ ) &&
( dwType != REG_EXPAND_SZ ) ) {
//
// Type mismatch, registry data NOT a string.
// Use default.
//
err = ERROR_FILE_NOT_FOUND;
}
else {
//
// Item found, allocate a buffer.
//
if (!SUCCEEDED(AllocCbPpv(2*cbBuffer+sizeof(WCHAR),&pszBuffer1)) ){
err = GetLastError();
}
else {
//
// Now read the value into the buffer.
//
//if (g_NoUnicodePlatform) {
DWORD dwType;
err = RegQueryValueExA( hkey,
pszValueNameA,
NULL,
&dwType,
(LPBYTE)pszBuffer1,
&cbBuffer );
//
// The string came back as ANSI but we need UNICODE. Conversion in place
// is not allowed, so do it with second buffer
//
if (SUCCEEDED(AllocCbPpv(2*cbBuffer+sizeof(WCHAR),&pszBuffer2))){
AToU(pszBuffer2,cbBuffer,(LPSTR)pszBuffer1);
memcpy(pszBuffer1,pszBuffer2,2*cbBuffer+sizeof(WCHAR));
FreePpv(&pszBuffer2);
//
// Truncate returned string to MAX_REG_CHAR characters
// (only for REG_SZ)
//
if ((dwType == REG_SZ) && (cbBuffer >= MAX_REG_CHAR)) {
pszBuffer1[MAX_REG_CHAR] = L'\0';
}
}
//}
}
}
}
}
FreePpv(&pszValueNameA);
//if( err == ERROR_FILE_NOT_FOUND ) {
if( err != NOERROR ) {
//
// Item not found, use empty string (L"") as value
//
err = NO_ERROR;
if( pszDefaultValueW != NULL ) {
if (!SUCCEEDED(AllocCbPpv((OSUtil_StrLenW(L"") + 1) * sizeof(WCHAR),&pszBuffer1))) {
err = GetLastError();
}
else {
OSUtil_lstrcpyW( pszBuffer1, L"" );
}
}
}
if( err != NO_ERROR )
{
//
// Tragic error reading registry, abort now.
//
goto ErrorCleanup;
}
//
// pszBuffer1 holds the registry value. Now expand
// the environment strings if necessary.
//
if( !fExpand ) {
*ppwszResult = pszBuffer1;
return S_OK;
}
#if 0
// Does not work on Win95 ?
//
// Returns number of characters
//
cbBuffer = ExpandEnvironmentStrings( pszBuffer1,
NULL,
0 );
if (!SUCCEEDED(OSUtil_GetAnsiString(&pszBuffer2, (cbBuffer+1)*sizeof(TCHAR) ))){
goto ErrorCleanup;
}
if( ExpandEnvironmentStrings( pszBuffer1,
pszBuffer2,
cbBuffer ) > cbBuffer ) {
goto ErrorCleanup;
}
//
// pszBuffer2 now contains the registry value with
// environment strings expanded.
//
FreePpv(&pszBuffer1);
return pszBuffer2;
#endif
ErrorCleanup:
//
// Something tragic happend; free any allocated buffers
// and return NULL to the caller, indicating failure.
//
FreePpv(&pszValueNameA);
FreePpv(&pszBuffer1);
FreePpv(&pszBuffer2);
return HRESULT_FROM_WIN32(err);
}
HRESULT
ReadRegistryStringW(
HKEY hkey,
LPCWSTR pszValueNameW,
LPCWSTR pszDefaultValueW,
BOOL fExpand,
LPWSTR * ppwszResult
)
{
WCHAR * pszBuffer1 = NULL;
DWORD cbBuffer;
DWORD dwType;
DWORD err = NOERROR;
if (!ppwszResult) {
return STIERR_INVALID_PARAM;
}
*ppwszResult = NULL;
//
// Determine the buffer size.
//
pszBuffer1 = NULL;
cbBuffer = 0;
if( hkey == NULL ) {
//
// Pretend the key wasn't found.
//
err = ERROR_FILE_NOT_FOUND;
}
else {
err = RegQueryValueExW( hkey,
pszValueNameW,
NULL,
&dwType,
NULL,
&cbBuffer );
if( ( err == NO_ERROR ) || ( err == ERROR_MORE_DATA ) ) {
if( ( dwType != REG_SZ ) &&
( dwType != REG_MULTI_SZ ) &&
( dwType != REG_EXPAND_SZ ) ) {
//
// Type mismatch, registry data NOT a string.
// Use default.
//
err = ERROR_FILE_NOT_FOUND;
}
else {
//
// Item found, allocate a buffer.
//
if (!SUCCEEDED(AllocCbPpv(cbBuffer+sizeof(WCHAR),&pszBuffer1)) ){
err = GetLastError();
}
else {
//
// Now read the value into the buffer.
//
DWORD dwType;
err = RegQueryValueExW( hkey,
pszValueNameW,
NULL,
&dwType,
(LPBYTE)pszBuffer1,
&cbBuffer );
}
}
}
}
if( err != NOERROR ) {
//
// Item not found, use empty string (L"") as value
//
err = NO_ERROR;
if( pszDefaultValueW != NULL ) {
if (!SUCCEEDED(AllocCbPpv((OSUtil_StrLenW(L"") + 1) * sizeof(WCHAR),&pszBuffer1))) {
err = GetLastError();
}
else {
OSUtil_lstrcpyW( pszBuffer1, L"" );
}
}
}
if( err != NO_ERROR )
{
//
// Tragic error reading registry, abort now.
//
goto ErrorCleanup;
}
//
// pszBuffer1 holds the registry value. Now expand
// the environment strings if necessary.
//
if( !fExpand ) {
*ppwszResult = pszBuffer1;
return S_OK;
}
ErrorCleanup:
//
// Something tragic happend; free any allocated buffers
// and return NULL to the caller, indicating failure.
//
FreePpv(&pszBuffer1);
return HRESULT_FROM_WIN32(err);
}
HANDLE
WINAPI
OSUtil_CreateFileW(
LPCWSTR lpszFileNameW,
DWORD dwDesiredAccess,
DWORD dwShareMode,
LPSECURITY_ATTRIBUTES lpSecurityAttributes,
DWORD dwCreationDisposition,
DWORD dwFlagsAndAttributes,
HANDLE hTemplateFile
)
{
HANDLE hRet = INVALID_HANDLE_VALUE;
if (g_NoUnicodePlatform) {
CHAR *pFileNameA = NULL;
if ( SUCCEEDED(OSUtil_GetAnsiString(&pFileNameA,lpszFileNameW))) {
hRet = CreateFileA(pFileNameA,
dwDesiredAccess,dwShareMode,lpSecurityAttributes,dwCreationDisposition,
dwFlagsAndAttributes,hTemplateFile);
FreePpv(&pFileNameA);
}
else {
DebugOutPtszV(DbgFl,TEXT("Failed in LoadLibraryW"));
hRet = INVALID_HANDLE_VALUE;
}
}
else {
hRet = CreateFileW(lpszFileNameW,
dwDesiredAccess,dwShareMode,lpSecurityAttributes,dwCreationDisposition,
dwFlagsAndAttributes,hTemplateFile);
}
return hRet;
} // OSUtil_LoadLibrary
HRESULT
WINAPI
ExtractCommandLineArgumentW(
LPCSTR lpszSwitchName,
LPWSTR pwszSwitchValue
)
{
HRESULT hres;
LPSTR lpszCommandLine;
LPSTR lpszSwitch;
LPSTR pszT;
DWORD cch;
lpszCommandLine = GetCommandLineA();
if (!lpszCommandLine || !*lpszCommandLine) {
return STIERR_GENERIC;
}
if (!pwszSwitchValue) {
return STIERR_GENERIC;
}
// Search for switch with given name
lpszSwitch = strstr(lpszCommandLine,lpszSwitchName);
if (!lpszSwitch ) {
return STIERR_GENERIC;
}
lpszSwitch += lstrlenA(lpszSwitchName);
if (*lpszSwitch != ':') {
return STIERR_GENERIC;
}
lpszSwitch=CharNextA(lpszSwitch);
// Skip till space
pszT = lpszSwitch;
while (*pszT && *pszT > ' ') {
pszT = CharNextA(pszT);
}
cch = MultiByteToWideChar(CP_ACP, 0,
lpszSwitch, (INT)(pszT-lpszSwitch),
pwszSwitchValue,STI_MAX_INTERNAL_NAME_LENGTH
);
pwszSwitchValue[cch] = L'\0';
hres = (cch) ? STI_OK : HRESULT_FROM_WIN32(GetLastError());
return hres;
}
HRESULT
WINAPI
ExtractCommandLineArgumentA(
LPCSTR lpszSwitchName,
LPSTR pszSwitchValue
)
{
HRESULT hres;
LPSTR lpszCommandLine;
LPSTR lpszSwitch;
LPSTR pszT;
DWORD cch;
lpszCommandLine = GetCommandLineA();
if (!lpszCommandLine || !*lpszCommandLine) {
return STIERR_GENERIC;
}
if (!pszSwitchValue) {
return STIERR_GENERIC;
}
// Search for switch with given name
lpszSwitch = strstr(lpszCommandLine,lpszSwitchName);
if (!lpszSwitch ) {
return STIERR_GENERIC;
}
lpszSwitch += lstrlenA(lpszSwitchName);
if (*lpszSwitch != ':') {
return STIERR_GENERIC;
}
lpszSwitch=CharNextA(lpszSwitch);
// Skip till space
pszT = lpszSwitch;
while (*pszT && *pszT > ' ') {
pszT = CharNextA(pszT);
}
cch = min((INT)(pszT-lpszSwitch),STI_MAX_INTERNAL_NAME_LENGTH);
memcpy(pszSwitchValue,lpszSwitch,cch);
pszSwitchValue[cch] = L'\0';
hres = (cch) ? STI_OK : STIERR_INVALID_PARAM;
return hres;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @func HRESULT | DupEventHandle |
*
* Duplicate an event handle intra-process-ly. If the incoming
* handle is NULL, then so is the output handle (and the call
* succeeds).
*
* @parm HANDLE | h |
*
* Source handle.
*
* @parm LPHANDLE | phOut |
*
* Receives output handle.
*
*****************************************************************************/
HRESULT EXTERNAL
DupEventHandle(HANDLE h, LPHANDLE phOut)
{
HRESULT hres;
EnterProc(DupEventHandle, (_ "p", h));
if (h) {
HANDLE hProcessMe = GetCurrentProcess();
if (DuplicateHandle(hProcessMe, h, hProcessMe, phOut,
EVENT_MODIFY_STATE, 0, 0)) {
hres = S_OK;
} else {
hres = hresLe(GetLastError());
}
} else {
*phOut = h;
hres = S_OK;
}
ExitOleProc();
return hres;
}
void
WINAPI
StiLogTrace(
DWORD dwMessageType,
DWORD idMessage,
...
)
{
va_list list;
va_start (list, idMessage);
if(g_hStiFileLog) {
TCHAR *pchBuff = NULL;
DWORD cch;
HMODULE hm;
DWORD dwError;
pchBuff = NULL;
hm = GetModuleHandleA("STI.dll") ;
cch = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_MAX_WIDTH_MASK |
FORMAT_MESSAGE_FROM_HMODULE,
hm,
idMessage,
0,
(LPTSTR) &pchBuff,
1024,
(va_list *)&list
);
dwError = GetLastError();
if (cch && pchBuff) {
ReportStiLogMessage(g_hStiFileLog,
dwMessageType,
pchBuff);
}
if (pchBuff) {
LocalFree(pchBuff);
}
}
va_end(list);
}