windows-server-2003/printscan/print/spooler/localspl/drvupgrd.c

/*++

Copyright (c) 1995 Microsoft Corporation

Module Name:

    drvupgrd.c

Abstract:

    When the system is upgraded from one release to another printer drivers
    (e.g. RASDD ) wants to upgrade is PrinterDriverData to match the new mini driver.

    Setup from NT 4.0 on do this by calling EnumPrinterDriver and then AddPrinterDriver
    for each printer driver that we have installed.

    We call DrvUpgrade each time a printer driver is upgraded.

    For Example, pre NT 3.51 RASDD used to store its regstiry PrinterDriverData
    based on internal indexes into the mini drivers, which was not valid beween
    different updates of the mini driver, so before 3.51 it was by luck if there
    were problems in retriving the settings.   With 3.51 RASDD will convert these
    indexes back to meaningful key names ( like Memory ) so hopefully in future
    we don't have an upgrade problem.

    Note also that other than upgrade time ( which happens once ) DrvUpgrade needs to
    be called on Point and Print whenever a Driver file gets updated.  See Driver.C
    for details.   Or anyone updates a printer driver by calling AddPrinterDriver.

Author:

    Matthew A Felton ( MattFe ) March 11 1995

Revision History:

--*/

#include <precomp.h>
#pragma hdrstop

#include "clusspl.h"
#include <winddiui.h>


BOOL
UpdateUpgradeInfoStruct(
    LPBYTE pDriverUpgradeInfo,
    DWORD  dwLevel,
    LPWSTR pPrinterNameWithToken,
    LPWSTR pOldDriverDir,
    LPBYTE pDriverInfo
)

/*++
Function Description: This function fills in the Upgrade_Info struct with the
                      other parameters

Parameters: pDriverUpgradeInfo    -- pointer Upgrade_Info_* struct
            dwLevel               -- Upgrade_Info level
            pPrinterNameWithToken -- printer name
            pOldDriverDir         -- Directory containing the old driver files
            pDriverInfo           -- pointer to driver_info_4 struct

Return Values: TRUE for sucesss;
               FALSE otherwise
--*/

{
    BOOL  bReturn = TRUE;

    PDRIVER_UPGRADE_INFO_1 pDrvUpgInfo1;
    PDRIVER_UPGRADE_INFO_2 pDrvUpgInfo2;
    PDRIVER_INFO_4         pDriver4;

    switch (dwLevel) {
    case 1:

        pDrvUpgInfo1 = (PDRIVER_UPGRADE_INFO_1) pDriverUpgradeInfo;

        pDrvUpgInfo1->pPrinterName = pPrinterNameWithToken;
        pDrvUpgInfo1->pOldDriverDirectory = pOldDriverDir;

        break;

    case 2:

        if (pDriver4 = (PDRIVER_INFO_4) pDriverInfo) {

            pDrvUpgInfo2 = (PDRIVER_UPGRADE_INFO_2) pDriverUpgradeInfo;

            pDrvUpgInfo2->pPrinterName = pPrinterNameWithToken;
            pDrvUpgInfo2->pOldDriverDirectory = pOldDriverDir;
            pDrvUpgInfo2->cVersion = pDriver4->cVersion;
            pDrvUpgInfo2->pName = pDriver4->pName;
            pDrvUpgInfo2->pEnvironment = pDriver4->pEnvironment;
            pDrvUpgInfo2->pDriverPath = pDriver4->pDriverPath;
            pDrvUpgInfo2->pDataFile = pDriver4->pDataFile;
            pDrvUpgInfo2->pConfigFile = pDriver4->pConfigFile;
            pDrvUpgInfo2->pHelpFile = pDriver4->pHelpFile;
            pDrvUpgInfo2->pDependentFiles = pDriver4->pDependentFiles;
            pDrvUpgInfo2->pMonitorName = pDriver4->pMonitorName;
            pDrvUpgInfo2->pDefaultDataType = pDriver4->pDefaultDataType;
            pDrvUpgInfo2->pszzPreviousNames = pDriver4->pszzPreviousNames;

        } else {

            bReturn = FALSE;
        }

        break;

    default:

        bReturn = FALSE;
        break;
    }

    return bReturn;
}

