windows-xp/Source/XPSP1/NT/printscan/print/spooler/splsetup/ntprint.c

/*++

Copyright (c) 1995-97 Microsoft Corporation
All rights reserved.

Module Name:

    Ntprint.c

Abstract:

    Ntprint.dll main functions

Author:

    Muhunthan Sivapragasam (MuhuntS) 02-Jan-1996

Revision History:

--*/


#include "precomp.h"
#include "splcom.h"
#include "regstr.h"

HINSTANCE   ghInst;
DWORD       dwThisMajorVersion  =   3;

PCODEDOWNLOADINFO   gpCodeDownLoadInfo = NULL;

HANDLE      hPrintui = NULL;
DWORD       (*dwfnPnPInterface)(
                IN EPnPFunctionCode Function,
                IN TParameterBlock  *pParameterBlock
                )   = NULL;

TCHAR   cszMicrosoft[]                  = TEXT("Microsoft");
TCHAR   cszPrinter[]                    = TEXT("Printer");
TCHAR   cszPortName[]                   = TEXT("PortName");
TCHAR   cszPnPKey[]                     = TEXT("PnPData");
TCHAR   cszDeviceInstanceId[]           = TEXT("DeviceInstanceId");
TCHAR   cszHardwareID[]                 = TEXT("HardwareID");
TCHAR   cszManufacturer[]               = TEXT("Manufacturer");
TCHAR   cszOEMUrl[]                     = TEXT("OEM URL");
TCHAR   cszProcessAlways[]              = TEXT(".ProcessPerPnpInstance");
TCHAR   cszRunDll32[]                   = TEXT("rundll32.exe");
TCHAR   cszBestDriverInbox[]            = TEXT("InstallInboxDriver");

const   DWORD dwFourMinutes             = 240000;

OSVERSIONINFO       OsVersionInfo;
LCID                lcid;

#define MAX_PRINTER_NAME    MAX_PATH

MODULE_DEBUG_INIT(DBG_WARN|DBG_ERROR, DBG_ERROR);

BOOL 
DllMain(
    IN HINSTANCE  hInst,
    IN DWORD      dwReason,
    IN LPVOID     lpRes   
    )
/*++

Routine Description:
    Dll entry point.

Arguments:

Return Value:

--*/
{
    UNREFERENCED_PARAMETER(lpRes);

    switch( dwReason ){

        case DLL_PROCESS_ATTACH:

            ghInst              = hInst;

            if( !bSplLibInit(NULL))
            {
                DBGMSG( DBG_WARN,
                      ( "DllEntryPoint: Failed to init SplLib %d\n", GetLastError( )));

                return FALSE;
            }

            DisableThreadLibraryCalls(hInst);
            OsVersionInfo.dwOSVersionInfoSize = sizeof(OsVersionInfo);

            if ( !GetVersionEx(&OsVersionInfo) )
                return FALSE;
            lcid = GetUserDefaultLCID();

            InitializeCriticalSection(&CDMCritSect);
            InitializeCriticalSection(&SkipCritSect);

            if(IsInWow64())
            {
                //
                // 32-bit code running on Win64 -> set platform appropriately
                //
                MyPlatform = PlatformIA64;
            }

            break;

        case DLL_PROCESS_DETACH:
            if ( hPrintui )
                FreeLibrary(hPrintui);

            DeleteCriticalSection(&CDMCritSect);
            // Cleanup and CDM Context  created by windows update.
            DestroyCodedownload( gpCodeDownLoadInfo );
            gpCodeDownLoadInfo = NULL;

            CleanupSkipDir();
            vSplLibFree();
            break;

        default:
            return FALSE;
    }

    return TRUE;
}

BOOL
LoadAndInitializePrintui(
    VOID
    )
/*++

Routine Description:
    Check the refcount on printui, load it on 0 and increment the refcount.

Arguments:
    None

Return Value:
    TRUE on success, FALSE on error

--*/
{
    LPTSTR   szDll =
#ifdef  UNICODE
        TEXT("printui.dll");
#else
        TEXT("printuia.dll");
#endif

    if ( hPrintui ) {

        return TRUE;
    }

    if ( hPrintui = LoadLibraryUsingFullPath(szDll) ) {

        if ( (FARPROC)dwfnPnPInterface = GetProcAddress(hPrintui,
                                                        "PnPInterface") ) {

            return TRUE;
        } else {

            FreeLibrary(hPrintui);
            hPrintui = NULL;
        }
    }

    return FALSE;
}

BOOL
PSetupAssociateICMProfiles(
    IN  LPCTSTR     pszzICMFiles,
    IN  LPCTSTR     pszPrinterName
    )
/*++

Routine Description:
    Install ICM color profiles for a printer driver and associate it with
    the printer name given

Arguments:
    pszzICMFiles    : Multi-sz field giving ICM profile names
    pszPrinterName  : Printer name

Return Value:
    None

--*/
{
    TCHAR   szDir[MAX_PATH], *p;
    DWORD   dwSize, dwNeeded;

    dwSize      = SIZECHARS(szDir);
    dwNeeded    = sizeof(szDir);

    if ( !GetColorDirectory(NULL, szDir, &dwNeeded) )
        return FALSE;

    dwNeeded           /= sizeof(TCHAR);
    szDir[dwNeeded-1]   = TEXT('\\');

    //
    // Install and assoicate each profiles from the multi-sz field
    //
    for ( p = (LPTSTR)pszzICMFiles; *p ; p += lstrlen(p) + 1 ) {

        if ( dwNeeded + lstrlen(p) + 1 > dwSize ) {

            ASSERT(dwNeeded + lstrlen(p) + 1 <= dwSize);
            continue;
        }

        lstrcpy(szDir + dwNeeded, p);
        //
        // We do not need the right server name here since ICM should send it
        // to the right server
        //
        if ( !AssociateColorProfileWithDevice(NULL, szDir, pszPrinterName) )
            return FALSE;
    }

    return TRUE;
}


DWORD
GetPlugAndPlayInfo(
    IN  HDEVINFO            hDevInfo,
    IN  PSP_DEVINFO_DATA    pDevInfoData,
    IN  PPSETUP_LOCAL_DATA  pLocalData
    )
/*++

Routine Description:
    Get necessary PnP info LPT enumerator would have setup in the config
    manager registry

Arguments:
    hDevInfo        : Handle to the printer class device information list
    pDevInfoData    : Pointer to the device info element for the printer
    pLocalData      : Gives installation data

Return Value:
    TRUE on success, FALSE else.

--*/
{
    HKEY        hKey = NULL;
    TCHAR       buf[MAX_PATH];
    DWORD       dwType, dwSize, dwReturn;
    PNP_INFO    PnPInfo;

    ASSERT( !(pLocalData->Flags & VALID_PNP_INFO) );

    ZeroMemory(&PnPInfo, sizeof(PnPInfo));

    //
    // Look in the devnode for the printer created to get the port name and
    // the device instance id
    //
    if ( dwReturn = CM_Open_DevNode_Key(pDevInfoData->DevInst, KEY_READ, 0,
                                        RegDisposition_OpenExisting, &hKey,
                                        CM_REGISTRY_HARDWARE) )
        goto Cleanup;

    dwSize = sizeof(buf);

    if ( dwReturn = RegQueryValueEx(hKey, cszPortName, NULL, &dwType,
                                    (LPBYTE)&buf, &dwSize) ) {

        if ( dwReturn == ERROR_FILE_NOT_FOUND )
            dwReturn = ERROR_UNKNOWN_PORT;
        goto Cleanup;
    }

    if ( !(PnPInfo.pszPortName = AllocStr(buf)) ) {

        dwReturn = GetLastError();
        goto Cleanup;
    }

    //
    // This can't be bigger than MAX_DEVICE_ID_LEN so it is ok
    //
    if ( !SetupDiGetDeviceInstanceId(hDevInfo,
                                     pDevInfoData,
                                     buf,
                                     SIZECHARS(buf),
                                     NULL) ) {

        dwReturn = GetLastError();
        goto Cleanup;
    }

    if ( !(PnPInfo.pszDeviceInstanceId =  AllocStr(buf)) ) {

        dwReturn = GetLastError();
        goto Cleanup;
    }

Cleanup:

    if ( dwReturn == ERROR_SUCCESS ) {

        CopyMemory(&pLocalData->PnPInfo, &PnPInfo, sizeof(PnPInfo));
        pLocalData->Flags   |= VALID_PNP_INFO;
    } else {

        FreeStructurePointers((LPBYTE)&PnPInfo, PnPInfoOffsets, FALSE);
    }

    if ( hKey )
        RegCloseKey(hKey);

    return dwReturn;
}


