misc.c File Reference

#include "setupapi_private.h"
#include <winver.h>
#include <lzexpand.h>

Include dependency graph for misc.c:

Go to the source code of this file.

Classes
struct	callback_context

Functions
DWORD	GetFunctionPointer (IN PWSTR InstallerName, OUT HMODULE *ModulePointer, OUT PVOID *FunctionPointer)
DWORD	FreeFunctionPointer (IN HMODULE ModulePointer, IN PVOID FunctionPointer)
VOID WINAPI	MyFree (LPVOID lpMem)
LPVOID WINAPI	MyMalloc (DWORD dwSize)
LPVOID WINAPI	MyRealloc (LPVOID lpSrc, DWORD dwSize)
LPWSTR WINAPI	pSetupDuplicateString (LPCWSTR lpSrc)
LONG WINAPI	QueryRegistryValue (HKEY hKey, LPCWSTR lpValueName, LPBYTE *lpData, LPDWORD lpType, LPDWORD lpcbData)
LPWSTR WINAPI	pSetupMultiByteToUnicode (LPCSTR lpMultiByteStr, UINT uCodePage)
LPSTR WINAPI	pSetupUnicodeToMultiByte (LPCWSTR lpUnicodeStr, UINT uCodePage)
BOOL WINAPI	DoesUserHavePrivilege (LPCWSTR lpPrivilegeName)
BOOL WINAPI	pSetupEnablePrivilege (LPCWSTR lpPrivilegeName, BOOL bEnable)
BOOL WINAPI	DelayedMove (LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName)
BOOL WINAPI	FileExists (LPCWSTR lpFileName, LPWIN32_FIND_DATAW lpFileFindData)
DWORD WINAPI	CaptureStringArg (LPCWSTR pSrc, LPWSTR *pDst)
DWORD WINAPI	pSetupCaptureAndConvertAnsiArg (LPCSTR pSrc, LPWSTR *pDst)
DWORD WINAPI	pSetupOpenAndMapFileForRead (LPCWSTR lpFileName, LPDWORD lpSize, LPHANDLE lpFile, LPHANDLE lpMapping, LPVOID *lpBuffer)
BOOL WINAPI	pSetupUnmapAndCloseFile (HANDLE hFile, HANDLE hMapping, LPVOID lpBuffer)
DWORD WINAPI	StampFileSecurity (LPCWSTR lpFileName, PSECURITY_DESCRIPTOR pSecurityDescriptor)
DWORD WINAPI	TakeOwnershipOfFile (LPCWSTR lpFileName)
DWORD WINAPI	RetreiveFileSecurity (LPCWSTR lpFileName, PSECURITY_DESCRIPTOR *pSecurityDescriptor)
DWORD WINAPI	pSetupGetGlobalFlags (void)
void WINAPI	pSetupModifyGlobalFlags (DWORD mask, DWORD flags)
void WINAPI	pSetupSetGlobalFlags (DWORD flags)
BOOL WINAPI	SetupGetNonInteractiveMode (VOID)
BOOL WINAPI	SetupSetNonInteractiveMode (BOOL NonInteractiveFlag)
VOID WINAPI	AssertFail (LPSTR lpFile, UINT uLine, LPSTR lpMessage)
DWORD WINAPI	GetSetFileTimestamp (LPCWSTR lpFileName, LPFILETIME lpCreationTime, LPFILETIME lpLastAccessTime, LPFILETIME lpLastWriteTime, BOOLEAN bSetFileTime)
LPWSTR WINAPI	pSetupGetFileTitle (LPCWSTR lpFileName)
BOOL WINAPI	pSetupConcatenatePaths (LPWSTR lpPath, LPCWSTR lpAppend, DWORD dwBufferSize, LPDWORD lpRequiredSize)
VOID WINAPI	pSetupCenterWindowRelativeToParent (HWND hwnd)
BOOL WINAPI	pSetupGetVersionInfoFromImage (LPWSTR lpFileName, PULARGE_INTEGER lpFileVersion, LPWORD lpVersionVarSize)
BOOL WINAPI	SetupUninstallOEMInfW (PCWSTR inf_file, DWORD flags, PVOID reserved)
BOOL WINAPI	SetupUninstallOEMInfA (PCSTR inf_file, DWORD flags, PVOID reserved)
DWORD WINAPI	InstallCatalog (LPCSTR catalog, LPCSTR basename, LPSTR fullname)
DWORD WINAPI	pSetupInstallCatalog (LPCWSTR catalog, LPCWSTR basename, LPWSTR fullname)
static UINT	detect_compression_type (LPCWSTR file)
static BOOL	get_file_size (LPCWSTR file, DWORD *size)
static BOOL	get_file_sizes_none (LPCWSTR source, DWORD *source_size, DWORD *target_size)
static BOOL	get_file_sizes_lz (LPCWSTR source, DWORD *source_size, DWORD *target_size)
static UINT CALLBACK	file_compression_info_callback (PVOID context, UINT notification, UINT_PTR param1, UINT_PTR param2)
static BOOL	get_file_sizes_cab (LPCWSTR source, DWORD *source_size, DWORD *target_size)
BOOL WINAPI	SetupGetFileCompressionInfoExA (PCSTR source, PSTR name, DWORD len, PDWORD required, PDWORD source_size, PDWORD target_size, PUINT type)
BOOL WINAPI	SetupGetFileCompressionInfoExW (PCWSTR source, PWSTR name, DWORD len, PDWORD required, PDWORD source_size, PDWORD target_size, PUINT type)
DWORD WINAPI	SetupGetFileCompressionInfoA (PCSTR source, PSTR *name, PDWORD source_size, PDWORD target_size, PUINT type)
DWORD WINAPI	SetupGetFileCompressionInfoW (PCWSTR source, PWSTR *name, PDWORD source_size, PDWORD target_size, PUINT type)
static DWORD	decompress_file_lz (LPCWSTR source, LPCWSTR target)
static UINT CALLBACK	decompress_or_copy_callback (PVOID context, UINT notification, UINT_PTR param1, UINT_PTR param2)
static DWORD	decompress_file_cab (LPCWSTR source, LPCWSTR target)
DWORD WINAPI	SetupDecompressOrCopyFileA (PCSTR source, PCSTR target, PUINT type)
DWORD WINAPI	SetupDecompressOrCopyFileW (PCWSTR source, PCWSTR target, PUINT type)
static BOOL	TrimGuidString (PCWSTR szString, LPWSTR szNewString)
DWORD WINAPI	pSetupGuidFromString (PCWSTR pString, LPGUID lpGUID)
DWORD WINAPI	pSetupStringFromGuid (LPGUID lpGUID, PWSTR pString, DWORD dwStringLen)
BOOL WINAPI	pSetupIsGuidNull (LPGUID lpGUID)
BOOL WINAPI	pSetupIsUserAdmin (VOID)
HSPFILELOG WINAPI	SetupInitializeFileLogW (LPCWSTR LogFileName, DWORD Flags)
HSPFILELOG WINAPI	SetupInitializeFileLogA (LPCSTR LogFileName, DWORD Flags)
BOOL WINAPI	SetupTerminateFileLog (HANDLE FileLogHandle)
void WINAPI	SetupCloseLog (void)
BOOL WINAPI	SetupOpenLog (BOOL reserved)
BOOL WINAPI	SetupLogErrorA (LPCSTR message, LogSeverity severity)
BOOL WINAPI	SetupLogErrorW (LPCWSTR message, LogSeverity severity)

Variables
static const WCHAR	BackSlash [] = {'\\',0}
static const WCHAR	TranslationRegKey [] = {'\\','V','e','r','F','i','l','e','I','n','f','o','\\','T','r','a','n','s','l','a','t','i','o','n',0}
static HANDLE	setupact = INVALID_HANDLE_VALUE
static HANDLE	setuperr = INVALID_HANDLE_VALUE
static CRITICAL_SECTION	setupapi_cs = { &critsect_debug, -1, 0, 0, 0, 0 }
static CRITICAL_SECTION_DEBUG	critsect_debug
DWORD	GlobalSetupFlags = 0

Function Documentation

AssertFail()

VOID WINAPI AssertFail	(	LPSTR	lpFile,
		UINT	uLine,
		LPSTR	lpMessage
	)

Definition at line 905 of file misc.c.

{
    CHAR szModule[MAX_PATH];
    CHAR szBuffer[2048];
    LPSTR lpName;
//    LPSTR lpBuffer;
 
    TRACE("%s %u %s\n", lpFile, uLine, lpMessage);
 
    GetModuleFileNameA(hInstance, szModule, MAX_PATH);
    lpName = strrchr(szModule, '\\');
    if (lpName != NULL)
        lpName++;
    else
        lpName = szModule;
 
    wsprintfA(szBuffer,
              "Assertion failure at line %u in file %s: %s\n\nCall DebugBreak()?",
              uLine, lpFile, lpMessage);
 
    if (MessageBoxA(NULL, szBuffer, lpName, MB_SETFOREGROUND |
                    MB_TASKMODAL | MB_ICONERROR | MB_YESNO) == IDYES)
        DebugBreak();
}

CaptureStringArg()

DWORD WINAPI CaptureStringArg	(	LPCWSTR	pSrc,
		LPWSTR *	pDst
	)

Definition at line 547 of file misc.c.

{
    if (pDst == NULL)
        return ERROR_INVALID_PARAMETER;
 
    *pDst = pSetupDuplicateString(pSrc);
 
    return ERROR_SUCCESS;
}

decompress_file_cab()