BOOL
bIsNewFile(
    LPWSTR              pDriverFile,
    PINTERNAL_DRV_FILE  pInternalDriverFiles,
    DWORD               dwFileCount
)
/*++
Function Description: This function checks to see if a driver file was updated

Parameters: pDriverFile         -- driver file
            pInternalDriverFiles -- array of INTERNAL_DRV_FILE structures
            dwFileCount         -- number of files in file set

Return Values: TRUE for sucesss;
               FALSE otherwise
--*/
{
    DWORD   dwIndex;
    LPCWSTR psz;
    BOOL    bRet = FALSE;
    //
    // Must have some files.
    //
    SPLASSERT( dwFileCount );

    //
    // Search for pDriverFile in  ppFileNames array
    //
    for ( dwIndex = 0; dwIndex < dwFileCount ; ++dwIndex ) {

        if( pInternalDriverFiles[dwIndex].pFileName ) {

            //
            // Find the filename portion of a path
            //
            psz = FindFileName(pInternalDriverFiles[dwIndex].pFileName );

            if( psz ){

                if( !lstrcmpi(pDriverFile, psz) ){

                    //
                    // Check if the file was updated
                    //
                    bRet = pInternalDriverFiles[dwIndex].bUpdated;
                    break;
                }

            }
        }
    }

    return bRet;

}

BOOL
DriversShareFiles(
    PINIDRIVER          pIniDriver1,
    PINIDRIVER          pIniDriver2,
    PINTERNAL_DRV_FILE  pInternalDriverFiles,
    DWORD               dwFileCount
)
/*++
Function Description: Determines if the drivers have common files and
                      if the common files were updated

Parameters:  pIniDriver1         -- driver #1
             pIniDriver2         -- driver #2
             pInternalDriverFiles -- array of INTERNAL_DRV_FILE structures
             dwFileCount         -- number of files in file set
             pUpdateStatusBitMap -- map of bits that tells what files in the file set were actually updated

Return Values: TRUE if files are shared;
               FALSE otherwise
--*/
{
    LPWSTR  pStr1, pStr2;

    if (!pIniDriver1 || !pIniDriver2) {
        return FALSE;
    }

    if (pIniDriver1->cVersion != pIniDriver2->cVersion) {
        return FALSE;
    }

    //
    // Compare the file names and if they were updated
    //

    if (pIniDriver1->pDriverFile && pIniDriver2->pDriverFile &&
        !lstrcmpi(pIniDriver1->pDriverFile, pIniDriver2->pDriverFile) &&
        bIsNewFile(pIniDriver1->pDriverFile, pInternalDriverFiles, dwFileCount)) {

        return TRUE;
    }

    if (pIniDriver1->pConfigFile && pIniDriver2->pConfigFile &&
        !lstrcmpi(pIniDriver1->pConfigFile, pIniDriver2->pConfigFile) &&
        bIsNewFile(pIniDriver1->pConfigFile, pInternalDriverFiles, dwFileCount)) {

        return TRUE;
    }

    if (pIniDriver1->pHelpFile && pIniDriver2->pHelpFile &&
        !lstrcmpi(pIniDriver1->pHelpFile, pIniDriver2->pHelpFile) &&
        bIsNewFile(pIniDriver1->pHelpFile, pInternalDriverFiles, dwFileCount)) {

        return TRUE;
    }

    if (pIniDriver1->pDataFile && pIniDriver2->pDataFile &&
        !lstrcmpi(pIniDriver1->pDataFile, pIniDriver2->pDataFile) &&
        bIsNewFile(pIniDriver1->pDataFile, pInternalDriverFiles, dwFileCount)) {

        return TRUE;
    }

    // Compare each pair of files from the Dependent file list
    for (pStr1 = pIniDriver1->pDependentFiles;
         pStr1 && *pStr1;
         pStr1 += wcslen(pStr1) + 1) {

        for (pStr2 = pIniDriver2->pDependentFiles;
             pStr2 && *pStr2;
             pStr2 += wcslen(pStr2) + 1) {

            if (!lstrcmpi(pStr1, pStr2) &&
                bIsNewFile(pStr1, pInternalDriverFiles, dwFileCount)) {
                return TRUE;
            }
        }
    }

    return FALSE;
}