BOOL
PrinterGoingToPort(
    IN  LPPRINTER_INFO_2    pPrinterInfo2,
    IN  LPCTSTR             pszPortName
    )
/*++

Routine Description:
    Find out if a printer is going to a port (it may go to other ports also)

Arguments:
    pPrinterInfo2   : Gives the PRINTER_INFO_2 for the print queue
    pszPortName     : The port name

Return Value:
    If the print queue is going to the port TRUE, else FALSE

--*/
{
    LPTSTR  pszStr1 = pPrinterInfo2->pPortName, pszStr2;

    //
    // Port names are returned comma separated by spooler; and there are blanks
    //
    while ( pszStr2 = lstrchr(pszStr1, sComma) ) {

        *pszStr2 = sZero;
        ++pszStr2;

        if ( !lstrcmpi(pszPortName, pszStr1) )
            return TRUE;
        pszStr1 = pszStr2;

        //
        // Skip spaces
        //
        while ( *pszStr1 == TEXT(' ') )
            ++pszStr1;
    }

    if ( !lstrcmpi(pszPortName, pszStr1) )
        return TRUE;

    return FALSE;
}


BOOL
SetPnPInfoForPrinter(
    IN  HANDLE      hPrinter,
    IN  LPCTSTR     pszDeviceInstanceId,
    IN  LPCTSTR     pszHardwareID,
    IN  LPCTSTR     pszManufacturer,
    IN  LPCTSTR     pszOEMUrl
    )
/*++

Routine Description:
    Set registry values in the PnPInfo subkey

Arguments:
    hPrinter            : Printer handle
    pszDeviceInstanceId : DeviceInstance Id
    pszHardwareID       : Device PnP or Compat Id
    pszManufacturer     : Manufacturer (from the inf)
    pszOEMUrl           : Manufacturer URL (from the inf)

Return Value:
    TRUE on success, FALSE else.

--*/
{
    DWORD   dwLastError = ERROR_SUCCESS;

    if ( pszDeviceInstanceId && *pszDeviceInstanceId)
        dwLastError = SetPrinterDataEx(hPrinter,
                                       cszPnPKey,
                                       cszDeviceInstanceId,
                                       REG_SZ,
                                       (LPBYTE)pszDeviceInstanceId,
                                       (lstrlen(pszDeviceInstanceId) + 1)
                                                * sizeof(TCHAR));

    if ( dwLastError == ERROR_SUCCESS && pszHardwareID && *pszHardwareID )
        dwLastError = SetPrinterDataEx(hPrinter,
                                       cszPnPKey,
                                       cszHardwareID,
                                       REG_SZ,
                                       (LPBYTE)pszHardwareID,
                                       (lstrlen(pszHardwareID) + 1)
                                            * sizeof(TCHAR));

    if ( dwLastError == ERROR_SUCCESS && pszManufacturer && *pszManufacturer )
        dwLastError = SetPrinterDataEx(hPrinter,
                                       cszPnPKey,
                                       cszManufacturer,
                                       REG_SZ,
                                       (LPBYTE)pszManufacturer,
                                       (lstrlen(pszManufacturer) + 1)
                                            * sizeof(TCHAR));

    if ( dwLastError == ERROR_SUCCESS && pszOEMUrl && *pszOEMUrl )
        dwLastError = SetPrinterDataEx(hPrinter,
                                       cszPnPKey,
                                       cszOEMUrl,
                                       REG_SZ,
                                       (LPBYTE)pszOEMUrl,
                                       (lstrlen(pszOEMUrl) + 1)
                                            * sizeof(TCHAR));

    if ( dwLastError ) {

        SetLastError(dwLastError);
        return FALSE;
    }

    return TRUE;
}


BOOL
PrinterInfo2s(
    OUT LPPRINTER_INFO_2   *ppPI2,
    OUT LPDWORD             pdwReturned
    )
/*++

Routine Description:
    Does an EnumPrinter and returns a list of PRINTER_INFO_2s of all local
    printers. Caller should free the pointer.

Arguments:
    ppPI2       : Points to PRINTER_INFO_2s on return
    pdwReturned : Tells how many PRINTER_INFO_2s are returned

Return Value:
    TRUE on success, FALSE else

--*/
{
    BOOL    bRet = FALSE;
    DWORD   dwNeeded = 0x1000;
    LPBYTE  pBuf;

    if ( !(pBuf = LocalAllocMem(dwNeeded)) )
        goto Cleanup;

    if ( !EnumPrinters(PRINTER_ENUM_LOCAL,
                       NULL,
                       2,
                       pBuf,
                       dwNeeded,
                       &dwNeeded,
                       pdwReturned) ) {

        if ( GetLastError() != ERROR_INSUFFICIENT_BUFFER )
            goto Cleanup;

        LocalFreeMem(pBuf);
        if ( !(pBuf = LocalAllocMem(dwNeeded))   ||
             !EnumPrinters(PRINTER_ENUM_LOCAL,
                           NULL,
                           2,
                           pBuf,
                           dwNeeded,
                           &dwNeeded,
                           pdwReturned) ) {

            goto Cleanup;
        }
   }

   bRet = TRUE;

Cleanup:

    if ( bRet ) {

        *ppPI2 = (LPPRINTER_INFO_2)pBuf;
    } else {

        if ( pBuf )
            LocalFreeMem(pBuf);

        *ppPI2 = NULL;
        *pdwReturned = 0;
        }

    return bRet;
}


BOOL
DuplicateDevice(
    IN  PPSETUP_LOCAL_DATA  pLocalData
    )
/*++

Routine Description:
    Find out if a PnP reported printer is already installed

Arguments:
    pLocalData  : Gives installation data

Return Value:
    If the printer is already install TRUE, else FALSE

--*/
{
    PRINTER_DEFAULTS    PrinterDefault = {NULL, NULL, PRINTER_ALL_ACCESS};
    LPPRINTER_INFO_2    p = NULL, pPrinterInfo2;
    BOOL                bReturn = FALSE;
    DWORD               dwReturned, dwNeeded;
    HANDLE              hPrinter;
    LPTSTR              pszDriverName = pLocalData->DrvInfo.pszModelName,
                        pszPortName = pLocalData->PnPInfo.pszPortName;

    ASSERT( (pLocalData->Flags & VALID_PNP_INFO)    &&
            (pLocalData->Flags & VALID_INF_INFO) );

    if ( !PrinterInfo2s(&p, &dwReturned) )
        goto Cleanup;

    //
    // If there is a local printer using the same driver and going to the
    // same port then it is a duplicate
    //
    for ( dwNeeded = 0, pPrinterInfo2 = p ;
          dwNeeded < dwReturned ;
          ++dwNeeded, pPrinterInfo2++ ) {

        if ( !lstrcmpi(pszDriverName, pPrinterInfo2->pDriverName) &&
             PrinterGoingToPort(pPrinterInfo2, pszPortName) )
            break; // for loop
    }

    if ( dwNeeded == dwReturned )
        goto Cleanup;

    bReturn = TRUE;

    if ( bReturn ) {

        if ( OpenPrinter(pPrinterInfo2->pPrinterName,
                         &hPrinter,
                         &PrinterDefault) ) {

            //
            // If it fails can't help
            //
            (VOID)SetPnPInfoForPrinter(hPrinter,
                                       pLocalData->PnPInfo.pszDeviceInstanceId,
                                       pLocalData->DrvInfo.pszHardwareID,
                                       pLocalData->DrvInfo.pszManufacturer,
                                       pLocalData->DrvInfo.pszOEMUrl);

            ClosePrinter(hPrinter);
        }
    }

Cleanup:
    LocalFreeMem(p);

    return bReturn;
}


