printerdrivers.c File Reference

#include "precomp.h"
#include <marshalling/printerdrivers.h>

Include dependency graph for printerdrivers.c:

Go to the source code of this file.

Functions
static int	multi_sz_lenA (const char *str)
static int	multi_sz_lenW (const WCHAR *str)
BOOL WINAPI	AddPrinterDriverA (PSTR pName, DWORD Level, PBYTE pDriverInfo)
BOOL WINAPI	AddPrinterDriverExA (PSTR pName, DWORD Level, PBYTE pDriverInfo, DWORD dwFileCopyFlags)
BOOL WINAPI	AddPrinterDriverExW (PWSTR pName, DWORD Level, PBYTE pDriverInfo, DWORD dwFileCopyFlags)
BOOL WINAPI	AddPrinterDriverW (PWSTR pName, DWORD Level, PBYTE pDriverInfo)
BOOL WINAPI	DeletePrinterDriverA (PSTR pName, PSTR pEnvironment, PSTR pDriverName)
BOOL WINAPI	DeletePrinterDriverExA (PSTR pName, PSTR pEnvironment, PSTR pDriverName, DWORD dwDeleteFlag, DWORD dwVersionFlag)
BOOL WINAPI	DeletePrinterDriverExW (PWSTR pName, PWSTR pEnvironment, PWSTR pDriverName, DWORD dwDeleteFlag, DWORD dwVersionFlag)
BOOL WINAPI	DeletePrinterDriverW (PWSTR pName, PWSTR pEnvironment, PWSTR pDriverName)
BOOL WINAPI	EnumPrinterDriversA (PSTR pName, PSTR pEnvironment, DWORD Level, PBYTE pDriverInfo, DWORD cbBuf, PDWORD pcbNeeded, PDWORD pcReturned)
BOOL WINAPI	EnumPrinterDriversW (PWSTR pName, PWSTR pEnvironment, DWORD Level, PBYTE pDriverInfo, DWORD cbBuf, PDWORD pcbNeeded, PDWORD pcReturned)
BOOL WINAPI	GetPrinterDriverA (HANDLE hPrinter, LPSTR pEnvironment, DWORD Level, LPBYTE pDriverInfo, DWORD cbBuf, LPDWORD pcbNeeded)
BOOL WINAPI	GetPrinterDriverW (HANDLE hPrinter, LPWSTR pEnvironment, DWORD Level, LPBYTE pDriverInfo, DWORD cbBuf, LPDWORD pcbNeeded)
BOOL WINAPI	GetPrinterDriverDirectoryA (PSTR pName, PSTR pEnvironment, DWORD Level, PBYTE pDriverDirectory, DWORD cbBuf, PDWORD pcbNeeded)
BOOL WINAPI	GetPrinterDriverDirectoryW (PWSTR pName, PWSTR pEnvironment, DWORD Level, PBYTE pDriverDirectory, DWORD cbBuf, PDWORD pcbNeeded)

Variables
const WCHAR	wszCurrentEnvironment []

Function Documentation

AddPrinterDriverA()

BOOL WINAPI AddPrinterDriverA	(	PSTR	pName,
		DWORD	Level,
		PBYTE	pDriverInfo
	)

Definition at line 38 of file printerdrivers.c.

{
    TRACE("AddPrinterDriverA(%s, %lu, %p)\n", pName, Level, pDriverInfo);
    return AddPrinterDriverExA(pName, Level, pDriverInfo, APD_COPY_NEW_FILES);
}

AddPrinterDriverExA()

BOOL WINAPI AddPrinterDriverExA	(	PSTR	pName,
		DWORD	Level,
		PBYTE	pDriverInfo,
		DWORD	dwFileCopyFlags
	)

Definition at line 45 of file printerdrivers.c.

