/*++

Copyright (C) Microsoft Corporation, 1996 - 1997
All rights reserved.

Module Name:

    drvrver.hxx

Abstract:

    Driver version detection header.

Author:

    Steve Kiraly (SteveKi)  21-Jan-1996

Revision History:

--*/

#include "precomp.hxx"
#pragma hdrstop

#include "psetup.hxx"
#include "drvver.hxx"
#include "splapip.h"
#include "compinfo.hxx"

BOOL
bGetCurrentDriver(
    IN      LPCTSTR pszServerName,
        OUT LPDWORD pdwCurrentDriver
    )
{
    TCHAR   szArch[kStrMax];
    BOOL    bRetval = FALSE;
    DWORD   dwVer   = 0;

    //
    // Attempt to get the architecture / version from the machine.
    // First attempt to get the information from the spooler.
    //
    bRetval = bGetArchUseSpooler( pszServerName, szArch, COUNTOF( szArch ), &dwVer );

    //
    // If spooler did not respond, this may be a downlevel
    // print spooler.  "Downlevel" meaning older version.
    //
    if( !bRetval )
    {
        //
        // Attempt to get the information using the remote registry calls
        // We only connect to the remote registry if a server name was passed.
        //
        if( pszServerName )
        {
            bRetval = bGetArchUseReg( pszServerName, szArch, COUNTOF( szArch ), &dwVer );
        }
    }

    //
    // Check for any retuned information.
    //
    if( bRetval )
    {
        DBGMSG( DBG_TRACE, ( "Server " TSTR " Arch " TSTR " Ver %d\n", DBGSTR(pszServerName), szArch, dwVer ) );

        //
        // Encode the architecture / version  into a dword.
        //
        if( bEncodeArchVersion( szArch, dwVer, pdwCurrentDriver ) )
        {
            DBGMSG( DBG_TRACE, ( "Encoded Arch / Version %d\n", *pdwCurrentDriver ) );
            bRetval = TRUE;
        }
        else
        {
            DBGMSG( DBG_WARN, ( "Encode architecture and version failed.\n" ) );
            bRetval = FALSE;
        }
    }
    else
    {
        DBGMSG( DBG_WARN, ( "Fetching architecture and version failed.\n" ) );
        bRetval = FALSE;
    }
    return bRetval;
}

BOOL
bGetArchUseSpooler(
    IN      LPCTSTR  pName,
        OUT LPTSTR   pszArch,
    IN      DWORD    dwSize,
    IN  OUT LPDWORD  pdwVer
    )
/*++

Routine Description:

    Gets the specified print server the architectue and
    driver version using the spooler.

Arguments:

    pName       - pointer to print server name.
    pszArch     - pointer to a buffer where to return the machine architecture string
    dwSize      - Size in characters of the provided architecture string
    pdwVersion  - pointer where to return the remote machine driver version.

Return Value:

    TRUE - remote information returned, FALSE - remote information not available.

--*/
{
    //
    // Attempt to open print server with full access.
    //
    BOOL bReturn    = FALSE;
    DWORD dwStatus  = ERROR_SUCCESS;
    DWORD dwAccess  = SERVER_READ;
    HANDLE hServer  = NULL;
    TStatus Status;

    //
    // Open the server for read access.
    //
    Status DBGCHK = TPrinter::sOpenPrinter( pName,
                                            &dwAccess,
                                            &hServer );

    //
    // Save administrator capability flag.
    //
    if( Status == ERROR_SUCCESS ){

        //
        // Get the remote spooler's architecture type and version.
        //
        TCHAR szArch[kStrMax];
        memset( szArch, 0, sizeof( szArch ) );

        DWORD dwNeeded      = 0;
        DWORD dwVer         = 0;
        DWORD dwVerType     = REG_DWORD;
        DWORD dwArchType    = REG_SZ;

        if( dwStatus == ERROR_SUCCESS ){

            dwStatus = GetPrinterData( hServer,
                                       SPLREG_ARCHITECTURE,
                                       &dwArchType,
                                       (PBYTE)szArch,
                                       sizeof( szArch ),
                                       &dwNeeded );
        }

        if( dwStatus == ERROR_SUCCESS ){

            dwStatus = GetPrinterData( hServer,
                                       SPLREG_MAJOR_VERSION,
                                       &dwVerType,
                                       (PBYTE)&dwVer,
                                       sizeof( dwVer ),
                                       &dwNeeded );
        }

        if( dwStatus == ERROR_SUCCESS ){

            DBGMSG( DBG_TRACE, ( "GetPrinterData: Architecture " TSTR "\n" , szArch ) );
            DBGMSG( DBG_TRACE, ( "GetPrinterData: MajorVersion %d\n" , dwVer ) );

            //
            // Only success if provided buffer is big enough.
            //
            if( (DWORD)lstrlen( szArch ) < dwSize ){

                lstrcpy( pszArch, szArch );
                *pdwVer = dwVer;
                bReturn = TRUE;

            } else {
                dwStatus = ERROR_INSUFFICIENT_BUFFER;
                SetLastError( ERROR_INSUFFICIENT_BUFFER );
                bReturn = FALSE;
            }

        } else {

            DBGMSG( DBG_WARN, ( "GetPrinterData failed with %d\n", dwStatus ) );

        }
    }

    if( hServer ){
        ClosePrinter( hServer );
    }

    return bReturn;
}