BOOL
ForEachPrinterCallDriverDrvUpgrade(
    PINISPOOLER         pIniSpooler,
    PINIDRIVER          pIniDriver,
    LPCWSTR             pOldDriverDir,
    PINTERNAL_DRV_FILE  pInternalDriverFiles,
    DWORD               dwFileCount,
    LPBYTE              pDriverInfo
)
/*++

Routine Description:

    This routine is called at Spooler Initialization time if an upgrade is detected.

    It will loop through all printers and then call the Printer Drivers DrvUpgrade
    entry point giving it a chance to upgrade any configuration data ( PrinterDriverData )
    passing them a pointer to the old Drivers Directory.

    This routine also converts devmode to current version by calling the driver.
    If driver does not support devmode conversion we will NULL the devmode so
    that we do not have devmodes of different version in the system.

    SECURITY NOTE - This routine Stops impersonation, because the printer drivers UI dll
    needs to call SetPrinterData even if the user doesn't have permission to do it.
    That is because the driver upgrading the settings.


Arguments:

    pIniSpooler - Pointer to Spooler
    pIniVersion - Pointer to the version of driver added
    pOldDriverDir - Point to Directory where old driver files are stored.
    pInternalDriverFiles - array of INTERNAL_DRV_FILE structures
    dwFileCount - number of files in array
    pUpdateStatusBitMap - map of bits that tells what files in the file set were actually updated
    pDriverInfo - Driver Info buffer


Return Value:

    TRUE    - Success
    FALSE   - something major failed, like allocating memory.

--*/