{
    PDRIVER_INFO_8A  pdiA;
    DRIVER_INFO_8W   diW;
    LPWSTR  nameW = NULL;
    DWORD   lenA;
    DWORD   len;
    BOOL    res = FALSE;
 
    TRACE("AddPrinterDriverExA(%s, %d, %p, 0x%x)\n", debugstr_a(pName), Level, pDriverInfo, dwFileCopyFlags);
 
    pdiA = (DRIVER_INFO_8A *) pDriverInfo;
    ZeroMemory(&diW, sizeof(diW));
 
    if (Level < 2 || Level == 5 || Level == 7 || Level > 8)
    {
        SetLastError(ERROR_INVALID_LEVEL);
        return FALSE;
    }
 
    if (pdiA == NULL)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    /* convert servername to unicode */
    if (pName)
    {
        len = MultiByteToWideChar(CP_ACP, 0, pName, -1, NULL, 0);
        nameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
        MultiByteToWideChar(CP_ACP, 0, pName, -1, nameW, len);
    }
 
    /* common fields */
    diW.cVersion = pdiA->cVersion;
 
    if (pdiA->pName)
    {
        len = MultiByteToWideChar(CP_ACP, 0, pdiA->pName, -1, NULL, 0);
        diW.pName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
        MultiByteToWideChar(CP_ACP, 0, pdiA->pName, -1, diW.pName, len);
    }
 
    if (pdiA->pEnvironment)
    {
        len = MultiByteToWideChar(CP_ACP, 0, pdiA->pEnvironment, -1, NULL, 0);
        diW.pEnvironment = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
        MultiByteToWideChar(CP_ACP, 0, pdiA->pEnvironment, -1, diW.pEnvironment, len);
    }
 
    if (pdiA->pDriverPath)
    {
        len = MultiByteToWideChar(CP_ACP, 0, pdiA->pDriverPath, -1, NULL, 0);
        diW.pDriverPath = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
        MultiByteToWideChar(CP_ACP, 0, pdiA->pDriverPath, -1, diW.pDriverPath, len);
    }
 
    if (pdiA->pDataFile)
    {
        len = MultiByteToWideChar(CP_ACP, 0, pdiA->pDataFile, -1, NULL, 0);
        diW.pDataFile = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
        MultiByteToWideChar(CP_ACP, 0, pdiA->pDataFile, -1, diW.pDataFile, len);
    }
 
    if (pdiA->pConfigFile)
    {
        len = MultiByteToWideChar(CP_ACP, 0, pdiA->pConfigFile, -1, NULL, 0);
        diW.pConfigFile = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
        MultiByteToWideChar(CP_ACP, 0, pdiA->pConfigFile, -1, diW.pConfigFile, len);
    }
 
    if ((Level > 2) && pdiA->pHelpFile)
    {
        len = MultiByteToWideChar(CP_ACP, 0, pdiA->pHelpFile, -1, NULL, 0);
        diW.pHelpFile = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
        MultiByteToWideChar(CP_ACP, 0, pdiA->pHelpFile, -1, diW.pHelpFile, len);
    }
 
    if ((Level > 2) && pdiA->pDependentFiles)
    {
        lenA = multi_sz_lenA(pdiA->pDependentFiles);
        len = MultiByteToWideChar(CP_ACP, 0, pdiA->pDependentFiles, lenA, NULL, 0);
        diW.pDependentFiles = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
        MultiByteToWideChar(CP_ACP, 0, pdiA->pDependentFiles, lenA, diW.pDependentFiles, len);
    }
 
    if ((Level > 2) && pdiA->pMonitorName)
    {
        len = MultiByteToWideChar(CP_ACP, 0, pdiA->pMonitorName, -1, NULL, 0);
        diW.pMonitorName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
        MultiByteToWideChar(CP_ACP, 0, pdiA->pMonitorName, -1, diW.pMonitorName, len);
    }
 
    if ((Level > 2) && pdiA->pDefaultDataType)
    {
        len = MultiByteToWideChar(CP_ACP, 0, pdiA->pDefaultDataType, -1, NULL, 0);
        diW.pDefaultDataType = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
        MultiByteToWideChar(CP_ACP, 0, pdiA->pDefaultDataType, -1, diW.pDefaultDataType, len);
    }
 
    if ((Level > 3) && pdiA->pszzPreviousNames)
    {
        lenA = multi_sz_lenA(pdiA->pszzPreviousNames);
        len = MultiByteToWideChar(CP_ACP, 0, pdiA->pszzPreviousNames, lenA, NULL, 0);
        diW.pszzPreviousNames = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
        MultiByteToWideChar(CP_ACP, 0, pdiA->pszzPreviousNames, lenA, diW.pszzPreviousNames, len);
    }
 
    if (Level > 5)
    {
        diW.ftDriverDate = pdiA->ftDriverDate;
        diW.dwlDriverVersion = pdiA->dwlDriverVersion;
    }
 
    if ((Level > 5) && pdiA->pszMfgName)
    {
        len = MultiByteToWideChar(CP_ACP, 0, pdiA->pszMfgName, -1, NULL, 0);
        diW.pszMfgName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
        MultiByteToWideChar(CP_ACP, 0, pdiA->pszMfgName, -1, diW.pszMfgName, len);
    }
 
    if ((Level > 5) && pdiA->pszOEMUrl)
    {
        len = MultiByteToWideChar(CP_ACP, 0, pdiA->pszOEMUrl, -1, NULL, 0);
        diW.pszOEMUrl = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
        MultiByteToWideChar(CP_ACP, 0, pdiA->pszOEMUrl, -1, diW.pszOEMUrl, len);
    }
 
    if ((Level > 5) && pdiA->pszHardwareID)
    {
        len = MultiByteToWideChar(CP_ACP, 0, pdiA->pszHardwareID, -1, NULL, 0);
        diW.pszHardwareID = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
        MultiByteToWideChar(CP_ACP, 0, pdiA->pszHardwareID, -1, diW.pszHardwareID, len);
    }
 
    if ((Level > 5) && pdiA->pszProvider)
    {
        len = MultiByteToWideChar(CP_ACP, 0, pdiA->pszProvider, -1, NULL, 0);
        diW.pszProvider = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
        MultiByteToWideChar(CP_ACP, 0, pdiA->pszProvider, -1, diW.pszProvider, len);
    }
 
    if ((Level > 7) && pdiA->pszPrintProcessor)
    {
        len = MultiByteToWideChar(CP_ACP, 0, pdiA->pszPrintProcessor, -1, NULL, 0);
        diW.pszPrintProcessor = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
        MultiByteToWideChar(CP_ACP, 0, pdiA->pszPrintProcessor, -1, diW.pszPrintProcessor, len);
    }
 
    if ((Level > 7) && pdiA->pszVendorSetup)
    {
        len = MultiByteToWideChar(CP_ACP, 0, pdiA->pszVendorSetup, -1, NULL, 0);
        diW.pszVendorSetup = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
        MultiByteToWideChar(CP_ACP, 0, pdiA->pszVendorSetup, -1, diW.pszVendorSetup, len);
    }
 
    if ((Level > 7) && pdiA->pszzColorProfiles)
    {
        lenA = multi_sz_lenA(pdiA->pszzColorProfiles);
        len = MultiByteToWideChar(CP_ACP, 0, pdiA->pszzColorProfiles, lenA, NULL, 0);
        diW.pszzColorProfiles = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
        MultiByteToWideChar(CP_ACP, 0, pdiA->pszzColorProfiles, lenA, diW.pszzColorProfiles, len);
    }
 
    if ((Level > 7) && pdiA->pszInfPath)
    {
        len = MultiByteToWideChar(CP_ACP, 0, pdiA->pszInfPath, -1, NULL, 0);
        diW.pszInfPath = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
        MultiByteToWideChar(CP_ACP, 0, pdiA->pszInfPath, -1, diW.pszInfPath, len);
    }
 
    if ((Level > 7) && pdiA->pszzCoreDriverDependencies)
    {
        lenA = multi_sz_lenA(pdiA->pszzCoreDriverDependencies);
        len = MultiByteToWideChar(CP_ACP, 0, pdiA->pszzCoreDriverDependencies, lenA, NULL, 0);
        diW.pszzCoreDriverDependencies = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
        MultiByteToWideChar(CP_ACP, 0, pdiA->pszzCoreDriverDependencies, lenA, diW.pszzCoreDriverDependencies, len);
    }
 
    if (Level > 7)
    {
        diW.dwPrinterDriverAttributes = pdiA->dwPrinterDriverAttributes;
        diW.ftMinInboxDriverVerDate = pdiA->ftMinInboxDriverVerDate;
        diW.dwlMinInboxDriverVerVersion = pdiA->dwlMinInboxDriverVerVersion;
    }
 
    res = AddPrinterDriverExW(nameW, Level, (LPBYTE) &diW, dwFileCopyFlags);
 
    TRACE("got %u with %u\n", res, GetLastError());
    if (nameW) HeapFree(GetProcessHeap(), 0, nameW);
    if (diW.pName) HeapFree(GetProcessHeap(), 0, diW.pName);
    if (diW.pEnvironment) HeapFree(GetProcessHeap(), 0, diW.pEnvironment);
    if (diW.pDriverPath) HeapFree(GetProcessHeap(), 0, diW.pDriverPath);
    if (diW.pDataFile) HeapFree(GetProcessHeap(), 0, diW.pDataFile);
    if (diW.pConfigFile) HeapFree(GetProcessHeap(), 0, diW.pConfigFile);
    if (diW.pHelpFile) HeapFree(GetProcessHeap(), 0, diW.pHelpFile);
    if (diW.pDependentFiles) HeapFree(GetProcessHeap(), 0, diW.pDependentFiles);
    if (diW.pMonitorName) HeapFree(GetProcessHeap(), 0, diW.pMonitorName);
    if (diW.pDefaultDataType) HeapFree(GetProcessHeap(), 0, diW.pDefaultDataType);
    if (diW.pszzPreviousNames) HeapFree(GetProcessHeap(), 0, diW.pszzPreviousNames);
    if (diW.pszMfgName) HeapFree(GetProcessHeap(), 0, diW.pszMfgName);
    if (diW.pszOEMUrl) HeapFree(GetProcessHeap(), 0, diW.pszOEMUrl);
    if (diW.pszHardwareID) HeapFree(GetProcessHeap(), 0, diW.pszHardwareID);
    if (diW.pszProvider) HeapFree(GetProcessHeap(), 0, diW.pszProvider);
    if (diW.pszPrintProcessor) HeapFree(GetProcessHeap(), 0, diW.pszPrintProcessor);
    if (diW.pszVendorSetup) HeapFree(GetProcessHeap(), 0, diW.pszVendorSetup);
    if (diW.pszzColorProfiles) HeapFree(GetProcessHeap(), 0, diW.pszzColorProfiles);
    if (diW.pszInfPath) HeapFree(GetProcessHeap(), 0, diW.pszInfPath);
    if (diW.pszzCoreDriverDependencies) HeapFree(GetProcessHeap(), 0, diW.pszzCoreDriverDependencies);
 
    TRACE("=> %u with %u\n", res, GetLastError());
    return res;
}