BOOL
bGetArchUseReg(
    IN      LPCTSTR  pName,
        OUT LPTSTR   pszArch,
    IN      DWORD    dwSize,
        OUT LPDWORD  pdwVer
    )
/*++

Routine Description:

    Gets the specified print server the architectue and
    driver version using the remote registry.

Arguments:

    pName       - pointer to print server name.
    pszArch     - pointer to a buffer where to return the machine architecture string
    dwSize      - Size in characters of the provided architecture string
    pdwVersion  - pointer where to return the remote machine driver version.

Return Value:

    TRUE - remote information returned, FALSE - remote information not available.

--*/
{
    BOOL bStatus        = TRUE;
    DWORD dwDriverEnvId = 0;
    DWORD dwArch        = 0;
    TString strDriverEnv;

    //
    // Create the computer information.
    //
    CComputerInfo CompInfo ( pName );

    //
    // Get the information from the remote machine.
    //
    if( !CompInfo.GetInfo() ){

        DBGMSG( DBG_WARN, ( "CComputerInfo.GetInfo failed with %d\n", GetLastError() ) );

        return FALSE;
    }

    //
    // If this is a windows 95 machine set resource string
    // id and set the version to zero.
    //
    if( CompInfo.IsRunningWindows95() ){

        dwDriverEnvId   = IDS_ENVIRONMENT_WIN95;
        *pdwVer         = 0;

    } else {

        //
        // Convert processor type to spooler defined environment string.
        //
        dwArch      = CompInfo.GetProcessorArchitecture();
        *pdwVer     = CompInfo.GetSpoolerVersion();

        struct ArchMap {
            DWORD dwArch;
            DWORD dwVersion;
            UINT uId;
            };

        //
        // disable MIPS & PPC drivers, since they are not supported from setup
        //
        static ArchMap aArchMap [] = {
            { PROCESSOR_ARCHITECTURE_INTEL,   0, IDS_ENVIRONMENT_WIN95  },
            //{ PROCESSOR_ARCHITECTURE_MIPS,    0, IDS_ENVIRONMENT_MIPS   },
            { PROCESSOR_ARCHITECTURE_ALPHA,   0, IDS_ENVIRONMENT_ALPHA  },
            { PROCESSOR_ARCHITECTURE_INTEL,   0, IDS_ENVIRONMENT_X86    },
            //{ PROCESSOR_ARCHITECTURE_MIPS,    1, IDS_ENVIRONMENT_MIPS   },
            { PROCESSOR_ARCHITECTURE_ALPHA,   1, IDS_ENVIRONMENT_ALPHA  },
            //{ PROCESSOR_ARCHITECTURE_PPC,     1, IDS_ENVIRONMENT_PPC    },
            { PROCESSOR_ARCHITECTURE_INTEL,   1, IDS_ENVIRONMENT_X86    },
            //{ PROCESSOR_ARCHITECTURE_MIPS,    2, IDS_ENVIRONMENT_MIPS   },
            { PROCESSOR_ARCHITECTURE_ALPHA,   2, IDS_ENVIRONMENT_ALPHA  },
            //{ PROCESSOR_ARCHITECTURE_PPC,     2, IDS_ENVIRONMENT_PPC    },
            { PROCESSOR_ARCHITECTURE_INTEL,   2, IDS_ENVIRONMENT_X86    },
            { PROCESSOR_ARCHITECTURE_ALPHA,   3, IDS_ENVIRONMENT_ALPHA  },
            { PROCESSOR_ARCHITECTURE_INTEL,   3, IDS_ENVIRONMENT_X86    }};

        bStatus = FALSE;
        for( UINT i = 0; i < COUNTOF( aArchMap ); i++ ){

            //
            // If a version and architecture match.
            //
            if( aArchMap[i].dwVersion == *pdwVer &&
                aArchMap[i].dwArch == dwArch ){

                dwDriverEnvId = aArchMap[i].uId;
                bStatus = TRUE;
                break;
            }
        }
    }

    //
    // If Environment ID and version found.
    //
    if( !bStatus ){
        DBGMSG( DBG_WARN, ( "Failed to find architecture in map.\n" ) );
        return FALSE;
    }

    //
    // Load the environment string from our resource file.
    //
    if( !strDriverEnv.bLoadString( ghInst, dwDriverEnvId ) ){

        DBGMSG( DBG_WARN, ( "Failed to load driver name string resource with %d\n", GetLastError() ) );
        return FALSE;
    }

    //
    // Check the provided buffer is large enough.
    //
    if( (DWORD)lstrlen( strDriverEnv ) >= ( dwSize - 1 ) ){
        DBGMSG( DBG_WARN, ( "Insuffcient buffer provided to bGetArchUseReg.\n" ) );
        return FALSE;
    }

    //
    // Copy back environment string to provided buffer.
    //
    lstrcpy( pszArch, strDriverEnv );

    DBGMSG( DBG_TRACE, ( "CComputerInfo.GetInfo: Architecture " TSTR "\n" , pszArch ) );
    DBGMSG( DBG_TRACE, ( "CComputerInfo.GetInfo: MajorVersion %d\n" , *pdwVer ) );

    return TRUE;

}