BOOL
PrinterPnPDataSame(
    IN LPTSTR pszDeviceInstanceId,
    IN LPTSTR pszPrinterName
)
/*

Routine Description:
    Find out if a PnP printer has been installed with different driver name.
    We need to associate the queue previously used with this new driver as
    pnp says it's the new best driver for the device.

Arguments:
    pszDeviceInstanceId  : Gives the device ID instance string of the pnped device.
    pszPrinterName       : The name of the printer to compare the device instance ID to.

Return Value:
    If printer's pnp data holds the same device instance ID as the passed ID returns TRUE, else FALSE.

*/
{
    BOOL              bRet           = FALSE;
    PRINTER_DEFAULTS  PrinterDefault = {NULL, NULL, PRINTER_ALL_ACCESS};
    HANDLE            hPrinter;
    DWORD             dwNeeded;
    TCHAR             szPrnId[MAX_DEVICE_ID_LEN];

    if( pszPrinterName && pszDeviceInstanceId ) {

        if ( OpenPrinter(pszPrinterName,
                         &hPrinter,
                         &PrinterDefault) ) {

            if ( ERROR_SUCCESS == GetPrinterDataEx(hPrinter,
                                                   cszPnPKey,
                                                   cszDeviceInstanceId,
                                                   &dwNeeded,
                                                   (LPBYTE)szPrnId,
                                                   sizeof(szPrnId),
                                                   &dwNeeded)           &&
                 !lstrcmp(szPrnId, pszDeviceInstanceId) ) {

                bRet = TRUE;
            }

            ClosePrinter(hPrinter);
        }
    }

    return bRet;
}


BOOL
NewDriverForInstalledDevice(
    IN     PPSETUP_LOCAL_DATA  pLocalData,
    OUT    LPTSTR              pszPrinterName
    )
/*++

Routine Description:
    Find out if a PnP printer has been installed with different driver name.
    We need to associate the queue previously used with this new driver as
    pnp says it's the new best driver for the device.

Arguments:
    pLocalData     : Gives installation data
    pszPrinterName : Gives the printer name to return and use.

Return Value:
    If a printer is already installed which uses another driver TRUE, else FALSE

--*/
{
    PRINTER_DEFAULTS    PrinterDefault = {NULL, NULL, PRINTER_ALL_ACCESS};
    LPPRINTER_INFO_2    p = NULL, pPrinterInfo2;
    BOOL                bReturn = FALSE;
    DWORD               dwReturned, dwNeeded;
    HANDLE              hPrinter;
    LPTSTR              pszPortName = pLocalData->PnPInfo.pszPortName;
    LPTSTR              pszDeviceInstanceId = pLocalData->PnPInfo.pszDeviceInstanceId;

    ASSERT( (pLocalData->Flags & VALID_PNP_INFO)    &&
            (pLocalData->Flags & VALID_INF_INFO) );

    if ( !PrinterInfo2s(&p, &dwReturned) )
        goto Cleanup;

    //
    // If there is a printer going to that same port and with the same pnp
    // info, then it has been reinstalled with a newer driver.
    //
    for ( dwNeeded = 0, pPrinterInfo2 = p ;
          dwNeeded < dwReturned ;
          ++dwNeeded, pPrinterInfo2++ ) {

        if ( PrinterGoingToPort(pPrinterInfo2, pszPortName) &&
            PrinterPnPDataSame(pszDeviceInstanceId, pPrinterInfo2->pPrinterName) ) {

            break; // for loop
        }
    }

    if ( dwNeeded == dwReturned ) {
        //
        // We didn't find anything...
        //
        goto Cleanup;
    }

    if ( OpenPrinter(pPrinterInfo2->pPrinterName,
                     &hPrinter,
                     &PrinterDefault) ) {

        pPrinterInfo2->pDriverName = pLocalData->DrvInfo.pszModelName;

        if( SetPrinter( hPrinter, 2, (LPBYTE)pPrinterInfo2, 0 ) ) {

            lstrcpyn( pszPrinterName, pPrinterInfo2->pPrinterName, MAX_PRINTER_NAME );
            bReturn = TRUE;
        }

        ClosePrinter(hPrinter);
    }

Cleanup:
    if( p ) {

        LocalFreeMem(p);
    }

    return bReturn;
}


VOID
CallVendorDll(
    IN  PPSETUP_LOCAL_DATA  pLocalData,
    IN  LPCTSTR             pszPrinterName,
    IN  HWND                hwnd
    )
/*++

Routine Description:
    A VendorSetup was specified in the INF. Call the dll with the name of the
    printer just created

Arguments:
    pLocalData      : Gives installation data
    pszPrinterName  : Name of the printer which got installed
    hwnd            : Window handle for any UI

Return Value:
    If the printer is already install TRUE, else FALSE

--*/
{
    TCHAR               szCmd[MAX_PATH];
    SHELLEXECUTEINFO    ShellExecInfo;
    TCHAR               *pszExecutable  = NULL;
    TCHAR               *pszParams      = NULL;
    LPTSTR              pszVendorSetup  = pLocalData->InfInfo.pszVendorSetup;
    INT                 cParamsLength   = 0;
    INT                 cLength         = 0;

    
    if (IsSystemSetupInProgress())
    {
        goto Cleanup;
    }

    ASSERT(pLocalData->Flags & VALID_INF_INFO);

    cParamsLength = lstrlen(pszVendorSetup) + lstrlen(pszPrinterName) + 4;
    pszParams     = LocalAllocMem(cParamsLength * sizeof(TCHAR));
    if (!pszParams) 
    {
        goto Cleanup;
    }

    wsprintf(pszParams, TEXT("%s \"%s\""), pszVendorSetup, pszPrinterName);

    GetSystemDirectory( szCmd, SIZECHARS(szCmd) );
    cLength = lstrlen( szCmd ) + lstrlen( cszRunDll32 ) + 2;
    pszExecutable = LocalAllocMem( cLength * sizeof(TCHAR) );
    if (!pszExecutable) 
    {
        goto Cleanup;
    }
    lstrcpy(pszExecutable, szCmd);
    cLength = lstrlen( pszExecutable );
    if (*(pszExecutable + (cLength - 1)) != TEXT('\\'))
    {
        lstrcat( pszExecutable, TEXT("\\"));
    }
    lstrcat(pszExecutable, cszRunDll32 );

    ZeroMemory(&ShellExecInfo, sizeof(ShellExecInfo));
    ShellExecInfo.cbSize        = sizeof(ShellExecInfo);
    ShellExecInfo.hwnd          = hwnd;
    ShellExecInfo.lpFile        = pszExecutable;
    ShellExecInfo.nShow         = SW_SHOWNORMAL;
    ShellExecInfo.fMask         = SEE_MASK_NOCLOSEPROCESS;
    ShellExecInfo.lpParameters  = pszParams;

    //
    // Call run32dll and wait for the vendor dll to return before proceeding
    //
    if ( ShellExecuteEx(&ShellExecInfo) && ShellExecInfo.hProcess ) {

        WaitForSingleObject(ShellExecInfo.hProcess, dwFourMinutes );
        CloseHandle(ShellExecInfo.hProcess);
    }

Cleanup:

    LocalFreeMem(pszExecutable);
    LocalFreeMem(pszParams);
    return;
}


BOOL
SetPackageName (
    IN  HDEVINFO            hDevInfo,
    IN  PSP_DEVINFO_DATA    pDevInfoData
    )
{
   SP_WINDOWSUPDATE_PARAMS     WinUpParams;

   //
   // Get current SelectDevice parameters, and then set the fields
   // we wanted changed from default
   //
   WinUpParams.ClassInstallHeader.cbSize = sizeof(WinUpParams.ClassInstallHeader);
   WinUpParams.ClassInstallHeader.InstallFunction = DIF_GETWINDOWSUPDATEINFO;
   if ( !SetupDiGetClassInstallParams( hDevInfo,
                                       pDevInfoData,
                                       &WinUpParams.ClassInstallHeader,
                                       sizeof(WinUpParams),
                                       NULL) )
   {
       return FALSE;
   }

   lstrcpy( WinUpParams.PackageId,  cszWebNTPrintPkg );
   WinUpParams.CDMContext = gpCodeDownLoadInfo->hConnection;

   if ( !SetupDiSetClassInstallParams( hDevInfo,
                                       pDevInfoData,
                                       (PSP_CLASSINSTALL_HEADER) &WinUpParams,
                                       sizeof(WinUpParams) ) )
   {
       return FALSE;
   }

   return TRUE;
}

