setupapi_private.h File Reference

#include <wchar.h>
#include <windef.h>
#include <winbase.h>
#include <winuser.h>
#include <wingdi.h>
#include <winreg.h>
#include <winspool.h>
#include <wincon.h>
#include <commdlg.h>
#include <objbase.h>
#include <cfgmgr32.h>
#include <regstr.h>
#include <sddl.h>
#include <setupapi.h>
#include <softpub.h>
#include <mscat.h>
#include <lzexpand.h>
#include <shlobj.h>
#include <wine/unicode.h>
#include <ndk/rtlfuncs.h>
#include <wine/debug.h>
#include "resource.h"

Include dependency graph for setupapi_private.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	DeviceInterface
struct	InfFileDetails
struct	DriverInfoElement
struct	ClassInstallParams
struct	DeviceInfo
struct	DeviceInfoSet
struct	ClassImageList
struct	FileLog
struct	callback_WtoA_context

Macros
#define	WIN32_NO_STATUS
#define	_INC_WINDOWS
#define	COM_NO_WINDOWS_H
#define	COBJMACROS
#define	NTOS_MODE_USER
#define	SETUP_DEVICE_INFO_SET_MAGIC   0xd00ff057
#define	SETUP_CLASS_IMAGE_LIST_MAGIC   0xd00ff058
#define	CMP_MAGIC   0x01234567
#define	PSPGF_NO_BACKUP   0x0002
#define	PSPGF_NONINTERACTIVE   0x0004
#define	RC_STRING_MAX_SIZE   256
#define	REG_INSTALLEDFILES   "System\\CurrentControlSet\\Control\\InstalledFiles"
#define	REGPART_RENAME   "\\Rename"
#define	REG_VERSIONCONFLICT   "Software\\Microsoft\\VersionConflictManager"
#define	_S_IWRITE   0x0080
#define	_S_IREAD   0x0100

Typedefs
typedef BOOL(*	FIND_CALLBACK) (LPCWSTR SectionName, PVOID Context)

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (setupapi)
static WCHAR *	strdupAtoW (const char *str)
const WCHAR *	DIRID_get_string (int dirid)
const WCHAR *	PARSER_get_inf_filename (HINF hinf) DECLSPEC_HIDDEN
WCHAR *	PARSER_get_src_root (HINF hinf) DECLSPEC_HIDDEN
WCHAR *	PARSER_get_dest_dir (INFCONTEXT *context) DECLSPEC_HIDDEN
UINT CALLBACK	QUEUE_callback_WtoA (void *context, UINT notification, UINT_PTR, UINT_PTR)
DWORD	GetErrorCodeFromCrCode (const IN CONFIGRET cr)
BOOL	CreateDeviceInfo (IN struct DeviceInfoSet *list, IN LPCWSTR InstancePath, IN LPCGUID pClassGuid, OUT struct DeviceInfo **pDeviceInfo)
LONG	SETUP_CreateDevicesList (IN OUT struct DeviceInfoSet *list, IN PCWSTR MachineName OPTIONAL, IN CONST GUID *Class OPTIONAL, IN PCWSTR Enumerator OPTIONAL)
HKEY	SETUPDI_CreateDevKey (HKEY RootKey, struct DeviceInfo *devInfo, REGSAM samDesired)
HKEY	SETUPDI_CreateDrvKey (HKEY RootKey, struct DeviceInfo *devInfo, UUID *ClassGuid, REGSAM samDesired)
HKEY	SETUPDI_OpenDevKey (HKEY RootKey, struct DeviceInfo *devInfo, REGSAM samDesired)
HKEY	SETUPDI_OpenDrvKey (HKEY RootKey, struct DeviceInfo *devInfo, REGSAM samDesired)
struct InfFileDetails *	CreateInfFileDetails (IN LPCWSTR FullInfFileName)
VOID	DereferenceInfFile (struct InfFileDetails *infFile)
BOOL	DestroyDriverInfoElement (struct DriverInfoElement *driverInfo)
BOOL	GetStringField (PINFCONTEXT context, DWORD index, PWSTR *value)
BOOL	DestroyDeviceInterface (struct DeviceInterface *deviceInterface)
LONG	SETUP_CreateInterfaceList (struct DeviceInfoSet *list, PCWSTR MachineName, CONST GUID *InterfaceGuid, PCWSTR DeviceInstanceW, BOOL OnlyPresentInterfaces)
DWORD	GetFunctionPointer (IN PWSTR InstallerName, OUT HMODULE *ModulePointer, OUT PVOID *FunctionPointer)
DWORD	FreeFunctionPointer (IN HMODULE ModulePointer, IN PVOID FunctionPointer)
DWORD WINAPI	pSetupStringFromGuid (LPGUID lpGUID, PWSTR pString, DWORD dwStringLen)
DWORD WINAPI	CaptureAndConvertAnsiArg (LPCSTR pSrc, LPWSTR *pDst)
VOID WINAPI	MyFree (LPVOID lpMem)
LPVOID WINAPI	MyMalloc (DWORD dwSize)
LPVOID WINAPI	MyRealloc (LPVOID lpSrc, DWORD dwSize)
LPWSTR WINAPI	DuplicateString (LPCWSTR lpSrc)
BOOL WINAPI	IsUserAdmin (VOID)
LPWSTR WINAPI	MultiByteToUnicode (LPCSTR lpMultiByteStr, UINT uCodePage)
LPSTR WINAPI	UnicodeToMultiByte (LPCWSTR lpUnicodeStr, UINT uCodePage)
BOOL	EnumerateSectionsStartingWith (HINF hInf, LPCWSTR pStr, FIND_CALLBACK Callback, PVOID Context)

Variables
HINSTANCE	hInstance
OSVERSIONINFOEXW	OsVersionInfo
DWORD	GlobalSetupFlags

Macro Definition Documentation

_INC_WINDOWS

#define _INC_WINDOWS

Definition at line 26 of file setupapi_private.h.

_S_IREAD

#define _S_IREAD   0x0100

Definition at line 297 of file setupapi_private.h.

_S_IWRITE

#define _S_IWRITE   0x0080

Definition at line 296 of file setupapi_private.h.

CMP_MAGIC

#define CMP_MAGIC   0x01234567

Definition at line 66 of file setupapi_private.h.

COBJMACROS

#define COBJMACROS

Definition at line 29 of file setupapi_private.h.