Referenced by AddPrinterDriverA().

AddPrinterDriverExW()

BOOL WINAPI AddPrinterDriverExW	(	PWSTR	pName,
		DWORD	Level,
		PBYTE	pDriverInfo,
		DWORD	dwFileCopyFlags
	)

Definition at line 261 of file printerdrivers.c.

{
    DWORD dwErrorCode = ERROR_SUCCESS;
    WINSPOOL_DRIVER_INFO_8 * pdi = NULL;
    WINSPOOL_DRIVER_CONTAINER pDriverContainer;
 
    TRACE("AddPrinterDriverExW(%S, %lu, %p, %lu)\n", pName, Level, pDriverInfo, dwFileCopyFlags);
 
    pDriverContainer.Level = Level;
 
    switch (Level)
    {
        case 8:
        {
            PDRIVER_INFO_8W pdi8w = (PDRIVER_INFO_8W)pDriverInfo;
            pdi = HeapAlloc(hProcessHeap, 0, sizeof(WINSPOOL_DRIVER_INFO_8));
 
            pdi->pPrintProcessor   = pdi8w->pszPrintProcessor;
            pdi->pVendorSetup      = pdi8w->pszVendorSetup;
 
            pdi->pszzColorProfiles = pdi8w->pszzColorProfiles;
            pdi->cchColorProfiles = 0;
            if ( pdi8w->pszzColorProfiles && *pdi8w->pszzColorProfiles )
            {
                pdi->cchColorProfiles = multi_sz_lenW( pdi8w->pszzColorProfiles );
            }
 
            pdi->pInfPath = pdi8w->pszInfPath;
 
            pdi->pszzCoreDriverDependencies = pdi8w->pszzCoreDriverDependencies;
            pdi->cchCoreDependencies = 0;
            if ( pdi8w->pszzCoreDriverDependencies && *pdi8w->pszzCoreDriverDependencies )
            {
                pdi->cchCoreDependencies = multi_sz_lenW( pdi8w->pszzCoreDriverDependencies );
            }
 
            pdi->ftMinInboxDriverVerDate     = pdi8w->ftMinInboxDriverVerDate;
            pdi->dwlMinInboxDriverVerVersion = pdi8w->dwlMinInboxDriverVerVersion;
        }
        case 6:
        {
            PDRIVER_INFO_6W pdi6w = (PDRIVER_INFO_6W)pDriverInfo;
            if ( pdi == NULL ) pdi = HeapAlloc(hProcessHeap, 0, sizeof(WINSPOOL_DRIVER_INFO_6));
 
            pdi->pMfgName         = pdi6w->pszMfgName;
            pdi->pOEMUrl          = pdi6w->pszOEMUrl;
            pdi->pHardwareID      = pdi6w->pszHardwareID;
            pdi->pProvider        = pdi6w->pszProvider;
            pdi->ftDriverDate     = pdi6w->ftDriverDate;
            pdi->dwlDriverVersion = pdi6w->dwlDriverVersion;
        }
        case 4:
        {
            PDRIVER_INFO_4W pdi4w = (PDRIVER_INFO_4W)pDriverInfo;
            if ( pdi == NULL )  pdi = HeapAlloc(hProcessHeap, 0, sizeof(WINSPOOL_DRIVER_INFO_4));
 
            pdi->pszzPreviousNames = pdi4w->pszzPreviousNames;
            pdi->cchPreviousNames  = 0;
            if ( pdi4w->pDependentFiles && *pdi4w->pDependentFiles )
            {
               pdi->cchPreviousNames = multi_sz_lenW( pdi4w->pDependentFiles );
            }
        }
        case 3:
        {
            PDRIVER_INFO_3W pdi3w = (PDRIVER_INFO_3W)pDriverInfo;
            if ( pdi == NULL ) pdi = HeapAlloc(hProcessHeap, 0, sizeof(WINSPOOL_DRIVER_INFO_3));
 
            pdi->pHelpFile        = pdi3w->pHelpFile;
            pdi->pDependentFiles  = pdi3w->pDependentFiles;
            pdi->pMonitorName     = pdi3w->pMonitorName;
            pdi->pDefaultDataType = pdi3w->pDefaultDataType;
 
            pdi->pDependentFiles = pdi3w->pDependentFiles;
            pdi->cchDependentFiles = 0;
            if ( pdi3w->pDependentFiles && *pdi3w->pDependentFiles )
            {
                pdi->cchDependentFiles = multi_sz_lenW( pdi3w->pDependentFiles );
            }
        }
        case 2:
        {
            PDRIVER_INFO_2W pdi2w = (PDRIVER_INFO_2W)pDriverInfo;
            if ( pdi == NULL ) pdi = HeapAlloc(hProcessHeap, 0, sizeof(WINSPOOL_DRIVER_INFO_2));
 
            pdi->pName = pdi2w->pName;
 
            pdi->pEnvironment = pdi2w->pEnvironment;
            if ( !pdi2w->pEnvironment || !*pdi2w->pEnvironment )
            {
                pdi2w->pEnvironment = (PWSTR)wszCurrentEnvironment;
            }
 
            pdi->pDriverPath = pdi2w->pDriverPath;
            pdi->pDataFile   = pdi2w->pDataFile;
            pdi->pConfigFile = pdi2w->pConfigFile;
        }
            break;
 
        default:
            SetLastError(ERROR_INVALID_LEVEL);
            return FALSE;
    }
 
    pDriverContainer.DriverInfo.Level8 = pdi;
 
    RpcTryExcept
    {
        dwErrorCode = _RpcAddPrinterDriverEx( pName, &pDriverContainer, dwFileCopyFlags );
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwErrorCode = RpcExceptionCode();
        ERR("_RpcAddPrinterDriverEx failed with exception code %lu!\n", dwErrorCode);
    }
    RpcEndExcept;
 
    if ( pdi ) HeapFree( GetProcessHeap(), 0, pdi );
 
    SetLastError(dwErrorCode);
    return (dwErrorCode == ERROR_SUCCESS);
}