{
    PINIPRINTER pIniPrinter = NULL;
    LPWSTR      pPrinterNameWithToken = NULL;
    DWORD       dwNeeded;
    DWORD       dwServerMajorVersion;
    DWORD       dwServerMinorVersion;
    BOOL        bInSem = TRUE;
    LPWSTR      pConfigFile = NULL;
    HMODULE     hModuleDriverUI = NULL;
    HANDLE      hPrinter = NULL;
    BOOL        (*pfnDrvUpgrade)() = NULL;
    BOOL        bReturnValue = FALSE;
    DRIVER_UPGRADE_INFO_1   DriverUpgradeInfo1;
    DRIVER_UPGRADE_INFO_2   DriverUpgradeInfo2;
    WCHAR       ErrorBuffer[ 11 ];
    HANDLE      hToken = INVALID_HANDLE_VALUE;
    LPDEVMODE   pNewDevMode = NULL;

try {

    SplInSem();

    SPLASSERT( ( pIniSpooler != NULL ) &&
               ( pIniSpooler->signature == ISP_SIGNATURE ));

    if (!pOldDriverDir && !pDriverInfo) {
        leave;
    }

    //
    //  Stop Impersonating User
    //  So drivers can call SetPrinterData even if the user is not admin.
    //

    hToken = RevertToPrinterSelf();


    //
    //  Loop Through All Printers. Skip the printers that use drivers that doesn't share files with
    //  the updated driver. Skip the printers that share files,but the files weren't updated.
    //

    for ( pIniPrinter = pIniSpooler->pIniPrinter ;
          pIniPrinter ;
          pIniPrinter = pIniPrinter->pNext ) {

        SPLASSERT( pIniPrinter->signature == IP_SIGNATURE );
        SPLASSERT( pIniPrinter->pName != NULL );
        SplInSem();

        // Verify if DrvUpgradePrinter needs to be called on this printer
        if (!DriversShareFiles( pIniPrinter->pIniDriver,
                                pIniDriver,
                                pInternalDriverFiles,
                                dwFileCount)) {
            continue;
        }

        //
        // Cleanup from previous iteration
        //
        FreeSplStr( pPrinterNameWithToken );
        FreeSplStr(pConfigFile);
        FreeSplMem(pNewDevMode);

        pPrinterNameWithToken   = NULL;
        pConfigFile             = NULL;
        pNewDevMode             = NULL;

        //
        // If we download a driver of newer version we need to update
        // pIniPrinter->pIniDriver
        //
        pIniPrinter->pIniDriver = FindLocalDriver(pIniPrinter->pIniSpooler, pIniPrinter->pIniDriver->pName);
        if ( pIniPrinter->pIniDriver->pIniLangMonitor == NULL )
            pIniPrinter->Attributes &= ~PRINTER_ATTRIBUTE_ENABLE_BIDI;

        //  Prepare PrinterName to be passed to DrvUpgrade
        //  The name passed is "PrinterName, UpgradeToken"
        //  So that OpenPrinter can do an open without opening
        //  the port in the downlevel connection case.
        //  ( see openprn.c for details )

        pPrinterNameWithToken = pszGetPrinterName( pIniPrinter,
                                                   TRUE,
                                                   pszLocalOnlyToken );

        if ( pPrinterNameWithToken == NULL ) {

            DBGMSG( DBG_WARNING, ("FEPCDDU Failed to allocated ScratchBuffer %d\n", GetLastError() ));
            leave;
        }

        DBGMSG( DBG_TRACE, ("FEPCDDU PrinterNameWithToken %ws\n", pPrinterNameWithToken ));


        pConfigFile = GetConfigFilePath(pIniPrinter);

        if ( !pConfigFile ) {

            DBGMSG( DBG_WARNING, ("FEPCDDU failed SplGetPrinterDriverEx %d\n", GetLastError() ));
            leave;
        }

        INCPRINTERREF(pIniPrinter);

       LeaveSplSem();
       SplOutSem();
       bInSem = FALSE;

        //
        //  Load the UI DLL
        //

        hModuleDriverUI = LoadDriver(pConfigFile);

        if ( hModuleDriverUI == NULL ) {

            DBGMSG( DBG_WARNING, ("FEPCDDU failed LoadLibrary %ws error %d\n", pConfigFile, GetLastError() ));

            StringCchPrintf(ErrorBuffer, COUNTOF(ErrorBuffer), L"%d", GetLastError());

            SplLogEvent( pLocalIniSpooler,
                         LOG_ERROR,
                         MSG_DRIVER_FAILED_UPGRADE,
                         FALSE,
                         pPrinterNameWithToken,
                         pConfigFile,
                         ErrorBuffer,
                         NULL );

           SplOutSem();
           EnterSplSem();
           bInSem = TRUE;
           DECPRINTERREF( pIniPrinter );
            continue;
        }

        DBGMSG( DBG_TRACE, ("FEPCDDU successfully loaded %ws\n", pConfigFile ));


        //
        //  Call DrvUpgrade
        //
        pfnDrvUpgrade = (BOOL (*)())GetProcAddress( hModuleDriverUI, "DrvUpgradePrinter" );

        if ( pfnDrvUpgrade != NULL ) {

            try {

                SPLASSERT( pPrinterNameWithToken != NULL );

                SplOutSem();

                //
                //  Call Driver UI DrvUpgrade
                //
                if (UpdateUpgradeInfoStruct((LPBYTE) &DriverUpgradeInfo2, 2,
                                            pPrinterNameWithToken, (LPWSTR) pOldDriverDir,
                                            pDriverInfo)) {

                    bReturnValue = (*pfnDrvUpgrade)(2 , &DriverUpgradeInfo2);
                }

                if ( bReturnValue == FALSE ) {

                    UpdateUpgradeInfoStruct((LPBYTE) &DriverUpgradeInfo1, 1,
                                            pPrinterNameWithToken, (LPWSTR) pOldDriverDir,
                                            NULL);

                    bReturnValue = (*pfnDrvUpgrade)(1 , &DriverUpgradeInfo1);
                }

                if ( bReturnValue == FALSE ) {

                    DBGMSG( DBG_WARNING, ("FEPCDDU Driver returned FALSE, doesn't support level %d error %d\n", 1, GetLastError() ));

                    StringCchPrintf(ErrorBuffer, COUNTOF(ErrorBuffer), L"%d", GetLastError());

                    SplLogEvent(  pLocalIniSpooler,
                                  LOG_ERROR,
                                  MSG_DRIVER_FAILED_UPGRADE,
                                  FALSE,
                                  pPrinterNameWithToken,
                                  pConfigFile,
                                  ErrorBuffer,
                                  NULL );
                }

            } except(1) {

                SetLastError( GetExceptionCode() );
                DBGMSG( DBG_ERROR, ("FEPCDDU ExceptionCode %x Driver %ws Error %d\n", GetLastError(), pConfigFile, GetLastError() ));

                //
                // Despite the exception in this driver we'll continue to do all printers
                //
            }

        } else {

            //  Note this is non fatal, since a driver might not have a DrvUpgrade Entry Point.

            DBGMSG( DBG_TRACE, ("FEPCDDU failed GetProcAddress DrvUpgrade error %d\n", GetLastError() ));
        }


        SplOutSem();
        EnterSplSem();
        bInSem = TRUE;

        //
        //  Call ConvertDevMode -- On upgrading we will either convert devmode,
        //  or set to driver default, or NULL it. This way we can make sure
        //  we do not have any different version devmodes
        //

        pNewDevMode = ConvertDevModeToSpecifiedVersion(pIniPrinter,
                                                       pIniPrinter->pDevMode,
                                                       pConfigFile,
                                                       pPrinterNameWithToken,
                                                       CURRENT_VERSION);

        SplInSem();

        FreeSplMem(pIniPrinter->pDevMode);

        pIniPrinter->pDevMode = (LPDEVMODE) pNewDevMode;
        if ( pNewDevMode ) {

            pIniPrinter->cbDevMode = ((LPDEVMODE)pNewDevMode)->dmSize
                                        + ((LPDEVMODE)pNewDevMode)->dmDriverExtra;

            SPLASSERT(pIniPrinter->cbDevMode);

        } else {

            StringCchPrintf(ErrorBuffer, COUNTOF(ErrorBuffer), L"%d", GetLastError());

            SplLogEvent(pLocalIniSpooler,
                        LOG_ERROR,
                        MSG_DRIVER_FAILED_UPGRADE,
                        TRUE,
                        pIniPrinter->pName,
                        pIniPrinter->pIniDriver->pName,
                        ErrorBuffer,
                        NULL);

            pIniPrinter->cbDevMode = 0;
        }

        pNewDevMode = NULL;

        SplInSem();
        if ( !UpdatePrinterIni(pIniPrinter, UPDATE_CHANGEID)) {

            DBGMSG(DBG_WARNING, ("FEPCDDU: UpdatePrinterIni failed with %d\n", GetLastError()));
        }

        //
        //  Clean Up - Free UI DLL
        //

        LeaveSplSem();
        SplOutSem();

        UnloadDriver( hModuleDriverUI );

        EnterSplSem();
        SplInSem();

        hModuleDriverUI = NULL;

        //
        //  End of Loop, Move to Next Printer
        //

        SPLASSERT( pIniPrinter->signature == IP_SIGNATURE );

        DECPRINTERREF( pIniPrinter );
    }

    //
    //  Done
    //

    bReturnValue = TRUE;

    DBGMSG( DBG_TRACE, ("FEPCDDU - Success\n" ));



 } finally {

    //
    //  Clean Up
    //

    FreeSplStr(pConfigFile);
    FreeSplMem(pNewDevMode);
    FreeSplStr(pPrinterNameWithToken);

    if ( hModuleDriverUI != NULL )
        UnloadDriver( hModuleDriverUI );

    if ( !bInSem )
        EnterSplSem();

    if ( hToken != INVALID_HANDLE_VALUE )
        ImpersonatePrinterClient(hToken);

 }
    SplInSem();
    return bReturnValue;
}


