windows-server-2003/base/pnp/setupapi/devinst.h

/*++

Copyright (c) Microsoft Corporation.  All rights reserved.

Module Name:

    devinst.h

Abstract:

    Private header file for setup device installation routines.

Author:

    Lonny McMichael (lonnym) 10-May-1995

Revision History:

--*/


//
// For now, define the size (in characters) of a GUID string,
// including terminating NULL.
//
#define GUID_STRING_LEN (39)

//
// Define the maximum number of IDs that may be present in an ID list
// (either HardwareID or CompatibleIDs).
//
#define MAX_HCID_COUNT (64)

//
// ISSUE: 2001/10/24-JamieHun REGSTR_VAL_SVCPAKCACHEPATH needs to be moved to regstr.h
// defined here for SP fixes so we don't affect public headers
//
#define REGSTR_VAL_SVCPAKCACHEPATH      TEXT("ServicePackCachePath")


//
// Global strings used by device installer routines.  Sizes are included
// so that we can do sizeof() instead of lstrlen() to determine string
// length.
//
// The content of the following strings is defined in regstr.h:
//
extern CONST TCHAR pszNoUseClass[SIZECHARS(REGSTR_VAL_NOUSECLASS)],
                   pszNoInstallClass[SIZECHARS(REGSTR_VAL_NOINSTALLCLASS)],
                   pszNoDisplayClass[SIZECHARS(REGSTR_VAL_NODISPLAYCLASS)],
                   pszDeviceDesc[SIZECHARS(REGSTR_VAL_DEVDESC)],
                   pszDevicePath[SIZECHARS(REGSTR_VAL_DEVICEPATH)],
                   pszPathSetup[SIZECHARS(REGSTR_PATH_SETUP)],
                   pszKeySetup[SIZECHARS(REGSTR_KEY_SETUP)],
                   pszPathRunOnce[SIZECHARS(REGSTR_PATH_RUNONCE)],
                   pszSourcePath[SIZECHARS(REGSTR_VAL_SRCPATH)],
                   pszSvcPackPath[SIZECHARS(REGSTR_VAL_SVCPAKSRCPATH)],
                   pszSvcPackCachePath[SIZECHARS(REGSTR_VAL_SVCPAKCACHEPATH)],
                   pszDriverCachePath[SIZECHARS(REGSTR_VAL_DRIVERCACHEPATH)],
                   pszBootDir[SIZECHARS(REGSTR_VAL_BOOTDIR)],
                   pszInsIcon[SIZECHARS(REGSTR_VAL_INSICON)],
                   pszInstaller32[SIZECHARS(REGSTR_VAL_INSTALLER_32)],
                   pszEnumPropPages32[SIZECHARS(REGSTR_VAL_ENUMPROPPAGES_32)],
                   pszInfPath[SIZECHARS(REGSTR_VAL_INFPATH)],
                   pszInfSection[SIZECHARS(REGSTR_VAL_INFSECTION)],
                   pszDrvDesc[SIZECHARS(REGSTR_VAL_DRVDESC)],
                   pszHardwareID[SIZECHARS(REGSTR_VAL_HARDWAREID)],
                   pszCompatibleIDs[SIZECHARS(REGSTR_VAL_COMPATIBLEIDS)],
                   pszDriver[SIZECHARS(REGSTR_VAL_DRIVER)],
                   pszConfigFlags[SIZECHARS(REGSTR_VAL_CONFIGFLAGS)],
                   pszMfg[SIZECHARS(REGSTR_VAL_MFG)],
                   pszService[SIZECHARS(REGSTR_VAL_SERVICE)],
                   pszProviderName[SIZECHARS(REGSTR_VAL_PROVIDER_NAME)],
                   pszFriendlyName[SIZECHARS(REGSTR_VAL_FRIENDLYNAME)],
                   pszServicesRegPath[SIZECHARS(REGSTR_PATH_SERVICES)],
                   pszInfSectionExt[SIZECHARS(REGSTR_VAL_INFSECTIONEXT)],
                   pszDeviceClassesPath[SIZECHARS(REGSTR_PATH_DEVICE_CLASSES)],
                   pszDeviceInstance[SIZECHARS(REGSTR_VAL_DEVICE_INSTANCE)],
                   pszDefault[SIZECHARS(REGSTR_VAL_DEFAULT)],
                   pszControl[SIZECHARS(REGSTR_KEY_CONTROL)],
                   pszLinked[SIZECHARS(REGSTR_VAL_LINKED)],
                   pszDeviceParameters[SIZECHARS(REGSTR_KEY_DEVICEPARAMETERS)],
                   pszLocationInformation[SIZECHARS(REGSTR_VAL_LOCATION_INFORMATION)],
                   pszCapabilities[SIZECHARS(REGSTR_VAL_CAPABILITIES)],
                   pszUiNumber[SIZECHARS(REGSTR_VAL_UI_NUMBER)],
                   pszRemovalPolicyOverride[SIZECHARS(REGSTR_VAL_REMOVAL_POLICY)],
                   pszUpperFilters[SIZECHARS(REGSTR_VAL_UPPERFILTERS)],
                   pszLowerFilters[SIZECHARS(REGSTR_VAL_LOWERFILTERS)],
                   pszMatchingDeviceId[SIZECHARS(REGSTR_VAL_MATCHINGDEVID)],
                   pszBasicProperties32[SIZECHARS(REGSTR_VAL_BASICPROPERTIES_32)],
                   pszCoInstallers32[SIZECHARS(REGSTR_VAL_COINSTALLERS_32)],
                   pszPathCoDeviceInstallers[SIZECHARS(REGSTR_PATH_CODEVICEINSTALLERS)],
                   pszSystem[SIZECHARS(REGSTR_KEY_SYSTEM)],
                   pszDrvSignPath[SIZECHARS(REGSTR_PATH_DRIVERSIGN)],
                   pszNonDrvSignPath[SIZECHARS(REGSTR_PATH_NONDRIVERSIGN)],
                   pszDrvSignPolicyPath[SIZECHARS(REGSTR_PATH_DRIVERSIGN_POLICY)],
                   pszNonDrvSignPolicyPath[SIZECHARS(REGSTR_PATH_NONDRIVERSIGN_POLICY)],
                   pszDrvSignPolicyValue[SIZECHARS(REGSTR_VAL_POLICY)],
                   pszDrvSignBehaviorOnFailedVerifyDS[SIZECHARS(REGSTR_VAL_BEHAVIOR_ON_FAILED_VERIFY)],
                   pszDriverDate[SIZECHARS(REGSTR_VAL_DRIVERDATE)],
                   pszDriverDateData[SIZECHARS(REGSTR_VAL_DRIVERDATEDATA)],
                   pszDriverVersion[SIZECHARS(REGSTR_VAL_DRIVERVERSION)],
                   pszDevSecurity[SIZECHARS(REGSTR_VAL_DEVICE_SECURITY_DESCRIPTOR)],
                   pszDevType[SIZECHARS(REGSTR_VAL_DEVICE_TYPE)],
                   pszExclusive[SIZECHARS(REGSTR_VAL_DEVICE_EXCLUSIVE)],
                   pszCharacteristics[SIZECHARS(REGSTR_VAL_DEVICE_CHARACTERISTICS)],
                   pszUiNumberDescFormat[SIZECHARS(REGSTR_VAL_UI_NUMBER_DESC_FORMAT)],
                   pszReinstallPath[SIZECHARS(REGSTR_PATH_REINSTALL)],
                   pszReinstallDeviceInstanceIds[SIZECHARS(REGSTR_VAL_REINSTALL_DEVICEINSTANCEIDS)],
                   pszReinstallDisplayName[SIZECHARS(REGSTR_VAL_REINSTALL_DISPLAYNAME)],
                   pszReinstallString[SIZECHARS(REGSTR_VAL_REINSTALL_STRING)];