static DWORD decompress_file_cab ( LPCWSTR  source, LPCWSTR  target  )

static

Definition at line 1640 of file misc.c.

{
    struct callback_context context = {0, target};
    BOOL ret;
 
    ret = SetupIterateCabinetW( source, 0, decompress_or_copy_callback, &context );
 
    if (ret) return ERROR_SUCCESS;
    else return GetLastError();
}

Referenced by SetupDecompressOrCopyFileW().

decompress_file_lz()

static DWORD decompress_file_lz ( LPCWSTR  source, LPCWSTR  target  )

static

Definition at line 1582 of file misc.c.

{
    DWORD ret;
    LONG error;
    INT src, dst;
    OFSTRUCT sof, dof;
 
    if ((src = LZOpenFileW( (LPWSTR)source, &sof, OF_READ )) < 0)
    {
        ERR("cannot open source file for reading\n");
        return ERROR_FILE_NOT_FOUND;
    }
    if ((dst = LZOpenFileW( (LPWSTR)target, &dof, OF_CREATE )) < 0)
    {
        ERR("cannot open target file for writing\n");
        LZClose( src );
        return ERROR_FILE_NOT_FOUND;
    }
    if ((error = LZCopy( src, dst )) >= 0) ret = ERROR_SUCCESS;
    else
    {
        WARN("failed to decompress file %d\n", error);
        ret = ERROR_INVALID_DATA;
    }
 
    LZClose( src );
    LZClose( dst );
    return ret;
}

Referenced by SetupDecompressOrCopyFileW().

decompress_or_copy_callback()

static UINT CALLBACK decompress_or_copy_callback ( PVOID  context, UINT  notification, UINT_PTR  param1, UINT_PTR  param2  )

static

Definition at line 1618 of file misc.c.

{
    struct callback_context *context_info = context;
    FILE_IN_CABINET_INFO_W *info = (FILE_IN_CABINET_INFO_W *)param1;
 
    switch (notification)
    {
    case SPFILENOTIFY_FILEINCABINET:
    {
        if (context_info->has_extracted)
            return FILEOP_ABORT;
 
        TRACE("Requesting extraction of cabinet file %s\n",
              wine_dbgstr_w(info->NameInCabinet));
        strcpyW( info->FullTargetName, context_info->target );
        context_info->has_extracted = TRUE;
        return FILEOP_DOIT;
    }
    default: return NO_ERROR;
    }
}

Referenced by decompress_file_cab().

DelayedMove()

BOOL WINAPI DelayedMove	(	LPCWSTR	lpExistingFileName,
		LPCWSTR	lpNewFileName
	)

Definition at line 482 of file misc.c.

{
    return MoveFileExW(lpExistingFileName, lpNewFileName,
                       MOVEFILE_REPLACE_EXISTING | MOVEFILE_DELAY_UNTIL_REBOOT);
}

detect_compression_type()

static UINT detect_compression_type ( LPCWSTR  file )

static

Definition at line 1293 of file misc.c.

{
    DWORD size;
    HANDLE handle;
    UINT type = FILE_COMPRESSION_NONE;
    static const BYTE LZ_MAGIC[] = { 0x53, 0x5a, 0x44, 0x44, 0x88, 0xf0, 0x27, 0x33 };
    static const BYTE MSZIP_MAGIC[] = { 0x4b, 0x57, 0x41, 0x4a };
    static const BYTE NTCAB_MAGIC[] = { 0x4d, 0x53, 0x43, 0x46 };
    BYTE buffer[8];
 
    handle = CreateFileW( file, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL );
    if (handle == INVALID_HANDLE_VALUE)
    {
        ERR("cannot open file %s\n", debugstr_w(file));
        return FILE_COMPRESSION_NONE;
    }
    if (!ReadFile( handle, buffer, sizeof(buffer), &size, NULL ) || size != sizeof(buffer))
    {
        CloseHandle( handle );
        return FILE_COMPRESSION_NONE;
    }
    if (!memcmp( buffer, LZ_MAGIC, sizeof(LZ_MAGIC) )) type = FILE_COMPRESSION_WINLZA;
    else if (!memcmp( buffer, MSZIP_MAGIC, sizeof(MSZIP_MAGIC) )) type = FILE_COMPRESSION_MSZIP;
    else if (!memcmp( buffer, NTCAB_MAGIC, sizeof(NTCAB_MAGIC) )) type = FILE_COMPRESSION_MSZIP; /* not a typo */
 
    CloseHandle( handle );
    return type;
}

Referenced by SetupDecompressOrCopyFileW(), and SetupGetFileCompressionInfoExW().

DoesUserHavePrivilege()

BOOL WINAPI DoesUserHavePrivilege

(

LPCWSTR

lpPrivilegeName

)

Definition at line 366 of file misc.c.

{
    HANDLE hToken;
    DWORD dwSize;
    PTOKEN_PRIVILEGES lpPrivileges;
    LUID PrivilegeLuid;
    DWORD i;
    BOOL bResult = FALSE;
 
    TRACE("%s\n", debugstr_w(lpPrivilegeName));
 
    if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken))
        return FALSE;
 
    if (!GetTokenInformation(hToken, TokenPrivileges, NULL, 0, &dwSize))
    {
        if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
        {
            CloseHandle(hToken);
            return FALSE;
        }
    }
 
    lpPrivileges = MyMalloc(dwSize);
    if (lpPrivileges == NULL)
    {
        CloseHandle(hToken);
        return FALSE;
    }
 
    if (!GetTokenInformation(hToken, TokenPrivileges, lpPrivileges, dwSize, &dwSize))
    {
        MyFree(lpPrivileges);
        CloseHandle(hToken);
        return FALSE;
    }
 
    CloseHandle(hToken);
 
    if (!LookupPrivilegeValueW(NULL, lpPrivilegeName, &PrivilegeLuid))
    {
        MyFree(lpPrivileges);
        return FALSE;
    }
 
    for (i = 0; i < lpPrivileges->PrivilegeCount; i++)
    {
        if (lpPrivileges->Privileges[i].Luid.HighPart == PrivilegeLuid.HighPart &&
            lpPrivileges->Privileges[i].Luid.LowPart == PrivilegeLuid.LowPart)
        {
            bResult = TRUE;
        }
    }
 
    MyFree(lpPrivileges);
 
    return bResult;
}

file_compression_info_callback()

static UINT CALLBACK file_compression_info_callback ( PVOID  context, UINT  notification, UINT_PTR  param1, UINT_PTR  param2  )

static

Definition at line 1373 of file misc.c.

{
    DWORD *size = context;
    FILE_IN_CABINET_INFO_W *info = (FILE_IN_CABINET_INFO_W *)param1;
 
    switch (notification)
    {
    case SPFILENOTIFY_FILEINCABINET:
    {
        *size = info->FileSize;
        return FILEOP_SKIP;
    }
    default: return NO_ERROR;
    }
}

Referenced by get_file_sizes_cab().

FileExists()

BOOL WINAPI FileExists	(	LPCWSTR	lpFileName,
		LPWIN32_FIND_DATAW	lpFileFindData
	)

Definition at line 502 of file misc.c.

{
    WIN32_FIND_DATAW FindData;
    HANDLE hFind;
    UINT uErrorMode;
    DWORD dwError;
 
    uErrorMode = SetErrorMode(SEM_FAILCRITICALERRORS);
 
    hFind = FindFirstFileW(lpFileName, &FindData);
    if (hFind == INVALID_HANDLE_VALUE)
    {
        dwError = GetLastError();
        SetErrorMode(uErrorMode);
        SetLastError(dwError);
        return FALSE;
    }
 
    FindClose(hFind);
 
    if (lpFileFindData)
        memcpy(lpFileFindData, &FindData, sizeof(WIN32_FIND_DATAW));
 
    SetErrorMode(uErrorMode);
 
    return TRUE;
}

Referenced by SetupInitializeFileLogW().

FreeFunctionPointer()

DWORD FreeFunctionPointer	(	IN HMODULE	ModulePointer,
		IN PVOID	FunctionPointer
	)

Definition at line 105 of file misc.c.

{
    if (ModulePointer == NULL)
        return ERROR_SUCCESS;
    if (FreeLibrary(ModulePointer))
       return ERROR_SUCCESS;
    else
       return GetLastError();
}

Referenced by SetupDiCallClassInstaller().

get_file_size()

static BOOL get_file_size ( LPCWSTR  file, DWORD *  size  )

static

Definition at line 1322 of file misc.c.

{
    HANDLE handle;
 
    handle = CreateFileW( file, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL );
    if (handle == INVALID_HANDLE_VALUE)
    {
        ERR("cannot open file %s\n", debugstr_w(file));
        return FALSE;
    }
    *size = GetFileSize( handle, NULL );
    CloseHandle( handle );
    return TRUE;
}

get_file_sizes_cab()

static BOOL get_file_sizes_cab ( LPCWSTR  source, DWORD *  source_size, DWORD *  target_size  )

static

Definition at line 1389 of file misc.c.

{
    DWORD size;
    BOOL ret = TRUE;
 
    if (source_size)
    {
        if (!get_file_size( source, &size )) ret = FALSE;
        else *source_size = size;
    }
    if (target_size)
    {
        ret = SetupIterateCabinetW( source, 0, file_compression_info_callback, target_size );
    }
    return ret;
}

Referenced by SetupGetFileCompressionInfoExW().

get_file_sizes_lz()

static BOOL get_file_sizes_lz ( LPCWSTR  source, DWORD *  source_size, DWORD *  target_size  )