AddPrinterDriverW()

BOOL WINAPI AddPrinterDriverW	(	PWSTR	pName,
		DWORD	Level,
		PBYTE	pDriverInfo
	)

Definition at line 385 of file printerdrivers.c.

{
    TRACE("AddPrinterDriverW(%S, %lu, %p)\n", pName, Level, pDriverInfo);
    return AddPrinterDriverExW(pName, Level, pDriverInfo, APD_COPY_NEW_FILES);
}

DeletePrinterDriverA()

BOOL WINAPI DeletePrinterDriverA	(	PSTR	pName,
		PSTR	pEnvironment,
		PSTR	pDriverName
	)

Definition at line 392 of file printerdrivers.c.

{
    TRACE("DeletePrinterDriverA(%s, %s, %s)\n", pName, pEnvironment, pDriverName);
    return DeletePrinterDriverExA(pName, pEnvironment, pDriverName, 0, 0);
}

DeletePrinterDriverExA()

BOOL WINAPI DeletePrinterDriverExA	(	PSTR	pName,
		PSTR	pEnvironment,
		PSTR	pDriverName,
		DWORD	dwDeleteFlag,
		DWORD	dwVersionFlag
	)

Definition at line 399 of file printerdrivers.c.

{
    DWORD dwErrorCode;
    UNICODE_STRING NameW, EnvW, DriverW;
    BOOL ret;
 
    TRACE("DeletePrinterDriverExA(%s, %s, %s, %lu, %lu)\n", pName, pEnvironment, pDriverName, dwDeleteFlag, dwVersionFlag);
 
    AsciiToUnicode(&NameW, pName);
    AsciiToUnicode(&EnvW, pEnvironment);
    AsciiToUnicode(&DriverW, pDriverName);
 
    ret = DeletePrinterDriverExW(NameW.Buffer, EnvW.Buffer, DriverW.Buffer, dwDeleteFlag, dwVersionFlag);
 
    dwErrorCode = GetLastError();
 
    RtlFreeUnicodeString(&DriverW);
    RtlFreeUnicodeString(&EnvW);
    RtlFreeUnicodeString(&NameW);
 
    SetLastError(dwErrorCode);
    return ret;
}

Referenced by DeletePrinterDriverA().

DeletePrinterDriverExW()

BOOL WINAPI DeletePrinterDriverExW	(	PWSTR	pName,
		PWSTR	pEnvironment,
		PWSTR	pDriverName,
		DWORD	dwDeleteFlag,
		DWORD	dwVersionFlag
	)

Definition at line 424 of file printerdrivers.c.

{
    DWORD dwErrorCode;
 
    TRACE("DeletePrinterDriverExW(%S, %S, %S, %lu, %lu)\n", pName, pEnvironment, pDriverName, dwDeleteFlag, dwVersionFlag);
 
    if ( !pDriverName || !*pDriverName )
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    if ( !pEnvironment || !*pEnvironment )
    {
        pEnvironment = (PWSTR)wszCurrentEnvironment;
    }
 
    // Do the RPC call.
    RpcTryExcept
    {
        dwErrorCode = _RpcDeletePrinterDriverEx(pName, pEnvironment, pDriverName, dwDeleteFlag, dwVersionFlag);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwErrorCode = RpcExceptionCode();
        ERR("_RpcDeletePrinterDriverEx failed with exception code %lu!\n", dwErrorCode);
    }
    RpcEndExcept;
 
    SetLastError(dwErrorCode);
    return (dwErrorCode == ERROR_SUCCESS);
 
}