BOOL
GetFileNamesFromDriverVersionInfo (
    IN  LPDRIVER_INFO_VERSION   pDriverInfo,
    OUT LPWSTR                  *ppszDriverPath,
    OUT LPWSTR                  *ppszConfigFile,
    OUT LPWSTR                  *ppszDataFile,
    OUT LPWSTR                  *ppszHelpFile
    )
/*++

Routine Name:

    GetFileNamesFromDriverVersionInfo

Routine Description:

    Get the name of Driver, Config, Data, Help file from an
    array of DRIVER_FILE_INFO structures.

Arguments:

    pDriverInfo - Pointer to LPDRIVER_INFO_VERSION buffer.
    ppszDriverPath - out pointer to driver file string
    ppszConfigFile - out pointer to config file string
    ppszDataFile - out pointer to data file string
    ppszHelpFile - out pointer to help file string

Return Value:

    TRUE if file pointers successfully returned.

--*/
{
    BOOL    bRetValue = FALSE;
    DWORD   dwIndex;

    if (pDriverInfo && pDriverInfo->pFileInfo)
    {
        bRetValue = TRUE;

        for (dwIndex = 0; dwIndex < pDriverInfo->dwFileCount; dwIndex++)
        {
            switch (pDriverInfo->pFileInfo[dwIndex].FileType)
            {
                case DRIVER_FILE:
                    if (ppszDriverPath)
                    {
                        *ppszDriverPath = MakePTR(pDriverInfo,
                                                  pDriverInfo->pFileInfo[dwIndex].FileNameOffset);
                    }
                    break;
                case CONFIG_FILE:
                    if (ppszConfigFile)
                    {
                        *ppszConfigFile = MakePTR(pDriverInfo,
                                                  pDriverInfo->pFileInfo[dwIndex].FileNameOffset);
                    }
                    break;
                case DATA_FILE:
                    if (ppszDataFile)
                    {
                        *ppszDataFile = MakePTR(pDriverInfo,
                                                pDriverInfo->pFileInfo[dwIndex].FileNameOffset);
                    }
                    break;
                case HELP_FILE:
                    if (ppszHelpFile)
                    {
                        *ppszHelpFile = MakePTR(pDriverInfo,
                                                pDriverInfo->pFileInfo[dwIndex].FileNameOffset);
                    }
                    break;
                case DEPENDENT_FILE:
                    break;
                default:
                    bRetValue = FALSE;
                    break;
            }
        }
    }

    return bRetValue;
}