DWORD
ProcessPerInstanceAddRegSections(
    IN  HDEVINFO            hDevInfo,
    IN  PSP_DEVINFO_DATA    pDevInfoData,
    IN  PPSETUP_LOCAL_DATA  pLocalData
)
/*++

Routine Description:
    Processes the AddReg section for this printer that is marked as to process per instance of this
    device

Arguments:
    hDevInfo            : Handle to the printer class device information list
    pDevInfoData        : Pointer to the device info element for the printer
    pLocalData          : Pointer to the print setup local data

Return Value:
    Win 32 error code

--*/
{
    DWORD dwReturn;
    HINF hPrinterInf;
    TCHAR *pszSection = NULL;

    dwReturn = StrCatAlloc(&pszSection, pLocalData->InfInfo.pszInstallSection, cszProcessAlways, NULL);

    if (dwReturn != ERROR_SUCCESS)
    {
        goto Done;
    }
    
    hPrinterInf = SetupOpenInfFile(pLocalData->DrvInfo.pszInfName, 
                                   NULL, 
                                   INF_STYLE_WIN4,
                                   NULL);

    if (hPrinterInf != INVALID_HANDLE_VALUE)
    {
        //
        // Ignore return value - it doesn't make much sense to fail the install here
        //
        if (!SetupInstallFromInfSection(NULL,
                                        hPrinterInf,
                                        pszSection,
                                        SPINST_REGISTRY,
                                        NULL,
                                        NULL,
                                        0,
                                        NULL,
                                        NULL,
                                        hDevInfo,
                                        pDevInfoData))
        {
            DBGMSG( DBG_ERROR,("ProcessPerInstanceAddRegSections: SetupInstallFromInfSection failed: %d\n", GetLastError( )));
        }
        
        SetupCloseInfFile(hPrinterInf);
    }
    else
    {
        DBGMSG( DBG_ERROR,("ProcessPerInstanceAddRegSections: SetupOpenInfFile %s failed: %d\n", pLocalData->DrvInfo.pszInfName, GetLastError( )));
    }

Done:
    FreeSplMem(pszSection);

    return dwReturn;
}

DWORD
ClassInstall_SelectDevice(
    IN  HDEVINFO            hDevInfo,
    IN  PSP_DEVINFO_DATA    pDevInfoData
    )
/*++

Routine Description:
    This function handles the class installer entry point for DIF_SELECTDEVICE

Arguments:
    hDevInfo        : Handle to the printer class device information list
    pDevInfoData    : Pointer to the device info element for the printer

Return Value:
    Win 32 error code

--*/
{

    return SetSelectDevParams(hDevInfo, pDevInfoData, FALSE, NULL)  &&
           SetDevInstallParams(hDevInfo, pDevInfoData, NULL)
                ? ERROR_DI_DO_DEFAULT
                : GetLastError();
}


DWORD
ClassInstall_InstallDevice(
    IN  HDEVINFO                hDevInfo,
    IN  PSP_DEVINFO_DATA        pDevInfoData,
    IN  PSP_DEVINSTALL_PARAMS   pDevInstallParams
    )
/*++

Routine Description:
    This function handles the class installer entry point for DIF_INSTALLDEVICE

Arguments:
    hDevInfo            : Handle to the printer class device information list
    pDevInfoData        : Pointer to the device info element for the printer
    pDevInstallParam    : Pointer to the device install structure

Return Value:
    Win 32 error code

--*/
{
    PRINTER_DEFAULTS    PrinterDefault = {NULL, NULL, PRINTER_ALL_ACCESS};
    PPSETUP_LOCAL_DATA  pLocalData = NULL;
    TPrinterInstall     TPrnInstData;
    TParameterBlock     TParm;
    TCHAR               szPrinterName[MAX_PRINTER_NAME];
    HANDLE              hPrinter = NULL;
    DWORD               dwReturn;
    SP_DRVINFO_DATA     DrvInfoData = {0};


    if ( !pDevInfoData ) {

        return ERROR_INVALID_PARAMETER;
    }

    //
    // check whether this is the NULL driver - we get that request if we fail DIF_ALLOW_INSTALL.
    // If the DI_FLAGSEX_SETFAILEDINSTALL we must succeed. In this case call the default class installer
    // to do it's thing, then set the REINSTALL flag on the devnode so on first boot 
    // they will try to reinstall the device
    //
    DrvInfoData.cbSize = sizeof(DrvInfoData);
    
    if ( 
         !SetupDiGetSelectedDriver(hDevInfo, pDevInfoData, &DrvInfoData) &&
         (ERROR_NO_DRIVER_SELECTED == GetLastError()) &&
         IsSystemSetupInProgress() &&
         (pDevInstallParams->FlagsEx & DI_FLAGSEX_SETFAILEDINSTALL)
       )
    {
        DWORD dwConfigFlags = 0, cbRequiredSize =0, dwDataType = REG_DWORD;

        //
        // run the default class installer
        //
        if (SetupDiInstallDevice(hDevInfo, pDevInfoData))
        {
            //
            // now set the appropriate config flags
            //
            dwReturn = SetupDiGetDeviceRegistryProperty(hDevInfo,
                                                        pDevInfoData,
                                                        SPDRP_CONFIGFLAGS,
                                                        &dwDataType,
                                                        (PBYTE) &dwConfigFlags,
                                                        sizeof(dwConfigFlags),
                                                        &cbRequiredSize) ? 
                                                            (REG_DWORD == dwDataType ? ERROR_SUCCESS : ERROR_INVALID_PARAMETER) 
                                                            : GetLastError();                   

            if (ERROR_SUCCESS == dwReturn) 
            {
                dwConfigFlags |= CONFIGFLAG_REINSTALL;      // to make setupapi reinstall this on first boot
                dwConfigFlags &= ~CONFIGFLAG_FAILEDINSTALL; // per LonnyM's request in order not to screw up anything setupapi-internal

                dwReturn = SetupDiSetDeviceRegistryProperty(hDevInfo,
                                                            pDevInfoData,
                                                            SPDRP_CONFIGFLAGS,
                                                            (PBYTE) &dwConfigFlags,
                                                            sizeof(dwConfigFlags)) ? 
                                                                ERROR_SUCCESS : GetLastError();
            }
        }
        else
        {
            dwReturn = GetLastError();
        }
       
        //
        // don't go through the normal cleanup path that would munge the error code to 
        // DI_DO_DEFAULT - we have already called the default class installer and it would
        // clean out the flags we've set.
        //

        return dwReturn;
    }

    //
    //
    // Parse the inf and also get PnP info from config manger registry
    //
    if ( !(pLocalData = BuildInternalData(hDevInfo, pDevInfoData))  ||
         !ParseInf(hDevInfo, pLocalData, MyPlatform, NULL, 0) ) {

        dwReturn = GetLastError();
        goto Done;
    }
    
    if ( dwReturn = ProcessPerInstanceAddRegSections(hDevInfo, pDevInfoData, pLocalData)) {
        goto Done;
    }

    if ( dwReturn = GetPlugAndPlayInfo(hDevInfo, pDevInfoData, pLocalData) ) {
        goto Done;
    }

    //
    // Install printer driver if FORCECOPY is set or if the driver is not
    // available and it is ok to put up ui
    //
    if ( (pDevInstallParams->Flags & DI_FORCECOPY)  ||
         DRIVER_MODEL_INSTALLED_AND_IDENTICAL !=
                PSetupIsTheDriverFoundInInfInstalled(NULL,
                                                     pLocalData,
                                                     MyPlatform,
                                                     KERNEL_MODE_DRIVER_VERSION) ) {

        if ( pDevInstallParams->Flags & DI_NOFILECOPY ) {

            dwReturn = ERROR_UNKNOWN_PRINTER_DRIVER;
            goto Done;
        }

        dwReturn = InstallDriverFromCurrentInf(hDevInfo,
                                               pLocalData,
                                               pDevInstallParams->hwndParent,
                                               MyPlatform,
                                               dwThisMajorVersion,
                                               NULL,
                                               pDevInstallParams->FileQueue,
                                               pDevInstallParams->InstallMsgHandlerContext,
                                               pDevInstallParams->InstallMsgHandler,
                                               pDevInstallParams->Flags,
                                               NULL,
                                               DRVINST_NO_WARNING_PROMPT,
                                               APD_COPY_NEW_FILES, 
                                               NULL,
                                               NULL,
                                               NULL);

        if ( dwReturn != ERROR_SUCCESS )
            goto Done;
    }

    //
    // If the printer is already installed nothing to do
    //
    if ( DuplicateDevice(pLocalData) ) {

        dwReturn = ERROR_SUCCESS;
        goto Done;
    }

    if( !NewDriverForInstalledDevice(pLocalData, (LPTSTR)&szPrinterName) ) {

        if ( !LoadAndInitializePrintui() ) {

            dwReturn = GetLastError();
            goto Done;
        }

        TPrnInstData.cbSize                 = sizeof(TPrinterInstall);
        TPrnInstData.pszServerName          = NULL;
        TPrnInstData.pszDriverName          = pLocalData->DrvInfo.pszModelName;
        TPrnInstData.pszPortName            = pLocalData->PnPInfo.pszPortName;
        TPrnInstData.pszPrinterNameBuffer   = szPrinterName;
        TPrnInstData.cchPrinterName         = SIZECHARS(szPrinterName);

        TParm.pPrinterInstall   = &TPrnInstData;

        if ( dwReturn = dwfnPnPInterface(kPrinterInstall, &TParm) )
            goto Done;
    } else {

        dwReturn = ERROR_SUCCESS;
    }

    //
    // Set the device instance id with spooler
    //
    if ( OpenPrinter(szPrinterName, &hPrinter, &PrinterDefault) ) {

        (VOID)SetPnPInfoForPrinter(hPrinter,
                                   pLocalData->PnPInfo.pszDeviceInstanceId,
                                   pLocalData->DrvInfo.pszHardwareID,
                                   pLocalData->DrvInfo.pszManufacturer,
                                   pLocalData->DrvInfo.pszOEMUrl);
    }

    //
    // If a vendor dll is given we need to call into it
    //
    if ( pLocalData->InfInfo.pszVendorSetup )
        CallVendorDll(pLocalData, szPrinterName, pDevInstallParams->hwndParent);

    //
    // If ICM files need to installed and associated do it
    //
    if ( pLocalData->InfInfo.pszzICMFiles )
        (VOID)PSetupAssociateICMProfiles(pLocalData->InfInfo.pszzICMFiles,
                                         szPrinterName);

Done:
    if ( hPrinter )
        ClosePrinter(hPrinter);

    DestroyLocalData(pLocalData);

    //
    // On everything going smoothly we want setup to whatever it needs to do
    // to make PnP system happy so that the devnode is marked as configured
    // But we do not want them to copy files again
    //
    if ( dwReturn == ERROR_SUCCESS ) {

        pDevInstallParams->Flags |= DI_NOFILECOPY;

        SetupDiSetDeviceInstallParams(hDevInfo,
                                      pDevInfoData,
                                      pDevInstallParams);

        dwReturn = ERROR_DI_DO_DEFAULT;
    }

    return dwReturn;
}