DeletePrinterDriverW()

BOOL WINAPI DeletePrinterDriverW	(	PWSTR	pName,
		PWSTR	pEnvironment,
		PWSTR	pDriverName
	)

Definition at line 459 of file printerdrivers.c.

{
    TRACE("DeletePrinterDriverW(%S, %S, %S)\n", pName, pEnvironment, pDriverName);
    return DeletePrinterDriverExW(pName, pEnvironment, pDriverName, 0, 0);
}

EnumPrinterDriversA()

BOOL WINAPI EnumPrinterDriversA	(	PSTR	pName,
		PSTR	pEnvironment,
		DWORD	Level,
		PBYTE	pDriverInfo,
		DWORD	cbBuf,
		PDWORD	pcbNeeded,
		PDWORD	pcReturned
	)

Definition at line 466 of file printerdrivers.c.

{
    BOOL ret = FALSE;
    DWORD dwErrorCode, i;
    UNICODE_STRING pNameW, pEnvironmentW;
    PWSTR pwstrNameW, pwstrEnvironmentW;
    PDRIVER_INFO_1W pdi1w = (PDRIVER_INFO_1W)pDriverInfo;
    PDRIVER_INFO_8W pdi8w = (PDRIVER_INFO_8W)pDriverInfo;
 
    FIXME("EnumPrinterDriversA(%s, %s, %lu, %p, %lu, %p, %p)\n", pName, pEnvironment, Level, pDriverInfo, cbBuf, pcbNeeded, pcReturned);
 
    pwstrNameW = AsciiToUnicode(&pNameW, pName);
    pwstrEnvironmentW = AsciiToUnicode(&pEnvironmentW, pEnvironment);
 
    ret = EnumPrinterDriversW( pwstrNameW, pwstrEnvironmentW, Level, pDriverInfo, cbBuf, pcbNeeded, pcReturned );
 
    dwErrorCode = GetLastError();
 
    if (ret)
    {
        for ( i = 0; i < *pcReturned; i++ )
        {
            switch (Level)
            {
                case 1:
                {
                    dwErrorCode = UnicodeToAnsiInPlace(pdi1w[i].pName);
                    if (dwErrorCode != ERROR_SUCCESS)
                    {
                        goto Cleanup;
                    }
                    break;
                }
                case 8:
                {
                    dwErrorCode = UnicodeToAnsiInPlace(pdi8w[i].pszPrintProcessor);
                    if (dwErrorCode != ERROR_SUCCESS)
                    {
                        goto Cleanup;
                    }
                    dwErrorCode = UnicodeToAnsiInPlace(pdi8w[i].pszVendorSetup);
                    if (dwErrorCode != ERROR_SUCCESS)
                    {
                        goto Cleanup;
                    }
                    dwErrorCode = UnicodeToAnsiZZInPlace(pdi8w[i].pszzColorProfiles);
                    if (dwErrorCode != ERROR_SUCCESS)
                    {
                        goto Cleanup;
                    }
                    dwErrorCode = UnicodeToAnsiInPlace(pdi8w[i].pszInfPath);
                    if (dwErrorCode != ERROR_SUCCESS)
                    {
                        goto Cleanup;
                    }
                    dwErrorCode = UnicodeToAnsiZZInPlace(pdi8w[i].pszzCoreDriverDependencies);
                    if (dwErrorCode != ERROR_SUCCESS)
                    {
                        goto Cleanup;
                    }
                }
                case 6:
                {
                    dwErrorCode = UnicodeToAnsiInPlace(pdi8w[i].pszMfgName);
                    if (dwErrorCode != ERROR_SUCCESS)
                    {
                        goto Cleanup;
                    }
 
                    dwErrorCode = UnicodeToAnsiInPlace(pdi8w[i].pszOEMUrl);
                    if (dwErrorCode != ERROR_SUCCESS)
                    {
                        goto Cleanup;
                    }
 
                    dwErrorCode = UnicodeToAnsiInPlace(pdi8w[i].pszHardwareID);
                    if (dwErrorCode != ERROR_SUCCESS)
                    {
                        goto Cleanup;
                    }
 
                    dwErrorCode = UnicodeToAnsiInPlace(pdi8w[i].pszProvider);
                    if (dwErrorCode != ERROR_SUCCESS)
                    {
                        goto Cleanup;
                    }
                }
                case 4:
                {
                    dwErrorCode = UnicodeToAnsiZZInPlace(pdi8w[i].pszzPreviousNames);
                    if (dwErrorCode != ERROR_SUCCESS)
                    {
                        goto Cleanup;
                    }
                }
                case 3:
                {
                    dwErrorCode = UnicodeToAnsiInPlace(pdi8w[i].pHelpFile);
                    if (dwErrorCode != ERROR_SUCCESS)
                    {
                        goto Cleanup;
                    }
 
                    dwErrorCode = UnicodeToAnsiZZInPlace(pdi8w[i].pDependentFiles);
                    if (dwErrorCode != ERROR_SUCCESS)
                    {
                        goto Cleanup;
                    }
 
                    dwErrorCode = UnicodeToAnsiInPlace(pdi8w[i].pMonitorName);
                    if (dwErrorCode != ERROR_SUCCESS)
                    {
                        goto Cleanup;
                    }
 
                    dwErrorCode = UnicodeToAnsiInPlace(pdi8w[i].pDefaultDataType);
                    if (dwErrorCode != ERROR_SUCCESS)
                    {
                        goto Cleanup;
                    }
                }
                case 2:
                case 5:
                {
                    dwErrorCode = UnicodeToAnsiInPlace(pdi8w[i].pName);
                    if (dwErrorCode != ERROR_SUCCESS)
                    {
                        goto Cleanup;
                    }
 
                    dwErrorCode = UnicodeToAnsiInPlace(pdi8w[i].pEnvironment);
                    if (dwErrorCode != ERROR_SUCCESS)
                    {
                        goto Cleanup;
                    }
 
                    dwErrorCode = UnicodeToAnsiInPlace(pdi8w[i].pDriverPath);
                    if (dwErrorCode != ERROR_SUCCESS)
                    {
                        goto Cleanup;
                    }
 
                    dwErrorCode = UnicodeToAnsiInPlace(pdi8w[i].pDataFile);
                    if (dwErrorCode != ERROR_SUCCESS)
                    {
                        goto Cleanup;
                    }
 
                    dwErrorCode = UnicodeToAnsiInPlace(pdi8w[i].pConfigFile);
                    if (dwErrorCode != ERROR_SUCCESS)
                    {
                        goto Cleanup;
                    }
                }
            }
        }
        dwErrorCode = ERROR_SUCCESS;
    }
Cleanup:
    RtlFreeUnicodeString(&pNameW);
    RtlFreeUnicodeString(&pEnvironmentW);
    SetLastError(dwErrorCode);
    FIXME("EnumPrinterDriversA Exit %d Err %d\n",ret,GetLastError());
    return ret;
}