BOOL
BuildDependentFilesFromDriverInfo (
    IN  LPDRIVER_INFO_VERSION pDriverInfo,
    OUT LPWSTR               *ppDependentFiles
)
/*++

Routine Name:

    BuildDependentFilesFromDriverInfo

Routine Description:

    Build a multisz string of driver dependent files from
    a DRIVER_INFO_VERSION structure.

Arguments:

    pDriverInfo      - pointer to  DRIVER_INFO_VERSION structure
    ppDependentFiles - pointer to allocated multi-sz string

Return Value:

    TRUE if SUCCESS

--*/
{
    BOOL    bRetValue = TRUE;
    DWORD   dwIndex;
    SIZE_T  Length = 0;
    LPWSTR  pszDllFile = NULL;

    if (ppDependentFiles && pDriverInfo && pDriverInfo->pFileInfo)
    {
        *ppDependentFiles = NULL;

        for (dwIndex = 0;
             bRetValue && dwIndex < pDriverInfo->dwFileCount;
             dwIndex++)
        {
            switch (pDriverInfo->pFileInfo[dwIndex].FileType)
            {
                case DRIVER_FILE:
                case CONFIG_FILE:
                case DATA_FILE:
                case HELP_FILE:
                    break;
                case DEPENDENT_FILE:
                {
                    Length += wcslen(MakePTR(pDriverInfo,
                                               pDriverInfo->pFileInfo[dwIndex].FileNameOffset)) + 1;
                    break;
                }
                default:
                {
                    bRetValue = FALSE;
                    break;
                }
            }
        }

        if (bRetValue && Length > 0)
        {
            Length++;
            Length *= sizeof(WCHAR);

            pszDllFile = (LPWSTR)AllocSplMem((DWORD)Length);

            if (pszDllFile)
            {
                *ppDependentFiles = pszDllFile;

                for (dwIndex = 0;
                     bRetValue && dwIndex < pDriverInfo->dwFileCount;
                     dwIndex++)
                {
                    switch (pDriverInfo->pFileInfo[dwIndex].FileType)
                    {
                        case DRIVER_FILE:
                        case CONFIG_FILE:
                        case DATA_FILE:
                        case HELP_FILE:
                            break;
                        case DEPENDENT_FILE:
                        {
                            StrCchCopyMultipleStr(pszDllFile,
                                                  Length,
                                                  MakePTR(pDriverInfo,pDriverInfo->pFileInfo[dwIndex].FileNameOffset),
                                                  &pszDllFile,
                                                  &Length);

                            break;
                        }
                        default:
                        {
                            bRetValue = FALSE;
                            break;
                        }
                    }
                }
            }
            else
            {
                bRetValue = FALSE;
            }
        }
    }

    if (bRetValue == FALSE && ppDependentFiles)
    {
        FreeSplMem(*ppDependentFiles);
        *ppDependentFiles = NULL;
    }

    return bRetValue;
}


BOOL
DriverAddedOrUpgraded (
    IN  PINTERNAL_DRV_FILE  pInternalDriverFiles,
    IN  DWORD               dwFileCount
    )