//
// Other misc. global strings:
//
#define DISTR_INF_WILDCARD                (TEXT("*.inf"))
#define DISTR_OEMINF_WILDCARD             (TEXT("oem*.inf"))
#define DISTR_CI_DEFAULTPROC              (TEXT("ClassInstall"))
#define DISTR_UNIQUE_SUBKEY               (TEXT("\\%04u"))
#define DISTR_OEMINF_GENERATE             (TEXT("%s\\oem%d.inf"))
#define DISTR_OEMINF_DEFAULTPATH          (TEXT("A:\\"))
#define DISTR_DEFAULT_SERVICE             (TEXT("Default Service"))
#define DISTR_GUID_NULL                   (TEXT("{00000000-0000-0000-0000-000000000000}"))
#define DISTR_EVENTLOG                    (TEXT("\\EventLog"))
#define DISTR_GROUPORDERLIST_PATH         (REGSTR_PATH_CURRENT_CONTROL_SET TEXT("\\GroupOrderList"))
#define DISTR_SERVICEGROUPORDER_PATH      (REGSTR_PATH_CURRENT_CONTROL_SET TEXT("\\ServiceGroupOrder"))
#define DISTR_OPTIONS                     (TEXT("Options"))
#define DISTR_OPTIONSTEXT                 (TEXT("OptionsText"))
#define DISTR_LANGUAGESSUPPORTED          (TEXT("LanguagesSupported"))
#define DISTR_RUNONCE_EXE                 (TEXT("runonce"))
#define DISTR_GRPCONV                     (TEXT("grpconv -o"))
#define DISTR_GRPCONV_NOUI                (TEXT("grpconv -u"))
#define DISTR_DEFAULT_SYSPART             (TEXT("C:\\"))
#define DISTR_BASICPROP_DEFAULTPROC       (TEXT("BasicProperties"))
#define DISTR_ENUMPROP_DEFAULTPROC        (TEXT("EnumPropPages"))
#define DISTR_CODEVICEINSTALL_DEFAULTPROC (TEXT("CoDeviceInstall"))
#define DISTR_DRIVER_OBJECT_PATH_PREFIX   (TEXT("\\DRIVER\\"))      // must be uppercase!
#define DISTR_DRIVER_SIGNING_CLASSES      (TEXT("DriverSigningClasses"))
#define DISTR_PATH_EMBEDDED_NT_SECURITY   (TEXT("Software\\Microsoft\\EmbeddedNT\\Security"))
#define DISTR_VAL_MINIMIZE_FOOTPRINT      (TEXT("MinimizeFootprint"))
#define DISTR_VAL_DISABLE_SCE             (TEXT("DisableSCE"))

extern CONST TCHAR pszInfWildcard[SIZECHARS(DISTR_INF_WILDCARD)],
                   pszOemInfWildcard[SIZECHARS(DISTR_OEMINF_WILDCARD)],
                   pszCiDefaultProc[SIZECHARS(DISTR_CI_DEFAULTPROC)],
                   pszUniqueSubKey[SIZECHARS(DISTR_UNIQUE_SUBKEY)],
                   pszOemInfGenerate[SIZECHARS(DISTR_OEMINF_GENERATE)],
                   pszOemInfDefaultPath[SIZECHARS(DISTR_OEMINF_DEFAULTPATH)],
                   pszDefaultService[SIZECHARS(DISTR_DEFAULT_SERVICE)],
                   pszGuidNull[SIZECHARS(DISTR_GUID_NULL)],
                   pszEventLog[SIZECHARS(DISTR_EVENTLOG)],
                   pszGroupOrderListPath[SIZECHARS(DISTR_GROUPORDERLIST_PATH)],
                   pszServiceGroupOrderPath[SIZECHARS(DISTR_SERVICEGROUPORDER_PATH)],
                   pszOptions[SIZECHARS(DISTR_OPTIONS)],
                   pszOptionsText[SIZECHARS(DISTR_OPTIONSTEXT)],
                   pszLanguagesSupported[SIZECHARS(DISTR_LANGUAGESSUPPORTED)],
                   pszRunOnceExe[SIZECHARS(DISTR_RUNONCE_EXE)],
                   pszGrpConv[SIZECHARS(DISTR_GRPCONV)],
                   pszGrpConvNoUi[SIZECHARS(DISTR_GRPCONV_NOUI)],
                   pszDefaultSystemPartition[SIZECHARS(DISTR_DEFAULT_SYSPART)],
                   pszBasicPropDefaultProc[SIZECHARS(DISTR_BASICPROP_DEFAULTPROC)],
                   pszEnumPropDefaultProc[SIZECHARS(DISTR_ENUMPROP_DEFAULTPROC)],
                   pszCoInstallerDefaultProc[SIZECHARS(DISTR_CODEVICEINSTALL_DEFAULTPROC)],
                   pszDriverObjectPathPrefix[SIZECHARS(DISTR_DRIVER_OBJECT_PATH_PREFIX)],
                   pszDriverSigningClasses[SIZECHARS(DISTR_DRIVER_SIGNING_CLASSES)],
                   pszEmbeddedNTSecurity[SIZECHARS(DISTR_PATH_EMBEDDED_NT_SECURITY)],
                   pszMinimizeFootprint[SIZECHARS(DISTR_VAL_MINIMIZE_FOOTPRINT)],
                   pszDisableSCE[SIZECHARS(DISTR_VAL_DISABLE_SCE)];


//
// Global translation array for finding CM_DRP_* ordinal
// given property name or SPDRP_* value.
//
extern STRING_TO_DATA InfRegValToDevRegProp[];
extern STRING_TO_DATA InfRegValToClassRegProp[];

//
// Define a macro that does the DI-to-CM property translation
//
#define SPDRP_TO_CMDRP(i) (InfRegValToDevRegProp[(i)].Data)
//
// Class registry translation uses the same table
//
#define SPCRP_TO_CMCRP(i) (InfRegValToClassRegProp[(i)].Data)

//
// Define a value indicating a no-match ranking.
//
#define RANK_NO_MATCH (0xFFFFFFFF)

//
// Driver ranking bases. Lower Ranks are better.  Rank 0 is the best possible Rank.
// Any Rank less than 0x00001000 is a HardwareID match that is considered a good match.
//
#define RANK_HWID_INF_HWID_BASE 0x00000000      // For match with Hardware's HardwareID and INF's HardwareID
#define RANK_HWID_INF_CID_BASE  0x00001000      // For match with Hardware's HardwareID and INF's CompatibleID
#define RANK_CID_INF_HWID_BASE  0x00002000      // For match with Hardware's CompatibleID and INF's HardwareID
#define RANK_CID_INF_CID_BASE   0x00003000      // For match with Hardware's CompatibleID and INF's CompatibleID
#define RANK_CID_INF_CID_INC    0x00000100      // added to RANK_CID_INF_CID_BASE for each CompatID location

//
// Define special value used to indicate that one of our enumeration 'hint'
// indices is invalid.
//
#define INVALID_ENUM_INDEX  (0xFFFFFFFF)

//
// Define prototype of callback function supplied by class installers.
//
typedef DWORD (CALLBACK* CLASS_INSTALL_PROC) (
    IN DI_FUNCTION      InstallFunction,
    IN HDEVINFO         DeviceInfoSet,
    IN PSP_DEVINFO_DATA DeviceInfoData OPTIONAL
    );

//
// Define prototype of property sheet provider function--basically, an
// ExtensionPropSheetPageProc function with a (potentially) different name.
//
typedef BOOL (CALLBACK* PROPSHEET_PROVIDER_PROC) (
    IN PSP_PROPSHEETPAGE_REQUEST PropPageRequest,
    IN LPFNADDPROPSHEETPAGE lpfnAddPropSheetPageProc,
    IN LPARAM lParam
    );

//
// Define prototype of the co-installer function.
//
typedef DWORD (CALLBACK* COINSTALLER_PROC) (
    IN     DI_FUNCTION               InstallFunction,
    IN     HDEVINFO                  DeviceInfoSet,
    IN     PSP_DEVINFO_DATA          DeviceInfoData, OPTIONAL
    IN OUT PCOINSTALLER_CONTEXT_DATA Context
    );