BOOL
bEncodeArchVersion(
    IN      LPCTSTR  pszArch,
    IN      DWORD    dwVer,
        OUT LPDWORD  pdwVal
    )
/*++

Routine Description:

    Encode the Architecture and version into a DWORD.

Arguments:

    pszArch     - pointer to machine spooler defined environment string
    dwVer       - machines driver version
    pdwVal      - pointer where to store the encoded value

Return Value:

    TRUE - remote information returned, FALSE - remote information not available.

--*/
{

    struct ArchMap {
        UINT uArchId;
        DWORD dwVersion;
        DWORD dwPUIVer;
        DWORD dwPUIArch;
        };

    //
    // disable MIPS & PPC drivers, since they are not supported from setup
    //
    static ArchMap aArchMap [] = {
        { IDS_ENVIRONMENT_ALPHA,   0,  VERSION_0,  ARCH_ALPHA  },
        { IDS_ENVIRONMENT_X86,     0,  VERSION_0,  ARCH_X86    },
        //{ IDS_ENVIRONMENT_MIPS,    0,  VERSION_0,  ARCH_MIPS   },
        { IDS_ENVIRONMENT_WIN95,   0,  VERSION_0,  ARCH_WIN95  },
        { IDS_ENVIRONMENT_ALPHA,   1,  VERSION_1,  ARCH_ALPHA  },
        { IDS_ENVIRONMENT_X86,     1,  VERSION_1,  ARCH_X86    },
        //{ IDS_ENVIRONMENT_MIPS,    1,  VERSION_1,  ARCH_MIPS   },
        //{ IDS_ENVIRONMENT_PPC,     1,  VERSION_1,  ARCH_PPC    },
        { IDS_ENVIRONMENT_ALPHA,   2,  VERSION_2,  ARCH_ALPHA  },
        { IDS_ENVIRONMENT_X86,     2,  VERSION_2,  ARCH_X86    },
        //{ IDS_ENVIRONMENT_MIPS,    2,  VERSION_2,  ARCH_MIPS   },
        //{ IDS_ENVIRONMENT_PPC,     2,  VERSION_2,  ARCH_PPC    },
        { IDS_ENVIRONMENT_ALPHA,   3,  VERSION_3,  ARCH_ALPHA  },
        { IDS_ENVIRONMENT_X86,     3,  VERSION_3,  ARCH_X86    },
        { IDS_ENVIRONMENT_IA64,    3,  VERSION_3,  ARCH_IA64   }};

    BOOL bRetval = FALSE;
    TString strDriverEnv;
    for( UINT i = 0; i < COUNTOF( aArchMap ); i++ ){

        //
        // Attempt to load the driver environment string from our resource file.
        //
        if( !strDriverEnv.bLoadString( ghInst, aArchMap[i].uArchId ) ){
            DBGMSG( DBG_WARN, ( "Error loading environment string from resource.\n" ) );
            break;
        }

        //
        // If the environment and version match, then encode the environment
        // and version into a single dword.
        //
        if( !lstrcmpi( pszArch, (LPCTSTR)strDriverEnv ) &&
            aArchMap[i].dwVersion == dwVer ){

            *pdwVal = aArchMap[i].dwPUIVer + aArchMap[i].dwPUIArch;
            bRetval = TRUE;
            break;
        }
    }

    return bRetval;
}