EnumPrinterDriversW()

BOOL WINAPI EnumPrinterDriversW	(	PWSTR	pName,
		PWSTR	pEnvironment,
		DWORD	Level,
		PBYTE	pDriverInfo,
		DWORD	cbBuf,
		PDWORD	pcbNeeded,
		PDWORD	pcReturned
	)

Definition at line 633 of file printerdrivers.c.

{
    DWORD dwErrorCode;
 
    FIXME("EnumPrinterDriversW(%S, %S, %lu, %p, %lu, %p, %p)\n", pName, pEnvironment, Level, pDriverInfo, cbBuf, pcbNeeded, pcReturned);
 
    // Dismiss invalid levels already at this point.
    if (Level < 1 || Level == 7 || Level > 8)
    {
        dwErrorCode = ERROR_INVALID_LEVEL;
        goto Cleanup;
    }
 
    if ( !pEnvironment || !*pEnvironment )
    {
        pEnvironment = (PWSTR)wszCurrentEnvironment;
    }
 
    if (cbBuf && pDriverInfo)
        ZeroMemory(pDriverInfo, cbBuf);
 
    // Do the RPC call
    RpcTryExcept
    {
        dwErrorCode = _RpcEnumPrinterDrivers( pName, pEnvironment, Level, pDriverInfo, cbBuf, pcbNeeded, pcReturned );
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwErrorCode = RpcExceptionCode();
        ERR("_RpcEnumPrinterDrivers failed with exception code %lu!\n", dwErrorCode);
    }
    RpcEndExcept;
 
    if (dwErrorCode == ERROR_SUCCESS)
    {
        // Replace relative offset addresses in the output by absolute pointers.
        ASSERT(Level <= 6 || Level == 8);
        MarshallUpStructuresArray(cbBuf, pDriverInfo, *pcReturned, pPrinterDriverMarshalling[Level]->pInfo, pPrinterDriverMarshalling[Level]->cbStructureSize, TRUE);
    }
 
Cleanup:
    SetLastError(dwErrorCode); FIXME("EnumPrinterDriversW Exit Err %d\n",dwErrorCode);
    return (dwErrorCode == ERROR_SUCCESS);
 
}

GetPrinterDriverA()

BOOL WINAPI GetPrinterDriverA	(	HANDLE	hPrinter,
		LPSTR	pEnvironment,
		DWORD	Level,
		LPBYTE	pDriverInfo,
		DWORD	cbBuf,
		LPDWORD	pcbNeeded
	)

Definition at line 680 of file printerdrivers.c.