static

Definition at line 1347 of file misc.c.

{
    DWORD size;
    BOOL ret = TRUE;
 
    if (source_size)
    {
        if (!get_file_size( source, &size )) ret = FALSE;
        else *source_size = size;
    }
    if (target_size)
    {
        INT file;
        OFSTRUCT of;
 
        if ((file = LZOpenFileW( (LPWSTR)source, &of, OF_READ )) < 0)
        {
            ERR("cannot open source file for reading\n");
            return FALSE;
        }
        *target_size = LZSeek( file, 0, 2 );
        LZClose( file );
    }
    return ret;
}

Referenced by SetupGetFileCompressionInfoExW().

get_file_sizes_none()

static BOOL get_file_sizes_none ( LPCWSTR  source, DWORD *  source_size, DWORD *  target_size  )

static

Definition at line 1337 of file misc.c.

{
    DWORD size;
 
    if (!get_file_size( source, &size )) return FALSE;
    if (source_size) *source_size = size;
    if (target_size) *target_size = size;
    return TRUE;
}

Referenced by SetupGetFileCompressionInfoExW().

GetFunctionPointer()

DWORD GetFunctionPointer	(	IN PWSTR	InstallerName,
		OUT HMODULE *	ModulePointer,
		OUT PVOID *	FunctionPointer
	)

Definition at line 44 of file misc.c.

{
    HMODULE hModule = NULL;
    LPSTR FunctionNameA = NULL;
    PWCHAR Comma;
    DWORD rc;
 
    *ModulePointer = NULL;
    *FunctionPointer = NULL;
 
    Comma = strchrW(InstallerName, ',');
    if (!Comma)
    {
        rc = ERROR_INVALID_PARAMETER;
        goto cleanup;
    }
 
    /* Load library */
    *Comma = '\0';
    hModule = LoadLibraryW(InstallerName);
    *Comma = ',';
    if (!hModule)
    {
        rc = GetLastError();
        goto cleanup;
    }
 
    /* Skip comma spaces */
    while (*Comma == ',' || isspaceW(*Comma))
        Comma++;
 
    /* W->A conversion for function name */
    FunctionNameA = pSetupUnicodeToMultiByte(Comma, CP_ACP);
    if (!FunctionNameA)
    {
        rc = GetLastError();
        goto cleanup;
    }
 
    /* Search function */
    *FunctionPointer = GetProcAddress(hModule, FunctionNameA);
    if (!*FunctionPointer)
    {
        rc = GetLastError();
        goto cleanup;
    }
 
    *ModulePointer = hModule;
    rc = ERROR_SUCCESS;
 
cleanup:
    if (rc != ERROR_SUCCESS && hModule)
        FreeLibrary(hModule);
    MyFree(FunctionNameA);
    return rc;
}

Referenced by SetupDiCallClassInstaller(), and SetupDiGetClassDevPropertySheetsW().

GetSetFileTimestamp()

DWORD WINAPI GetSetFileTimestamp	(	LPCWSTR	lpFileName,
		LPFILETIME	lpCreationTime,
		LPFILETIME	lpLastAccessTime,
		LPFILETIME	lpLastWriteTime,
		BOOLEAN	bSetFileTime
	)

Definition at line 948 of file misc.c.

{
    HANDLE hFile;
    BOOLEAN bRet;
    DWORD dwError = ERROR_SUCCESS;
 
    TRACE("%s %p %p %p %x\n", debugstr_w(lpFileName), lpCreationTime,
          lpLastAccessTime, lpLastWriteTime, bSetFileTime);
 
    hFile = CreateFileW(lpFileName,
                        bSetFileTime ? GENERIC_WRITE : GENERIC_READ,
                        FILE_SHARE_READ | FILE_SHARE_WRITE,
                        NULL,
                        OPEN_EXISTING,
                        0,
                        NULL);
 
    if (hFile == INVALID_HANDLE_VALUE)
        return GetLastError();
 
    if (bSetFileTime)
        bRet = SetFileTime(hFile, lpCreationTime, lpLastAccessTime, lpLastWriteTime);
    else
        bRet = GetFileTime(hFile, lpCreationTime, lpLastAccessTime, lpLastWriteTime);
 
    if (bRet == FALSE)
        dwError = GetLastError();
 
     CloseHandle(hFile);
 
     return dwError;
}

InstallCatalog()

DWORD WINAPI InstallCatalog	(	LPCSTR	catalog,
		LPCSTR	basename,
		LPSTR	fullname
	)

Definition at line 1259 of file misc.c.

{
    FIXME("%s, %s, %p\n", debugstr_a(catalog), debugstr_a(basename), fullname);
    return 0;
}

MyFree()

VOID WINAPI MyFree

(

LPVOID

lpMem

)

Definition at line 128 of file misc.c.

{
    TRACE("%p\n", lpMem);
    HeapFree(GetProcessHeap(), 0, lpMem);
}

Referenced by AddDriverToList(), CheckSectionValid(), CM_Add_ID_ExA(), CM_Connect_MachineA(), CM_Create_DevNode_ExA(), CM_Delete_DevNode_Key_Ex(), CM_Free_Resource_Conflict_Handle(), CM_Get_Device_ID_List_ExA(), CM_Get_Device_ID_List_Size_ExA(), CM_Get_Device_Interface_List_ExA(), CM_Get_Device_Interface_List_Size_ExA(), CM_Get_DevNode_Custom_Property_ExA(), CM_Get_HW_Prof_Flags_ExA(), CM_Locate_DevNode_ExA(), CM_Open_Class_Key_ExA(), CM_Open_DevNode_Key_Ex(), CM_Query_Resource_Conflict_List(), CM_Register_Device_Interface_ExA(), CM_Set_DevNode_Registry_Property_ExA(), CM_Set_HW_Prof_Flags_ExA(), CM_Unregister_Device_Interface_ExA(), DoesUserHavePrivilege(), FixupServiceBinaryPath(), GetDeviceInstanceKeyPath(), GetFunctionPointer(), GetHardwareAndCompatibleIDsLists(), GetStringField(), InfIsFromOEMLocation(), InstallOneService(), profile_items_callback(), pSetupGetVersionInfoFromImage(), pSetupMultiByteToUnicode(), pSetupStringTableAddString(), pSetupStringTableAddStringEx(), pSetupStringTableDestroy(), pSetupStringTableDuplicate(), pSetupStringTableInitialize(), pSetupStringTableInitializeEx(), pSetupUnicodeToMultiByte(), QueryRegistryValue(), registry_callback(), RetreiveFileSecurity(), SETUP_GetClassIconInfo(), SETUP_GetIconIndex(), SETUP_PropertyAddPropertyAdvancedHandler(), SETUP_PropertyChangeHandler(), SetupCopyOEMInfA(), SetupCopyOEMInfW(), SetupDecompressOrCopyFileA(), SetupDiBuildClassInfoListExA(), SetupDiBuildDriverInfoList(), SetupDiClassGuidsFromNameExA(), SetupDiClassNameFromGuidExA(), SetupDiClassNameFromGuidExW(), SetupDiCreateDeviceInfoA(), SetupDiCreateDeviceInfoListExA(), SetupDiCreateDeviceInfoListExW(), SetupDiCreateDeviceInterfaceA(), SetupDiCreateDeviceInterfaceRegKeyA(), SetupDiCreateDevRegKeyA(), SetupDiDestroyClassImageList(), SetupDiGetActualSectionToInstallExA(), SetupDiGetClassDescriptionExA(), SetupDiGetClassDescriptionExW(), SetupDiGetClassDevsExA(), SetupDiGetClassImageListExA(), SetupDiGetClassImageListExW(), SetupDiGetDeviceInstanceIdA(), SetupDiGetDeviceInterfaceDetailA(), SetupDiGetDriverInfoDetailA(), SetupDiGetDriverInfoDetailW(), SetupDiGetINFClassA(), SetupDiInstallClassExA(), SetupDiInstallDeviceInterfaces(), SetupDiLoadClassIcon(), SetupDiOpenClassRegKeyExA(), SetupDiOpenDeviceInfoA(), SetupDiOpenDeviceInterfaceA(), SetupGetFileCompressionInfoA(), SetupGetFileCompressionInfoExA(), SetupGetFileCompressionInfoW(), SetupGetInfFileListA(), SetupGetInfFileListW(), SetupQueueCopySectionW(), TakeOwnershipOfFile(), and test_SetupGetFileCompressionInfo().

MyMalloc()

LPVOID WINAPI MyMalloc

(

DWORD

dwSize

)

Definition at line 147 of file misc.c.

{
    TRACE("%lu\n", dwSize);
    return HeapAlloc(GetProcessHeap(), 0, dwSize);
}