//
// Define structure for the internal representation of a single
// driver information node.
//
typedef struct _DRIVER_NODE {

    struct _DRIVER_NODE *Next;

    UINT Rank;

    FILETIME InfDate;

    LONG DrvDescription;

    //
    // Have to have both forms of the strings below because we must have both
    // case-insensitive (i.e., atom-like) behavior, and keep the original case
    // for display.
    //
    LONG DevDescription;
    LONG DevDescriptionDisplayName;

    LONG ProviderName;
    LONG ProviderDisplayName;

    LONG MfgName;
    LONG MfgDisplayName;

    LONG InfFileName;

    LONG InfSectionName;

    LONG HardwareId;

    DWORD NumCompatIds;

    PLONG CompatIdList;

    //
    // Store the index of the device ID that a compatible match was based on.  If
    // this was a HardwareId match, this value is -1, otherwise, it is the index
    // into the CompatIdList array of the device ID that matched.
    //
    LONG MatchingDeviceId;

    DWORD Flags;

    DWORD_PTR PrivateData;

    //
    // Store the GUID index INF's class from which this node came.  We need to do this,
    // in order to easily determine the class of the driver node (e.g., so that we
    // can change the device's class when a new driver node is selected).
    //
    LONG GuidIndex;

    FILETIME  DriverDate;
    DWORDLONG DriverVersion;

} DRIVER_NODE, *PDRIVER_NODE;


//
// Define structure to contain a co-installer entry.
//
typedef struct _COINSTALLER_NODE {
    HINSTANCE        hinstCoInstaller;
    COINSTALLER_PROC CoInstallerEntryPoint;
    HANDLE           CoInstallerFusionContext;
} COINSTALLER_NODE, *PCOINSTALLER_NODE;

//
// Define structure containing context information about co-installer
// callbacks for the duration of a DIF call.
//
typedef struct _COINSTALLER_INTERNAL_CONTEXT {
    COINSTALLER_CONTEXT_DATA Context;
    BOOL                     DoPostProcessing;
    COINSTALLER_PROC         CoInstallerEntryPoint;
    HANDLE                   CoInstallerFusionContext;
} COINSTALLER_INTERNAL_CONTEXT, *PCOINSTALLER_INTERNAL_CONTEXT;


//
// Define structure for the internal storage of device installation
// parameters.
//
typedef struct _DEVINSTALL_PARAM_BLOCK {

    //
    // Flags for controlling installation and UI functions.
    //
    DWORD Flags;
    DWORD FlagsEx;

    //
    // Specifies the window handle that will own UI related to this
    // installation.  MAY BE NULL.
    //
    HWND hwndParent;

    //
    // Installation message handling parameters.
    //
    PSP_FILE_CALLBACK InstallMsgHandler;
    PVOID             InstallMsgHandlerContext;
    BOOL              InstallMsgHandlerIsNativeCharWidth;

    //
    // Handle to a caller-supplied copy-queue.  If this handle is present,
    // then file copy/rename/delete operations will be queued to this handle
    // instead of being acted upon.  This will only happen if the DI_NOVCP
    // bit is set in the Flags field.
    // If no caller-supplied queue is present, this value is NULL
    // (_not_ INVALID_HANDLE_VALUE).
    //
    HSPFILEQ UserFileQ;

    //
    // Private DWORD reserved for Class Installer usage.
    //
    ULONG_PTR ClassInstallReserved;

    //
    // Specifies the string table index of an optional INF file
    // path.  If the string is not supplied, its index will be -1.
    //
    LONG DriverPath;

    //
    // Pointer to class installer parameters.  The first field of any class
    // installer parameter block is always a SP_CLASSINSTALL_HEADER structure.
    // The cbSize field of that structure gives the size, in bytes, of the header
    // (used for versioning), and the InstallFunction field gives the DI_FUNCTION
    // code that indicates how the parameter buffer is to be interpreted.
    // MAY BE NULL!
    //
    PSP_CLASSINSTALL_HEADER ClassInstallHeader;
    DWORD ClassInstallParamsSize;

    //
    // THE FOLLOWING PARAMETERS ARE NOT EXPOSED TO CALLERS (i.e., via
    // SetupDi(Get|Set)DeviceInstallParams).
    //

    HINSTANCE hinstClassInstaller;
    CLASS_INSTALL_PROC ClassInstallerEntryPoint;
    HANDLE             ClassInstallerFusionContext;

    HINSTANCE hinstClassPropProvider;
    PROPSHEET_PROVIDER_PROC ClassEnumPropPagesEntryPoint;
    HANDLE                  ClassEnumPropPagesFusionContext;

    HINSTANCE hinstDevicePropProvider;
    PROPSHEET_PROVIDER_PROC DeviceEnumPropPagesEntryPoint;
    HANDLE                  DeviceEnumPropPagesFusionContext;

    HINSTANCE hinstBasicPropProvider;
    PROPSHEET_PROVIDER_PROC EnumBasicPropertiesEntryPoint;
    HANDLE                  EnumBasicPropertiesFusionContext;

    //
    // Maintain a list of co-installers to be called along with the class installer.
    // The count will be -1 if the list hasn't been retrieved yet.
    //
    LONG CoInstallerCount;
    PCOINSTALLER_NODE CoInstallerList;

    //
    // Logging context -- this is only here because this struct is shared
    // by both DEVINFO_ELEM and DEVINFO_SET.
    //
    PSETUP_LOG_CONTEXT LogContext;

} DEVINSTALL_PARAM_BLOCK, *PDEVINSTALL_PARAM_BLOCK;


//
// Define structures used for associating lists of device interfaces with
// devinfo elements.
//
typedef struct _DEVICE_INTERFACE_NODE {

    struct _DEVICE_INTERFACE_NODE *Next;

    //
    // String table ID for this device interface's symbolic link name.
    //
    LONG SymLinkName;

    //
    // Store the interface class GUID index in each node.  We need to do this,
    // in order to easily determine the class of the node.
    //
    LONG GuidIndex;

    //
    // The Flags field contains the same flags as the client sees in their
    // SP_DEVICE_INTERFACE_DATA structure.
    //
    DWORD Flags;

    //
    // Store a back-pointer to the devinfo element, because device interfaces
    // may be enumerated outside the context of a device information element, 
    // and we need to know how to get back to the owning device instance.
    //
    struct _DEVINFO_ELEM *OwningDevInfoElem;

} DEVICE_INTERFACE_NODE, *PDEVICE_INTERFACE_NODE;

typedef struct _INTERFACE_CLASS_LIST {
    LONG                   GuidIndex;
    PDEVICE_INTERFACE_NODE DeviceInterfaceNode;
    PDEVICE_INTERFACE_NODE DeviceInterfaceTruncateNode;  // used for rollback.
    DWORD                  DeviceInterfaceCount;
} INTERFACE_CLASS_LIST, *PINTERFACE_CLASS_LIST;


//
// Define flags for DiElemFlags field of DEVINFO_ELEM structure.
//
#define DIE_IS_PHANTOM      (0x00000001) // is this a phantom (not live) devinst?
#define DIE_IS_REGISTERED   (0x00000002) // has this devinst been registered?
#define DIE_IS_LOCKED       (0x00000004) // are we explicitly locked? (e.g.,
                                         // during some UI operation or nested
                                         // call into helper modules)