COM_NO_WINDOWS_H

#define COM_NO_WINDOWS_H

Definition at line 27 of file setupapi_private.h.

NTOS_MODE_USER

#define NTOS_MODE_USER

Definition at line 51 of file setupapi_private.h.

PSPGF_NO_BACKUP

#define PSPGF_NO_BACKUP   0x0002

Definition at line 256 of file setupapi_private.h.

PSPGF_NONINTERACTIVE

#define PSPGF_NONINTERACTIVE   0x0004

Definition at line 257 of file setupapi_private.h.

RC_STRING_MAX_SIZE

#define RC_STRING_MAX_SIZE   256

Definition at line 259 of file setupapi_private.h.

REG_INSTALLEDFILES

#define REG_INSTALLEDFILES   "System\\CurrentControlSet\\Control\\InstalledFiles"

Definition at line 261 of file setupapi_private.h.

REG_VERSIONCONFLICT

#define REG_VERSIONCONFLICT   "Software\\Microsoft\\VersionConflictManager"

Definition at line 263 of file setupapi_private.h.

REGPART_RENAME

#define REGPART_RENAME   "\\Rename"

Definition at line 262 of file setupapi_private.h.

SETUP_CLASS_IMAGE_LIST_MAGIC

#define SETUP_CLASS_IMAGE_LIST_MAGIC   0xd00ff058

Definition at line 64 of file setupapi_private.h.

SETUP_DEVICE_INFO_SET_MAGIC

#define SETUP_DEVICE_INFO_SET_MAGIC   0xd00ff057

Definition at line 63 of file setupapi_private.h.

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 25 of file setupapi_private.h.

Typedef Documentation

FIND_CALLBACK

typedef BOOL(* FIND_CALLBACK) (LPCWSTR SectionName, PVOID Context)

Definition at line 383 of file setupapi_private.h.

Function Documentation

CaptureAndConvertAnsiArg()

DWORD WINAPI CaptureAndConvertAnsiArg	(	LPCSTR	pSrc,
		LPWSTR *	pDst
	)

CreateDeviceInfo()

BOOL CreateDeviceInfo	(	IN struct DeviceInfoSet *	list,
		IN LPCWSTR	InstancePath,
		IN LPCGUID	pClassGuid,
		OUT struct DeviceInfo **	pDeviceInfo
	)

Definition at line 528 of file devinst.c.

{
    DWORD size;
    CONFIGRET cr;
    struct DeviceInfo *deviceInfo;
 
    *pDeviceInfo = NULL;
 
    size = FIELD_OFFSET(struct DeviceInfo, Data) + (strlenW(InstancePath) + 1) * sizeof(WCHAR);
    deviceInfo = HeapAlloc(GetProcessHeap(), 0, size);
    if (!deviceInfo)
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }
    ZeroMemory(deviceInfo, size);
 
    cr = CM_Locate_DevNode_ExW(&deviceInfo->dnDevInst, (DEVINSTID_W)InstancePath, CM_LOCATE_DEVNODE_PHANTOM, list->hMachine);
    if (cr != CR_SUCCESS)
    {
        SetLastError(GetErrorCodeFromCrCode(cr));
        return FALSE;
    }
 
    deviceInfo->set = list;
    deviceInfo->InstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS_W);
    strcpyW(deviceInfo->Data, InstancePath);
    deviceInfo->instanceId = deviceInfo->Data;
    deviceInfo->UniqueId = strrchrW(deviceInfo->Data, '\\');
    deviceInfo->DeviceDescription = NULL;
    memcpy(&deviceInfo->ClassGuid, pClassGuid, sizeof(GUID));
    deviceInfo->CreationFlags = 0;
    InitializeListHead(&deviceInfo->DriverListHead);
    InitializeListHead(&deviceInfo->InterfaceListHead);
 
    *pDeviceInfo = deviceInfo;
    return TRUE;
}

Referenced by SETUP_CreateDevicesList(), SETUP_CreateInterfaceList(), SetupDiCreateDeviceInfoW(), SetupDiOpenDeviceInfoW(), and SetupDiOpenDeviceInterfaceW().

CreateInfFileDetails()

struct InfFileDetails * CreateInfFileDetails

(

IN LPCWSTR

FullInfFileName

)

Definition at line 55 of file driver.c.

{
    struct InfFileDetails *details;
    PWCHAR last;
    DWORD Needed;
 
    Needed = FIELD_OFFSET(struct InfFileDetails, szData)
        + strlenW(FullInfFileName) * sizeof(WCHAR) + sizeof(UNICODE_NULL);
 
    details = HeapAlloc(GetProcessHeap(), 0, Needed);
    if (!details)
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return NULL;
    }
 
    memset(details, 0, Needed);
    strcpyW(details->szData, FullInfFileName);
    last = strrchrW(details->szData, '\\');
    if (last)
    {
        details->DirectoryName = details->szData;
        details->FileName = last + 1;
        *last = '\0';
    }
    else
        details->FileName = details->szData;
    ReferenceInfFile(details);
    details->hInf = SetupOpenInfFileW(FullInfFileName, NULL, INF_STYLE_WIN4, NULL);
    if (details->hInf == INVALID_HANDLE_VALUE)
    {
        HeapFree(GetProcessHeap(), 0, details);
        return NULL;
    }
    return details;
}

Referenced by SetupDiBuildDriverInfoList(), and SetupDiInstallDevice().

DereferenceInfFile()

VOID DereferenceInfFile

(

struct InfFileDetails *

infFile

)

Definition at line 45 of file driver.c.

{
    if (InterlockedDecrement(&infFile->References) == 0)
    {
        SetupCloseInfFile(infFile->hInf);
        HeapFree(GetProcessHeap(), 0, infFile);
    }
}

Referenced by DestroyDriverInfoElement(), SetupDiBuildDriverInfoList(), and SetupDiInstallDevice().

DestroyDeviceInterface()

BOOL DestroyDeviceInterface

(

struct DeviceInterface *

deviceInterface

)

Definition at line 61 of file interface.c.

{
    return HeapFree(GetProcessHeap(), 0, deviceInterface);
}

Referenced by DestroyDeviceInfo(), and SETUP_CreateInterfaceList().

DestroyDriverInfoElement()

BOOL DestroyDriverInfoElement

(

struct DriverInfoElement *

driverInfo

)