DWORD
ClassInstall_DestroyWizardData(
    IN  HDEVINFO                hDevInfo,
    IN  PSP_DEVINFO_DATA        pDevInfoData,
    IN  PSP_DEVINSTALL_PARAMS   pDevInstallParams
    )
/*++

Routine Description:
    This function handles the class installer entry point for DIF_DESTROYWIZARDDATA
Arguments:
    hDevInfo            : Handle to the printer class device information list
    pDevInfoData        : Pointer to the device info element for the printer
    pDevInstallParam    : Pointer to the device install structure

Return Value:
    Win 32 error code

--*/
{
    SP_INSTALLWIZARD_DATA   InstallWizData;
    TDestroyWizard          TDestroyWsd;
    TParameterBlock         TParams;
    DWORD                   dwReturn;

    ASSERT(hPrintui && dwfnPnPInterface);

    InstallWizData.ClassInstallHeader.cbSize
                = sizeof(InstallWizData.ClassInstallHeader);

    if ( !SetupDiGetClassInstallParams(hDevInfo,
                                       pDevInfoData,
                                       &InstallWizData.ClassInstallHeader,
                                       sizeof(InstallWizData),
                                       NULL)    ||
         InstallWizData.ClassInstallHeader.InstallFunction != DIF_DESTROYWIZARDDATA ) {

        return ERROR_DI_DO_DEFAULT;
    }

    TDestroyWsd.cbSize          = sizeof(TDestroyWsd);
    TDestroyWsd.pszServerName   = NULL;
    TDestroyWsd.pData           = &InstallWizData;
    TDestroyWsd.pReferenceData  = (PVOID)pDevInstallParams->ClassInstallReserved;

    TParams.pDestroyWizard      = &TDestroyWsd;

    dwReturn = dwfnPnPInterface(kDestroyWizardData, &TParams);

    return dwReturn;
}


DWORD
ClassInstall_InstallWizard(
    IN  HDEVINFO                hDevInfo,
    IN  PSP_DEVINFO_DATA        pDevInfoData,
    IN  PSP_DEVINSTALL_PARAMS   pDevInstallParams
    )
/*++

Routine Description:
    This function handles the class installer entry point for DIF_INSTALLWIZARD

Arguments:
    hDevInfo            : Handle to the printer class device information list
    pDevInfoData        : Pointer to the device info element for the printer
    pDevInstallParam    : Pointer to the device install structure

Return Value:
    Win 32 error code

--*/

{
    SP_INSTALLWIZARD_DATA   InstallWizData;
    TInstallWizard          TInstWzd;
    TParameterBlock         TParams;
    DWORD                   dwReturn;

    InstallWizData.ClassInstallHeader.cbSize
                = sizeof(InstallWizData.ClassInstallHeader);

    if ( !SetupDiGetClassInstallParams(hDevInfo,
                                       pDevInfoData,
                                       &InstallWizData.ClassInstallHeader,
                                       sizeof(InstallWizData),
                                       NULL)    ||
         InstallWizData.ClassInstallHeader.InstallFunction != DIF_INSTALLWIZARD ) {

        return ERROR_DI_DO_DEFAULT;
    }

    if ( !LoadAndInitializePrintui() )
        return GetLastError();

    TInstWzd.cbSize         = sizeof(TInstWzd);
    TInstWzd.pszServerName  = NULL;
    TInstWzd.pData          = &InstallWizData;
    TInstWzd.pReferenceData = (PVOID)pDevInstallParams->ClassInstallReserved;

    TParams.pInstallWizard  = &TInstWzd;

    if ( dwReturn = dwfnPnPInterface(kInstallWizard, &TParams) )
        goto Cleanup;

    if ( !SetupDiSetClassInstallParams(hDevInfo,
                                       pDevInfoData,
                                       &InstallWizData.ClassInstallHeader,
                                       sizeof(InstallWizData)) ) {

        dwReturn = GetLastError();
    }

    pDevInstallParams->ClassInstallReserved = (LPARAM)TInstWzd.pReferenceData;
    if ( !SetupDiSetDeviceInstallParams(hDevInfo,
                                        pDevInfoData,
                                        pDevInstallParams) ) {

        dwReturn = GetLastError();
    }

Cleanup:
    if ( dwReturn != ERROR_SUCCESS ) {

        ClassInstall_DestroyWizardData(hDevInfo,
                                       pDevInfoData,
                                       pDevInstallParams);
    }

    return dwReturn;
}

            

DWORD
ClassInstall_InstallDeviceFiles(
    IN  HDEVINFO                hDevInfo,
    IN  PSP_DEVINFO_DATA        pDevInfoData,
    IN  PSP_DEVINSTALL_PARAMS   pDevInstallParams
    )
/*++

Routine Description:
    This function handles the class installer entry point for DIF_INSTALLDEVICEFILES

Arguments:
    hDevInfo            : Handle to the printer class device information list
    pDevInfoData        : Pointer to the device info element for the printer
    pDevInstallParam    : Pointer to the device install structure

Return Value:
    Win 32 error code

--*/
{
    PPSETUP_LOCAL_DATA      pLocalData;
    DWORD                   dwReturn;

    if ( pLocalData = BuildInternalData(hDevInfo, pDevInfoData) ) 
    {
        dwReturn = InstallDriverFromCurrentInf(hDevInfo,
                                               pLocalData,
                                               pDevInstallParams->hwndParent,
                                               MyPlatform,
                                               dwThisMajorVersion,
                                               NULL,
                                               pDevInstallParams->FileQueue,
                                               pDevInstallParams->InstallMsgHandlerContext,
                                               pDevInstallParams->InstallMsgHandler,
                                               pDevInstallParams->Flags,
                                               NULL,
                                               DRVINST_NO_WARNING_PROMPT,
                                               APD_COPY_NEW_FILES,
                                               NULL,
                                               NULL,
                                               NULL);
        
        DestroyLocalData(pLocalData);
    } 
    else 
    {
        dwReturn = GetLastError();
    }

    return dwReturn;
}


DWORD
ClassInstall_RemoveDevice(
    IN  HDEVINFO                hDevInfo,
    IN  PSP_DEVINFO_DATA        pDevInfoData,
    IN  PSP_DEVINSTALL_PARAMS   pDevInstallParams
    )