//
// Define structure for the internal representation of a single
// device information element.
//
typedef struct _DEVINFO_ELEM {
    //
    // Store the address of the containing devinfo set at the beginning of
    // this structure.  This is used for validation of a caller-supplied
    // SP_DEVINFO_DATA, and is more efficient than the previous method of
    // searching through all devinfo elements in the set to make sure the
    // specified element exists in the set.  This field should be zeroed
    // out when this element is destroyed.
    //
    struct _DEVICE_INFO_SET *ContainingDeviceInfoSet;

    //
    // Pointer to the next element in the set.
    //
    struct _DEVINFO_ELEM *Next;

    //
    // Specifies the device instance handle for this device.  This will
    // be a phantom device instance handle if DIE_IS_PHANTOM is set.
    //
    // This should always contain a handle, unless the device instance
    // handle could not be re-opened after a re-enumeration (in which case,
    // the DI_NEEDREBOOT flag will be set), or if the device information
    // element was globally removed or config-specific removed from the last
    // hardware profile.
    //
    DEVINST DevInst;

    //
    // Specifies the GUID for this device's class.
    //
    GUID ClassGuid;

    //
    // Specifies flags pertaining to this device information element.
    // These DIE_* flags are for internal use only.
    //
    DWORD DiElemFlags;

    //
    // List of class drivers for this element.
    //
    UINT          ClassDriverCount;
    PDRIVER_NODE  ClassDriverHead;
    PDRIVER_NODE  ClassDriverTail;

    //
    // class drivernode index 'hint' to speed up enumeration via
    // SetupDiEnumDriverInfo
    //
    PDRIVER_NODE ClassDriverEnumHint;       // may be NULL
    DWORD        ClassDriverEnumHintIndex;  // may be INVALID_ENUM_INDEX

    //
    // List of compatible drivers for this element.
    //
    UINT          CompatDriverCount;
    PDRIVER_NODE  CompatDriverHead;
    PDRIVER_NODE  CompatDriverTail;

    //
    // compatible drivernode index 'hint' to speed up enumeration via
    // SetupDiEnumDriverInfo
    //
    PDRIVER_NODE CompatDriverEnumHint;       // may be NULL
    DWORD        CompatDriverEnumHintIndex;  // may be INVALID_ENUM_INDEX

    //
    // Pointer to selected driver for this element (may be
    // NULL if none currently selected).  Whether this is a
    // class or compatible driver is specified by the
    // SelectedDriverType field.
    //
    PDRIVER_NODE  SelectedDriver;
    DWORD         SelectedDriverType;

    //
    // Installation parameter block.
    //
    DEVINSTALL_PARAM_BLOCK InstallParamBlock;

    //
    // Specifies the string table index of the device description.
    // If no description is known, this value will be -1.
    //
    // We store this string twice--once case-sensitively and once case-insensitively,
    // because we need it for displaying _and_ for fast lookup.
    //
    LONG DeviceDescription;
    LONG DeviceDescriptionDisplayName;

    //
    // Maintain an array of device interface lists.  These lists represent the 
    // device interfaces owned by this device instance (but only those that have 
    // been retrieved, e.g. by calling SetupDiGetClassDevs with the 
    // DIGCF_DEVICEINTERFACE flag).
    //
    // (This array pointer may be NULL.)
    //
    PINTERFACE_CLASS_LIST InterfaceClassList;
    DWORD                 InterfaceClassListSize;

    //
    // Extra (non-class installer) data associated with each device information element.
    // Only exposed via private API for use during GUI-mode setup.
    //
    DWORD Context;

} DEVINFO_ELEM, *PDEVINFO_ELEM;


//
// Structure containing dialog data for wizard pages.  (Amalgamation of
// DIALOGDATA structures defined in setupx and sysdm.)
//
typedef struct _SP_DIALOGDATA {

    INT             iBitmap;              // index into mini-icon bitmap

    HDEVINFO        DevInfoSet;           // DevInfo set we're working with
    PDEVINFO_ELEM   DevInfoElem;          // if DD_FLAG_USE_DEVINFO_ELEM flag set
    UINT            flags;

    HWND            hwndDrvList;          // window of the driver list
    HWND            hwndMfgList;          // window of the Manufacturer list

    BOOL            bShowCompat;

    BOOL            bKeeplpCompatDrvList;
    BOOL            bKeeplpClassDrvList;
    BOOL            bKeeplpSelectedDrv;

    LONG            iCurDesc;             // string table index for the description of currently
                                          // selected driver (or to-be-selected driver)

    BOOL            AuxThreadRunning;       // Is our class driver search thread still running?
    DWORD           PendingAction;          // What (if anything) should we do when it finishes?
    int             CurSelectionForSuccess; // If we have a pending successful return, what is the
                                            // listbox index for the successful selection?
    HIMAGELIST      hImageList;

    HFONT           hFontNormal;
    HFONT           hFontBold;

} SP_DIALOGDATA, *PSP_DIALOGDATA;

//
// Flags for SP_DIALOGDATA.flags:
//
#define DD_FLAG_USE_DEVINFO_ELEM   0x00000001
#define DD_FLAG_IS_DIALOGBOX       0x00000002
#define DD_FLAG_CLASSLIST_FAILED   0x00000004
#define DD_FLAG_SHOWSIMILARDRIVERS 0x00000008

//
// Pending Action codes used in the NEWDEVWIZ_DATA structure to indicate what
// should happen as soon as the auxilliary class driver search thread notifies us
// of its termination.
//
#define PENDING_ACTION_NONE             0
#define PENDING_ACTION_SELDONE          1
#define PENDING_ACTION_SHOWCLASS        2
#define PENDING_ACTION_CANCEL           3
#define PENDING_ACTION_OEM              4
#define PENDING_ACTION_WINDOWSUPDATE    5

//
// Icons that are associated with an item in the list view.
//
#define IMAGE_ICON_NOT_SIGNED           0
#define IMAGE_ICON_SIGNED               1
#define IMAGE_ICON_AUTHENTICODE_SIGNED  2

//
// Define structure used for internal state storage by Device Installer
// wizard pages.  (From NEWDEVWIZ_INSTANCE struct in Win95 sysdm.)
//
typedef struct _NEWDEVWIZ_DATA {

    SP_INSTALLWIZARD_DATA InstallData;

    SP_DIALOGDATA         ddData;

    BOOL                  bInit;
    UINT_PTR              idTimer;

} NEWDEVWIZ_DATA, *PNEWDEVWIZ_DATA;

//
// Define wizard page object structure used to ensure that wizard page
// buffer is kept as long as needed, and destroyed when no longer in use.
//
typedef struct _WIZPAGE_OBJECT {

    struct _WIZPAGE_OBJECT *Next;

    DWORD RefCount;

    PNEWDEVWIZ_DATA ndwData;

} WIZPAGE_OBJECT, *PWIZPAGE_OBJECT;


//
// Define driver list object structure used in the device information set
// to keep track of the various class driver lists that devinfo elements
// have referenced.
//
typedef struct _DRIVER_LIST_OBJECT {

    struct _DRIVER_LIST_OBJECT *Next;

    DWORD RefCount;

    //
    // We keep track of what parameters were used to create this driver
    // list, so that we can copy them to a new devinfo element during
    // inheritance.
    //
    DWORD ListCreationFlags;
    DWORD ListCreationFlagsEx;
    LONG ListCreationDriverPath;

    //
    // Also, keep track of what class this list was built for.  Although a
    // device's class may change, this GUID remains constant.
    //
    GUID ClassGuid;

    //
    // Actual driver list.  (This is also used as an ID used to find the
    // driver list object given a driver list head.  We can do this, since
    // we know that once a driver list is built, the head element never
    // changes.)
    //
    PDRIVER_NODE DriverListHead;

} DRIVER_LIST_OBJECT, *PDRIVER_LIST_OBJECT;


//
// Define node that tracks addition module handles to be unloaded when the
// device information set is destroyed.  This is used when a class installer,
// property page provider, or co-installer becomes invalid (e.g., as a result
// of a change in the device's class), but we can't unload the module yet.
//

typedef struct _MODULE_HANDLE_LIST_INSTANCE {
    HINSTANCE ModuleHandle;
    HANDLE    FusionContext;
} MODULE_HANDLE_LIST_INSTANCE,*PMODULE_HANDLE_LIST_INSTANCE;

typedef struct _MODULE_HANDLE_LIST_NODE {

    struct _MODULE_HANDLE_LIST_NODE *Next;

    DWORD ModuleCount;
    MODULE_HANDLE_LIST_INSTANCE ModuleList[ANYSIZE_ARRAY];

} MODULE_HANDLE_LIST_NODE, *PMODULE_HANDLE_LIST_NODE;

//
// Define flags for DiSetFlags field of DEVICE_INFO_SET structure.
//
#define DISET_IS_LOCKED (0x00000001) // Set is locked, and cannot be destroyed.