{
    DWORD dwErrorCode;
    /*
     * We are mapping multiple different pointers to the same pDriverInfo pointer here so that
     * we can use the same incoming pointer for different Levels
     */
    PDRIVER_INFO_1W pdi1w = (PDRIVER_INFO_1W)pDriverInfo;
    PDRIVER_INFO_8W pdi8w = (PDRIVER_INFO_8W)pDriverInfo;
 
    DWORD cch;
    PWSTR pwszEnvironment = NULL;
 
    TRACE("GetPrinterDriverA(%p, %s, %lu, %p, %lu, %p)\n", hPrinter, pEnvironment, Level, pDriverInfo, cbBuf, pcbNeeded);
 
    // Check for invalid levels here for early error return. Should be 1-6 & 8.
    if (Level <  1 || Level == 7 || Level > 8)
    {
        dwErrorCode = ERROR_INVALID_LEVEL;
        ERR("Invalid Level! %d\n",Level);
        goto Cleanup;
    }
 
    if (pEnvironment)
    {
        // Convert pEnvironment to a Unicode string pwszEnvironment.
        cch = strlen(pEnvironment);
 
        pwszEnvironment = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(WCHAR));
        if (!pwszEnvironment)
        {
            dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
            ERR("HeapAlloc failed!\n");
            goto Cleanup;
        }
 
        MultiByteToWideChar(CP_ACP, 0, pEnvironment, -1, pwszEnvironment, cch + 1);
    }
 
    if (!GetPrinterDriverW(hPrinter, pwszEnvironment, Level, pDriverInfo, cbBuf, pcbNeeded))
    {
        dwErrorCode = GetLastError();
        goto Cleanup;
    }
 
    // Do Unicode to ANSI conversions for strings based on Level
    switch (Level)
    {
        case 1:
        {
            dwErrorCode = UnicodeToAnsiInPlace(pdi1w->pName);
            if (dwErrorCode != ERROR_SUCCESS)
            {
                goto Cleanup;
            }
            break;
        }
        case 8:
        {
            dwErrorCode = UnicodeToAnsiInPlace(pdi8w->pszPrintProcessor);
            if (dwErrorCode != ERROR_SUCCESS)
            {
                goto Cleanup;
            }
            dwErrorCode = UnicodeToAnsiInPlace(pdi8w->pszVendorSetup);
            if (dwErrorCode != ERROR_SUCCESS)
            {
                goto Cleanup;
            }
            dwErrorCode = UnicodeToAnsiZZInPlace(pdi8w->pszzColorProfiles);
            if (dwErrorCode != ERROR_SUCCESS)
            {
                goto Cleanup;
            }
            dwErrorCode = UnicodeToAnsiInPlace(pdi8w->pszInfPath);
            if (dwErrorCode != ERROR_SUCCESS)
            {
                goto Cleanup;
            }
            dwErrorCode = UnicodeToAnsiZZInPlace(pdi8w->pszzCoreDriverDependencies);
            if (dwErrorCode != ERROR_SUCCESS)
            {
                goto Cleanup;
            }
        }
        case 6:
        {
            dwErrorCode = UnicodeToAnsiInPlace(pdi8w->pszMfgName);
            if (dwErrorCode != ERROR_SUCCESS)
            {
                goto Cleanup;
            }
 
            dwErrorCode = UnicodeToAnsiInPlace(pdi8w->pszOEMUrl);
            if (dwErrorCode != ERROR_SUCCESS)
            {
                goto Cleanup;
            }
 
            dwErrorCode = UnicodeToAnsiInPlace(pdi8w->pszHardwareID);
            if (dwErrorCode != ERROR_SUCCESS)
            {
                goto Cleanup;
            }
 
            dwErrorCode = UnicodeToAnsiInPlace(pdi8w->pszProvider);
            if (dwErrorCode != ERROR_SUCCESS)
            {
                goto Cleanup;
            }
        }
        case 4:
        {
            dwErrorCode = UnicodeToAnsiZZInPlace(pdi8w->pszzPreviousNames);
            if (dwErrorCode != ERROR_SUCCESS)
            {
                goto Cleanup;
            }
        }
        case 3:
        {
            dwErrorCode = UnicodeToAnsiInPlace(pdi8w->pHelpFile);
            if (dwErrorCode != ERROR_SUCCESS)
            {
                goto Cleanup;
            }
 
            dwErrorCode = UnicodeToAnsiZZInPlace(pdi8w->pDependentFiles);
            if (dwErrorCode != ERROR_SUCCESS)
            {
                goto Cleanup;
            }
 
            dwErrorCode = UnicodeToAnsiInPlace(pdi8w->pMonitorName);
            if (dwErrorCode != ERROR_SUCCESS)
            {
                goto Cleanup;
            }
 
            dwErrorCode = UnicodeToAnsiInPlace(pdi8w->pDefaultDataType);
            if (dwErrorCode != ERROR_SUCCESS)
            {
                goto Cleanup;
            }
        }
        case 2:
        case 5:
        {
            dwErrorCode = UnicodeToAnsiInPlace(pdi8w->pConfigFile);
            if (dwErrorCode != ERROR_SUCCESS)
            {
                goto Cleanup;
            }
            dwErrorCode = UnicodeToAnsiInPlace(pdi8w->pDataFile);
 
            if (dwErrorCode != ERROR_SUCCESS)
            {
                goto Cleanup;
            }
 
            dwErrorCode = UnicodeToAnsiInPlace(pdi8w->pDriverPath);
            if (dwErrorCode != ERROR_SUCCESS)
            {
                goto Cleanup;
            }
 
            dwErrorCode = UnicodeToAnsiInPlace(pdi8w->pEnvironment);
            if (dwErrorCode != ERROR_SUCCESS)
            {
                goto Cleanup;
            }
 
            dwErrorCode = UnicodeToAnsiInPlace(pdi8w->pName);
            if (dwErrorCode != ERROR_SUCCESS)
            {
                goto Cleanup;
            }
        }
    }
 
    dwErrorCode = ERROR_SUCCESS;
 
Cleanup:
    if (pwszEnvironment)
    {
        HeapFree(hProcessHeap, 0, pwszEnvironment);
    }
 
    SetLastError(dwErrorCode);
    return (dwErrorCode == ERROR_SUCCESS);
}

Referenced by get_driver_infoA(), PRINTDLG_ChangePrinterA(), PrintDlgA(), and test_GetPrinterDriver().

GetPrinterDriverDirectoryA()

BOOL WINAPI GetPrinterDriverDirectoryA	(	PSTR	pName,
		PSTR	pEnvironment,
		DWORD	Level,
		PBYTE	pDriverDirectory,
		DWORD	cbBuf,
		PDWORD	pcbNeeded
	)

Definition at line 927 of file printerdrivers.c.

{
    UNICODE_STRING nameW, environmentW;
    BOOL ret;
    DWORD pcbNeededW;
    INT len = cbBuf * sizeof(WCHAR)/sizeof(CHAR);
    WCHAR *driverDirectoryW = NULL;
 
    TRACE("GetPrinterDriverDirectoryA(%s, %s, %d, %p, %d, %p)\n", debugstr_a(pName), debugstr_a(pEnvironment), Level, pDriverDirectory, cbBuf, pcbNeeded);
 
    if (len) driverDirectoryW = HeapAlloc( GetProcessHeap(), 0, len );
 
    if (pName)
    {
        RtlCreateUnicodeStringFromAsciiz(&nameW, pName);
    }
    else
    {
        nameW.Buffer = NULL;
    }
    if (pEnvironment)
    {
        RtlCreateUnicodeStringFromAsciiz(&environmentW, pEnvironment);
    }
    else
    {
        environmentW.Buffer = NULL;
    }
 
    ret = GetPrinterDriverDirectoryW( nameW.Buffer, environmentW.Buffer, Level, (LPBYTE)driverDirectoryW, len, &pcbNeededW );
 
    if (ret)
    {
        DWORD needed =  WideCharToMultiByte( CP_ACP, 0, driverDirectoryW, -1, (LPSTR)pDriverDirectory, cbBuf, NULL, NULL);
 
        if ( pcbNeeded )
            *pcbNeeded = needed;
 
        ret = needed <= cbBuf;
    }
    else
    {
        if (pcbNeeded) *pcbNeeded = pcbNeededW * sizeof(CHAR)/sizeof(WCHAR);
    }
 
    TRACE("required: 0x%x/%d\n", pcbNeeded ? *pcbNeeded : 0, pcbNeeded ? *pcbNeeded : 0);
 
    HeapFree( GetProcessHeap(), 0, driverDirectoryW );
    RtlFreeUnicodeString(&environmentW);
    RtlFreeUnicodeString(&nameW);
 
    return ret;
}