Definition at line 94 of file driver.c.

{
    DereferenceInfFile(driverInfo->InfFileDetails);
    HeapFree(GetProcessHeap(), 0, driverInfo->MatchingId);
    HeapFree(GetProcessHeap(), 0, driverInfo);
    return TRUE;
}

Referenced by DestroyDeviceInfo(), and SetupDiDestroyDriverInfoList().

DIRID_get_string()

const WCHAR * DIRID_get_string

(

int

dirid

)

Definition at line 159 of file dirid.c.

{
    int i;
 
    if (dirid == DIRID_ABSOLUTE || dirid == DIRID_ABSOLUTE_16BIT) dirid = DIRID_NULL;
 
    if (dirid >= DIRID_USER)
    {
        for (i = 0; i < nb_user_dirids; i++)
            if (user_dirids[i].id == dirid) return user_dirids[i].str;
        WARN("user id %d not found\n", dirid );
        return NULL;
    }
    else if (dirid >= MIN_CSIDL_DIRID)
    {
        if (dirid > MAX_CSIDL_DIRID) return get_unknown_dirid();
        dirid -= MIN_CSIDL_DIRID;
        if (!csidl_dirids[dirid]) csidl_dirids[dirid] = get_csidl_dir( dirid );
        return csidl_dirids[dirid];
    }
    else
    {
        if (dirid > MAX_SYSTEM_DIRID) return get_unknown_dirid();
        if (!system_dirids[dirid]) system_dirids[dirid] = create_system_dirid( dirid );
        return system_dirids[dirid];
    }
}

Referenced by Concatenate(), and get_dirid_subst().

DuplicateString()

LPWSTR WINAPI DuplicateString

(

LPCWSTR

lpSrc

)

EnumerateSectionsStartingWith()

BOOL EnumerateSectionsStartingWith	(	HINF	hInf,
		LPCWSTR	pStr,
		FIND_CALLBACK	Callback,
		PVOID	Context
	)

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().

GetErrorCodeFromCrCode()

DWORD GetErrorCodeFromCrCode

(

const IN CONFIGRET

cr

)

Definition at line 94 of file devinst.c.

{
  switch (cr)
  {
    case CR_ACCESS_DENIED:        return ERROR_ACCESS_DENIED;
    case CR_BUFFER_SMALL:         return ERROR_INSUFFICIENT_BUFFER;
    case CR_CALL_NOT_IMPLEMENTED: return ERROR_CALL_NOT_IMPLEMENTED;
    case CR_FAILURE:              return ERROR_GEN_FAILURE;
    case CR_INVALID_DATA:         return ERROR_INVALID_USER_BUFFER;
    case CR_INVALID_DEVICE_ID:    return ERROR_INVALID_PARAMETER;
    case CR_INVALID_MACHINENAME:  return ERROR_INVALID_COMPUTERNAME;
    case CR_INVALID_DEVNODE:      return ERROR_INVALID_PARAMETER;
    case CR_INVALID_FLAG:         return ERROR_INVALID_FLAGS;
    case CR_INVALID_POINTER:      return ERROR_INVALID_PARAMETER;
    case CR_INVALID_PROPERTY:     return ERROR_INVALID_PARAMETER;
    case CR_NO_SUCH_DEVNODE:      return ERROR_FILE_NOT_FOUND;
    case CR_NO_SUCH_REGISTRY_KEY: return ERROR_FILE_NOT_FOUND;
    case CR_NO_SUCH_VALUE:        return ERROR_FILE_NOT_FOUND;
    case CR_OUT_OF_MEMORY:        return ERROR_NOT_ENOUGH_MEMORY;
    case CR_REGISTRY_ERROR:       return ERROR_GEN_FAILURE;
    case CR_ALREADY_SUCH_DEVINST: return ERROR_DEVINST_ALREADY_EXISTS;
    case CR_SUCCESS:              return ERROR_SUCCESS;
    default:                      return ERROR_GEN_FAILURE;
  }
 
  /* Does not happen */
}

Referenced by CreateDeviceInfo(), ResetDevice(), SETUP_CreateDevicesList(), SetupDiBuildClassInfoListExW(), SetupDiCreateDeviceInfoListExW(), SetupDiCreateDeviceInfoW(), SetupDiRestartDevices(), and StopDevice().

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().

GetStringField()

BOOL GetStringField	(	PINFCONTEXT	context,
		DWORD	index,
		PWSTR *	value
	)

Definition at line 1703 of file install.c.

{
    DWORD RequiredSize;
    BOOL ret;
 
    ret = SetupGetStringFieldW(
        context,
        index,
        NULL, 0,
        &RequiredSize);
    if (!ret)
        return FALSE;
    else if (RequiredSize == 0)
    {
        *value = NULL;
        return TRUE;
    }
 
    /* We got the needed size for the buffer */
    *value = MyMalloc(RequiredSize * sizeof(WCHAR));
    if (!*value)
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }
    ret = SetupGetStringFieldW(
        context,
        index,
        *value, RequiredSize, NULL);
    if (!ret)
        MyFree(*value);
 
    return ret;
}

Referenced by profile_items_callback(), SetupDiInstallDeviceInterfaces(), and SetupInstallServicesFromInfSectionExW().

IsUserAdmin()

BOOL WINAPI IsUserAdmin

(

VOID

)

Definition at line 81 of file register.cpp.

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

MultiByteToUnicode()

LPWSTR WINAPI MultiByteToUnicode	(	LPCSTR	lpMultiByteStr,
		UINT	uCodePage
	)

MyFree()

VOID WINAPI MyFree

(

LPVOID

lpMem

)

Definition at line 128 of file misc.c.

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

MyMalloc()

LPVOID WINAPI MyMalloc

(

DWORD

dwSize

)

Definition at line 147 of file misc.c.

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

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);
}

PARSER_get_dest_dir()

WCHAR * PARSER_get_dest_dir

(

INFCONTEXT *

context

)

Definition at line 1116 of file parser.c.