/*++

Routine Description:
    This function handles the class installer entry point for DIF_REMOVEDEVICE

Arguments:
    hDevInfo            : Handle to the printer class device information list
    pDevInfoData        : Pointer to the device info element for the printer
    pDevInstallParam    : Pointer to the device install structure

Return Value:
    Win 32 error code

--*/
{
    DWORD               dwRet = ERROR_SUCCESS, dwIndex, dwCount, dwNeeded;
    HANDLE              hPrinter;
    LPPRINTER_INFO_2    pPrinterInfo2, pBuf = NULL;
    PRINTER_DEFAULTS    PrinterDefault = {NULL, NULL, PRINTER_ALL_ACCESS};
    TCHAR               szDevId[MAX_DEVICE_ID_LEN], szPrnId[MAX_DEVICE_ID_LEN];

    if ( !SetupDiGetDeviceInstanceId(hDevInfo,
                                     pDevInfoData,
                                     szDevId,
                                     SIZECHARS(szDevId),
                                     NULL)                  ||
         !PrinterInfo2s(&pBuf, &dwCount) )
        return GetLastError();

    for ( dwIndex = 0, pPrinterInfo2 = pBuf ;
          dwIndex < dwCount ;
          ++dwIndex, ++pPrinterInfo2 ) {

        if ( !OpenPrinter(pPrinterInfo2->pPrinterName,
                          &hPrinter,
                          &PrinterDefault) )
            continue;

        if ( ERROR_SUCCESS == GetPrinterDataEx(hPrinter,
                                               cszPnPKey,
                                               cszDeviceInstanceId,
                                               &dwNeeded,
                                               (LPBYTE)szPrnId,
                                               sizeof(szPrnId),
                                               &dwNeeded)           &&
             !lstrcmp(szPrnId, szDevId) ) {

            dwRet = DeletePrinter(hPrinter) ? ERROR_SUCCESS : GetLastError();
            ClosePrinter(hPrinter);
            goto Done;
        }

        ClosePrinter(hPrinter);
    }

    //
    // If we did not find the printer with spooler let setup do whatever they
    // want to. Note even if a printer failed to install they can call us to
    // remove it when Uninstall is selected from DevMan
    //
    dwRet = ERROR_DI_DO_DEFAULT;

Done:
    LocalFreeMem(pBuf);

    return dwRet;
}


DWORD
ClassInstall_DriverInfo(
    IN  HDEVINFO                hDevInfo,
    IN  PSP_DEVINFO_DATA        pDevInfoData,
    IN  PSP_DEVINSTALL_PARAMS   pDevInstallParams
    )
/*++

Routine Description:
    This function handles the class installer entry point for DIF_DRIVERINFO
    This is a class installer entry point specific to printer class installer.

Arguments:
    hDevInfo            : Handle to the printer class device information list
    pDevInfoData        : Pointer to the device info element for the printer
    pDevInstallParam    : Pointer to the device install structure

Return Value:
    Win 32 error code

--*/
{
    PPRINTER_CLASSINSTALL_INFO  pClassInstallInfo;
    PPSETUP_LOCAL_DATA          pLocalData;
    DWORD                       dwReturn;

    //
    // PRINTER_CLASSINSTALL_INFO could expand in the future
    //
    pClassInstallInfo = (PPRINTER_CLASSINSTALL_INFO)
                                    pDevInstallParams->ClassInstallReserved;

    if ( !pClassInstallInfo ||
         pClassInstallInfo->cbSize < sizeof(PRINTER_CLASSINSTALL_INFO) ) {

        return ERROR_INVALID_PARAMETER;
    }

    if ( pClassInstallInfo->dwLevel != 2    &&
         pClassInstallInfo->dwLevel != 3    &&
         pClassInstallInfo->dwLevel != 4 )
        return ERROR_INVALID_LEVEL;

    if ( !(pLocalData = BuildInternalData(hDevInfo, pDevInfoData))      ||
         !ParseInf(hDevInfo, pLocalData, MyPlatform, NULL, 0) ) {

        dwReturn = GetLastError();
        goto Done;
    }

    *pClassInstallInfo->pcbNeeded = pLocalData->InfInfo.cbDriverInfo6;
    if ( pClassInstallInfo->cbBufSize < *pClassInstallInfo->pcbNeeded ) {

        dwReturn = ERROR_INSUFFICIENT_BUFFER;
        goto Done;
    }

    PackDriverInfo6(&pLocalData->InfInfo.DriverInfo6,
                    (LPDRIVER_INFO_6)pClassInstallInfo->pBuf,
                    pLocalData->InfInfo.cbDriverInfo6);
    dwReturn = ERROR_SUCCESS;

Done:
    DestroyLocalData(pLocalData);
    return dwReturn;
}

BOOL
FindDriver(
    IN  HDEVINFO                hDevInfo,
    IN  PSP_DEVINFO_DATA        pDevInfoData,
    OUT PSP_DRVINFO_DATA        pDrvInfoData
    )
/*++

Routine Description:
    Gets the DeviceInstanceId for the pnp device and searches through all installed printer's pnp data to see if
    this device has already been installed.  This will only be called if no device has been selected and we're
    being asked to install a NULL driver.

    If there is a printer installed for this instance, get it's driver info and put the driver, mfg and provider names
    into the pDrvInfoData structure to return.

Arguments:
    hDevInfo     - passed in from pnp.
    pDevInfoData - passed in from pnp.
    pDrvInfoData - will return with the relevant driver information to search for to install.

--*/
{
    TCHAR               szDeviceInstanceId[MAX_DEVICE_ID_LEN];
    HANDLE              hPrinter       = INVALID_HANDLE_VALUE;
    BOOL                bRet           = FALSE;
    DWORD               dwReturned,
                        dwIndex,
                        dwNeeded       = 0;
    LPPRINTER_INFO_2    p              = NULL,
                        pPrinterInfo2;
    LPDRIVER_INFO_6     lpDriverInfo6  = NULL;
    PRINTER_DEFAULTS    PrinterDefault = {NULL, NULL, PRINTER_ALL_ACCESS};

    if( !pDrvInfoData || pDrvInfoData->cbSize != sizeof(SP_DRVINFO_DATA) ) {

        goto Cleanup;
    }

    if ( !SetupDiGetDeviceInstanceId(hDevInfo,
                                     pDevInfoData,
                                     szDeviceInstanceId,
                                     SIZECHARS(szDeviceInstanceId),
                                     NULL) ) {

        goto Cleanup;
    }

    if ( !PrinterInfo2s(&p, &dwReturned) )
        goto Cleanup;

    //
    // If there is a printer going to that same port and with the same pnp
    // info, then it has been reinstalled with a newer driver.
    //
    for ( dwIndex = 0, pPrinterInfo2 = p ;
          dwIndex < dwReturned ;
          ++dwIndex, pPrinterInfo2++ ) {

        if ( PrinterPnPDataSame(szDeviceInstanceId, pPrinterInfo2->pPrinterName) )
        {
            //
            // Get a DRIVER_INFO_6 for the installed driver.
            //
            if( OpenPrinter(pPrinterInfo2->pPrinterName, &hPrinter, &PrinterDefault) ) {

                if( !GetPrinterDriver( hPrinter,
                                       PlatformEnv[MyPlatform].pszName,
                                       6,
                                       (LPBYTE)lpDriverInfo6,
                                       dwNeeded,
                                       &dwNeeded) ) {

                    if( GetLastError() != ERROR_INSUFFICIENT_BUFFER           ||
                        NULL == ( lpDriverInfo6 = LocalAllocMem( dwNeeded ) ) ||
                        !GetPrinterDriver( hPrinter,
                                           PlatformEnv[MyPlatform].pszName,
                                           6,
                                           (LPBYTE)lpDriverInfo6,
                                           dwNeeded,
                                           &dwNeeded) ) {

                        ClosePrinter( hPrinter );
                        goto Cleanup;
                    }
                }

                //
                // We have some info, so clear the pDrvInfoData and set it up.
                //
                ZeroMemory( pDrvInfoData, sizeof(SP_DRVINFO_DATA) );

                pDrvInfoData->cbSize = sizeof(SP_DRVINFO_DATA);

                pDrvInfoData->DriverType = SPDIT_CLASSDRIVER;

                //
                // We have the DRIVER_INFO_6 - now get the Driver, Mfg and Provider names from the struct
                // to use as the install info.
                //
                lstrcpyn( pDrvInfoData->Description, lpDriverInfo6->pName, LINE_LEN );
                lstrcpyn( pDrvInfoData->MfgName, lpDriverInfo6->pszMfgName, LINE_LEN );
                lstrcpyn( pDrvInfoData->ProviderName, lpDriverInfo6->pszProvider, LINE_LEN );

                ClosePrinter( hPrinter );
                bRet = TRUE;

                goto Cleanup;
            }
        }
    }

Cleanup:

    if( p ) {

        LocalFreeMem( p );
    }

    if( lpDriverInfo6 ) {

        LocalFreeMem( lpDriverInfo6 );
    }

    return bRet;
}