//
// Define structure for the internal representation of a
// device information set.
//
typedef struct _DEVICE_INFO_SET {

    //
    // Specifies whether there is a class GUID associated
    // with this set, and if so, what it is.
    //
    BOOL          HasClassGuid;
    GUID          ClassGuid;

    //
    // List of class drivers for this set.
    //
    UINT          ClassDriverCount;
    PDRIVER_NODE  ClassDriverHead;
    PDRIVER_NODE  ClassDriverTail;

    //
    // class drivernode index 'hint' to speed up enumeration via
    // SetupDiEnumDriverInfo
    //
    PDRIVER_NODE ClassDriverEnumHint;       // may be NULL
    DWORD        ClassDriverEnumHintIndex;  // may be INVALID_ENUM_INDEX

    //
    // Pointer to selected class driver for this device information
    // set (may be NULL if none currently selected).
    //
    PDRIVER_NODE  SelectedClassDriver;

    //
    // List of device information elements in the set.
    //
    UINT          DeviceInfoCount;
    PDEVINFO_ELEM DeviceInfoHead;
    PDEVINFO_ELEM DeviceInfoTail;

    //
    // devinfo element index 'hint' to speed up enumeration via
    // SetupDiEnumDeviceInfo
    //
    PDEVINFO_ELEM DeviceInfoEnumHint;       // may be NULL
    DWORD         DeviceInfoEnumHintIndex;  // may be INVALID_ENUM_INDEX

    //
    // Pointer to selected device for this device information set (may
    // be NULL if none currently selected).  This is used during
    // installation wizard.
    //
    PDEVINFO_ELEM SelectedDevInfoElem;

    //
    // Installation parameter block (for global class driver list, if
    // present).
    //
    DEVINSTALL_PARAM_BLOCK InstallParamBlock;

    //
    // Private string table.
    //
    PVOID StringTable;

    //
    // Maintain a list of currently-active wizard objects.  This allows us
    // to do the refcounting correctly for each object, and to keep the
    // set from being deleted until all wizard objects are destroyed.
    //
    PWIZPAGE_OBJECT WizPageList;

    //
    // Maintain a list of class driver lists that are currently being 
    // referenced by various devinfo elements, as well as by the device info 
    // set itself (i.e., for the current global class driver list.)
    //
    PDRIVER_LIST_OBJECT ClassDrvListObjectList;

    //
    // Maintain a reference count on how many times a thread has acquired
    // the lock on this device information set.  This indicates how deeply
    // nested we currently are in device installer calls.  The set can only
    // be deleted if this count is 1.
    //
    DWORD LockRefCount;

    //
    // Maintain a list of additional module handles we need to do a FreeLibrary
    // on when this device information set is destroyed.
    //
    PMODULE_HANDLE_LIST_NODE ModulesToFree;

    //
    // Maintain an array of class GUIDs for all driver nodes and device
    // interfaces used by members of this set.  (May be NULL.)
    //
    LPGUID GuidTable;
    DWORD  GuidTableSize;

    //
    // ConfigMgr machine name (string id) and handle, if this is a remote 
    // HDEVINFO set.
    //
    LONG     MachineName;   // -1 if local
    HMACHINE hMachine;      // NULL if local

    //
    // Maintain any applicable DISET_* flags for this HDEVINFO set.
    //
    DWORD DiSetFlags;

    //
    // Synchronization
    //
    MYLOCK Lock;

} DEVICE_INFO_SET, *PDEVICE_INFO_SET;

#define LockDeviceInfoSet(d)   BeginSynchronizedAccess(&((d)->Lock))

#define UnlockDeviceInfoSet(d)          \
                                        \
    ((d)->LockRefCount)--;              \
    EndSynchronizedAccess(&((d)->Lock))


//
// Define structures for global mini-icon storage.
//
typedef struct _CLASSICON {

    CONST GUID        *ClassGuid;
    UINT               MiniBitmapIndex;
    struct _CLASSICON *Next;

} CLASSICON, *PCLASSICON;

typedef struct _MINI_ICON_LIST {

    //
    // HDC for memory containing mini-icon bitmap
    //
    HDC hdcMiniMem;

    //
    // Handle to the bitmap image for the mini-icons
    //
    HBITMAP hbmMiniImage;

    //
    // Handle to the bitmap image for the mini-icon mask.
    //
    HBITMAP hbmMiniMask;

    //
    // Number of mini-icons in the bitmap
    //
    UINT NumClassImages;

    //
    // Head of list for installer-provided class icons.
    //
    PCLASSICON ClassIconList;

    //
    // Synchronization
    //
    MYLOCK Lock;

} MINI_ICON_LIST, *PMINI_ICON_LIST;

#define LockMiniIconList(d)   BeginSynchronizedAccess(&((d)->Lock))
#define UnlockMiniIconList(d) EndSynchronizedAccess(&((d)->Lock))

//
// Global mini-icon list.
//
extern MINI_ICON_LIST GlobalMiniIconList;




typedef struct _CLASS_IMAGE_LIST {

    //
    // Index of the "Unknown" class image
    //
    int         UnknownImageIndex;

    //
    // List of class guids
    //
    LPGUID      ClassGuidList;

    //
    // Head of linked list of class icons.
    //
    PCLASSICON  ClassIconList;

    //
    // Synchronization
    //
    MYLOCK      Lock;

} CLASS_IMAGE_LIST, *PCLASS_IMAGE_LIST;


#define LockImageList(d)   BeginSynchronizedAccess(&((d)->Lock))
#define UnlockImageList(d) EndSynchronizedAccess(&((d)->Lock))


typedef struct _DRVSEARCH_INPROGRESS_NODE {

    struct _DRVSEARCH_INPROGRESS_NODE *Next;

    //
    // Handle of device information set for which driver list is
    // currently being built.
    //
    HDEVINFO DeviceInfoSet;

    //
    // Flag indicating that the driver search should be aborted.
    //
    BOOL CancelSearch;

    //
    // Event handle that auxiliary thread waits on once it has set
    // the 'CancelSearch' flag (and once it has release the list
    // lock).  When the thread doing the search notices the cancel
    // request, it will signal the event, thus the waiting thread
    // can ensure that the search has been cancelled before it returns.
    //
    HANDLE SearchCancelledEvent;

} DRVSEARCH_INPROGRESS_NODE, *PDRVSEARCH_INPROGRESS_NODE;

typedef struct _DRVSEARCH_INPROGRESS_LIST {

    //
    // Head of linked list containing nodes for each device information
    // set for which a driver search is currently underway.
    //
    PDRVSEARCH_INPROGRESS_NODE DrvSearchHead;

    //
    // Synchronization
    //
    MYLOCK Lock;

} DRVSEARCH_INPROGRESS_LIST, *PDRVSEARCH_INPROGRESS_LIST;

#define LockDrvSearchInProgressList(d)   BeginSynchronizedAccess(&((d)->Lock))
#define UnlockDrvSearchInProgressList(d) EndSynchronizedAccess(&((d)->Lock))

//
// Global "Driver Search In-Progress" list.
//
extern DRVSEARCH_INPROGRESS_LIST GlobalDrvSearchInProgressList;


//
// Device Information Set manipulation routines
//
PDEVICE_INFO_SET
AllocateDeviceInfoSet(
    VOID
    );

VOID
DestroyDeviceInfoElement(
    IN HDEVINFO         hDevInfo,
    IN PDEVICE_INFO_SET pDeviceInfoSet,
    IN PDEVINFO_ELEM    DeviceInfoElement
    );

DWORD
DestroyDeviceInfoSet(
    IN HDEVINFO         hDevInfo,      OPTIONAL
    IN PDEVICE_INFO_SET pDeviceInfoSet
    );

PDEVICE_INFO_SET
AccessDeviceInfoSet(
    IN HDEVINFO DeviceInfoSet
    );

PDEVICE_INFO_SET
CloneDeviceInfoSet(
    IN HDEVINFO hDevInfo
    );

PDEVICE_INFO_SET
RollbackDeviceInfoSet(
    IN HDEVINFO hDevInfo,
    IN PDEVICE_INFO_SET ClonedDeviceInfoSet
    );