Referenced by AddDriverToList(), CM_Delete_DevNode_Key_Ex(), CM_Get_Device_ID_List_ExA(), CM_Get_Device_Interface_List_ExA(), CM_Open_DevNode_Key_Ex(), CM_Query_Resource_Conflict_List(), CM_Set_DevNode_Registry_Property_ExA(), Concatenate(), DoesUserHavePrivilege(), FixupServiceBinaryPath(), GetDeviceInstanceKeyPath(), GetHardwareAndCompatibleIDsLists(), GetStringField(), InfIsFromOEMLocation(), InstallOneService(), profile_items_callback(), pSetupDuplicateString(), pSetupGetVersionInfoFromImage(), pSetupMultiByteToUnicode(), pSetupStringTableAddString(), pSetupStringTableAddStringEx(), pSetupStringTableDuplicate(), pSetupStringTableInitialize(), pSetupStringTableInitializeEx(), pSetupStringTableSetExtraData(), pSetupUnicodeToMultiByte(), QueryRegistryValue(), registry_callback(), RetreiveFileSecurity(), SETUP_GetClassIconInfo(), SETUP_GetIconIndex(), SETUP_PropertyAddPropertyAdvancedHandler(), SETUP_PropertyChangeHandler(), SetupCopyOEMInfA(), SetupCopyOEMInfW(), SetupDiCreateDeviceInfoListExW(), SetupDiGetActualSectionToInstallExA(), SetupDiGetClassDescriptionExA(), SetupDiGetDeviceInstanceIdA(), SetupDiGetDeviceInterfaceDetailA(), SetupDiGetDriverInfoDetailA(), SetupDiGetINFClassA(), SetupGetFileCompressionInfoA(), SetupGetFileCompressionInfoW(), SetupGetInfFileListA(), SetupGetInfFileListW(), SetupQueueCopySectionW(), and TakeOwnershipOfFile().

MyRealloc()

LPVOID WINAPI MyRealloc	(	LPVOID	lpSrc,
		DWORD	dwSize
	)

Definition at line 172 of file misc.c.

{
    TRACE("%p %lu\n", lpSrc, dwSize);
 
    if (lpSrc == NULL)
        return HeapAlloc(GetProcessHeap(), 0, dwSize);
 
    return HeapReAlloc(GetProcessHeap(), 0, lpSrc, dwSize);
}

Referenced by RetreiveFileSecurity().

pSetupCaptureAndConvertAnsiArg()

DWORD WINAPI pSetupCaptureAndConvertAnsiArg	(	LPCSTR	pSrc,
		LPWSTR *	pDst
	)

Definition at line 574 of file misc.c.

{
    if (pDst == NULL)
        return ERROR_INVALID_PARAMETER;
 
    *pDst = pSetupMultiByteToUnicode(pSrc, CP_ACP);
 
    return ERROR_SUCCESS;
}

Referenced by CM_Add_ID_ExA(), CM_Connect_MachineA(), CM_Create_DevNode_ExA(), CM_Get_Device_ID_List_ExA(), CM_Get_Device_ID_List_Size_ExA(), CM_Get_Device_Interface_List_ExA(), CM_Get_Device_Interface_List_Size_ExA(), CM_Get_HW_Prof_Flags_ExA(), CM_Locate_DevNode_ExA(), CM_Open_Class_Key_ExA(), CM_Register_Device_Interface_ExA(), CM_Set_HW_Prof_Flags_ExA(), and CM_Unregister_Device_Interface_ExA().

pSetupCenterWindowRelativeToParent()

VOID WINAPI pSetupCenterWindowRelativeToParent

(

HWND

hwnd

)

Definition at line 1108 of file misc.c.

{
    HWND hwndOwner;
    POINT ptOrigin;
    RECT rcWindow;
    RECT rcOwner;
    INT nWindowWidth, nWindowHeight;
    INT nOwnerWidth, nOwnerHeight;
    INT posX, posY;
 
    hwndOwner = GetWindow(hwnd, GW_OWNER);
    if (hwndOwner == NULL)
        return;
 
    ptOrigin.x = 0;
    ptOrigin.y = 0;
    ClientToScreen(hwndOwner, &ptOrigin);
 
    GetWindowRect(hwnd, &rcWindow);
    GetClientRect(hwndOwner, &rcOwner);
 
    nWindowWidth = rcWindow.right - rcWindow.left;
    nWindowHeight = rcWindow.bottom - rcWindow.top;
 
    nOwnerWidth = rcOwner.right - rcOwner.left;
    nOwnerHeight = rcOwner.bottom - rcOwner.top;
 
    posX = ((nOwnerWidth - nWindowWidth) / 2) + ptOrigin.x;
    posY = ((nOwnerHeight - nWindowHeight) / 2) + ptOrigin.y;
 
    MoveWindow(hwnd, posX, posY, nWindowWidth, nWindowHeight, 0);
}

pSetupConcatenatePaths()

BOOL WINAPI pSetupConcatenatePaths	(	LPWSTR	lpPath,
		LPCWSTR	lpAppend,
		DWORD	dwBufferSize,
		LPDWORD	lpRequiredSize
	)

Definition at line 1040 of file misc.c.

{
    DWORD dwPathSize;
    DWORD dwAppendSize;
    DWORD dwTotalSize;
    BOOL bBackslash = FALSE;
 
    TRACE("%s %s %lu %p\n", debugstr_w(lpPath), debugstr_w(lpAppend),
          dwBufferSize, lpRequiredSize);
 
    dwPathSize = lstrlenW(lpPath);
 
    /* Ignore trailing backslash */
    if (lpPath[dwPathSize - 1] == (WCHAR)'\\')
        dwPathSize--;
 
    dwAppendSize = lstrlenW(lpAppend);
 
    /* Does the source string have a leading backslash? */
    if (lpAppend[0] == (WCHAR)'\\')
    {
        bBackslash = TRUE;
        dwAppendSize--;
    }
 
    dwTotalSize = dwPathSize + dwAppendSize + 2;
    if (lpRequiredSize != NULL)
        *lpRequiredSize = dwTotalSize;
 
    /* Append a backslash to the destination string */
    if (bBackslash == FALSE)
    {
        if (dwPathSize < dwBufferSize)
        {
            lpPath[dwPathSize - 1] = (WCHAR)'\\';
            dwPathSize++;
        }
    }
 
    if (dwPathSize + dwAppendSize < dwBufferSize)
    {
        lstrcpynW(&lpPath[dwPathSize],
                  lpAppend,
                  dwAppendSize);
    }
 
    if (dwBufferSize >= dwTotalSize)
        lpPath[dwTotalSize - 1] = 0;
 
    return (dwBufferSize >= dwTotalSize);
}

pSetupDuplicateString()

LPWSTR WINAPI pSetupDuplicateString

(

LPCWSTR

lpSrc

)

Definition at line 198 of file misc.c.

{
    LPWSTR lpDst;
 
    TRACE("%s\n", debugstr_w(lpSrc));
 
    lpDst = MyMalloc((lstrlenW(lpSrc) + 1) * sizeof(WCHAR));
    if (lpDst == NULL)
        return NULL;
 
    strcpyW(lpDst, lpSrc);
 
    return lpDst;
}

Referenced by CaptureStringArg(), CheckSectionValid(), and profile_items_callback().

pSetupEnablePrivilege()

BOOL WINAPI pSetupEnablePrivilege	(	LPCWSTR	lpPrivilegeName,
		BOOL	bEnable
	)

Definition at line 440 of file misc.c.

{
    TOKEN_PRIVILEGES Privileges;
    HANDLE hToken;
    BOOL bResult;
 
    TRACE("%s %s\n", debugstr_w(lpPrivilegeName), bEnable ? "TRUE" : "FALSE");
 
    if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
        return FALSE;
 
    Privileges.PrivilegeCount = 1;
    Privileges.Privileges[0].Attributes = (bEnable) ? SE_PRIVILEGE_ENABLED : 0;
 
    if (!LookupPrivilegeValueW(NULL, lpPrivilegeName,
                               &Privileges.Privileges[0].Luid))
    {
        CloseHandle(hToken);
        return FALSE;
    }
 
    bResult = AdjustTokenPrivileges(hToken, FALSE, &Privileges, 0, NULL, NULL);
 
    CloseHandle(hToken);
 
    return bResult;
}

Referenced by SaveDefaultUserHive().

pSetupGetFileTitle()

LPWSTR WINAPI pSetupGetFileTitle

(

LPCWSTR

lpFileName

)

Definition at line 998 of file misc.c.

{
    LPWSTR ptr;
    LPWSTR ret;
    WCHAR c;
 
    TRACE("%s\n", debugstr_w(lpFileName));
 
    ptr = (LPWSTR)lpFileName;
    ret = ptr;
    while (TRUE)
    {
        c = *ptr;
 
        if (c == 0)
            break;
 
        ptr++;
        if (c == (WCHAR)'\\' || c == (WCHAR)'/' || c == (WCHAR)':')
            ret = ptr;
    }
 
    return ret;
}

pSetupGetGlobalFlags()

DWORD WINAPI pSetupGetGlobalFlags

(

void

)

Definition at line 850 of file misc.c.

{
    return GlobalSetupFlags;
}

pSetupGetVersionInfoFromImage()

BOOL WINAPI pSetupGetVersionInfoFromImage	(	LPWSTR	lpFileName,
		PULARGE_INTEGER	lpFileVersion,
		LPWORD	lpVersionVarSize
	)

Definition at line 1158 of file misc.c.

{
    DWORD dwHandle;
    DWORD dwSize;
    LPVOID lpInfo;
    UINT uSize;
    VS_FIXEDFILEINFO *lpFixedInfo;
    LPWORD lpVarSize;
 
    dwSize = GetFileVersionInfoSizeW(lpFileName, &dwHandle);
    if (dwSize == 0)
        return FALSE;
 
    lpInfo = MyMalloc(dwSize);
    if (lpInfo == NULL)
        return FALSE;
 
    if (!GetFileVersionInfoW(lpFileName, 0, dwSize, lpInfo))
    {
        MyFree(lpInfo);
        return FALSE;
    }
 
    if (!VerQueryValueW(lpInfo, BackSlash,
                        (LPVOID*)&lpFixedInfo, &uSize))
    {
        MyFree(lpInfo);
        return FALSE;
    }
 
    lpFileVersion->LowPart = lpFixedInfo->dwFileVersionLS;
    lpFileVersion->HighPart = lpFixedInfo->dwFileVersionMS;
 
    *lpVersionVarSize = 0;
    if (!VerQueryValueW(lpInfo, TranslationRegKey,
                        (LPVOID*)&lpVarSize, &uSize))
    {
        MyFree(lpInfo);
        return TRUE;
    }
 
    if (uSize >= 4)
    {
        *lpVersionVarSize = *lpVarSize;
    }
 
    MyFree(lpInfo);
 
    return TRUE;
}