GetPrinterDriverDirectoryW()

BOOL WINAPI GetPrinterDriverDirectoryW	(	PWSTR	pName,
		PWSTR	pEnvironment,
		DWORD	Level,
		PBYTE	pDriverDirectory,
		DWORD	cbBuf,
		PDWORD	pcbNeeded
	)

Definition at line 982 of file printerdrivers.c.

{
    DWORD dwErrorCode;
 
    TRACE("GetPrinterDriverDirectoryW(%S, %S, %lu, %p, %lu, %p)\n", pName, pEnvironment, Level, pDriverDirectory, cbBuf, pcbNeeded);
 
    if (Level != 1)
    {
        dwErrorCode = ERROR_INVALID_LEVEL;
        goto Cleanup;
    }
 
    if ( !pEnvironment || !*pEnvironment )
    {
        pEnvironment = (PWSTR)wszCurrentEnvironment;
    }
 
    // Do the RPC call.
    RpcTryExcept
    {
        dwErrorCode = _RpcGetPrinterDriverDirectory(pName, pEnvironment, Level, pDriverDirectory, cbBuf, pcbNeeded);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwErrorCode = RpcExceptionCode();
        ERR("_RpcGetPrinterDriverDirectory failed with exception code %lu!\n", dwErrorCode);
    }
    RpcEndExcept;
 
Cleanup:
    SetLastError(dwErrorCode);
    return (dwErrorCode == ERROR_SUCCESS);
}

GetPrinterDriverW()

BOOL WINAPI GetPrinterDriverW	(	HANDLE	hPrinter,
		LPWSTR	pEnvironment,
		DWORD	Level,
		LPBYTE	pDriverInfo,
		DWORD	cbBuf,
		LPDWORD	pcbNeeded
	)

Definition at line 873 of file printerdrivers.c.

{
    DWORD dwErrorCode;
    PSPOOLER_HANDLE pHandle = (PSPOOLER_HANDLE)hPrinter;
 
    TRACE("GetPrinterDriverW(%p, %S, %lu, %p, %lu, %p)\n", hPrinter, pEnvironment, Level, pDriverInfo, cbBuf, pcbNeeded);
 
    // Sanity checks.
    if (!pHandle)
    {
        dwErrorCode = ERROR_INVALID_HANDLE;
        goto Cleanup;
    }
 
    // Dismiss invalid levels already at this point.
    if (Level > 8 || Level == 7 || Level < 1)
    {
        dwErrorCode = ERROR_INVALID_LEVEL;
        goto Cleanup;
    }
 
    if ( !pEnvironment || !*pEnvironment )
    {
        pEnvironment = (PWSTR)wszCurrentEnvironment;
    }
 
    if (cbBuf && pDriverInfo)
        ZeroMemory(pDriverInfo, cbBuf);
 
    // Do the RPC call
    RpcTryExcept
    {
        dwErrorCode = _RpcGetPrinterDriver(pHandle->hPrinter, pEnvironment, Level, pDriverInfo, cbBuf, pcbNeeded);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwErrorCode = RpcExceptionCode();
        ERR("_RpcGetPrinterDriver failed with exception code %lu!\n", dwErrorCode);
    }
    RpcEndExcept;
 
    if (dwErrorCode == ERROR_SUCCESS)
    {
        // Replace relative offset addresses in the output by absolute pointers.
        ASSERT(Level <= 6 || Level == 8);
        MarshallUpStructure(cbBuf, pDriverInfo, pPrinterDriverMarshalling[Level]->pInfo, pPrinterDriverMarshalling[Level]->cbStructureSize, TRUE);
    }
 
Cleanup:
    SetLastError(dwErrorCode);
    return (dwErrorCode == ERROR_SUCCESS);
}

Referenced by get_driver_infoW(), LoadPrinterDriver(), pagesetup_change_printer(), PRINTDLG_ChangePrinterW(), and PrintDlgW().

multi_sz_lenA()

static int multi_sz_lenA ( const char *  str )

static

Definition at line 13 of file printerdrivers.c.

{
    const char *ptr = str;
    if(!str) return 0;
    do
    {
        ptr += lstrlenA(ptr) + 1;
    } while(*ptr);
 
    return ptr - str + 1;
}

Referenced by AddPrinterDriverExA().

multi_sz_lenW()

static int multi_sz_lenW ( const WCHAR *  str )

static

Definition at line 25 of file printerdrivers.c.

{
    const WCHAR *ptr = str;
    if (!str) return 0;
    do
    {
        ptr += lstrlenW(ptr) + 1;
    } while (*ptr);
 
    return (ptr - str + 1);
}

Referenced by AddPrinterDriverExW(), and myAddPrinterDriverEx().

Variable Documentation

wszCurrentEnvironment

const WCHAR wszCurrentEnvironment[]

extern

Definition at line 11 of file prtprocenv.h.

Referenced by _LocalGetMonitorLevel2(), _LocalGetPrinterDriverLevel2(), _LocalGetPrinterDriverLevel3(), _LocalGetPrinterDriverLevel4(), _LocalGetPrinterDriverLevel5(), _LocalGetPrinterDriverLevel6(), _LocalGetPrinterDriverLevel8(), _LocalGetPrintServerHandleData(), AddPrinterDriverExW(), AddPrintProcessorW(), DeletePrinterDriverExW(), DeletePrintProcessorW(), EnumPrinterDriversW(), EnumPrintProcessorsW(), GetPrinterDriverDirectoryW(), GetPrinterDriverW(), GetPrintProcessorDirectoryW(), InitializePrinterDrivers(), and InitializePrintProcessorList().