PDEVICE_INFO_SET
CommitDeviceInfoSet(
    IN HDEVINFO hDevInfo,
    IN PDEVICE_INFO_SET ClonedDeviceInfoSet
    );

PDEVINFO_ELEM
FindDevInfoByDevInst(
    IN  PDEVICE_INFO_SET  DeviceInfoSet,
    IN  DEVINST           DevInst,
    OUT PDEVINFO_ELEM    *PrevDevInfoElem OPTIONAL
    );

BOOL
DevInfoDataFromDeviceInfoElement(
    IN  PDEVICE_INFO_SET DeviceInfoSet,
    IN  PDEVINFO_ELEM    DevInfoElem,
    OUT PSP_DEVINFO_DATA DeviceInfoData
    );

PDEVINFO_ELEM
FindAssociatedDevInfoElem(
    IN  PDEVICE_INFO_SET  DeviceInfoSet,
    IN  PSP_DEVINFO_DATA  DeviceInfoData,
    OUT PDEVINFO_ELEM    *PreviousElement OPTIONAL
    );


//
// Driver Node manipulation routines.
//
DWORD
CreateDriverNode(
    IN  UINT          Rank,
    IN  PCTSTR        DevDescription,
    IN  PCTSTR        DrvDescription,
    IN  PCTSTR        ProviderName,   OPTIONAL
    IN  PCTSTR        MfgName,
    IN  PFILETIME     InfDate,
    IN  PCTSTR        InfFileName,
    IN  PCTSTR        InfSectionName,
    IN  PVOID         StringTable,
    IN  LONG          InfClassGuidIndex,
    OUT PDRIVER_NODE *DriverNode
    );

PDRIVER_LIST_OBJECT
GetAssociatedDriverListObject(
    IN  PDRIVER_LIST_OBJECT  ObjectListHead,
    IN  PDRIVER_NODE         DriverListHead,
    OUT PDRIVER_LIST_OBJECT *PrevDriverListObject OPTIONAL
    );

VOID
DereferenceClassDriverList(
    IN PDEVICE_INFO_SET DeviceInfoSet,
    IN PDRIVER_NODE     DriverListHead OPTIONAL
    );

VOID
DestroyDriverNodes(
    IN PDRIVER_NODE DriverNode,
    IN PDEVICE_INFO_SET pDeviceInfoSet OPTIONAL
    );

BOOL
DrvInfoDataFromDriverNode(
    IN  PDEVICE_INFO_SET DeviceInfoSet,
    IN  PDRIVER_NODE     DriverNode,
    IN  DWORD            DriverType,
    OUT PSP_DRVINFO_DATA DriverInfoData
    );

PDRIVER_NODE
FindAssociatedDriverNode(
    IN  PDRIVER_NODE      DriverListHead,
    IN  PSP_DRVINFO_DATA  DriverInfoData,
    OUT PDRIVER_NODE     *PreviousNode    OPTIONAL
    );

PDRIVER_NODE
SearchForDriverNode(
    IN  PVOID             StringTable,
    IN  PDRIVER_NODE      DriverListHead,
    IN  PSP_DRVINFO_DATA  DriverInfoData,
    OUT PDRIVER_NODE     *PreviousNode    OPTIONAL
    );

DWORD
DrvInfoDetailsFromDriverNode(
    IN  PDEVICE_INFO_SET        DeviceInfoSet,
    IN  PDRIVER_NODE            DriverNode,
    OUT PSP_DRVINFO_DETAIL_DATA DriverInfoDetailData, OPTIONAL
    IN  DWORD                   BufferSize,
    OUT PDWORD                  RequiredSize          OPTIONAL
    );


//
// Installation parameter manipulation routines
//
DWORD
GetDevInstallParams(
    IN  PDEVICE_INFO_SET        DeviceInfoSet,
    IN  PDEVINSTALL_PARAM_BLOCK DevInstParamBlock,
    OUT PSP_DEVINSTALL_PARAMS   DeviceInstallParams
    );

DWORD
GetClassInstallParams(
    IN  PDEVINSTALL_PARAM_BLOCK DevInstParamBlock,
    OUT PSP_CLASSINSTALL_HEADER ClassInstallParams, OPTIONAL
    IN  DWORD                   BufferSize,
    OUT PDWORD                  RequiredSize        OPTIONAL
    );

DWORD
SetDevInstallParams(
    IN OUT PDEVICE_INFO_SET        DeviceInfoSet,
    IN     PSP_DEVINSTALL_PARAMS   DeviceInstallParams,
    OUT    PDEVINSTALL_PARAM_BLOCK DevInstParamBlock,
    IN     BOOL                    MsgHandlerIsNativeCharWidth
    );

DWORD
SetClassInstallParams(
    IN OUT PDEVICE_INFO_SET        DeviceInfoSet,
    IN     PSP_CLASSINSTALL_HEADER ClassInstallParams,    OPTIONAL
    IN     DWORD                   ClassInstallParamsSize,
    OUT    PDEVINSTALL_PARAM_BLOCK DevInstParamBlock
    );

VOID
DestroyInstallParamBlock(
    IN HDEVINFO                hDevInfo,         OPTIONAL
    IN PDEVICE_INFO_SET        pDeviceInfoSet,
    IN PDEVINFO_ELEM           DevInfoElem,      OPTIONAL
    IN PDEVINSTALL_PARAM_BLOCK InstallParamBlock
    );

DWORD
GetDrvInstallParams(
    IN  PDRIVER_NODE          DriverNode,
    OUT PSP_DRVINSTALL_PARAMS DriverInstallParams
    );

DWORD
SetDrvInstallParams(
    IN  PSP_DRVINSTALL_PARAMS DriverInstallParams,
    OUT PDRIVER_NODE          DriverNode
    );


//
// String Table helper functions
//
LONG
AddMultiSzToStringTable(
    IN  PVOID   StringTable,
    IN  PTCHAR  MultiSzBuffer,
    OUT PLONG   StringIdList,
    IN  DWORD   StringIdListSize,
    IN  BOOL    CaseSensitive,
    OUT PTCHAR *UnprocessedBuffer    OPTIONAL
    );

LONG
LookUpStringInDevInfoSet(
    IN HDEVINFO DeviceInfoSet,
    IN PTSTR    String,
    IN BOOL     CaseSensitive
    );


//
// INF processing functions
//

typedef struct _DRVSEARCH_CONTEXT {
    PDRIVER_NODE           *pDriverListHead;
    PDRIVER_NODE           *pDriverListTail;
    PUINT                   pDriverCount;
    GUID                    ClassGuid;
    PDEVICE_INFO_SET        DeviceInfoSet;
    DWORD                   Flags;
    BOOL                    BuildClassDrvList;
    LONG                    IdList[2][MAX_HCID_COUNT+1]; // leave extra entry for '-1' end-of-list marker.
    PVOID                   StringTable;
    PBOOL                   CancelSearch;
    TCHAR                   ClassGuidString[GUID_STRING_LEN];
    TCHAR                   ClassName[MAX_CLASS_NAME_LEN];
    LONG                    InstalledDescription;
    LONG                    InstalledMfgName;
    LONG                    InstalledProviderName;
    LONG                    InstalledInfSection;
    LONG                    InstalledInfSectionExt;
    LONG                    InstalledMatchingDeviceId;
    PSP_ALTPLATFORM_INFO_V2 AltPlatformInfo;        // may be NULL
    VERIFY_CONTEXT          VerifyContext;
} DRVSEARCH_CONTEXT, *PDRVSEARCH_CONTEXT;

//
// DRVSEARCH_CONTEXT.Flags
//
#define DRVSRCH_HASCLASSGUID             0x00000001
#define DRVSRCH_FILTERCLASS              0x00000002
#define DRVSRCH_TRY_PNF                  0x00000004
#define DRVSRCH_UNUSED1                  0x00000008 // obsolete DRVSRCH_USEOLDINFS flag
#define DRVSRCH_FROM_INET                0x00000010
#define DRVSRCH_CLEANUP_SOURCE_PATH      0x00000020
#define DRVSRCH_EXCLUDE_OLD_INET_DRIVERS 0x00000040
#define DRVSRCH_ALLOWEXCLUDEDDRVS        0x00000080
#define DRVSRCH_FILTERSIMILARDRIVERS     0x00000100
#define DRVSRCH_INSTALLEDDRIVER          0x00000200
#define DRVSRCH_NO_CLASSLIST_NODE_MERGE  0x00000400