{
    const WCHAR *dir;
    WCHAR *ptr, *ret;
    INT dirid;
    unsigned int len1;
    DWORD len2;
 
    if (!SetupGetIntField( context, 1, &dirid )) return NULL;
    if (!(dir = get_dirid_subst( context->Inf, dirid, &len1 ))) return NULL;
    if (!SetupGetStringFieldW( context, 2, NULL, 0, &len2 )) len2 = 0;
    if (!(ret = HeapAlloc( GetProcessHeap(), 0, (len1+len2+1) * sizeof(WCHAR) ))) return NULL;
    memcpy( ret, dir, len1 * sizeof(WCHAR) );
    ptr = ret + len1;
    if (len2 && ptr > ret && ptr[-1] != '\\') *ptr++ = '\\';
    if (!SetupGetStringFieldW( context, 2, ptr, len2, NULL )) *ptr = 0;
    return ret;
}

Referenced by get_destination_dir(), register_dlls_callback(), and SetupGetTargetPathW().

PARSER_get_inf_filename()

const WCHAR * PARSER_get_inf_filename

(

HINF

hinf

)

Definition at line 1084 of file parser.c.

{
    struct inf_file *file = hinf;
    return file->filename;
}

Referenced by fill_inf_info().

PARSER_get_src_root()

WCHAR * PARSER_get_src_root

(

HINF

hinf

)

Definition at line 1096 of file parser.c.

{
    unsigned int len;
    const WCHAR *dir = get_inf_dir( hinf, &len );
    WCHAR *ret = HeapAlloc( GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR) );
    if (ret)
    {
        memcpy( ret, dir, len * sizeof(WCHAR) );
        ret[len] = 0;
    }
    return ret;
}

Referenced by get_src_file_info().

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;
}

QUEUE_callback_WtoA()

UINT CALLBACK QUEUE_callback_WtoA	(	void *	context,
		UINT	notification,
		UINT_PTR	param1,
		UINT_PTR	param2
	)

Definition at line 187 of file queue.c.

{
    struct callback_WtoA_context *callback_ctx = context;
    char buffer[MAX_PATH];
    UINT ret;
    UINT_PTR old_param2 = param2;
 
    switch(notification)
    {
    case SPFILENOTIFY_COPYERROR:
        param2 = (UINT_PTR)&buffer;
        /* fall through */
    case SPFILENOTIFY_STARTDELETE:
    case SPFILENOTIFY_ENDDELETE:
    case SPFILENOTIFY_DELETEERROR:
    case SPFILENOTIFY_STARTRENAME:
    case SPFILENOTIFY_ENDRENAME:
    case SPFILENOTIFY_RENAMEERROR:
    case SPFILENOTIFY_STARTCOPY:
    case SPFILENOTIFY_ENDCOPY:
    case SPFILENOTIFY_QUEUESCAN_EX:
        {
            FILEPATHS_W *pathsW = (FILEPATHS_W *)param1;
            FILEPATHS_A pathsA;
 
            pathsA.Source     = strdupWtoA( pathsW->Source );
            pathsA.Target     = strdupWtoA( pathsW->Target );
            pathsA.Win32Error = pathsW->Win32Error;
            pathsA.Flags      = pathsW->Flags;
            ret = callback_ctx->orig_handler( callback_ctx->orig_context, notification,
                                              (UINT_PTR)&pathsA, param2 );
            HeapFree( GetProcessHeap(), 0, (void *)pathsA.Source );
            HeapFree( GetProcessHeap(), 0, (void *)pathsA.Target );
        }
        if (notification == SPFILENOTIFY_COPYERROR)
            MultiByteToWideChar( CP_ACP, 0, buffer, -1, (WCHAR *)old_param2, MAX_PATH );
        break;
 
    case SPFILENOTIFY_STARTREGISTRATION:
    case SPFILENOTIFY_ENDREGISTRATION:
        {
            SP_REGISTER_CONTROL_STATUSW *statusW = (SP_REGISTER_CONTROL_STATUSW *)param1;
            SP_REGISTER_CONTROL_STATUSA statusA;
 
            statusA.cbSize = sizeof(statusA);
            statusA.FileName = strdupWtoA( statusW->FileName );
            statusA.Win32Error  = statusW->Win32Error;
            statusA.FailureCode = statusW->FailureCode;
            ret = callback_ctx->orig_handler( callback_ctx->orig_context, notification,
                                              (UINT_PTR)&statusA, param2 );
            HeapFree( GetProcessHeap(), 0, (LPSTR)statusA.FileName );
        }
        break;
 
    case SPFILENOTIFY_QUEUESCAN:
        {
            LPWSTR targetW = (LPWSTR)param1;
            LPSTR target = strdupWtoA( targetW );
 
            ret = callback_ctx->orig_handler( callback_ctx->orig_context, notification,
                                              (UINT_PTR)target, param2 );
            HeapFree( GetProcessHeap(), 0, target );
        }
        break;
 
    case SPFILENOTIFY_NEEDMEDIA:
        FIXME("mapping for %d not implemented\n",notification);
    case SPFILENOTIFY_STARTQUEUE:
    case SPFILENOTIFY_ENDQUEUE:
    case SPFILENOTIFY_STARTSUBQUEUE:
    case SPFILENOTIFY_ENDSUBQUEUE:
    default:
        ret = callback_ctx->orig_handler( callback_ctx->orig_context, notification, param1, param2 );
        break;
    }
    return ret;
}

Referenced by SetupCommitFileQueueA(), SetupInstallFileA(), SetupInstallFromInfSectionA(), and SetupScanFileQueueA().

SETUP_CreateDevicesList()

LONG SETUP_CreateDevicesList	(	IN OUT struct DeviceInfoSet *	list,
		IN PCWSTR MachineName	OPTIONAL,
		IN CONST GUID *Class	OPTIONAL,
		IN PCWSTR Enumerator	OPTIONAL
	)

Definition at line 121 of file devclass.c.