DWORD
ClassInstall_SelectBestCompatDrv(
    IN  HDEVINFO                hDevInfo,
    IN  PSP_DEVINFO_DATA        pDevInfoData,
    IN  PSP_DEVINSTALL_PARAMS   pDevInstallParams
    )
/*++

Routine Description:
    This function handles the class installer entry point for
    DIF_SELECTBESTCOMPATDRV.

    We try to handle the broken OEM models which return same PnP id for
    multiple devices. For that we do the following:
        1. If only one compatible driver has been found by setup we got
           nothing to do. We ask setup to do the default since this is a good
           devive.
        2. If multiple drivers are found we do the following:
            2.1 What is the port this printer is attached to
            2.2 Find list of printers installed currently
            2.3 If we have a printer going to the port the PnP printer is
                attached to AND the driver for that printer is one of the
                compatible drivers then we got nothing to do. User has already
                manually installed it.

Arguments:
    hDevInfo            : Handle to the printer class device information list
    pDevInfoData        : Pointer to the device info element for the printer
    pDevInstallParam    : Pointer to the device install structure

Return Value:
    Win 32 error code

--*/
{
    BOOL                    bFound = FALSE, Rank0IHVMatchFound = FALSE;
    HKEY                    hKey = NULL;
    DWORD                   dwReturn = ERROR_DI_DO_DEFAULT, dwRank0Matches;
    DWORD                   dwSize, dwType, dwIndex1, dwIndex2, dwReturned;
    SP_DRVINFO_DATA         DrvInfoData;
    TCHAR                   szPortName[MAX_PATH];
    LPPRINTER_INFO_2        p = NULL, pPrinterInfo2;
    SP_DRVINSTALL_PARAMS    DrvInstData;
    LPTSTR                  pszModelName = NULL;
    PSP_DRVINFO_DETAIL_DATA pDetailData;
    DWORD                   dwDetailDataSize = sizeof(SP_DRVINFO_DETAIL_DATA); 

    //
    // Allocate pDetailData on the heap, it's quite chunky
    //
    pDetailData = LocalAllocMem(dwDetailDataSize);
    if ( !pDetailData )
    {
        goto Done;
    }

    //
    // If we do not have more than 1 compatible driver do default
    //   Note: API uses 0 based index.
    //
    for ( dwIndex1 = dwRank0Matches = 0 ; ; ++dwIndex1 ) {

        DrvInfoData.cbSize = sizeof(DrvInfoData);
        if ( !SetupDiEnumDriverInfo(hDevInfo, pDevInfoData, SPDIT_COMPATDRIVER,
                                    dwIndex1, &DrvInfoData) )
            break;

        DrvInstData.cbSize = sizeof(DrvInstData);
        if ( SetupDiGetDriverInstallParams(hDevInfo,
                                           pDevInfoData,
                                           &DrvInfoData,
                                           &DrvInstData))
        {
            if (DrvInstData.Rank < 0x1000 ) 
            {
               if (!pszModelName)
               {
                  pszModelName = AllocStr( DrvInfoData.Description );
                  ++dwRank0Matches;
               }
               else if ( lstrcmpi( pszModelName, DrvInfoData.Description ) )
               {
                  ++dwRank0Matches;
               }
            }
            
            //
            // Check for whether this match is in ntprint.inf. If so, set flag to prefer other drivers
            //
            ZeroMemory(pDetailData, dwDetailDataSize);
            pDetailData->cbSize = dwDetailDataSize;

            //
            // check whether it's ntprint.inf
            // function may return insufficient buffer if it couldn't stuff all the
            // hardware IDs at the end of the structure.
            //
            if ((SetupDiGetDriverInfoDetail(hDevInfo, 
                                            pDevInfoData, 
                                            &DrvInfoData,
                                            pDetailData,
                                            dwDetailDataSize,
                                            NULL))              || 
                (ERROR_INSUFFICIENT_BUFFER == GetLastError()))
            {
                SetLastError(ERROR_SUCCESS);
                if (IsSystemNTPrintInf( pDetailData->InfFileName ) )
                {
                    DrvInstData.Flags |= DNF_BASIC_DRIVER;
                    SetupDiSetDriverInstallParams(hDevInfo,
                                                  pDevInfoData,
                                                  &DrvInfoData,
                                                  &DrvInstData);

                }
                else if (DrvInstData.Rank < 0x1000 ) 
                {
                    Rank0IHVMatchFound = TRUE;
                }
            }

        }
    }

    //
    // Free the memory if allocated
    //
    LocalFreeMem( pszModelName );
    LocalFreeMem( pDetailData );

    if ( dwRank0Matches <= 1 )
        goto Done;

    //
    // Look in the devnode of the printer for the port name
    //
    dwSize = sizeof(szPortName);
    if ( ERROR_SUCCESS != CM_Open_DevNode_Key(pDevInfoData->DevInst, KEY_READ,
                                              0, RegDisposition_OpenExisting,
                                              &hKey, CM_REGISTRY_HARDWARE)  ||
         ERROR_SUCCESS != RegQueryValueEx(hKey, cszPortName, NULL, &dwType,
                                          (LPBYTE)&szPortName, &dwSize) )
        goto Done;

    if ( !PrinterInfo2s(&p, &dwReturned) )
        goto Done;


    //
    // If there is a local printer using a driver with rank-0 match and
    // going to the same port then it is a duplicate
    //
    for ( dwIndex1 = 0, pPrinterInfo2 = p ;
          dwIndex1 < dwReturned ;
          ++dwIndex1, pPrinterInfo2++ ) {

        if ( !PrinterGoingToPort(pPrinterInfo2, szPortName) )
            continue;

        dwIndex2 = 0;
        DrvInfoData.cbSize = sizeof(DrvInfoData);
        while ( SetupDiEnumDriverInfo(hDevInfo, pDevInfoData,
                                      SPDIT_COMPATDRIVER, dwIndex2,
                                      &DrvInfoData) ) {

            DrvInstData.cbSize = sizeof(DrvInstData);
            if ( SetupDiGetDriverInstallParams(hDevInfo,
                                               pDevInfoData,
                                               &DrvInfoData,
                                               &DrvInstData)            &&
                 DrvInstData.Rank < 0x1000                              &&
                 !lstrcmpi(DrvInfoData.Description,
                           pPrinterInfo2->pDriverName) ) {

                bFound = TRUE;
                break;
            }

            ++dwIndex2;
            DrvInfoData.cbSize = sizeof(DrvInfoData);
        }

        if ( bFound )
            break;
    }

    //
    // If we found a manually installed printer which matches one of the
    // compatible drivers that is what we want to install
    //
    if ( bFound ) {

        //
        // This means newdev will choose this as the driver to install
        //
        if ( SetupDiSetSelectedDriver(hDevInfo, pDevInfoData, &DrvInfoData) )
            dwReturn = ERROR_SUCCESS;
    } 
    else if (!Rank0IHVMatchFound)
    {
        //
        // We did not find a printer. So bump up the rank of all drivers
        // to force newdev to ask the user to select a driver
        //
        dwIndex2 = 0;
        DrvInfoData.cbSize = sizeof(DrvInfoData);
        while ( SetupDiEnumDriverInfo(hDevInfo, pDevInfoData,
                                      SPDIT_COMPATDRIVER, dwIndex2,
                                      &DrvInfoData) ) {

            DrvInstData.cbSize = sizeof(DrvInstData);
            if ( SetupDiGetDriverInstallParams(hDevInfo,
                                               pDevInfoData,
                                               &DrvInfoData,
                                               &DrvInstData)            &&
                 DrvInstData.Rank < 0x1000 ) {

                DrvInstData.Rank += 0x1000;
                SetupDiSetDriverInstallParams(hDevInfo,
                                              pDevInfoData,
                                              &DrvInfoData,
                                              &DrvInstData);
            }

            ++dwIndex2;
            DrvInfoData.cbSize = sizeof(DrvInfoData);

        }
    }

Done:
    LocalFreeMem(p);

    if ( hKey )
        RegCloseKey(hKey);

    return dwReturn;
}