pSetupGuidFromString()

DWORD WINAPI pSetupGuidFromString	(	PCWSTR	pString,
		LPGUID	lpGUID
	)

Definition at line 1751 of file misc.c.

{
    RPC_STATUS Status;
    WCHAR szBuffer[39];
 
    if (!TrimGuidString(pString, szBuffer))
    {
        return RPC_S_INVALID_STRING_UUID;
    }
 
    Status = UuidFromStringW(szBuffer, lpGUID);
    if (Status != RPC_S_OK)
    {
        return RPC_S_INVALID_STRING_UUID;
    }
 
    return NO_ERROR;
}

Referenced by DisplayClassProperties(), and GetDeviceDisplayInfo().

pSetupInstallCatalog()

DWORD WINAPI pSetupInstallCatalog	(	LPCWSTR	catalog,
		LPCWSTR	basename,
		LPWSTR	fullname
	)

Definition at line 1268 of file misc.c.

{
    HCATADMIN admin;
    HCATINFO cat;
 
    TRACE ("%s, %s, %p\n", debugstr_w(catalog), debugstr_w(basename), fullname);
 
    if (!CryptCATAdminAcquireContext(&admin,NULL,0))
        return GetLastError();
 
    if (!(cat = CryptCATAdminAddCatalog( admin, (PWSTR)catalog, (PWSTR)basename, 0 )))
    {
        DWORD rc = GetLastError();
        CryptCATAdminReleaseContext(admin, 0);
        return rc;
    }
    CryptCATAdminReleaseCatalogContext(admin, cat, 0);
    CryptCATAdminReleaseContext(admin,0);
 
    if (fullname)
        FIXME("not returning full installed catalog path\n");
 
    return NO_ERROR;
}

pSetupIsGuidNull()

BOOL WINAPI pSetupIsGuidNull

(

LPGUID

lpGUID

)

Definition at line 1807 of file misc.c.

{
    return IsEqualGUID(lpGUID, &GUID_NULL);
}

pSetupIsUserAdmin()

BOOL WINAPI pSetupIsUserAdmin

(

VOID

)

Definition at line 1817 of file misc.c.

{
    SID_IDENTIFIER_AUTHORITY Authority = {SECURITY_NT_AUTHORITY};
    BOOL bResult = FALSE;
    PSID lpSid;
 
    if (!AllocateAndInitializeSid(&Authority, 2, SECURITY_BUILTIN_DOMAIN_RID,
                                  DOMAIN_ALIAS_RID_ADMINS, 0, 0, 0, 0, 0, 0,
                                  &lpSid))
    {
        return FALSE;
    }
 
    if (!CheckTokenMembership(NULL, lpSid, &bResult))
    {
        bResult = FALSE;
    }
 
    FreeSid(lpSid);
 
    return bResult;
}

Referenced by CM_Add_Empty_Log_Conf_Ex(), CM_Add_ID_ExW(), CM_Create_DevNode_ExW(), CM_Delete_DevNode_Key_Ex(), CM_Disable_DevNode_Ex(), CM_Enable_DevNode_Ex(), CM_Free_Log_Conf_Ex(), CM_Move_DevNode_Ex(), CM_Run_Detection_Ex(), CM_Set_HW_Prof_Ex(), CM_Setup_DevNode_Ex(), CMP_Report_LogOn(), and SetupInitializeFileLogW().

pSetupModifyGlobalFlags()

void WINAPI pSetupModifyGlobalFlags	(	DWORD	mask,
		DWORD	flags
	)

Definition at line 858 of file misc.c.

{
    FIXME( "stub\n" );
    GlobalSetupFlags = (GlobalSetupFlags & ~mask) | (flags & mask);
}

Referenced by pSetupSetGlobalFlags(), and SetupSetNonInteractiveMode().

pSetupMultiByteToUnicode()

LPWSTR WINAPI pSetupMultiByteToUnicode	(	LPCSTR	lpMultiByteStr,
		UINT	uCodePage
	)

Definition at line 281 of file misc.c.

{
    LPWSTR lpUnicodeStr;
    int nLength;
 
    TRACE("%s %d\n", debugstr_a(lpMultiByteStr), uCodePage);
 
    nLength = MultiByteToWideChar(uCodePage, 0, lpMultiByteStr,
                                  -1, NULL, 0);
    if (nLength == 0)
        return NULL;
 
    lpUnicodeStr = MyMalloc(nLength * sizeof(WCHAR));
    if (lpUnicodeStr == NULL)
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return NULL;
    }
 
    if (!MultiByteToWideChar(uCodePage, 0, lpMultiByteStr,
                             nLength, lpUnicodeStr, nLength))
    {
        MyFree(lpUnicodeStr);
        return NULL;
    }
 
    return lpUnicodeStr;
}

Referenced by CM_Get_DevNode_Custom_Property_ExA(), pSetupCaptureAndConvertAnsiArg(), SetupCopyOEMInfA(), SetupDecompressOrCopyFileA(), SetupDiBuildClassInfoListExA(), SetupDiClassGuidsFromNameExA(), SetupDiClassNameFromGuidExA(), SetupDiCreateDeviceInfoA(), SetupDiCreateDeviceInfoListExA(), SetupDiCreateDeviceInterfaceA(), SetupDiCreateDeviceInterfaceRegKeyA(), SetupDiCreateDevRegKeyA(), SetupDiGetActualSectionToInstallExA(), SetupDiGetClassDescriptionExA(), SetupDiGetClassDevsExA(), SetupDiGetClassImageListExA(), SetupDiGetINFClassA(), SetupDiInstallClassExA(), SetupDiOpenClassRegKeyExA(), SetupDiOpenDeviceInfoA(), SetupDiOpenDeviceInterfaceA(), SetupGetFileCompressionInfoExA(), and SetupGetInfFileListA().

pSetupOpenAndMapFileForRead()

DWORD WINAPI pSetupOpenAndMapFileForRead	(	LPCWSTR	lpFileName,
		LPDWORD	lpSize,
		LPHANDLE	lpFile,
		LPHANDLE	lpMapping,
		LPVOID *	lpBuffer
	)

Definition at line 604 of file misc.c.

{
    DWORD dwError;
 
    TRACE("%s %p %p %p %p\n",
          debugstr_w(lpFileName), lpSize, lpFile, lpMapping, lpBuffer);
 
    *lpFile = CreateFileW(lpFileName, GENERIC_READ, FILE_SHARE_READ, NULL,
                          OPEN_EXISTING, 0, NULL);
    if (*lpFile == INVALID_HANDLE_VALUE)
        return GetLastError();
 
    *lpSize = GetFileSize(*lpFile, NULL);
    if (*lpSize == INVALID_FILE_SIZE)
    {
        dwError = GetLastError();
        CloseHandle(*lpFile);
        return dwError;
    }
 
    *lpMapping = CreateFileMappingW(*lpFile, NULL, PAGE_READONLY, 0,
                                    *lpSize, NULL);
    if (*lpMapping == NULL)
    {
        dwError = GetLastError();
        CloseHandle(*lpFile);
        return dwError;
    }
 
    *lpBuffer = MapViewOfFile(*lpMapping, FILE_MAP_READ, 0, 0, *lpSize);
    if (*lpBuffer == NULL)
    {
        dwError = GetLastError();
        CloseHandle(*lpMapping);
        CloseHandle(*lpFile);
        return dwError;
    }
 
    return ERROR_SUCCESS;
}

pSetupSetGlobalFlags()

void WINAPI pSetupSetGlobalFlags

(

DWORD

flags

)

Definition at line 867 of file misc.c.

{
    pSetupModifyGlobalFlags(0xFFFFFFFF, flags);
}

pSetupStringFromGuid()

DWORD WINAPI pSetupStringFromGuid	(	LPGUID	lpGUID,
		PWSTR	pString,
		DWORD	dwStringLen
	)

Definition at line 1775 of file misc.c.

{
    RPC_STATUS Status;
    RPC_WSTR rpcBuffer;
    WCHAR szBuffer[39];
 
    if (dwStringLen < 39)
    {
        return ERROR_INSUFFICIENT_BUFFER;
    }
 
    Status = UuidToStringW(lpGUID, &rpcBuffer);
    if (Status != RPC_S_OK)
    {
        return Status;
    }
 
    wcscpy(szBuffer, L"{");
    wcscat(szBuffer, rpcBuffer);
    wcscat(szBuffer, L"}");
 
    wcscpy(pString, szBuffer);
 
    RpcStringFreeW(&rpcBuffer);
    return NO_ERROR;
}

Referenced by CM_Get_Class_Registry_PropertyW(), CreateSymbolicLink(), and SetupDiCallClassInstaller().

pSetupUnicodeToMultiByte()

LPSTR WINAPI pSetupUnicodeToMultiByte	(	LPCWSTR	lpUnicodeStr,
		UINT	uCodePage
	)

Definition at line 327 of file misc.c.