{
    PWCHAR Buffer = NULL;
    DWORD BufferLength = 4096;
    PCWSTR InstancePath;
    struct DeviceInfo *deviceInfo;
    WCHAR ClassGuidBuffer[MAX_GUID_STRING_LEN];
    DWORD ClassGuidBufferSize;
    GUID ClassGuid;
    DEVINST dnDevInst;
    CONFIGRET cr;
 
    Buffer = HeapAlloc(GetProcessHeap(), 0, BufferLength);
    if (!Buffer)
       return ERROR_NOT_ENOUGH_MEMORY;
 
    do
    {
        cr = CM_Get_Device_ID_List_ExW(Enumerator,
                                       Buffer,
                                       BufferLength / sizeof(WCHAR),
                                       Enumerator ? CM_GETIDLIST_FILTER_ENUMERATOR : CM_GETIDLIST_FILTER_NONE,
                                       list->hMachine);
        if (cr == CR_BUFFER_SMALL)
        {
            if (Buffer)
                HeapFree(GetProcessHeap(), 0, Buffer);
            BufferLength *= 2;
            Buffer = HeapAlloc(GetProcessHeap(), 0, BufferLength);
            if (!Buffer)
                return ERROR_NOT_ENOUGH_MEMORY;
        }
        else if (cr != CR_SUCCESS)
        {
            TRACE("CM_Get_Device_ID_List_ExW() failed with status 0x%x\n", cr);
            if (Buffer)
                HeapFree(GetProcessHeap(), 0, Buffer);
            return GetErrorCodeFromCrCode(cr);
        }
    }
    while (cr != CR_SUCCESS);
 
    for (InstancePath = Buffer; *InstancePath != UNICODE_NULL; InstancePath += wcslen(InstancePath) + 1)
    {
        /* Check that device really exists */
        TRACE("Checking %S\n", InstancePath);
        cr = CM_Locate_DevNode_Ex(&dnDevInst,
                                  (DEVINSTID_W)InstancePath,
                                  CM_LOCATE_DEVNODE_NORMAL,
                                  list->hMachine);
        if (cr != CR_SUCCESS)
        {
            ERR("CM_Locate_DevNode_ExW('%S') failed with status 0x%x\n", InstancePath, cr);
            continue;
        }
 
        /* Retrieve GUID of this device */
        ClassGuidBufferSize = sizeof(ClassGuidBuffer);
        cr = CM_Get_DevNode_Registry_Property_ExW(dnDevInst,
                                                  CM_DRP_CLASSGUID,
                                                  NULL,
                                                  ClassGuidBuffer,
                                                  &ClassGuidBufferSize,
                                                  0,
                                                  list->hMachine);
        if (cr == CR_SUCCESS)
        {
            ClassGuidBuffer[MAX_GUID_STRING_LEN - 2] = '\0'; /* Replace the } by a NULL character */
            if (UuidFromStringW(&ClassGuidBuffer[1], &ClassGuid) != RPC_S_OK)
            {
                /* Bad GUID, skip the entry */
                ERR("Invalid ClassGUID '%S' for device %S\n", ClassGuidBuffer, InstancePath);
                continue;
            }
        }
        else
        {
            TRACE("Using default class GUID_NULL for device %S\n", InstancePath);
            memcpy(&ClassGuid, &GUID_NULL, sizeof(GUID));
        }
 
        if (Class && !IsEqualIID(&ClassGuid, Class))
        {
            TRACE("Skipping %S due to wrong class GUID\n", InstancePath);
            continue;
        }
 
        /* Good! Create a device info element */
        if (!CreateDeviceInfo(list, InstancePath, &ClassGuid, &deviceInfo))
        {
            ERR("Failed to create info for %S\n", InstancePath);
            HeapFree(GetProcessHeap(), 0, Buffer);
            return GetLastError();
        }
 
        TRACE("Adding device %s to list\n", debugstr_w(InstancePath));
        InsertTailList(&list->ListHead, &deviceInfo->ListEntry);
    }
 
    HeapFree(GetProcessHeap(), 0, Buffer);
    return ERROR_SUCCESS;
}

Referenced by SetupDiGetClassDevsExW().

SETUP_CreateInterfaceList()

LONG SETUP_CreateInterfaceList	(	struct DeviceInfoSet *	list,
		PCWSTR	MachineName,
		CONST GUID *	InterfaceGuid,
		PCWSTR	DeviceInstanceW,
		BOOL	OnlyPresentInterfaces
	)

Definition at line 68 of file interface.c.