/*++

Routine Name:

    DriverAddedOrUpgraded

Routine Description:

    Checks the Internal driver file array to see if at least
    one driver file was updated. This is a performance optimization
    for calling DrvUpgradePrinter for ecah printer using the upgraded
    driver or a driver sharing files in common with upgraded driver
    (see ForEachPrinterCallDriverDrvUpgrade).

Arguments:

    pInternalDriverFiles - array of INTERNAL_DRV_FILE structures
    dwFileCount - number of files in array

Return Value:

    TRUE if driver files where added or upgraded.

--*/
{
    BOOL    bDriverAddedOrUpgraded = FALSE;
    DWORD   dwIndex;

    for (dwIndex = 0; dwIndex < dwFileCount; dwIndex++)
    {
        if (pInternalDriverFiles[dwIndex].bUpdated)
        {
            bDriverAddedOrUpgraded = TRUE;
            break;
        }
    }

    return bDriverAddedOrUpgraded;
}

VOID
CleanupInternalDriverInfo(
    PINTERNAL_DRV_FILE  pInternalDriverFiles,
    DWORD               FileCount
    )
/*++

Routine Name:

    CleanupInternalDriverInfo

Routine Description:

    Frees array of INTERNAL_DRV_FILE.
    FileCount gives the element count in the array.

Arguments:

    pInternalDriverFiles -- array of INTERNAL_DRV_FILE structures
    FileCount           -- number of files in file set

Return Value:

    Nothing.

--*/
{
    DWORD dwIndex;

    if (pInternalDriverFiles)
    {
        for (dwIndex = 0; dwIndex < FileCount; dwIndex++)
        {
            FreeSplStr(pInternalDriverFiles[dwIndex].pFileName);

            if (pInternalDriverFiles[dwIndex].hFileHandle != INVALID_HANDLE_VALUE)
            {
                CloseHandle(pInternalDriverFiles[dwIndex].hFileHandle);
            }
        }

        FreeSplMem(pInternalDriverFiles);
    }
}

BOOL
GetDriverFileVersionsFromNames(
    IN  PINTERNAL_DRV_FILE    pInternalDriverFiles,
    IN  DWORD                 dwCount
    )
/*++

Routine Name:

    GetDriverFileVersionsFromNames

Routine Description:

    Fills the array of INTERNAL_DRV_FILE with driver minor version,
    by calling GetPrintDriverVersion for each file.
    The array already has the file names filled in.

Arguments:

    pInternalDriverFiles -- array of INTERNAL_DRV_FILE structures
    FileCount           -- number of files in file set

Return Value:

    TRUE if SUCCESS

--*/
{
    DWORD   Count, Size;
    BOOL    bReturnValue = TRUE;

    if (!pInternalDriverFiles || !dwCount)
    {
        bReturnValue = FALSE;
        SetLastError(ERROR_INVALID_DATA);
    }
    else
    {
        for (Count = 0 ; Count < dwCount ; ++Count)
        {
            if (IsEXEFile(pInternalDriverFiles[Count].pFileName))
            {
                if (!GetPrintDriverVersion(pInternalDriverFiles[Count].pFileName,
                                           NULL,
                                           &pInternalDriverFiles[Count].dwVersion))
                {
                    bReturnValue = FALSE;
                    break;
                }
            }
        }
    }

    return bReturnValue;
}

BOOL
GetDriverFileVersions(
    IN  LPDRIVER_INFO_VERSION pDriverVersion,
    IN  PINTERNAL_DRV_FILE    pInternalDriverFiles,
    IN  DWORD                 dwCount
    )
/*++

Routine Name:

    GetDriverFileVersions

Routine Description:

    Fills the array of INTERNAL_DRV_FILE with driver minor version
    stored in DRIVER_INFO_VERSION structure.

Arguments:

    pDriverVersion      - pointer to DRIVER_INFO_VERSION
    pInternalDriverFiles - pointer to array of INTERNAL_DRV_FILE
    dwCount             - number of elemnts in array

Return Value:

    TRUE if succeeded.

--*/
{
    DWORD   Count, Size;
    BOOL    bReturnValue = TRUE;
    DWORD   dwMajorVersion;

    if (!pDriverVersion ||
        !pDriverVersion->pFileInfo ||
        pDriverVersion->dwFileCount != dwCount)
    {
        bReturnValue = FALSE;
        SetLastError(ERROR_INVALID_DATA);
    }
    else
    {
        for (Count = 0; Count < pDriverVersion->dwFileCount; Count++)
        {
            pInternalDriverFiles[Count].dwVersion = pDriverVersion->pFileInfo[Count].FileVersion;
        }
    }

    return bReturnValue;
}