BOOL
bGetDriverEnv(
    IN      DWORD   dwDriverVersion,
        OUT TString &strDriverEnv
    )
/*++

Routine Description:

    Convert the Encoded the Architecture and version to a
    spooler defined environment string.

Arguments:

    dwDriverVersion - encoded driver version
    strDriverEnv    - string where to return the environment string.

Return Value:

    TRUE - environment string found, FALSE - error occured.

--*/
{
    struct ArchMap {
        DWORD dwDrvVer;
        UINT uArchId;
        };

    //
    // disable MIPS & PPC drivers, since they are not supported from setup
    //
    static ArchMap aArchMap [] = {
        { DRIVER_IA64_3,      IDS_ENVIRONMENT_IA64  },
        { DRIVER_X86_3,       IDS_ENVIRONMENT_X86   },
        { DRIVER_ALPHA_3,     IDS_ENVIRONMENT_ALPHA },
        { DRIVER_X86_2,       IDS_ENVIRONMENT_X86   },
        //{ DRIVER_MIPS_2,      IDS_ENVIRONMENT_MIPS  },
        { DRIVER_ALPHA_2,     IDS_ENVIRONMENT_ALPHA },
        //{ DRIVER_PPC_2,       IDS_ENVIRONMENT_PPC   },
        { DRIVER_X86_1,       IDS_ENVIRONMENT_X86   },
        //{ DRIVER_MIPS_1,      IDS_ENVIRONMENT_MIPS  },
        { DRIVER_ALPHA_1,     IDS_ENVIRONMENT_ALPHA },
        //{ DRIVER_PPC_1,       IDS_ENVIRONMENT_PPC   },
        { DRIVER_X86_0,       IDS_ENVIRONMENT_X86   },
        //{ DRIVER_MIPS_0,      IDS_ENVIRONMENT_MIPS  },
        { DRIVER_ALPHA_0,     IDS_ENVIRONMENT_ALPHA },
        { DRIVER_WIN95,       IDS_ENVIRONMENT_WIN95 }};

    UINT uId        = 0;
    BOOL bRetval    = FALSE;
    for( UINT i = 0; i < COUNTOF( aArchMap ); i++ ){

        if( aArchMap[i].dwDrvVer == dwDriverVersion ){
            uId = aArchMap[i].uArchId;
            bRetval = TRUE;
            break;
        }
    }

    if( bRetval ){

        //
        // Attempt to load the driver environment string from our resource file.
        //
        if( !strDriverEnv.bLoadString( ghInst, uId ) ){
            DBGMSG( DBG_WARN, ( "Error loading environment string from resource.\n" ) );
            bRetval = FALSE;
        }

    } else {

        DBGMSG( DBG_WARN, ( "Driver / Version not found, bGetDriverEnv.\n" ) );

    }

    return bRetval;
}


PLATFORM
GetDriverPlatform(
    IN DWORD dwDriver
    )
/*++

Routine Description:

    Return the driver platform value  (used by splsetup apis).

Arguments:

    dwDriver - DWORD indicating driver platform/version.

Return Value:

    PLATFORM.

--*/
{
    return (PLATFORM)( dwDriver % ARCH_MAX );
}

DWORD
GetDriverVersion(
    IN DWORD dwDriver
    )

/*++

Routine Description:

    Return the driver version value (used by DRIVER_INFO_x).

Arguments:

    dwDriver - DWORD indicating driver platform/version.

Return Value:

    DWORD version.

--*/

{
    return dwDriver / ARCH_MAX;
}