DWORD
EnumSingleDrvInf(
    IN     PCTSTR                       InfName,
    IN OUT LPWIN32_FIND_DATA            InfFileData,
    IN     DWORD                        SearchControl,
    IN     InfCacheCallback             EnumInfCallback,
    IN     PSETUP_LOG_CONTEXT           LogContext,
    IN OUT PDRVSEARCH_CONTEXT           Context
    );

DWORD
EnumDrvInfsInDirPathList(
    IN     PCTSTR                       DirPathList, OPTIONAL
    IN     DWORD                        SearchControl,
    IN     InfCacheCallback             EnumInfCallback,
    IN     BOOL                         IgnoreNonCriticalErrors,
    IN     PSETUP_LOG_CONTEXT           LogContext,
    IN OUT PDRVSEARCH_CONTEXT           Context
    );

BOOL
GetDecoratedModelsSection(
    IN  PSETUP_LOG_CONTEXT      LogContext,            OPTIONAL
    IN  PLOADED_INF             Inf,
    IN  PINF_LINE               MfgListLine,
    IN  PSP_ALTPLATFORM_INFO_V2 AltPlatformInfo,       OPTIONAL
    OUT PTSTR                   DecoratedModelsSection OPTIONAL
    );

PTSTR
GetFullyQualifiedMultiSzPathList(
    IN PCTSTR PathList
    );

BOOL
pRemoveDirectory(
    PTSTR Path
    );

BOOL
ShouldClassBeExcluded(
    IN LPGUID ClassGuid,
    IN BOOL   ExcludeNoInstallClass
    );

BOOL
ClassGuidFromInfVersionNode(
    IN  PINF_VERSION_NODE VersionNode,
    OUT LPGUID            ClassGuid
    );

VOID
AppendLoadIncludedInfs(
    IN HINF   hDeviceInf,
    IN PCTSTR InfFileName,
    IN PCTSTR InfSectionName,
    IN BOOL   AppendLayoutInfs
    );

DWORD
InstallFromInfSectionAndNeededSections(
    IN HWND              Owner,             OPTIONAL
    IN HINF              InfHandle,
    IN PCTSTR            SectionName,
    IN UINT              Flags,
    IN HKEY              RelativeKeyRoot,   OPTIONAL
    IN PCTSTR            SourceRootPath,    OPTIONAL
    IN UINT              CopyFlags,
    IN PSP_FILE_CALLBACK MsgHandler,
    IN PVOID             Context,           OPTIONAL
    IN HDEVINFO          DeviceInfoSet,     OPTIONAL
    IN PSP_DEVINFO_DATA  DeviceInfoData,    OPTIONAL
    IN HSPFILEQ          UserFileQ          OPTIONAL
    );

DWORD
MarkQueueForDeviceInstall(
    IN HSPFILEQ QueueHandle,
    IN HINF     DeviceInfHandle,
    IN PCTSTR   DeviceDesc       OPTIONAL
    );


//
// Icon list manipulation functions.
//
BOOL
InitMiniIconList(
    VOID
    );

BOOL
DestroyMiniIconList(
    VOID
    );


//
// "Driver Search In-Progress" list functions.
//
BOOL
InitDrvSearchInProgressList(
    VOID
    );

BOOL
DestroyDrvSearchInProgressList(
    VOID
    );


//
// 'helper module' manipulation functions.
//
DWORD
GetModuleEntryPoint(
    IN     HKEY                    hk,                    OPTIONAL
    IN     LPCTSTR                 RegistryValue,
    IN     LPCTSTR                 DefaultProcName,
    OUT    HINSTANCE              *phinst,
    OUT    FARPROC                *pEntryPoint,
    OUT    HANDLE                 *pFusionContext,
    OUT    BOOL                   *pMustAbort,            OPTIONAL
    IN     PSETUP_LOG_CONTEXT      LogContext,            OPTIONAL
    IN     HWND                    Owner,                 OPTIONAL
    IN     CONST GUID             *DeviceSetupClassGuid,  OPTIONAL
    IN     SetupapiVerifyProblem   Problem,
    IN     LPCTSTR                 DeviceDesc,            OPTIONAL
    IN     DWORD                   DriverSigningPolicy,
    IN     DWORD                   NoUI,
    IN OUT PVERIFY_CONTEXT         VerifyContext          OPTIONAL
    );

//
// Define flags for InvalidateHelperModules
//
#define IHM_COINSTALLERS_ONLY     0x00000001
#define IHM_FREE_IMMEDIATELY      0x00000002

DWORD
InvalidateHelperModules(
    IN HDEVINFO         DeviceInfoSet,
    IN PSP_DEVINFO_DATA DeviceInfoData, OPTIONAL
    IN DWORD            Flags
    );

//
// Define flags for _SetupDiCallClassInstaller
//
#define CALLCI_LOAD_HELPERS     0x00000001
#define CALLCI_CALL_HELPERS     0x00000002
#define CALLCI_ALLOW_DRVSIGN_UI 0x00000004

DWORD
_SetupDiCallClassInstaller(
    IN DI_FUNCTION      InstallFunction,
    IN HDEVINFO         DeviceInfoSet,
    IN PSP_DEVINFO_DATA DeviceInfoData,      OPTIONAL
    IN DWORD            Flags
    );


//
// OEM driver selection routines.
//
DWORD
SelectOEMDriver(
    IN HWND             hwndParent,     OPTIONAL
    IN HDEVINFO         DeviceInfoSet,
    IN PSP_DEVINFO_DATA DeviceInfoData, OPTIONAL
    IN BOOL             IsWizard
    );


//
// Registry helper routines.
//
DWORD
pSetupDeleteDevRegKeys(
    IN DEVINST  DevInst,
    IN DWORD    Scope,
    IN DWORD    HwProfile,
    IN DWORD    KeyType,
    IN BOOL     DeleteUserKeys,
    IN HMACHINE hMachine        OPTIONAL
    );

VOID
GetRegSubkeysFromDeviceInterfaceName(
    IN OUT PTSTR  DeviceInterfaceName,
    OUT    PTSTR *SubKeyName
    );

LONG
OpenDeviceInterfaceSubKey(
    IN     HKEY   hKeyInterfaceClass,
    IN     PCTSTR DeviceInterfaceName,
    IN     REGSAM samDesired,
    OUT    PHKEY  phkResult,
    OUT    PTSTR  OwningDevInstName,    OPTIONAL
    IN OUT PDWORD OwningDevInstNameSize OPTIONAL
    );


//
// Guid table routines.
//
LONG
AddOrGetGuidTableIndex(
    IN PDEVICE_INFO_SET  DeviceInfoSet,
    IN CONST GUID       *ClassGuid,
    IN BOOL              AddIfNotPresent
    );


//
// Device interface routines.
//
PINTERFACE_CLASS_LIST
AddOrGetInterfaceClassList(
    IN PDEVICE_INFO_SET DeviceInfoSet,
    IN PDEVINFO_ELEM    DevInfoElem,
    IN LONG             InterfaceClassGuidIndex,
    IN BOOL             AddIfNotPresent
    );

BOOL
DeviceInterfaceDataFromNode(
    IN  PDEVICE_INTERFACE_NODE     DeviceInterfaceNode,
    IN  CONST GUID                *InterfaceClassGuid,
    OUT PSP_DEVICE_INTERFACE_DATA  DeviceInterfaceData
    );

PDEVINFO_ELEM
FindDevInfoElemForDeviceInterface(
    IN PDEVICE_INFO_SET          DeviceInfoSet,
    IN PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData
    );