{
    HKEY hInterfaceKey;      /* HKLM\SYSTEM\CurrentControlSet\Control\DeviceClasses\{GUID} */
    HKEY hDeviceInstanceKey; /* HKLM\SYSTEM\CurrentControlSet\Control\DeviceClasses\{GUID}\##?#{InstancePath} */
    HKEY hReferenceKey;      /* HKLM\SYSTEM\CurrentControlSet\Control\DeviceClasses\{GUID}\##?#{InstancePath}\#{ReferenceString} */
    HKEY hControlKey;        /* HKLM\SYSTEM\CurrentControlSet\Control\DeviceClasses\{GUID}\##?#{InstancePath}\#{ReferenceString}\Control */
    HKEY hEnumKey;           /* HKLM\SYSTEM\CurrentControlSet\Enum */
    HKEY hKey;               /* HKLM\SYSTEM\CurrentControlSet\Enum\{Instance\Path} */
    LONG rc;
    WCHAR KeyBuffer[max(MAX_PATH, MAX_GUID_STRING_LEN) + 1];
    PWSTR pSymbolicLink = NULL;
    PWSTR InstancePath = NULL;
    DWORD i, j;
    DWORD dwLength, dwInstancePathLength;
    DWORD dwRegType;
    DWORD LinkedValue;
    GUID ClassGuid;
    struct DeviceInfo *deviceInfo;
 
    hInterfaceKey = INVALID_HANDLE_VALUE;
    hDeviceInstanceKey = NULL;
    hReferenceKey = NULL;
 
    /* Open registry key related to this interface */
    hInterfaceKey = SetupDiOpenClassRegKeyExW(InterfaceGuid, KEY_ENUMERATE_SUB_KEYS, DIOCR_INTERFACE, MachineName, NULL);
    if (hInterfaceKey == INVALID_HANDLE_VALUE)
    {
        /* Key doesn't exist. Let's keep it empty */
        rc = ERROR_SUCCESS;
        goto cleanup;
    }
 
    /* Enumerate sub keys of hInterfaceKey */
    i = 0;
    while (TRUE)
    {
        dwLength = sizeof(KeyBuffer) / sizeof(KeyBuffer[0]);
        rc = RegEnumKeyExW(hInterfaceKey, i, KeyBuffer, &dwLength, NULL, NULL, NULL, NULL);
        if (rc == ERROR_NO_MORE_ITEMS)
            break;
        if (rc != ERROR_SUCCESS)
            goto cleanup;
        i++;
 
        /* Open sub key */
        if (hDeviceInstanceKey != NULL)
            RegCloseKey(hDeviceInstanceKey);
        rc = RegOpenKeyExW(hInterfaceKey, KeyBuffer, 0, KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS, &hDeviceInstanceKey);
        if (rc != ERROR_SUCCESS)
            goto cleanup;
 
        /* Read DeviceInstance */
        rc = RegQueryValueExW(hDeviceInstanceKey, DeviceInstance, NULL, &dwRegType, NULL, &dwInstancePathLength);
        if (rc != ERROR_SUCCESS)
            goto cleanup;
        if (dwRegType != REG_SZ)
        {
            rc = ERROR_GEN_FAILURE;
            goto cleanup;
        }
        HeapFree(GetProcessHeap(), 0, InstancePath);
        InstancePath = HeapAlloc(GetProcessHeap(), 0, dwInstancePathLength + sizeof(WCHAR));
        if (!InstancePath)
        {
            rc = ERROR_NOT_ENOUGH_MEMORY;
            goto cleanup;
        }
        rc = RegQueryValueExW(hDeviceInstanceKey, DeviceInstance, NULL, NULL, (LPBYTE)InstancePath, &dwInstancePathLength);
        if (rc != ERROR_SUCCESS)
            goto cleanup;
        InstancePath[dwInstancePathLength / sizeof(WCHAR)] = '\0';
        TRACE("DeviceInstance %s\n", debugstr_w(InstancePath));
 
        if (DeviceInstanceW)
        {
            /* Check if device enumerator is not the right one */
            if (strcmpW(DeviceInstanceW, InstancePath) != 0)
                continue;
        }
 
        /* Find class GUID associated to the device instance */
        rc = RegOpenKeyExW(
            list->HKLM,
            REGSTR_PATH_SYSTEMENUM,
            0, /* Options */
            READ_CONTROL,
            &hEnumKey);
        if (rc != ERROR_SUCCESS)
            goto cleanup;
        rc = RegOpenKeyExW(
            hEnumKey,
            InstancePath,
            0, /* Options */
            KEY_QUERY_VALUE,
            &hKey);
        RegCloseKey(hEnumKey);
        if (rc != ERROR_SUCCESS)
            goto cleanup;
        dwLength = sizeof(KeyBuffer) - sizeof(WCHAR);
        rc = RegQueryValueExW(hKey, ClassGUID, NULL, NULL, (LPBYTE)KeyBuffer, &dwLength);
        RegCloseKey(hKey);
        if (rc != ERROR_SUCCESS)
            goto cleanup;
        KeyBuffer[dwLength / sizeof(WCHAR)] = '\0';
        KeyBuffer[37] = '\0'; /* Replace the } by a NULL character */
        if (UuidFromStringW(&KeyBuffer[1], &ClassGuid) != RPC_S_OK)
        {
            rc = ERROR_GEN_FAILURE;
            goto cleanup;
        }
        TRACE("ClassGUID %s\n", debugstr_guid(&ClassGuid));
 
        /* If current device doesn't match the list GUID (if any), skip this entry */
        if (!IsEqualIID(&list->ClassGuid, &GUID_NULL) && !IsEqualIID(&list->ClassGuid, &ClassGuid))
            continue;
 
        /* Enumerate subkeys of hDeviceInstanceKey (ie "#ReferenceString" in IoRegisterDeviceInterface). Skip entries that don't start with '#' */
        j = 0;
        while (TRUE)
        {
            struct DeviceInterface *interfaceInfo;
 
            dwLength = sizeof(KeyBuffer) / sizeof(KeyBuffer[0]);
            rc = RegEnumKeyExW(hDeviceInstanceKey, j, KeyBuffer, &dwLength, NULL, NULL, NULL, NULL);
            if (rc == ERROR_NO_MORE_ITEMS)
                break;
            if (rc != ERROR_SUCCESS)
                goto cleanup;
            j++;
            if (KeyBuffer[0] != '#')
                /* This entry doesn't represent an interesting entry */
                continue;
 
            /* Open sub key */
            if (hReferenceKey != NULL)
                RegCloseKey(hReferenceKey);
            rc = RegOpenKeyExW(hDeviceInstanceKey, KeyBuffer, 0, KEY_QUERY_VALUE, &hReferenceKey);
            if (rc != ERROR_SUCCESS)
                goto cleanup;
 
            /* Read SymbolicLink value */
            rc = RegQueryValueExW(hReferenceKey, SymbolicLink, NULL, &dwRegType, NULL, &dwLength);
            if (rc != ERROR_SUCCESS )
                goto cleanup;
            if (dwRegType != REG_SZ)
            {
                rc = ERROR_GEN_FAILURE;
                goto cleanup;
            }
 
            /* We have found a device */
            /* Step 1. Create a device info element */
            if (!CreateDeviceInfo(list, InstancePath, &ClassGuid, &deviceInfo))
            {
                rc = GetLastError();
                goto cleanup;
            }
            TRACE("Adding device %s to list\n", debugstr_w(InstancePath));
            InsertTailList(&list->ListHead, &deviceInfo->ListEntry);
 
            /* Step 2. Create an interface list for this element */
            HeapFree(GetProcessHeap(), 0, pSymbolicLink);
            pSymbolicLink = HeapAlloc(GetProcessHeap(), 0, dwLength + sizeof(WCHAR));
            if (!pSymbolicLink)
            {
                rc = ERROR_NOT_ENOUGH_MEMORY;
                goto cleanup;
            }
            rc = RegQueryValueExW(hReferenceKey, SymbolicLink, NULL, NULL, (LPBYTE)pSymbolicLink, &dwLength);
            pSymbolicLink[dwLength / sizeof(WCHAR)] = '\0';
            if (rc != ERROR_SUCCESS)
                goto cleanup;
            if (!CreateDeviceInterface(deviceInfo, pSymbolicLink, InterfaceGuid, &interfaceInfo))
            {
                rc = GetLastError();
                goto cleanup;
            }
 
            /* Step 3. Update flags */
            if (KeyBuffer[1] == '\0')
                interfaceInfo->Flags |= SPINT_DEFAULT;
            rc = RegOpenKeyExW(hReferenceKey, Control, 0, KEY_QUERY_VALUE, &hControlKey);
            if (rc != ERROR_SUCCESS)
            {
#if 0
                if (OnlyPresentInterfaces)
                {
                    DestroyDeviceInterface(interfaceInfo);
                    continue;
                }
                else
                    interfaceInfo->Flags |= SPINT_REMOVED;
#endif
            }
            else
            {
                dwLength = sizeof(DWORD);
                if (RegQueryValueExW(hControlKey, Linked, NULL, &dwRegType, (LPBYTE)&LinkedValue, &dwLength) == ERROR_SUCCESS
                    && dwRegType == REG_DWORD && LinkedValue)
                    interfaceInfo->Flags |= SPINT_ACTIVE;
                RegCloseKey(hControlKey);
            }
 
            TRACE("Adding interface %s to list\n", debugstr_w(pSymbolicLink));
            InsertTailList(&deviceInfo->InterfaceListHead, &interfaceInfo->ListEntry);
        }
    }
    rc = ERROR_SUCCESS;
 
cleanup:
    if (hReferenceKey != NULL)
        RegCloseKey(hReferenceKey);
    if (hDeviceInstanceKey != NULL)
        RegCloseKey(hDeviceInstanceKey);
    if (hInterfaceKey != INVALID_HANDLE_VALUE)
        RegCloseKey(hInterfaceKey);
    HeapFree(GetProcessHeap(), 0, InstancePath);
    HeapFree(GetProcessHeap(), 0, pSymbolicLink);
    return rc;
}