BOOL
bIsNativeDriver(
    IN LPCTSTR pszServerName,
    IN DWORD dwDriver
    )
/*++

Routine Description:

    Determines whether the platform/version is compatible with the
    current OS.

Arguments:

    dwDriver - DWORD indicating driver platform/version.

Return Value:

    TRUE - compatible, FALSE - not compatible.

--*/
{
    //
    // Get the current driver / version.
    //
    DWORD dwDrv;
    if( bGetCurrentDriver( pszServerName, &dwDrv ) ){
        return dwDrv == dwDriver;
    }
   return FALSE;
}

BOOL
bIs3xDriver(
    IN DWORD dwDriver
    )
/*++

Routine Description:

    Returns TRUE iff driver works with 3.5x.

Arguments:

    dwDriver - DWORD indicating driver platform/version.

Return Value:

--*/

{
    return dwDriver < VERSION_2;
}

BOOL
bGetArchName(
    IN      DWORD    dwDriver,
        OUT TString &strDrvArchName
    )
/*++

Routine Description:

    Retrieves the platform/version name from a driver platform/version.

Arguments:

    dwDriver         - DWORD indicating driver platform/version.
    strDrvArchName   - String where to retun platform/version string.

Return Value:

    TRUE strDrvArchName contains architecture name.
    FALSE error occurred reading string.

--*/

{
    TStatusB bStatus;

    //
    // Load the architecute / driver name.
    //
    bStatus DBGCHK = strDrvArchName.bLoadString( ghInst, IDS_DRIVER_BASE + dwDriver );

    return bStatus;
}


BOOL
bIsCompatibleDriverVersion(
    IN DWORD dwDriver,
    IN DWORD dwVersion
    )
/*++

Routine Description:

    Checks if the specified drivers version is a compatible version.

    NOTE: This function MUST be re-rewritten if the drvier model changes.

Arguments:

    dwDriver         - DWORD indicating driver platform/version.
    dwVersion        - DWORD version number to check.

Return Value:

    TRUE version is compatible.
    FALSE verion is not compatible.

--*/
{
    DWORD dwDriverVersion = GetDriverVersion( dwDriver );

    //
    // If the version are equal then they are compatible.
    //
    if( dwVersion == dwDriverVersion )
        return TRUE;

    //
    // If current driver version is a version 3 (Win2K or above)
    // then version 2 (NT4 Kernel mode) are compatible drivers.
    //
    if( dwDriverVersion == 3 && dwVersion == 2 )
        return TRUE;

    return FALSE;
}


BOOL
SpoolerGetVersionEx(
    IN      LPCTSTR         pszServerName,
    IN OUT  OSVERSIONINFO   *pOsVersionInfo
    )

/*++

Routine Description:

    Gets the osversion using spooler apis, thus it's remotable.

Arguments:

    pszServerName    - pointer to a string which contains the server name
                       a NULL indicates the local machine.
    pOsVersionInf    - pointer to osversion structure to fill in.

Return Value:

    TRUE version structure was filled successfully.
    FALSE error occurred.

--*/

{
    SPLASSERT ( pOsVersionInfo );

    TStatusB bStatus;
    bStatus DBGNOCHK = FALSE;

    if( !pszServerName )
    {
        //
        // Get the osversion info structure size
        //
        bStatus DBGCHK = GetVersionEx( pOsVersionInfo );
    }
    else
    {
        //
        // Attempt to open print server with just read.
        //
        DWORD dwStatus  = ERROR_SUCCESS;
        DWORD dwAccess  = SERVER_READ;
        HANDLE hServer  = NULL;
        DWORD dwNeeded  = 0;
        DWORD dwType    = REG_BINARY;

        //
        // Open the server for read access.
        //
        dwStatus = TPrinter::sOpenPrinter( pszServerName, &dwAccess, &hServer );

        //
        // Get the os version from the remote spooler.
        //
        if( dwStatus == ERROR_SUCCESS )
        {
            dwStatus = GetPrinterData( hServer,
                                       SPLREG_OS_VERSION,
                                       &dwType,
                                       (PBYTE)pOsVersionInfo,
                                       sizeof( OSVERSIONINFO ),
                                       &dwNeeded );

            if( dwStatus == ERROR_SUCCESS )
            {
                bStatus DBGCHK = TRUE;
            }
        }
    }

    return bStatus;
}