//
// Service installation routines.
//
typedef struct _SVCNAME_NODE {
    struct _SVCNAME_NODE *Next;
    TCHAR Name[MAX_SERVICE_NAME_LEN];
    BOOL DeleteEventLog;
    TCHAR EventLogType[256];
    TCHAR EventLogName[256];
    DWORD Flags;
} SVCNAME_NODE, *PSVCNAME_NODE;

//
// Define an additional (private) SPSVCINST flag for
// InstallNtService.
//
#define SPSVCINST_NO_DEVINST_CHECK  (0x80000000)

DWORD
InstallNtService(
    IN  PDEVINFO_ELEM    DevInfoElem,        OPTIONAL
    IN  HINF             hDeviceInf,
    IN  PCTSTR                   InfFileName,            OPTIONAL
    IN  PCTSTR           szSectionName,      OPTIONAL
    OUT PSVCNAME_NODE   *ServicesToDelete,   OPTIONAL
    IN  DWORD            Flags,
    OUT PBOOL            NullDriverInstalled
    );

//
// Ansi/Unicode conversion routines.
//
DWORD
pSetupDiDevInstParamsAnsiToUnicode(
    IN  PSP_DEVINSTALL_PARAMS_A AnsiDevInstParams,
    OUT PSP_DEVINSTALL_PARAMS_W UnicodeDevInstParams
    );

DWORD
pSetupDiDevInstParamsUnicodeToAnsi(
    IN  PSP_DEVINSTALL_PARAMS_W UnicodeDevInstParams,
    OUT PSP_DEVINSTALL_PARAMS_A AnsiDevInstParams
    );

DWORD
pSetupDiSelDevParamsAnsiToUnicode(
    IN  PSP_SELECTDEVICE_PARAMS_A AnsiSelDevParams,
    OUT PSP_SELECTDEVICE_PARAMS_W UnicodeSelDevParams
    );

DWORD
pSetupDiSelDevParamsUnicodeToAnsi(
    IN  PSP_SELECTDEVICE_PARAMS_W UnicodeSelDevParams,
    OUT PSP_SELECTDEVICE_PARAMS_A AnsiSelDevParams
    );

DWORD
pSetupDiDrvInfoDataAnsiToUnicode(
    IN  PSP_DRVINFO_DATA_A AnsiDrvInfoData,
    OUT PSP_DRVINFO_DATA_W UnicodeDrvInfoData
    );

DWORD
pSetupDiDrvInfoDataUnicodeToAnsi(
    IN  PSP_DRVINFO_DATA_W UnicodeDrvInfoData,
    OUT PSP_DRVINFO_DATA_A AnsiDrvInfoData
    );

DWORD
pSetupDiDevInfoSetDetailDataUnicodeToAnsi(
    IN  PSP_DEVINFO_LIST_DETAIL_DATA_W UnicodeDevInfoSetDetails,
    OUT PSP_DEVINFO_LIST_DETAIL_DATA_A AnsiDevInfoSetDetails
    );

//
// Misc. utility routines
//
DWORD
MapCrToSpErrorEx(
    IN CONFIGRET CmReturnCode,
    IN DWORD     Default,
    IN BOOL      BackwardCompatible
    );

//
// Define a macro to perform the backward-compatible mapping.  New code should
// NOT use this macro, and should instead use the CR_TO_SP macro.
//
#define MapCrToSpError(CmReturnCode,Default) MapCrToSpErrorEx((CmReturnCode),(Default),TRUE)

//
// This macro should be used by all newly-added code to map CONFIGRET errors to
// their setupapi (Win32) counterparts.
//
#define CR_TO_SP(CmReturnCode,Default) MapCrToSpErrorEx((CmReturnCode),(Default),FALSE)


VOID
SetDevnodeNeedsRebootProblemWithArg2(
    IN PDEVINFO_ELEM DevInfoElem,
    IN PDEVICE_INFO_SET DevInfoSet,
    IN DWORD    Reason,                  OPTIONAL
    IN ULONG_PTR Arg1,                   OPTIONAL
    IN ULONG_PTR Arg2                    OPTIONAL
    );

#define SetDevnodeNeedsRebootProblemWithArg(DevInfoElem,DevInfoSet,Reason,Arg) SetDevnodeNeedsRebootProblemWithArg2(DevInfoElem,DevInfoSet,Reason,Arg,0)
#define SetDevnodeNeedsRebootProblem(DevInfoElem,DevInfoSet,Reason) SetDevnodeNeedsRebootProblemWithArg2(DevInfoElem,DevInfoSet,Reason,0,0)

BOOL
GetBestDeviceDesc(
    IN  HDEVINFO         DeviceInfoSet,
    IN  PSP_DEVINFO_DATA DeviceInfoData,  OPTIONAL
    OUT PTSTR            DeviceDescBuffer
    );

DWORD
__inline
pSetupGetLastError(

#if ASSERTS_ON
    IN PCSTR Filename,
    IN DWORD Line
#else
    VOID
#endif

    )
/*++

Routine Description:

    This inline routine retrieves a Win32 error, and guarantees that the error
    isn't NO_ERROR.  This routine should not be called unless the preceding
    call failed, and GetLastError() is supposed to contain the problem's cause.

Arguments:

    If asserts are turned on, this function takes the (ANSI) Filename of the 
    source file that called the failing function, and also the DWORD Line
    number where the call was made.  This makes it much easier to debug
    scenarios where the failing function didn't set last error when it was
    supposed to.

Return Value:

    Win32 error code retrieved via GetLastError(), or ERROR_UNIDENTIFIED_ERROR
    if GetLastError() returned NO_ERROR.

--*/
{
    DWORD Err = GetLastError();

#if ASSERTS_ON
    if(Err == NO_ERROR) { 
        AssertFail(Filename,
                   Line,
                   "GetLastError() != NO_ERROR",
                   FALSE
                  ); 
    }
#endif

    return ((Err == NO_ERROR) ? ERROR_UNIDENTIFIED_ERROR : Err);
}


//
// Macro to simplify calling of a function that reports error status via
// GetLastError().  This macro allows the caller to specify what Win32 error
// code should be returned if the function reports success.  (If the default of
// NO_ERROR is desired, use the GLE_FN_CALL macro instead.)
//
// The "prototype" of this macro is as follows:
//
// DWORD
// GLE_FN_CALL_WITH_SUCCESS(
//     SuccessfulStatus, // Win32 error code to return if function succeeded
//     FailureIndicator, // value returned by function to indicate failure (e.g., FALSE, NULL, INVALID_HANDLE_VALUE)
//     FunctionCall      // actual call to the function
// );
//

#if ASSERTS_ON

#define GLE_FN_CALL_WITH_SUCCESS(SuccessfulStatus,         \
                                 FailureIndicator,         \
                                 FunctionCall)             \
                                                           \
            (SetLastError(NO_ERROR),                       \
             (((FunctionCall) != (FailureIndicator))       \
                 ? (SuccessfulStatus)                      \
                 : pSetupGetLastError(__FILE__, __LINE__)))
#else

#define GLE_FN_CALL_WITH_SUCCESS(SuccessfulStatus,         \
                                 FailureIndicator,         \
                                 FunctionCall)             \
                                                           \
            (SetLastError(NO_ERROR),                       \
             (((FunctionCall) != (FailureIndicator))       \
                 ? (SuccessfulStatus)                      \
                 : pSetupGetLastError()))
                 
#endif

//
// Macro to simplify calling of a function that reports error status via
// GetLastError().  If the function call is successful, NO_ERROR is returned.
// (To specify an alternate value returned upon success, use the
// GLE_FN_CALL_WITH_SUCCESS macro instead.)
//
// The "prototype" of this macro is as follows:
//
// DWORD
// GLE_FN_CALL(
//     FailureIndicator, // value returned by function to indicate failure (e.g., FALSE, NULL, INVALID_HANDLE_VALUE)
//     FunctionCall      // actual call to the function
// );
//

#define GLE_FN_CALL(FailureIndicator, FunctionCall)                           \
            GLE_FN_CALL_WITH_SUCCESS(NO_ERROR, FailureIndicator, FunctionCall)