Referenced by SetupDiGetClassDevsExW().

SETUPDI_CreateDevKey()

HKEY SETUPDI_CreateDevKey	(	HKEY	RootKey,
		struct DeviceInfo *	devInfo,
		REGSAM	samDesired
	)

Definition at line 5671 of file devinst.c.

{
    HKEY enumKey, key = INVALID_HANDLE_VALUE;
    LONG l;
 
    l = RegCreateKeyExW(RootKey, REGSTR_PATH_SYSTEMENUM, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_CREATE_SUB_KEY, NULL, &enumKey, NULL);
    if (!l)
    {
        l = RegCreateKeyExW(enumKey, devInfo->instanceId, 0, NULL, REG_OPTION_NON_VOLATILE, samDesired, NULL, &key, NULL);
        RegCloseKey(enumKey);
    }
    if (l)
        SetLastError(l);
    return key;
}

Referenced by SetupDiChangeState(), and SetupDiCreateDevRegKeyW().

SETUPDI_CreateDrvKey()

HKEY SETUPDI_CreateDrvKey	(	HKEY	RootKey,
		struct DeviceInfo *	devInfo,
		UUID *	ClassGuid,
		REGSAM	samDesired
	)

Definition at line 5687 of file devinst.c.

{
    HKEY key = INVALID_HANDLE_VALUE;
    LPWSTR lpGuidString = NULL;
    LPWSTR DriverKey = NULL; /* {GUID}\Index */
    LPWSTR pDeviceInstance; /* Points into DriverKey, on the Index field */
    DWORD Index; /* Index used in the DriverKey name */
    DWORD dwSize;
    DWORD Disposition;
    DWORD rc;
    HKEY hHWProfileKey = INVALID_HANDLE_VALUE;
    HKEY hEnumKey = NULL;
    HKEY hClassKey = NULL;
    HKEY hDeviceKey = INVALID_HANDLE_VALUE;
    HKEY hKey = NULL;
 
    /* Open device key, to read Driver value */
    hDeviceKey = SETUPDI_OpenDevKey(RootKey, devInfo, KEY_QUERY_VALUE | KEY_SET_VALUE);
    if (hDeviceKey == INVALID_HANDLE_VALUE)
        goto cleanup;
 
    rc = RegOpenKeyExW(RootKey, REGSTR_PATH_CLASS_NT, 0, KEY_CREATE_SUB_KEY, &hClassKey);
    if (rc != ERROR_SUCCESS)
    {
        SetLastError(rc);
        goto cleanup;
    }
 
    rc = RegQueryValueExW(hDeviceKey, REGSTR_VAL_DRIVER, NULL, NULL, NULL, &dwSize);
    if (rc != ERROR_SUCCESS)
    {
        /* Create a new driver key */
 
        if (UuidToStringW(ClassGuid, &lpGuidString) != RPC_S_OK)
            goto cleanup;
 
        /* The driver key is in \System\CurrentControlSet\Control\Class\{GUID}\Index */
        DriverKey = HeapAlloc(GetProcessHeap(), 0, (strlenW(lpGuidString) + 7) * sizeof(WCHAR) + sizeof(UNICODE_NULL));
        if (!DriverKey)
        {
            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
            goto cleanup;
        }
 
        DriverKey[0] = '{';
        strcpyW(&DriverKey[1], lpGuidString);
        pDeviceInstance = &DriverKey[strlenW(DriverKey)];
        *pDeviceInstance++ = '}';
        *pDeviceInstance++ = '\\';
 
        /* Try all values for Index between 0 and 9999 */
        Index = 0;
        while (Index <= 9999)
        {
            sprintfW(pDeviceInstance, InstanceKeyFormat, Index);
            rc = RegCreateKeyExW(hClassKey,
                DriverKey,
                0,
                NULL,
                REG_OPTION_NON_VOLATILE,
#if _WIN32_WINNT >= 0x502
                KEY_READ | KEY_WRITE,
#else
                KEY_ALL_ACCESS,
#endif
                NULL,
                &hKey,
                &Disposition);
            if (rc != ERROR_SUCCESS)
            {
                SetLastError(rc);
                goto cleanup;
            }
            if (Disposition == REG_CREATED_NEW_KEY)
                break;
            RegCloseKey(hKey);
            hKey = NULL;
            Index++;
        }
 
        if (Index > 9999)
        {
            /* Unable to create more than 9999 devices within the same class */
            SetLastError(ERROR_GEN_FAILURE);
            goto cleanup;
        }
 
        /* Write the new Driver value */
        rc = RegSetValueExW(hDeviceKey, REGSTR_VAL_DRIVER, 0, REG_SZ, (const BYTE *)DriverKey, (strlenW(DriverKey) + 1) * sizeof(WCHAR));
        if (rc != ERROR_SUCCESS)
        {
            SetLastError(rc);
            goto cleanup;
        }
    }
    else
    {
        /* Open the existing driver key */
 
        DriverKey = HeapAlloc(GetProcessHeap(), 0, dwSize);
        if (!DriverKey)
        {
            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
            goto cleanup;
        }
 
        rc = RegQueryValueExW(hDeviceKey, REGSTR_VAL_DRIVER, NULL, NULL, (LPBYTE)DriverKey, &dwSize);
        if (rc != ERROR_SUCCESS)
        {
            SetLastError(rc);
            goto cleanup;
        }
 
        rc = RegCreateKeyExW(hClassKey,
            DriverKey,
            0,
            NULL,
            REG_OPTION_NON_VOLATILE,
#if _WIN32_WINNT >= 0x502
            KEY_READ | KEY_WRITE,
#else
            KEY_ALL_ACCESS,
#endif
            NULL,
            &hKey,
            &Disposition);
        if (rc != ERROR_SUCCESS)
        {
            SetLastError(rc);
            goto cleanup;
        }
    }
 
    key = hKey;
 
cleanup:
        if (lpGuidString)
            RpcStringFreeW(&lpGuidString);
        HeapFree(GetProcessHeap(), 0, DriverKey);
        if (hHWProfileKey != INVALID_HANDLE_VALUE)
            RegCloseKey(hHWProfileKey);
        if (hEnumKey != NULL)
            RegCloseKey(hEnumKey);
        if (hClassKey != NULL)
            RegCloseKey(hClassKey);
        if (hDeviceKey != INVALID_HANDLE_VALUE)
            RegCloseKey(hDeviceKey);
        if (hKey != NULL && hKey != key)
            RegCloseKey(hKey);
 
    TRACE("Returning 0x%p\n", hKey);
    return hKey;
}