DWORD
StoreDriverTypeInDevnode(HDEVINFO hDevInfo, PSP_DEVINFO_DATA pDevInfoData)
{
    SP_DRVINFO_DATA DrvInfoData = {0};
    DWORD dwRet = ERROR_SUCCESS;

    DrvInfoData.cbSize = sizeof(DrvInfoData);

    if (SetupDiGetSelectedDriver(hDevInfo, pDevInfoData, &DrvInfoData))
    {
        DWORD  dwDetailDataSize = sizeof(SP_DRVINFO_DETAIL_DATA); 
        SP_DRVINSTALL_PARAMS DrvInstData = {0};

        DrvInstData.cbSize = sizeof(DrvInstData);

        if ( SetupDiGetDriverInstallParams(hDevInfo,
                                           pDevInfoData,
                                           &DrvInfoData,
                                           &DrvInstData))
        {
            HKEY    hKey;
            DWORD   InstallInboxDriver;

            InstallInboxDriver = (DrvInstData.Flags & DNF_BASIC_DRIVER) ? 1 : 0;
            
            hKey = SetupDiOpenDevRegKey(hDevInfo, pDevInfoData, DICS_FLAG_GLOBAL, 0, DIREG_DEV, KEY_WRITE);
            if (hKey != INVALID_HANDLE_VALUE)
            {
                dwRet = RegSetValueEx(hKey, cszBestDriverInbox, 0, REG_DWORD, (LPBYTE) &InstallInboxDriver, sizeof(InstallInboxDriver));

                RegCloseKey(hKey);
            }
            else
            {
                dwRet = GetLastError();
            }
        }
        else 
        {
            dwRet = GetLastError();
        }
    }
    else 
    {
        dwRet = GetLastError();
    }
    
    return dwRet;
}



DWORD
ClassInstall_AllowInstall(
    IN  HDEVINFO                hDevInfo,
    IN  PSP_DEVINFO_DATA        pDevInfoData,
    IN  PSP_DEVINSTALL_PARAMS   pDevInstallParams
    )
/*++

Routine Description:
    This function handles the class installer entry point for
    DIF_ALLOW_INSTALL.

    Do not allow PnP installs during GUI setup portion of system upgrade
    Do not allow install of INFs using VendorSetup if QUIETINSTALL bit is set

Arguments:
    hDevInfo            : Handle to the printer class device information list
    pDevInfoData        : Pointer to the device info element for the printer
    pDevInstallParam    : Pointer to the device install structure

Return Value:
    Win 32 error code

--*/
{
    DWORD               dwReturn = ERROR_DI_DO_DEFAULT;
    PPSETUP_LOCAL_DATA  pLocalData;

    if ( pDevInstallParams->Flags & DI_QUIETINSTALL ) {

        //
        // During system setup no PnP install of printers because there ain't no spooler
        // check that the spooler is running - failing this will punt to client-side installation
        // which should happen at a point in time where the spooler actually is running - we don't 
        // want to stall system startup until the spooler is up (think USB mouse...) 
        //
        if (IsSystemSetupInProgress() ||
            !IsSpoolerRunning()) {
            //
            // store the type (inbox or not) in the devnode. This fails if this is a clean install
            // but it doesn't matter because we only need it for drivers that have been installed
            // before upgrade.
            // We use it to determine later on whether to clear the CONFIGFLAG_REINSTALL
            // or not. We don't want to clear it if the best driver is inbox so we'll install it
            // on first boot.
            //
            StoreDriverTypeInDevnode(hDevInfo, pDevInfoData);

            dwReturn = ERROR_REQUIRES_INTERACTIVE_WINDOWSTATION;
            goto Done;
        }

        if ( (pLocalData = BuildInternalData(hDevInfo, pDevInfoData))   &&
             ParseInf(hDevInfo, pLocalData, MyPlatform, NULL, 0) ) {

            if ( pLocalData->InfInfo.pszVendorSetup &&
                 *pLocalData->InfInfo.pszVendorSetup )
                dwReturn = ERROR_REQUIRES_INTERACTIVE_WINDOWSTATION;
         } else {

            if ( (dwReturn = GetLastError()) == ERROR_SUCCESS )
                dwReturn = ERROR_INVALID_PARAMETER;
        }

    }

Done:
    return dwReturn;
}


DWORD
ClassInstall32(
    IN  DI_FUNCTION         InstallFunction,
    IN  HDEVINFO            hDevInfo,
    IN  PSP_DEVINFO_DATA    pDevInfoData
    )
/*++

Routine Description:
    This is the printer class installer entry point for SetupDiCallClassInstaller calls

Arguments:
    InstallFunction : The function being called
    hDevInfo        : Handle to the printer class device information list
    pDevInfoData    : Pointer to the device info element for the printer

Return Value:
    Win 32 error code

--*/
{
    SP_DEVINSTALL_PARAMS        DevInstallParams;
    DWORD                       dwReturn = ERROR_DI_DO_DEFAULT;

    DevInstallParams.cbSize = sizeof(DevInstallParams);
    if ( !SetupDiGetDeviceInstallParams(hDevInfo,
                                        pDevInfoData,
                                        &DevInstallParams) ) {

        dwReturn = GetLastError();
        goto Done;
    }

    switch (InstallFunction) {

        case DIF_SELECTDEVICE:
            dwReturn = ClassInstall_SelectDevice(hDevInfo, pDevInfoData);
            break;

        case DIF_INSTALLDEVICE:
            dwReturn = ClassInstall_InstallDevice(hDevInfo,
                                                  pDevInfoData,
                                                  &DevInstallParams);
            break;

        case  DIF_DRIVERINFO:
            dwReturn = ClassInstall_DriverInfo(hDevInfo,
                                               pDevInfoData,
                                               &DevInstallParams);
            break;

        case DIF_INSTALLWIZARD:
            dwReturn = ClassInstall_InstallWizard(hDevInfo,
                                                  pDevInfoData,
                                                  &DevInstallParams);
            break;

        case DIF_DESTROYWIZARDDATA:
            dwReturn = ClassInstall_DestroyWizardData(hDevInfo,
                                                      pDevInfoData,
                                                      &DevInstallParams);
            break;

        case DIF_INSTALLDEVICEFILES:
            dwReturn = ClassInstall_InstallDeviceFiles(hDevInfo,
                                                       pDevInfoData,
                                                       &DevInstallParams);
            break;

        case DIF_REMOVE:
            dwReturn = ClassInstall_RemoveDevice(hDevInfo,
                                                 pDevInfoData,
                                                 &DevInstallParams);
            break;

        case DIF_GETWINDOWSUPDATEINFO:


            if ( !InitCodedownload(HWND_DESKTOP) )
                dwReturn = GetLastError();
            else
            {
                if ( SetPackageName(hDevInfo, pDevInfoData) )
                   dwReturn = NO_ERROR;
                else
                   dwReturn = GetLastError();
            }
            break;
        case DIF_SELECTBESTCOMPATDRV:
            dwReturn = ClassInstall_SelectBestCompatDrv(hDevInfo,
                                                        pDevInfoData,
                                                        &DevInstallParams);
            break;

        case DIF_ALLOW_INSTALL:
            dwReturn = ClassInstall_AllowInstall(hDevInfo,
                                                 pDevInfoData,
                                                 &DevInstallParams);
            break;

        case DIF_DESTROYPRIVATEDATA:
        case DIF_MOVEDEVICE:

        default:
            break;
    }

Done:
    return dwReturn;
}


BOOL
PSetupProcessPrinterAdded(
    IN  HDEVINFO            hDevInfo,
    IN  PPSETUP_LOCAL_DATA  pLocalData,
    IN  LPCTSTR             pszPrinterName,
    IN  HWND                hwnd
    )
{
    BOOL                bRet = FALSE;
    HANDLE              hPrinter = NULL;
    PRINTER_DEFAULTS    PrinterDefault = {NULL, NULL, PRINTER_ALL_ACCESS};

    bRet = OpenPrinter((LPTSTR)pszPrinterName, &hPrinter, &PrinterDefault)  &&
           SetPnPInfoForPrinter(hPrinter,
                                pLocalData->PnPInfo.pszDeviceInstanceId,
                                pLocalData->DrvInfo.pszHardwareID,
                                pLocalData->DrvInfo.pszManufacturer,
                                pLocalData->DrvInfo.pszOEMUrl);

    //
    // If a vendor dll is given we need to call into it
    //
    if ( pLocalData->InfInfo.pszVendorSetup )
        CallVendorDll(pLocalData, pszPrinterName, hwnd);

    if ( pLocalData->InfInfo.pszzICMFiles )
        (VOID)PSetupAssociateICMProfiles(pLocalData->InfInfo.pszzICMFiles,
                                         pszPrinterName);

    if ( hPrinter )
        ClosePrinter(hPrinter);

    return bRet;
}