{
    LPSTR lpMultiByteStr;
    int nLength;
 
    TRACE("%s %d\n", debugstr_w(lpUnicodeStr), uCodePage);
 
    nLength = WideCharToMultiByte(uCodePage, 0, lpUnicodeStr, -1,
                                  NULL, 0, NULL, NULL);
    if (nLength == 0)
        return NULL;
 
    lpMultiByteStr = MyMalloc(nLength);
    if (lpMultiByteStr == NULL)
        return NULL;
 
    if (!WideCharToMultiByte(uCodePage, 0, lpUnicodeStr, -1,
                             lpMultiByteStr, nLength, NULL, NULL))
    {
        MyFree(lpMultiByteStr);
        return NULL;
    }
 
    return lpMultiByteStr;
}

Referenced by GetFunctionPointer(), and SetupGetFileCompressionInfoExA().

pSetupUnmapAndCloseFile()

BOOL WINAPI pSetupUnmapAndCloseFile	(	HANDLE	hFile,
		HANDLE	hMapping,
		LPVOID	lpBuffer
	)

Definition at line 664 of file misc.c.

{
    TRACE("%p %p %p\n",
          hFile, hMapping, lpBuffer);
 
    if (!UnmapViewOfFile(lpBuffer))
        return FALSE;
 
    if (!CloseHandle(hMapping))
        return FALSE;
 
    if (!CloseHandle(hFile))
        return FALSE;
 
    return TRUE;
}

QueryRegistryValue()

LONG WINAPI QueryRegistryValue	(	HKEY	hKey,
		LPCWSTR	lpValueName,
		LPBYTE *	lpData,
		LPDWORD	lpType,
		LPDWORD	lpcbData
	)

Definition at line 234 of file misc.c.

{
    LONG lError;
 
    TRACE("%p %s %p %p %p\n",
          hKey, debugstr_w(lpValueName), lpData, lpType, lpcbData);
 
    /* Get required buffer size */
    *lpcbData = 0;
    lError = RegQueryValueExW(hKey, lpValueName, 0, lpType, NULL, lpcbData);
    if (lError != ERROR_SUCCESS)
        return lError;
 
    /* Allocate buffer */
    *lpData = MyMalloc(*lpcbData);
    if (*lpData == NULL)
        return ERROR_NOT_ENOUGH_MEMORY;
 
    /* Query registry value */
    lError = RegQueryValueExW(hKey, lpValueName, 0, lpType, *lpData, lpcbData);
    if (lError != ERROR_SUCCESS)
        MyFree(*lpData);
 
    return lError;
}

RetreiveFileSecurity()

DWORD WINAPI RetreiveFileSecurity	(	LPCWSTR	lpFileName,
		PSECURITY_DESCRIPTOR *	pSecurityDescriptor
	)

Definition at line 794 of file misc.c.

{
    PSECURITY_DESCRIPTOR SecDesc;
    DWORD dwSize = 0x100;
    DWORD dwError;
 
    TRACE("%s %p\n", debugstr_w(lpFileName), pSecurityDescriptor);
 
    SecDesc = MyMalloc(dwSize);
    if (SecDesc == NULL)
        return ERROR_NOT_ENOUGH_MEMORY;
 
    if (GetFileSecurityW(lpFileName, OWNER_SECURITY_INFORMATION |
                         GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION,
                         SecDesc, dwSize, &dwSize))
    {
      *pSecurityDescriptor = SecDesc;
      return ERROR_SUCCESS;
    }
 
    dwError = GetLastError();
    if (dwError != ERROR_INSUFFICIENT_BUFFER)
    {
        MyFree(SecDesc);
        return dwError;
    }
 
    SecDesc = MyRealloc(SecDesc, dwSize);
    if (SecDesc == NULL)
        return ERROR_NOT_ENOUGH_MEMORY;
 
    if (GetFileSecurityW(lpFileName, OWNER_SECURITY_INFORMATION |
                         GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION,
                         SecDesc, dwSize, &dwSize))
    {
      *pSecurityDescriptor = SecDesc;
      return ERROR_SUCCESS;
    }
 
    dwError = GetLastError();
    MyFree(SecDesc);
 
    return dwError;
}

SetupCloseLog()

void WINAPI SetupCloseLog

(

void

)

Definition at line 2017 of file misc.c.

{
    EnterCriticalSection(&setupapi_cs);
 
    CloseHandle(setupact);
    setupact = INVALID_HANDLE_VALUE;
 
    CloseHandle(setuperr);
    setuperr = INVALID_HANDLE_VALUE;
 
    LeaveCriticalSection(&setupapi_cs);
}

Referenced by DllMain(), and test_SetupLogError().

SetupDecompressOrCopyFileA()

DWORD WINAPI SetupDecompressOrCopyFileA	(	PCSTR	source,
		PCSTR	target,
		PUINT	type
	)

Definition at line 1656 of file misc.c.

{
    DWORD ret = 0;
    WCHAR *sourceW = NULL, *targetW = NULL;
 
    if (source && !(sourceW = pSetupMultiByteToUnicode( source, CP_ACP ))) return FALSE;
    if (target && !(targetW = pSetupMultiByteToUnicode( target, CP_ACP )))
    {
        MyFree( sourceW );
        return ERROR_NOT_ENOUGH_MEMORY;
    }
 
    ret = SetupDecompressOrCopyFileW( sourceW, targetW, type );
 
    MyFree( sourceW );
    MyFree( targetW );
 
    return ret;
}

Referenced by test_SetupDecompressOrCopyFile().

SetupDecompressOrCopyFileW()

DWORD WINAPI SetupDecompressOrCopyFileW	(	PCWSTR	source,
		PCWSTR	target,
		PUINT	type
	)

Definition at line 1690 of file misc.c.

{
    UINT comp;
    DWORD ret = ERROR_INVALID_PARAMETER;
 
    if (!source || !target) return ERROR_INVALID_PARAMETER;
 
    if (!type) comp = detect_compression_type( source );
    else comp = *type;
 
    switch (comp)
    {
    case FILE_COMPRESSION_NONE:
        if (CopyFileW( source, target, FALSE )) ret = ERROR_SUCCESS;
        else ret = GetLastError();
        break;
    case FILE_COMPRESSION_WINLZA:
        ret = decompress_file_lz( source, target );
        break;
    case FILE_COMPRESSION_NTCAB:
    case FILE_COMPRESSION_MSZIP:
        ret = decompress_file_cab( source, target );
        break;
    default:
        WARN("unknown compression type %d\n", comp);
        break;
    }
 
    TRACE("%s -> %s %d\n", debugstr_w(source), debugstr_w(target), comp);
    return ret;
}

Referenced by SetupDecompressOrCopyFileA().

SetupGetFileCompressionInfoA()

DWORD WINAPI SetupGetFileCompressionInfoA	(	PCSTR	source,
		PSTR *	name,
		PDWORD	source_size,
		PDWORD	target_size,
		PUINT	type
	)

Definition at line 1512 of file misc.c.

{
    BOOL ret;
    DWORD error, required;
    LPSTR actual_name;
 
    TRACE("%s, %p, %p, %p, %p\n", debugstr_a(source), name, source_size, target_size, type);
 
    if (!source || !name || !source_size || !target_size || !type)
        return ERROR_INVALID_PARAMETER;
 
    ret = SetupGetFileCompressionInfoExA( source, NULL, 0, &required, NULL, NULL, NULL );
    if (!(actual_name = MyMalloc( required ))) return ERROR_NOT_ENOUGH_MEMORY;
 
    ret = SetupGetFileCompressionInfoExA( source, actual_name, required, &required,
                                          source_size, target_size, type );
    if (!ret)
    {
        error = GetLastError();
        MyFree( actual_name );
        return error;
    }
    *name = actual_name;
    return ERROR_SUCCESS;
}

Referenced by test_SetupGetFileCompressionInfo().

SetupGetFileCompressionInfoExA()

BOOL WINAPI SetupGetFileCompressionInfoExA	(	PCSTR	source,
		PSTR	name,
		DWORD	len,
		PDWORD	required,
		PDWORD	source_size,
		PDWORD	target_size,
		PUINT	type
	)

Definition at line 1411 of file misc.c.

{
    BOOL ret;
    WCHAR *nameW = NULL, *sourceW = NULL;
    DWORD nb_chars = 0;
    LPSTR nameA;
 
    TRACE("%s, %p, %d, %p, %p, %p, %p\n", debugstr_a(source), name, len, required,
          source_size, target_size, type);
 
    if (!source || !(sourceW = pSetupMultiByteToUnicode( source, CP_ACP ))) return FALSE;
 
    if (name)
    {
        ret = SetupGetFileCompressionInfoExW( sourceW, NULL, 0, &nb_chars, NULL, NULL, NULL );
        if (!(nameW = HeapAlloc( GetProcessHeap(), 0, nb_chars * sizeof(WCHAR) )))
        {
            MyFree( sourceW );
            return FALSE;
        }
    }
    ret = SetupGetFileCompressionInfoExW( sourceW, nameW, nb_chars, &nb_chars, source_size, target_size, type );
    if (ret)
    {
        if ((nameA = pSetupUnicodeToMultiByte( nameW, CP_ACP )))
        {
            if (name && len >= nb_chars) lstrcpyA( name, nameA );
            else
            {
                SetLastError( ERROR_INSUFFICIENT_BUFFER );
                ret = FALSE;
            }
            MyFree( nameA );
        }
    }
    if (required) *required = nb_chars;
    HeapFree( GetProcessHeap(), 0, nameW );
    MyFree( sourceW );
 
    return ret;
}