Referenced by SetupDiCreateDevRegKeyW(), SetupDiInstallDevice(), and SetupDiRegisterCoDeviceInstallers().

SETUPDI_OpenDevKey()

HKEY SETUPDI_OpenDevKey	(	HKEY	RootKey,
		struct DeviceInfo *	devInfo,
		REGSAM	samDesired
	)

Definition at line 5841 of file devinst.c.

{
    HKEY enumKey, key = INVALID_HANDLE_VALUE;
    LONG l;
 
    l = RegOpenKeyExW(RootKey, REGSTR_PATH_SYSTEMENUM, 0, READ_CONTROL, &enumKey);
    if (!l)
    {
        l = RegOpenKeyExW(enumKey, devInfo->instanceId, 0, samDesired, &key);
        RegCloseKey(enumKey);
    }
    if (l)
        SetLastError(l);
    return key;
}

Referenced by IntSetupDiSetDeviceRegistryPropertyAW(), SETUPDI_CreateDrvKey(), SETUPDI_OpenDrvKey(), SetupDiGetDeviceRegistryPropertyW(), SetupDiInstallDevice(), and SetupDiOpenDevRegKey().

SETUPDI_OpenDrvKey()

HKEY SETUPDI_OpenDrvKey	(	HKEY	RootKey,
		struct DeviceInfo *	devInfo,
		REGSAM	samDesired
	)

Definition at line 5857 of file devinst.c.

{
    LPWSTR DriverKey = NULL;
    DWORD dwLength = 0;
    DWORD dwRegType;
    DWORD rc;
    HKEY hEnumKey = NULL;
    HKEY hKey = NULL;
    HKEY key = INVALID_HANDLE_VALUE;
 
    hKey = SETUPDI_OpenDevKey(RootKey, devInfo, KEY_QUERY_VALUE);
    if (hKey == INVALID_HANDLE_VALUE)
        goto cleanup;
    /* Read the 'Driver' key */
    rc = RegQueryValueExW(hKey, REGSTR_VAL_DRIVER, NULL, &dwRegType, NULL, &dwLength);
    if (rc != ERROR_SUCCESS)
    {
        SetLastError(rc);
        goto cleanup;
    }
    else if (dwRegType != REG_SZ)
    {
        SetLastError(ERROR_GEN_FAILURE);
        goto cleanup;
    }
    DriverKey = HeapAlloc(GetProcessHeap(), 0, dwLength);
    if (!DriverKey)
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        goto cleanup;
    }
    rc = RegQueryValueExW(hKey, REGSTR_VAL_DRIVER, NULL, &dwRegType, (LPBYTE)DriverKey, &dwLength);
    if (rc != ERROR_SUCCESS)
    {
        SetLastError(rc);
        goto cleanup;
    }
    RegCloseKey(hKey);
    hKey = NULL;
    /* Need to open the driver key */
    rc = RegOpenKeyExW(
        RootKey,
        REGSTR_PATH_CLASS_NT,
        0, /* Options */
        READ_CONTROL,
        &hEnumKey);
    if (rc != ERROR_SUCCESS)
    {
        SetLastError(rc);
        goto cleanup;
    }
    rc = RegOpenKeyExW(
        hEnumKey,
        DriverKey,
        0, /* Options */
        samDesired,
        &hKey);
    if (rc != ERROR_SUCCESS)
    {
        SetLastError(rc);
        goto cleanup;
    }
    key = hKey;
 
cleanup:
    if (hEnumKey != NULL)
        RegCloseKey(hEnumKey);
    if (hKey != NULL && hKey != key)
        RegCloseKey(hKey);
    if (DriverKey)
        HeapFree(GetProcessHeap(), 0, DriverKey);
    return key;
}

Referenced by SetupDiBuildDriverInfoList(), SetupDiCallClassInstaller(), SetupDiChangeState(), SetupDiGetClassDevPropertySheetsW(), SetupDiInstallDevice(), SetupDiOpenDevRegKey(), and SetupDiRegisterCoDeviceInstallers().

strdupAtoW()

static WCHAR * strdupAtoW ( const char *  str )

inlinestatic

Definition at line 265 of file setupapi_private.h.

{
    WCHAR *ret = NULL;
    if (str)
    {
        DWORD len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
        if ((ret = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
            MultiByteToWideChar( CP_ACP, 0, str, -1, ret, len );
    }
    return ret;
}

UnicodeToMultiByte()

LPSTR WINAPI UnicodeToMultiByte	(	LPCWSTR	lpUnicodeStr,
		UINT	uCodePage
	)

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

setupapi

)

Variable Documentation

GlobalSetupFlags

DWORD GlobalSetupFlags

extern

Definition at line 845 of file misc.c.

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

hInstance

HINSTANCE hInstance

extern

Definition at line 19 of file charmap.c.

OsVersionInfo

OSVERSIONINFOEXW OsVersionInfo

extern

Definition at line 33 of file setupcab.c.

Referenced by DllMain(), and SetupDiGetActualSectionToInstallExW().