Referenced by main(), and SetupGetFileCompressionInfoA().

SetupGetFileCompressionInfoExW()

BOOL WINAPI SetupGetFileCompressionInfoExW	(	PCWSTR	source,
		PWSTR	name,
		DWORD	len,
		PDWORD	required,
		PDWORD	source_size,
		PDWORD	target_size,
		PUINT	type
	)

Definition at line 1472 of file misc.c.

{
    UINT comp;
    BOOL ret = FALSE;
    DWORD source_len;
 
    TRACE("%s, %p, %d, %p, %p, %p, %p\n", debugstr_w(source), name, len, required,
          source_size, target_size, type);
 
    if (!source) return FALSE;
 
    source_len = lstrlenW( source ) + 1;
    if (required) *required = source_len;
    if (name && len >= source_len)
    {
        lstrcpyW( name, source );
        ret = TRUE;
    }
    else return FALSE;
 
    comp = detect_compression_type( source );
    if (type) *type = comp;
 
    switch (comp)
    {
    case FILE_COMPRESSION_MSZIP:
    case FILE_COMPRESSION_NTCAB:  ret = get_file_sizes_cab( source, source_size, target_size ); break;
    case FILE_COMPRESSION_NONE:   ret = get_file_sizes_none( source, source_size, target_size ); break;
    case FILE_COMPRESSION_WINLZA: ret = get_file_sizes_lz( source, source_size, target_size ); break;
    default: break;
    }
    return ret;
}

Referenced by SetupGetFileCompressionInfoExA(), and SetupGetFileCompressionInfoW().

SetupGetFileCompressionInfoW()

DWORD WINAPI SetupGetFileCompressionInfoW	(	PCWSTR	source,
		PWSTR *	name,
		PDWORD	source_size,
		PDWORD	target_size,
		PUINT	type
	)

Definition at line 1555 of file misc.c.

{
    BOOL ret;
    DWORD error, required;
    LPWSTR actual_name;
 
    TRACE("%s, %p, %p, %p, %p\n", debugstr_w(source), name, source_size, target_size, type);
 
    if (!source || !name || !source_size || !target_size || !type)
        return ERROR_INVALID_PARAMETER;
 
    ret = SetupGetFileCompressionInfoExW( source, NULL, 0, &required, NULL, NULL, NULL );
    if (!(actual_name = MyMalloc( required*sizeof(WCHAR) ))) return ERROR_NOT_ENOUGH_MEMORY;
 
    ret = SetupGetFileCompressionInfoExW( source, actual_name, required, &required,
                                          source_size, target_size, type );
    if (!ret)
    {
        error = GetLastError();
        MyFree( actual_name );
        return error;
    }
    *name = actual_name;
    return ERROR_SUCCESS;
}

SetupGetNonInteractiveMode()

BOOL WINAPI SetupGetNonInteractiveMode

(

VOID

)

Definition at line 875 of file misc.c.

{
    return (GlobalSetupFlags & PSPGF_NONINTERACTIVE);
}

SetupInitializeFileLogA()

HSPFILELOG WINAPI SetupInitializeFileLogA	(	LPCSTR	LogFileName,
		DWORD	Flags
	)

Definition at line 1965 of file misc.c.

{
    HSPFILELOG hLog;
    LPWSTR LogFileNameW = NULL;
 
    TRACE("%s, 0x%x\n",debugstr_a(LogFileName),Flags);
 
    if (LogFileName)
    {
        LogFileNameW = strdupAtoW(LogFileName);
 
        if (!LogFileNameW)
        {
            /* not enough memory */
            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
            return INVALID_HANDLE_VALUE;
        }
 
        hLog = SetupInitializeFileLogW(LogFileNameW, Flags);
        HeapFree(GetProcessHeap(), 0, LogFileNameW);
    }
    else
    {
        hLog = SetupInitializeFileLogW(NULL, Flags);
    }
 
    return hLog;
}

SetupInitializeFileLogW()

HSPFILELOG WINAPI SetupInitializeFileLogW	(	LPCWSTR	LogFileName,
		DWORD	Flags
	)

Definition at line 1843 of file misc.c.

{
    struct FileLog * Log;
    HANDLE hLog;
    WCHAR Windir[MAX_PATH];
    DWORD ret;
 
    TRACE("%s, 0x%x\n",debugstr_w(LogFileName),Flags);
 
    if (Flags & SPFILELOG_SYSTEMLOG)
    {
        if (!pSetupIsUserAdmin() && !(Flags & SPFILELOG_QUERYONLY))
        {
            /* insufficient privileges */
            SetLastError(ERROR_ACCESS_DENIED);
            return INVALID_HANDLE_VALUE;
        }
 
        if (LogFileName || (Flags & SPFILELOG_FORCENEW))
        {
            /* invalid parameter */
            SetLastError(ERROR_INVALID_PARAMETER);
            return INVALID_HANDLE_VALUE;
        }
 
        ret = GetSystemWindowsDirectoryW(Windir, MAX_PATH);
        if (!ret || ret >= MAX_PATH)
        {
            /* generic failure */
            return INVALID_HANDLE_VALUE;
        }
 
        /* append path */
        wcscat(Windir, L"repair\\setup.log");
    }
    else
    {
        if (!LogFileName)
        {
            /* invalid parameter */
            SetLastError(ERROR_INVALID_PARAMETER);
            return INVALID_HANDLE_VALUE;
        }
        /* copy filename */
        wcsncpy(Windir, LogFileName, MAX_PATH);
    }
 
    if (FileExists(Windir, NULL))
    {
        /* take ownership */
        ret = TakeOwnershipOfFile(Windir);
 
        if (ret != ERROR_SUCCESS)
        {
            /* failed */
            SetLastError(ret);
            return INVALID_HANDLE_VALUE;
        }
 
        if (!SetFileAttributesW(Windir, FILE_ATTRIBUTE_NORMAL))
        {
            /* failed */
            return INVALID_HANDLE_VALUE;
        }
 
        if ((Flags & SPFILELOG_FORCENEW))
        {
            if (!DeleteFileW(Windir))
            {
                /* failed */
                return INVALID_HANDLE_VALUE;
            }
        }
    }
 
    /* open log file */
    hLog = CreateFileW(Windir,
                       (Flags & SPFILELOG_QUERYONLY) ? GENERIC_READ : GENERIC_WRITE,
                       FILE_SHARE_READ | FILE_SHARE_WRITE,
                       NULL,
                       OPEN_ALWAYS,
                       FILE_ATTRIBUTE_NORMAL,
                       NULL);
 
    if (hLog == INVALID_HANDLE_VALUE)
    {
        /* failed */
        return INVALID_HANDLE_VALUE;
    }
 
    /* close log handle */
    CloseHandle(hLog);
 
    /* allocate file log struct */
    Log = HeapAlloc(GetProcessHeap(), 0, sizeof(struct FileLog));
    if (!Log)
    {
        /* not enough memory */
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return INVALID_HANDLE_VALUE;
    }
 
    /* initialize log */
    Log->LogName = HeapAlloc(GetProcessHeap(), 0, (wcslen(Windir)+1) * sizeof(WCHAR));
    if (!Log->LogName)
    {
        /* not enough memory */
        HeapFree(GetProcessHeap(), 0, Log);
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return INVALID_HANDLE_VALUE;
    }
 
    wcscpy(Log->LogName, Windir);
    Log->ReadOnly = (Flags & SPFILELOG_QUERYONLY);
    Log->SystemLog = (Flags & SPFILELOG_SYSTEMLOG);
 
    return (HSPFILELOG)Log;
}

Referenced by SetupInitializeFileLogA().

SetupLogErrorA()

BOOL WINAPI SetupLogErrorA	(	LPCSTR	message,
		LogSeverity	severity
	)

Definition at line 2084 of file misc.c.

{
    static const char null[] = "(null)";
    BOOL ret;
    DWORD written;
    DWORD len;
 
    EnterCriticalSection(&setupapi_cs);
 
    if (setupact == INVALID_HANDLE_VALUE || setuperr == INVALID_HANDLE_VALUE)
    {
        SetLastError(ERROR_FILE_INVALID);
        ret = FALSE;
        goto done;
    }
 
    if (message == NULL)
        message = null;
 
    len = lstrlenA(message);
 
    ret = WriteFile(setupact, message, len, &written, NULL);
    if (!ret)
        goto done;
 
    if (severity >= LogSevMaximum)
    {
        ret = FALSE;
        goto done;
    }
 
    if (severity > LogSevInformation)
        ret = WriteFile(setuperr, message, len, &written, NULL);
 
done:
    LeaveCriticalSection(&setupapi_cs);
    return ret;
}

Referenced by SetupLogErrorW(), and test_SetupLogError().

SetupLogErrorW()

BOOL WINAPI SetupLogErrorW	(	LPCWSTR	message,
		LogSeverity	severity
	)

Definition at line 2126 of file misc.c.

{
    LPSTR msg = NULL;
    DWORD len;
    BOOL ret;
 
    if (message)
    {
        len = WideCharToMultiByte(CP_ACP, 0, message, -1, NULL, 0, NULL, NULL);
        msg = HeapAlloc(GetProcessHeap(), 0, len);
        if (msg == NULL)
        {
            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
            return FALSE;
        }
        WideCharToMultiByte(CP_ACP, 0, message, -1, msg, len, NULL, NULL);
    }
 
    /* This is the normal way to proceed. The log files are ASCII files
     * and W is to be converted.
     */
    ret = SetupLogErrorA(msg, severity);
 
    HeapFree(GetProcessHeap(), 0, msg);
    return ret;
}

SetupOpenLog()

BOOL WINAPI SetupOpenLog

(

BOOL

reserved

)

Definition at line 2033 of file misc.c.

{
    WCHAR path[MAX_PATH];
 
    static const WCHAR setupactlog[] = {'\\','s','e','t','u','p','a','c','t','.','l','o','g',0};
    static const WCHAR setuperrlog[] = {'\\','s','e','t','u','p','e','r','r','.','l','o','g',0};
 
    EnterCriticalSection(&setupapi_cs);
 
    if (setupact != INVALID_HANDLE_VALUE && setuperr != INVALID_HANDLE_VALUE)
    {
        LeaveCriticalSection(&setupapi_cs);
        return TRUE;
    }
 
    GetWindowsDirectoryW(path, MAX_PATH);
    lstrcatW(path, setupactlog);
 
    setupact = CreateFileW(path, FILE_GENERIC_WRITE, FILE_SHARE_WRITE | FILE_SHARE_READ,
                           NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    if (setupact == INVALID_HANDLE_VALUE)
    {
        LeaveCriticalSection(&setupapi_cs);
        return FALSE;
    }
 
    SetFilePointer(setupact, 0, NULL, FILE_END);
 
    GetWindowsDirectoryW(path, MAX_PATH);
    lstrcatW(path, setuperrlog);
 
    setuperr = CreateFileW(path, FILE_GENERIC_WRITE, FILE_SHARE_WRITE | FILE_SHARE_READ,
                           NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    if (setuperr == INVALID_HANDLE_VALUE)
    {
        CloseHandle(setupact);
        setupact = INVALID_HANDLE_VALUE;
        LeaveCriticalSection(&setupapi_cs);
        return FALSE;
    }
 
    SetFilePointer(setuperr, 0, NULL, FILE_END);
 
    LeaveCriticalSection(&setupapi_cs);
 
    return TRUE;
}

Referenced by test_SetupLogError().

SetupSetNonInteractiveMode()

BOOL WINAPI SetupSetNonInteractiveMode

(

BOOL

NonInteractiveFlag

)

Definition at line 883 of file misc.c.

{
    BOOL OldValue;
 
    OldValue = (GlobalSetupFlags & PSPGF_NONINTERACTIVE);
    pSetupModifyGlobalFlags(PSPGF_NONINTERACTIVE,
                            NonInteractiveFlag ? PSPGF_NONINTERACTIVE : 0);
 
    return OldValue;
}

SetupTerminateFileLog()

BOOL WINAPI SetupTerminateFileLog

(

HANDLE

FileLogHandle

)

Definition at line 1997 of file misc.c.

{
    struct FileLog * Log;
 
    TRACE ("%p\n",FileLogHandle);
 
    Log = (struct FileLog *)FileLogHandle;
 
    /* free file log handle */
    HeapFree(GetProcessHeap(), 0, Log->LogName);
    HeapFree(GetProcessHeap(), 0, Log);
 
    SetLastError(ERROR_SUCCESS);
 
    return TRUE;
}

SetupUninstallOEMInfA()

BOOL WINAPI SetupUninstallOEMInfA	(	PCSTR	inf_file,
		DWORD	flags,
		PVOID	reserved
	)

Definition at line 1243 of file misc.c.

{
    BOOL ret;
    WCHAR *inf_fileW = NULL;
 
    TRACE("%s, 0x%08x, %p\n", debugstr_a(inf_file), flags, reserved);
 
    if (inf_file && !(inf_fileW = strdupAtoW( inf_file ))) return FALSE;
    ret = SetupUninstallOEMInfW( inf_fileW, flags, reserved );
    HeapFree( GetProcessHeap(), 0, inf_fileW );
    return ret;
}

SetupUninstallOEMInfW()

BOOL WINAPI SetupUninstallOEMInfW	(	PCWSTR	inf_file,
		DWORD	flags,
		PVOID	reserved
	)

Definition at line 1214 of file misc.c.

{
    static const WCHAR infW[] = {'\\','i','n','f','\\',0};
    WCHAR target[MAX_PATH];
 
    TRACE("%s, 0x%08x, %p\n", debugstr_w(inf_file), flags, reserved);
 
    if (!inf_file)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    if (!GetWindowsDirectoryW( target, sizeof(target)/sizeof(WCHAR) )) return FALSE;
 
    strcatW( target, infW );
    strcatW( target, inf_file );
 
    if (flags & SUOI_FORCEDELETE)
        return DeleteFileW(target);
 
    FIXME("not deleting %s\n", debugstr_w(target));
 
    return TRUE;
}

Referenced by SetupUninstallOEMInfA().

StampFileSecurity()

DWORD WINAPI StampFileSecurity	(	LPCWSTR	lpFileName,
		PSECURITY_DESCRIPTOR	pSecurityDescriptor
	)

Definition at line 695 of file misc.c.

{
    TRACE("%s %p\n", debugstr_w(lpFileName), pSecurityDescriptor);
 
    if (!SetFileSecurityW(lpFileName, OWNER_SECURITY_INFORMATION |
                          GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION,
                          pSecurityDescriptor))
        return GetLastError();
 
    return ERROR_SUCCESS;
}

TakeOwnershipOfFile()

DWORD WINAPI TakeOwnershipOfFile

(

LPCWSTR

lpFileName

)

Definition at line 720 of file misc.c.

{
    SECURITY_DESCRIPTOR SecDesc;
    HANDLE hToken = NULL;
    PTOKEN_OWNER pOwner = NULL;
    DWORD dwError;
    DWORD dwSize;
 
    TRACE("%s\n", debugstr_w(lpFileName));
 
    if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken))
        return GetLastError();
 
    if (!GetTokenInformation(hToken, TokenOwner, NULL, 0, &dwSize))
    {
        goto fail;
    }
 
    pOwner = (PTOKEN_OWNER)MyMalloc(dwSize);
    if (pOwner == NULL)
    {
        CloseHandle(hToken);
        return ERROR_NOT_ENOUGH_MEMORY;
    }
 
    if (!GetTokenInformation(hToken, TokenOwner, pOwner, dwSize, &dwSize))
    {
        goto fail;
    }
 
    if (!InitializeSecurityDescriptor(&SecDesc, SECURITY_DESCRIPTOR_REVISION))
    {
        goto fail;
    }
 
    if (!SetSecurityDescriptorOwner(&SecDesc, pOwner->Owner, FALSE))
    {
        goto fail;
    }
 
    if (!SetFileSecurityW(lpFileName, OWNER_SECURITY_INFORMATION, &SecDesc))
    {
        goto fail;
    }
 
    MyFree(pOwner);
    CloseHandle(hToken);
 
    return ERROR_SUCCESS;
 
fail:;
    dwError = GetLastError();
 
    MyFree(pOwner);
 
    if (hToken != NULL)
        CloseHandle(hToken);
 
    return dwError;
}

Referenced by SetupInitializeFileLogW().

TrimGuidString()

static BOOL TrimGuidString ( PCWSTR  szString, LPWSTR  szNewString  )

static

Definition at line 1725 of file misc.c.

{
    WCHAR szBuffer[39];
    INT Index;
 
    if (wcslen(szString) == 38)
    {
        if ((szString[0] == L'{') && (szString[37] == L'}'))
        {
            for (Index = 0; Index < wcslen(szString); Index++)
                szBuffer[Index] = szString[Index + 1];
 
            szBuffer[36] = L'\0';
            wcscpy(szNewString, szBuffer);
            return TRUE;
        }
    }
    szNewString[0] = L'\0';
    return FALSE;
}

Referenced by pSetupGuidFromString().

Variable Documentation

BackSlash

const WCHAR BackSlash[] = {'\\',0}

static

Definition at line 28 of file misc.c.

Referenced by pSetupGetVersionInfoFromImage().

critsect_debug

CRITICAL_SECTION_DEBUG critsect_debug

static

Initial value:

=
{
    0, 0, &setupapi_cs,
    { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
    0, 0, { (DWORD_PTR)(__FILE__ ": setupapi_cs") }
}

Definition at line 35 of file misc.c.

GlobalSetupFlags

DWORD GlobalSetupFlags = 0

Definition at line 845 of file misc.c.

Referenced by InstallHinfSectionW(), pSetupGetGlobalFlags(), pSetupModifyGlobalFlags(), SetupGetNonInteractiveMode(), and SetupSetNonInteractiveMode().

setupact

HANDLE setupact = INVALID_HANDLE_VALUE

static

Definition at line 32 of file misc.c.

Referenced by SetupCloseLog(), SetupLogErrorA(), and SetupOpenLog().

setupapi_cs

static CRITICAL_SECTION setupapi_cs = { &critsect_debug, -1, 0, 0, 0, 0 }

static

Definition at line 34 of file misc.c.

Referenced by SetupCloseLog(), SetupLogErrorA(), and SetupOpenLog().

setuperr

HANDLE setuperr = INVALID_HANDLE_VALUE

static

Definition at line 33 of file misc.c.

Referenced by SetupCloseLog(), SetupLogErrorA(), and SetupOpenLog().

TranslationRegKey

const WCHAR TranslationRegKey[] = {'\\','V','e','r','F','i','l','e','I','n','f','o','\\','T','r','a','n','s','l','a','t','i','o','n',0}

static

Definition at line 29 of file misc.c.

Referenced by pSetupGetVersionInfoFromImage().