Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-07-10 14:45:06 +00:00
Code Issues Packages Projects Releases Wiki Activity
reactos/win32ss/printing/base/winspool/printers.c
Timo Kreuzer 0e68e27ff6 [WINSPOOL] Add a number of missing NULL checks.
2023-10-01 13:05:51 +03:00

4062 lines
124 KiB
C
Raw Blame History

/*
* PROJECT: ReactOS Spooler API
* LICENSE: GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+)
* PURPOSE: Functions related to Printers and printing
* COPYRIGHT: Copyright 2015-2018 Colin Finck (colin@reactos.org)
*/
#include "precomp.h"
#include <marshalling/printers.h>
//#include <marshalling/printerdrivers.h>
#include <strsafe.h>
extern HINSTANCE hinstWinSpool;
//
// See winddiui.h, ReactOS version is limited.
// Loading from XyzUI.dll part of XyzDRV.dll set. example TTYUI.DLL or UniDrvUI.DLL.
//
typedef DWORD (WINAPI *DEVICECAPABILITIES) (HANDLE,PWSTR,WORD,PVOID,PDEVMODEW);
static DEVICECAPABILITIES fpDeviceCapabilities;
typedef LONG (WINAPI *DEVICEPROPERTYSHEETS) (PPROPSHEETUI_INFO,LPARAM);
static DEVICEPROPERTYSHEETS fpDevicePropertySheets;
typedef LONG (WINAPI *DOCUMENTPROPERTYSHEETS) (PPROPSHEETUI_INFO,LPARAM);
static DOCUMENTPROPERTYSHEETS fpDocumentPropertySheets;
typedef LONG (WINAPI *COMMONPROPERTYSHEETUIW) (HWND,PFNPROPSHEETUI,LPARAM,LPDWORD);
static COMMONPROPERTYSHEETUIW fpCommonPropertySheetUIW;
typedef LONG (WINAPI *QUERYCOLORPROFILE) (HANDLE,PDEVMODEW,ULONG,PVOID,ULONG*,FLONG*);
static QUERYCOLORPROFILE fpQueryColorProfile;
typedef BOOL (WINAPI *SPOOLERPRINTEREVENT) (LPWSTR,int,DWORD,LPARAM);
static SPOOLERPRINTEREVENT fpPrinterEvent;
typedef BOOL (WINAPI *DEVQUERYPRINT) (HANDLE,LPDEVMODEW,DWORD*);
static DEVQUERYPRINT fpDevQueryPrint;
typedef BOOL (WINAPI *DEVQUERYPRINTEX) (PDEVQUERYPRINT_INFO);
static DEVQUERYPRINTEX fpDevQueryPrintEx;
//
// PrintUI.dll
//
LONG WINAPI ConstructPrinterFriendlyName( PWSTR, PVOID, LPDWORD Size );
typedef LONG (WINAPI *CONSTRUCTPRINTERFRIENDLYNAME) (PWSTR,PVOID,LPDWORD);
static CONSTRUCTPRINTERFRIENDLYNAME fpConstructPrinterFriendlyName;
//
// CompstUI User Data
//
typedef struct _COMPUI_USERDATA
{
HMODULE hModule;
LPWSTR pszPrinterName;
} COMPUI_USERDATA, *PCOMPUI_USERDATA;
// Local Constants
/** And the award for the most confusingly named setting goes to "Device", for storing the default printer of the current user.
Ok, I admit that this has historical reasons. It's still not straightforward in any way though! */
static const WCHAR wszWindowsKey[] = L"Software\\Microsoft\\Windows NT\\CurrentVersion\\Windows";
static const WCHAR wszDeviceValue[] = L"Device";
static DWORD
_StartDocPrinterSpooled(PSPOOLER_HANDLE pHandle, PDOC_INFO_1W pDocInfo1, PADDJOB_INFO_1W pAddJobInfo1)
{
DWORD cbNeeded;
DWORD dwErrorCode;
PJOB_INFO_1W pJobInfo1 = NULL;
// Create the spool file.
pHandle->hSPLFile = CreateFileW(pAddJobInfo1->Path, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, 0, NULL);
if (pHandle->hSPLFile == INVALID_HANDLE_VALUE)
{
dwErrorCode = GetLastError();
ERR("CreateFileW failed for \"%S\" with error %lu!\n", pAddJobInfo1->Path, dwErrorCode);
goto Cleanup;
}
// Get the size of the job information.
GetJobW((HANDLE)pHandle, pAddJobInfo1->JobId, 1, NULL, 0, &cbNeeded);
if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
{
dwErrorCode = GetLastError();
ERR("GetJobW failed with error %lu!\n", dwErrorCode);
goto Cleanup;
}
// Allocate enough memory for the returned job information.
pJobInfo1 = HeapAlloc(hProcessHeap, 0, cbNeeded);
if (!pJobInfo1)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
// Get the job information.
if (!GetJobW((HANDLE)pHandle, pAddJobInfo1->JobId, 1, (PBYTE)pJobInfo1, cbNeeded, &cbNeeded))
{
dwErrorCode = GetLastError();
ERR("GetJobW failed with error %lu!\n", dwErrorCode);
goto Cleanup;
}
// Add our document information.
if (pDocInfo1->pDatatype)
pJobInfo1->pDatatype = pDocInfo1->pDatatype;
pJobInfo1->pDocument = pDocInfo1->pDocName;
// Set the new job information.
if (!SetJobW((HANDLE)pHandle, pAddJobInfo1->JobId, 1, (PBYTE)pJobInfo1, 0))
{
dwErrorCode = GetLastError();
ERR("SetJobW failed with error %lu!\n", dwErrorCode);
goto Cleanup;
}
// We were successful!
pHandle->dwJobID = pAddJobInfo1->JobId;
dwErrorCode = ERROR_SUCCESS;
Cleanup:
if (pJobInfo1)
HeapFree(hProcessHeap, 0, pJobInfo1);
return dwErrorCode;
}
static DWORD
_StartDocPrinterWithRPC(PSPOOLER_HANDLE pHandle, PDOC_INFO_1W pDocInfo1)
{
DWORD dwErrorCode;
WINSPOOL_DOC_INFO_CONTAINER DocInfoContainer;
DocInfoContainer.Level = 1;
DocInfoContainer.DocInfo.pDocInfo1 = (WINSPOOL_DOC_INFO_1*)pDocInfo1;
RpcTryExcept
{
dwErrorCode = _RpcStartDocPrinter(pHandle->hPrinter, &DocInfoContainer, &pHandle->dwJobID);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
dwErrorCode = RpcExceptionCode();
ERR("_RpcStartDocPrinter failed with exception code %lu!\n", dwErrorCode);
}
RpcEndExcept;
return dwErrorCode;
}
BOOL WINAPI
AbortPrinter(HANDLE hPrinter)
{
DWORD dwErrorCode;
PSPOOLER_HANDLE pHandle = (PSPOOLER_HANDLE)hPrinter;
TRACE("AbortPrinter(%p)\n", hPrinter);
// Sanity checks.
if (!pHandle)
{
dwErrorCode = ERROR_INVALID_HANDLE;
goto Cleanup;
}
pHandle->bTrayIcon = pHandle->bStartedDoc = FALSE;
if ( pHandle->hSPLFile != INVALID_HANDLE_VALUE && pHandle->bJob )
{
// Close any open file handle.
CloseHandle( pHandle->hSPLFile );
pHandle->hSPLFile = INVALID_HANDLE_VALUE;
SetJobW( hPrinter, pHandle->dwJobID, 0, NULL, JOB_CONTROL_DELETE );
return ScheduleJob( hPrinter, pHandle->dwJobID );
}
// Do the RPC call.
RpcTryExcept
{
dwErrorCode = _RpcAbortPrinter(&pHandle->hPrinter);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
dwErrorCode = RpcExceptionCode();
ERR("_RpcAbortPrinter failed with exception code %lu!\n", dwErrorCode);
}
RpcEndExcept;
Cleanup:
SetLastError(dwErrorCode);
return (dwErrorCode == ERROR_SUCCESS);
}
HANDLE WINAPI
AddPrinterA(PSTR pName, DWORD Level, PBYTE pPrinter)
{
UNICODE_STRING pNameW, usBuffer;
PWSTR pwstrNameW;
PRINTER_INFO_2W *ppi2w = (PRINTER_INFO_2W*)pPrinter;
PRINTER_INFO_2A *ppi2a = (PRINTER_INFO_2A*)pPrinter;
HANDLE ret = NULL;
PWSTR pwszPrinterName = NULL;
PWSTR pwszServerName = NULL;
PWSTR pwszShareName = NULL;
PWSTR pwszPortName = NULL;
PWSTR pwszDriverName = NULL;
PWSTR pwszComment = NULL;
PWSTR pwszLocation = NULL;
PWSTR pwszSepFile = NULL;
PWSTR pwszPrintProcessor = NULL;
PWSTR pwszDatatype = NULL;
PWSTR pwszParameters = NULL;
PDEVMODEW pdmw = NULL;
TRACE("AddPrinterA(%s, %d, %p)\n", debugstr_a(pName), Level, pPrinter);
if(Level != 2)
{
ERR("Level = %d, unsupported!\n", Level);
SetLastError(ERROR_INVALID_LEVEL);
return NULL;
}
pwstrNameW = AsciiToUnicode(&pNameW,pName);
if (ppi2a->pShareName)
{
pwszShareName = AsciiToUnicode(&usBuffer, ppi2a->pShareName);
if (!(ppi2w->pShareName = pwszShareName)) goto Cleanup;
}
if (ppi2a->pPortName)
{
pwszPortName = AsciiToUnicode(&usBuffer, ppi2a->pPortName);
if (!(ppi2w->pPortName = pwszPortName)) goto Cleanup;
}
if (ppi2a->pDriverName)
{
pwszDriverName = AsciiToUnicode(&usBuffer, ppi2a->pDriverName);
if (!(ppi2w->pDriverName = pwszDriverName)) goto Cleanup;
}
if (ppi2a->pComment)
{
pwszComment = AsciiToUnicode(&usBuffer, ppi2a->pComment);
if (!(ppi2w->pComment = pwszComment)) goto Cleanup;
}
if (ppi2a->pLocation)
{
pwszLocation = AsciiToUnicode(&usBuffer, ppi2a->pLocation);
if (!(ppi2w->pLocation = pwszLocation)) goto Cleanup;
}
if (ppi2a->pSepFile)
{
pwszSepFile = AsciiToUnicode(&usBuffer, ppi2a->pSepFile);
if (!(ppi2w->pSepFile = pwszSepFile)) goto Cleanup;
}
if (ppi2a->pServerName)
{
pwszPrintProcessor = AsciiToUnicode(&usBuffer, ppi2a->pPrintProcessor);
if (!(ppi2w->pPrintProcessor = pwszPrintProcessor)) goto Cleanup;
}
if (ppi2a->pDatatype)
{
pwszDatatype = AsciiToUnicode(&usBuffer, ppi2a->pDatatype);
if (!(ppi2w->pDatatype = pwszDatatype)) goto Cleanup;
}
if (ppi2a->pParameters)
{
pwszParameters = AsciiToUnicode(&usBuffer, ppi2a->pParameters);
if (!(ppi2w->pParameters = pwszParameters)) goto Cleanup;
}
if ( ppi2a->pDevMode )
{
RosConvertAnsiDevModeToUnicodeDevmode( ppi2a->pDevMode, &pdmw );
ppi2w->pDevMode = pdmw;
}
if (ppi2a->pServerName)
{
pwszServerName = AsciiToUnicode(&usBuffer, ppi2a->pServerName);
if (!(ppi2w->pPrinterName = pwszServerName)) goto Cleanup;
}
if (ppi2a->pPrinterName)
{
pwszPrinterName = AsciiToUnicode(&usBuffer, ppi2a->pPrinterName);
if (!(ppi2w->pPrinterName = pwszPrinterName)) goto Cleanup;
}
ret = AddPrinterW(pwstrNameW, Level, (LPBYTE)ppi2w);
Cleanup:
if (pdmw) HeapFree(hProcessHeap, 0, pdmw);
if (pwszPrinterName) HeapFree(hProcessHeap, 0, pwszPrinterName);
if (pwszServerName) HeapFree(hProcessHeap, 0, pwszServerName);
if (pwszShareName) HeapFree(hProcessHeap, 0, pwszShareName);
if (pwszPortName) HeapFree(hProcessHeap, 0, pwszPortName);
if (pwszDriverName) HeapFree(hProcessHeap, 0, pwszDriverName);
if (pwszComment) HeapFree(hProcessHeap, 0, pwszComment);
if (pwszLocation) HeapFree(hProcessHeap, 0, pwszLocation);
if (pwszSepFile) HeapFree(hProcessHeap, 0, pwszSepFile);
if (pwszPrintProcessor) HeapFree(hProcessHeap, 0, pwszPrintProcessor);
if (pwszDatatype) HeapFree(hProcessHeap, 0, pwszDatatype);
if (pwszParameters) HeapFree(hProcessHeap, 0, pwszParameters);
RtlFreeUnicodeString(&pNameW);
return ret;
}
HANDLE WINAPI
AddPrinterW(PWSTR pName, DWORD Level, PBYTE pPrinter)
{
DWORD dwErrorCode;
WINSPOOL_PRINTER_CONTAINER PrinterContainer;
WINSPOOL_DEVMODE_CONTAINER DevModeContainer;
WINSPOOL_SECURITY_CONTAINER SecurityContainer;
SECURITY_DESCRIPTOR *sd = NULL;
DWORD size;
HANDLE hPrinter = NULL, hHandle = NULL;
PSPOOLER_HANDLE pHandle = NULL;
TRACE("AddPrinterW(%S, %lu, %p)\n", pName, Level, pPrinter);
DevModeContainer.cbBuf = 0;
DevModeContainer.pDevMode = NULL;
SecurityContainer.cbBuf = 0;
SecurityContainer.pSecurity = NULL;
if ( Level != 2 )
{
FIXME( "Unsupported level %d\n", Level );
SetLastError( ERROR_INVALID_LEVEL );
return hHandle;
}
else
{
PPRINTER_INFO_2W pi2w = (PPRINTER_INFO_2W)pPrinter;
if ( pi2w )
{
if ( pi2w->pDevMode )
{
if ( IsValidDevmodeNoSizeW( pi2w->pDevMode ) )
{
DevModeContainer.cbBuf = pi2w->pDevMode->dmSize + pi2w->pDevMode->dmDriverExtra;
DevModeContainer.pDevMode = (PBYTE)pi2w->pDevMode;
}
}
if ( pi2w->pSecurityDescriptor )
{
sd = get_sd( pi2w->pSecurityDescriptor, &size );
if ( sd )
{
SecurityContainer.cbBuf = size;
SecurityContainer.pSecurity = (PBYTE)sd;
}
}
}
else
{
SetLastError(ERROR_INVALID_PARAMETER);
return hHandle;
}
}
PrinterContainer.PrinterInfo.pPrinterInfo1 = (WINSPOOL_PRINTER_INFO_1*)pPrinter;
PrinterContainer.Level = Level;
// Do the RPC call
RpcTryExcept
{
dwErrorCode = _RpcAddPrinter( pName, &PrinterContainer, &DevModeContainer, &SecurityContainer, &hPrinter );
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
dwErrorCode = RpcExceptionCode();
}
RpcEndExcept;
if (hPrinter)
{
// Create a new SPOOLER_HANDLE structure.
pHandle = HeapAlloc(hProcessHeap, HEAP_ZERO_MEMORY, sizeof(SPOOLER_HANDLE));
if (!pHandle)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
_RpcDeletePrinter(hPrinter);
_RpcClosePrinter(hPrinter);
goto Cleanup;
}
pHandle->Sig = SPOOLER_HANDLE_SIG;
pHandle->hPrinter = hPrinter;
pHandle->hSPLFile = INVALID_HANDLE_VALUE;
pHandle->hSpoolFileHandle = INVALID_HANDLE_VALUE;
hHandle = (HANDLE)pHandle;
}
Cleanup:
if ( sd ) HeapFree( GetProcessHeap(), 0, sd );
SetLastError(dwErrorCode);
return hHandle;
}
BOOL WINAPI
ClosePrinter(HANDLE hPrinter)
{
DWORD dwErrorCode;
PSPOOLER_HANDLE pHandle = (PSPOOLER_HANDLE)hPrinter;
TRACE("ClosePrinter(%p)\n", hPrinter);
// Sanity checks.
if ( IntProtectHandle( hPrinter, TRUE ) )
{
dwErrorCode = ERROR_INVALID_HANDLE;
goto Cleanup;
}
// Do the RPC call.
RpcTryExcept
{
dwErrorCode = _RpcClosePrinter(&pHandle->hPrinter);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
dwErrorCode = RpcExceptionCode();
ERR("_RpcClosePrinter failed with exception code %lu!\n", dwErrorCode);
}
RpcEndExcept;
// Close any open file handle.
if (pHandle->hSPLFile != INVALID_HANDLE_VALUE)
CloseHandle(pHandle->hSPLFile);
pHandle->Sig = -1;
// Free the memory for the handle.
HeapFree(hProcessHeap, 0, pHandle);
Cleanup:
SetLastError(dwErrorCode);
return (dwErrorCode == ERROR_SUCCESS);
}
BOOL WINAPI
DeletePrinter(HANDLE hPrinter)
{
DWORD dwErrorCode;
PSPOOLER_HANDLE pHandle = (PSPOOLER_HANDLE)hPrinter;
TRACE("DeletePrinter(%p)\n", hPrinter);
// Sanity checks.
if (!pHandle)
{
dwErrorCode = ERROR_INVALID_HANDLE;
goto Cleanup;
}
// Do the RPC call.
RpcTryExcept
{
dwErrorCode = _RpcDeletePrinter(&pHandle->hPrinter);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
dwErrorCode = RpcExceptionCode();
ERR("_RpcDeletePrinter failed with exception code %lu!\n", dwErrorCode);
}
RpcEndExcept;
Cleanup:
SetLastError(dwErrorCode);
return (dwErrorCode == ERROR_SUCCESS);
}
//
// Based on GDI32:printdrv.c:IntGetPrinterDriver.
//
HMODULE
WINAPI
LoadPrinterDriver( HANDLE hspool )
{
INT iTries = 0;
DWORD Size = (sizeof(WCHAR) * MAX_PATH) * 2; // DRIVER_INFO_5W + plus strings.
PDRIVER_INFO_5W pdi = NULL;
HMODULE hLibrary = NULL;
do
{
++iTries;
pdi = RtlAllocateHeap( GetProcessHeap(), 0, Size);
if ( !pdi )
break;
if ( GetPrinterDriverW(hspool, NULL, 5, (LPBYTE)pdi, Size, &Size) )
{
TRACE("Level 5 Size %d\n",Size);
// Name and load configure library (for example, C:\DRIVERS\Pscrptui.dll). Not printui.dll!
hLibrary = LoadLibrary(pdi->pConfigFile);
FIXME("IGPD : Get Printer Driver Config File : %S\n",pdi->pConfigFile);
RtlFreeHeap( GetProcessHeap(), 0, pdi);
return hLibrary;
}
if ( GetLastError() != ERROR_INSUFFICIENT_BUFFER )
++iTries;
RtlFreeHeap( GetProcessHeap(), 0, pdi);
}
while ( iTries < 2 );
ERR("No Printer Driver Error %d\n",GetLastError());
return NULL;
}
DWORD WINAPI
DeviceCapabilitiesA(LPCSTR pDevice, LPCSTR pPort, WORD fwCapability, LPSTR pOutput, const DEVMODEA* pDevMode)
{
PWSTR pwszDeviceName = NULL;
PDEVMODEW pdmwInput = NULL;
BOOL bReturnValue = GDI_ERROR;
DWORD cch;
FIXME("DeviceCapabilitiesA(%s, %s, %hu, %p, %p)\n", pDevice, pPort, fwCapability, pOutput, pDevMode);
if (pDevice)
{
// Convert pName to a Unicode string pwszDeviceName.
cch = strlen(pDevice);
pwszDeviceName = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(WCHAR));
if (!pwszDeviceName)
{
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
MultiByteToWideChar(CP_ACP, 0, pDevice, -1, pwszDeviceName, cch + 1);
}
if (pDevMode)
{
RosConvertAnsiDevModeToUnicodeDevmode((PDEVMODEA)pDevMode, &pdmwInput);
}
// pPort is ignored so no need to pass it.
bReturnValue = DeviceCapabilitiesW( pwszDeviceName, NULL, fwCapability, (LPWSTR)pOutput, (const DEVMODEW*) pdmwInput );
Cleanup:
if(pwszDeviceName)
HeapFree(hProcessHeap, 0, pwszDeviceName);
if (pdmwInput)
HeapFree(hProcessHeap, 0, pdmwInput);
return bReturnValue;
}
DWORD WINAPI
DeviceCapabilitiesW(LPCWSTR pDevice, LPCWSTR pPort, WORD fwCapability, LPWSTR pOutput, const DEVMODEW* pDevMode)
{
HANDLE hPrinter;
HMODULE hLibrary;
DWORD iDevCap = GDI_ERROR;
FIXME("DeviceCapabilitiesW(%S, %S, %hu, %p, %p)\n", pDevice, pPort, fwCapability, pOutput, pDevMode);
if ( pDevMode )
{
if (!IsValidDevmodeNoSizeW( (PDEVMODEW)pDevMode ) )
{
ERR("DeviceCapabilitiesW : Devode Invalid\n");
return -1;
}
}
if ( OpenPrinterW( (LPWSTR)pDevice, &hPrinter, NULL ) )
{
hLibrary = LoadPrinterDriver( hPrinter );
if ( hLibrary )
{
fpDeviceCapabilities = (PVOID)GetProcAddress( hLibrary, "DrvDeviceCapabilities" );
if ( fpDeviceCapabilities )
{
iDevCap = fpDeviceCapabilities( hPrinter, (PWSTR)pDevice, fwCapability, pOutput, (PDEVMODE)pDevMode );
}
FreeLibrary(hLibrary);
}
ClosePrinter( hPrinter );
}
return iDevCap;
}
BOOL
WINAPI
DevQueryPrint( HANDLE hPrinter, LPDEVMODEW pDevMode, DWORD *pResID)
{
HMODULE hLibrary;
BOOL Ret = FALSE;
hLibrary = LoadPrinterDriver( hPrinter );
if ( hLibrary )
{
fpDevQueryPrint = (PVOID)GetProcAddress( hLibrary, "DevQueryPrint" );
if ( fpDevQueryPrint )
{
Ret = fpDevQueryPrint( hPrinter, pDevMode, pResID );
}
FreeLibrary(hLibrary);
}
return Ret;
}
BOOL WINAPI
DevQueryPrintEx( PDEVQUERYPRINT_INFO pDQPInfo )
{
HMODULE hLibrary;
BOOL Ret = FALSE;
hLibrary = LoadPrinterDriver( pDQPInfo->hPrinter );
if ( hLibrary )
{
fpDevQueryPrintEx = (PVOID)GetProcAddress( hLibrary, "DevQueryPrintEx" );
if ( fpDevQueryPrintEx )
{
Ret = fpDevQueryPrintEx( pDQPInfo );
}
FreeLibrary(hLibrary);
}
return Ret;
}
INT WINAPI
DocumentEvent( HANDLE hPrinter, HDC hdc, int iEsc, ULONG cbIn, PVOID pvIn, ULONG cbOut, PVOID pvOut)
{
FIXME("DocumentEvent(%p, %p, %lu, %lu, %p, %lu, %p)\n", hPrinter, hdc, iEsc, cbIn, pvIn, cbOut, pvOut);
UNIMPLEMENTED;
return DOCUMENTEVENT_UNSUPPORTED;
}
LONG WINAPI
DocumentPropertiesA(HWND hWnd, HANDLE hPrinter, LPSTR pDeviceName, PDEVMODEA pDevModeOutput, PDEVMODEA pDevModeInput, DWORD fMode)
{
PWSTR pwszDeviceName = NULL;
PDEVMODEW pdmwInput = NULL;
PDEVMODEW pdmwOutput = NULL;
LONG lReturnValue = -1;
DWORD cch;
FIXME("DocumentPropertiesA(%p, %p, %s, %p, %p, %lu)\n", hWnd, hPrinter, pDeviceName, pDevModeOutput, pDevModeInput, fMode);
if (pDeviceName)
{
// Convert pName to a Unicode string pwszDeviceName.
cch = strlen(pDeviceName);
pwszDeviceName = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(WCHAR));
if (!pwszDeviceName)
{
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
MultiByteToWideChar(CP_ACP, 0, pDeviceName, -1, pwszDeviceName, cch + 1);
}
if (pDevModeInput)
{
// Create working buffer for input to DocumentPropertiesW.
RosConvertAnsiDevModeToUnicodeDevmode(pDevModeInput, &pdmwInput);
}
if (pDevModeOutput)
{
// Create working buffer for output from DocumentPropertiesW.
// Do it RIGHT! Get the F...ing Size!
LONG Size = DocumentPropertiesW( hWnd, hPrinter, pwszDeviceName, NULL, NULL, 0 );
if ( Size < 0 )
{
goto Cleanup;
}
pdmwOutput = HeapAlloc(hProcessHeap, 0, Size);
if (!pdmwOutput)
{
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
}
lReturnValue = DocumentPropertiesW(hWnd, hPrinter, pwszDeviceName, pdmwOutput, pdmwInput, fMode);
FIXME("lReturnValue from DocumentPropertiesW is '%ld'.\n", lReturnValue);
if (lReturnValue < 0)
{
FIXME("DocumentPropertiesW failed!\n");
goto Cleanup;
}
if (pdmwOutput)
{
RosConvertUnicodeDevModeToAnsiDevmode(pdmwOutput, pDevModeOutput);
}
Cleanup:
if(pwszDeviceName)
HeapFree(hProcessHeap, 0, pwszDeviceName);
if (pdmwInput)
HeapFree(hProcessHeap, 0, pdmwInput);
if (pdmwOutput)
HeapFree(hProcessHeap, 0, pdmwOutput);
return lReturnValue;
}
PRINTER_INFO_9W * get_devmodeW(HANDLE hprn)
{
PRINTER_INFO_9W *pi9 = NULL;
DWORD needed = 0;
BOOL res;
res = GetPrinterW(hprn, 9, NULL, 0, &needed);
if (!res && (GetLastError() == ERROR_INSUFFICIENT_BUFFER))
{
pi9 = HeapAlloc(hProcessHeap, 0, needed);
if (!pi9)
{
ERR("Failed to allocate PRINTER_INFO_9W of %u bytes\n", needed);
return NULL;
}
res = GetPrinterW(hprn, 9, (LPBYTE)pi9, needed, &needed);
}
if (res)
return pi9;
ERR("GetPrinterW failed with %u\n", GetLastError());
HeapFree(hProcessHeap, 0, pi9);
return NULL;
}
BOOL
FASTCALL
CreateUIUserData( ULONG_PTR *puserdata, HANDLE hPrinter )
{
PCOMPUI_USERDATA pcui_ud = DllAllocSplMem( sizeof(COMPUI_USERDATA) );
*puserdata = (ULONG_PTR)pcui_ud;
FIXME("CreateUIUserData\n");
if ( pcui_ud )
{
pcui_ud->hModule = LoadPrinterDriver( hPrinter );
if ( !pcui_ud->hModule )
{
DllFreeSplMem( pcui_ud );
*puserdata = 0;
}
}
return *puserdata != 0;
}
VOID
FASTCALL
DestroyUIUserData( ULONG_PTR *puserdata )
{
PCOMPUI_USERDATA pcui_ud = (PCOMPUI_USERDATA)*puserdata;
FIXME("DestroyUIUserData\n");
if ( pcui_ud )
{
if ( pcui_ud->hModule )
{
FreeLibrary( pcui_ud->hModule );
pcui_ud->hModule = NULL;
}
if ( pcui_ud->pszPrinterName )
{
DllFreeSplMem( pcui_ud->pszPrinterName );
pcui_ud->pszPrinterName = NULL;
}
DllFreeSplMem( pcui_ud );
*puserdata = 0;
}
}
BOOL
FASTCALL
IntFixUpDevModeNames( PDOCUMENTPROPERTYHEADER pdphdr )
{
PRINTER_INFO_2W *pi2 = NULL;
DWORD needed = 0;
BOOL res;
if (!(pdphdr->fMode & DM_OUT_BUFFER) ||
pdphdr->fMode & DM_NOPERMISSION || // Do not allow the user to modify properties on the displayed property sheet pages.
!pdphdr->pdmOut )
{
return FALSE;
}
res = GetPrinterW( pdphdr->hPrinter, 2, NULL, 0, &needed);
if (!res && (GetLastError() == ERROR_INSUFFICIENT_BUFFER))
{
pi2 = HeapAlloc(hProcessHeap, 0, needed);
if (!pi2)
{
ERR("Failed to allocate PRINTER_INFO_2W of %u bytes\n", needed);
return FALSE;
}
res = GetPrinterW( pdphdr->hPrinter, 2, (LPBYTE)pi2, needed, &needed);
}
if (res)
{
/* Check if the provided buffer is large enough */
DWORD cbDevMode = pi2->pDevMode->dmSize + pi2->pDevMode->dmDriverExtra;
if (pdphdr->cbOut < cbDevMode)
{
ERR("cbOut (%lu) < cbDevMode(%u)\n", pdphdr->cbOut, cbDevMode);
res = FALSE;
goto Exit;
}
/* Copy the devmode */
RtlCopyMemory(pdphdr->pdmOut, pi2->pDevMode, cbDevMode);
TRACE("IFUDMN : Get Printer Name %S\n", pi2->pPrinterName);
StringCchCopyW( pdphdr->pdmOut->dmDeviceName, CCHDEVICENAME-1, pi2->pPrinterName );
pdphdr->pdmOut->dmDeviceName[CCHDEVICENAME-1] = 0;
}
else
{
ERR("IFUDMN : GetPrinterW failed with %u\n", GetLastError());
}
Exit:
HeapFree(hProcessHeap, 0, pi2);
return res;
}
LONG
WINAPI
CreatePrinterFriendlyName( PCOMPUI_USERDATA pcui_ud, LPWSTR pszPrinterName )
{
LONG Result = 0;
DWORD Size = 0;
HMODULE hLibrary = NULL;
hLibrary = LoadLibraryA( "printui.dll" );
if ( hLibrary )
{
fpConstructPrinterFriendlyName = (PVOID)GetProcAddress( hLibrary, "ConstructPrinterFriendlyName" );
if ( fpConstructPrinterFriendlyName )
{
if ( !fpConstructPrinterFriendlyName( pszPrinterName, NULL, &Size ) )
{
if ( GetLastError() == ERROR_INSUFFICIENT_BUFFER )
{
PWSTR pwstr = DllAllocSplMem( (Size + 1) * sizeof(WCHAR) );
pcui_ud->pszPrinterName = pwstr;
if ( pwstr )
Result = fpConstructPrinterFriendlyName( pszPrinterName, pwstr, &Size );
}
}
}
FreeLibrary( hLibrary );
}
if ( !Result )
{
DllFreeSplMem( pcui_ud->pszPrinterName );
pcui_ud->pszPrinterName = AllocSplStr( pszPrinterName );
}
return Result;
}
//
// Tested with XP CompstUI as a callback and works. Fails perfectly.
//
LONG
WINAPI
DocumentPropertySheets( PPROPSHEETUI_INFO pCPSUIInfo, LPARAM lparam )
{
LONG Result = -1;
PDOCUMENTPROPERTYHEADER pdphdr;
FIXME("DocumentPropertySheets(%p, 0x%lx)\n", pCPSUIInfo, lparam);
// If pPSUIInfo is NULL, and if either lParam -> fMode is zero or lParam -> pdmOut is NULL,
// this function should return the size, in bytes, of the printer's DEVMODEW structure.
if ( !pCPSUIInfo && lparam )
{
pdphdr = (PDOCUMENTPROPERTYHEADER)lparam;
if ( pdphdr->cbSize >= sizeof(PDOCUMENTPROPERTYHEADER) &&
!(pdphdr->fMode & DM_PROMPT) )
{
HMODULE hLibrary = LoadPrinterDriver( pdphdr->hPrinter );
if ( hLibrary )
{
fpDocumentPropertySheets = (PVOID)GetProcAddress( hLibrary, "DrvDocumentPropertySheets" );
if ( fpDocumentPropertySheets )
{
FIXME("DPS : fpDocumentPropertySheets(%p, 0x%lx) pdmOut %p\n", pCPSUIInfo, lparam, pdphdr->pdmOut);
Result = fpDocumentPropertySheets( pCPSUIInfo, lparam );
FIXME("DPS : fpDocumentPropertySheets result %d cbOut %d\n",Result, pdphdr->cbOut);
}
else
{
//
// ReactOS backup!!! Currently no supporting UI driver.
//
PRINTER_INFO_9W * pi9 = get_devmodeW( pdphdr->hPrinter );
if ( pi9 )
{
Result = pi9->pDevMode->dmSize + pi9->pDevMode->dmDriverExtra;
FIXME("IDPS : Using ReactOS backup!!! DevMode Size %d\n",Result);
HeapFree(hProcessHeap, 0, pi9);
}
}
FreeLibrary(hLibrary);
if ( Result > 0 )
{
IntFixUpDevModeNames( pdphdr );
}
return Result;
}
else
{
SetLastError(ERROR_INVALID_HANDLE);
}
}
else
{
SetLastError(ERROR_INVALID_PARAMETER);
}
return Result;
}
Result = 0;
if ( pCPSUIInfo )
{
PSETRESULT_INFO psri;
PPROPSHEETUI_INFO_HEADER ppsuiihdr;
PCOMPUI_USERDATA pcui_ud;
pdphdr = (PDOCUMENTPROPERTYHEADER)pCPSUIInfo->lParamInit;
if ( pdphdr->cbSize < sizeof(PDOCUMENTPROPERTYHEADER) )
{
SetLastError(ERROR_INVALID_PARAMETER);
return Result;
}
switch ( pCPSUIInfo->Reason )
{
case PROPSHEETUI_REASON_INIT:
{
FIXME("DocPS : PROPSHEETUI_REASON_INIT\n");
if ( CreateUIUserData( &pCPSUIInfo->UserData, pdphdr->hPrinter ) )
{
pcui_ud = (PCOMPUI_USERDATA)pCPSUIInfo->UserData;
fpDocumentPropertySheets = (PVOID)GetProcAddress( pcui_ud->hModule, "DrvDocumentPropertySheets" );
if ( fpDocumentPropertySheets )
{
pCPSUIInfo->pfnComPropSheet( pCPSUIInfo->hComPropSheet,
CPSFUNC_SET_FUSION_CONTEXT,
-3, // What type of handle is this?
0 ); // Not used, must be zero.
Result = pCPSUIInfo->pfnComPropSheet( pCPSUIInfo->hComPropSheet,
CPSFUNC_ADD_PFNPROPSHEETUIW,
(LPARAM)fpDocumentPropertySheets,
pCPSUIInfo->lParamInit );
break;
}
FIXME("DocPS : PROPSHEETUI_REASON_INIT Fail\n");
DestroyUIUserData( &pCPSUIInfo->UserData );
}
}
break;
case PROPSHEETUI_REASON_GET_INFO_HEADER:
FIXME("DocPS : PROPSHEETUI_REASON_GET_INFO_HEADER\n");
ppsuiihdr = (PPROPSHEETUI_INFO_HEADER)lparam;
pcui_ud = (PCOMPUI_USERDATA)pCPSUIInfo->UserData;
CreatePrinterFriendlyName( pcui_ud, pdphdr->pszPrinterName );
ppsuiihdr->Flags = PSUIHDRF_NOAPPLYNOW|PSUIHDRF_PROPTITLE;
ppsuiihdr->pTitle = pcui_ud->pszPrinterName;
ppsuiihdr->hInst = hinstWinSpool;
ppsuiihdr->IconID = IDI_CPSUI_DOCUMENT;
Result = CPSUI_OK;
break;
case PROPSHEETUI_REASON_DESTROY:
FIXME("DocPS : PROPSHEETUI_REASON_DESTROY\n");
DestroyUIUserData( &pCPSUIInfo->UserData );
Result = CPSUI_OK;
break;
case PROPSHEETUI_REASON_SET_RESULT:
FIXME("DocPS : PROPSHEETUI_REASON_SET_RESULT\n");
psri = (PSETRESULT_INFO)lparam;
pCPSUIInfo->Result = psri->Result;
if ( pCPSUIInfo->Result > 0 )
{
IntFixUpDevModeNames( pdphdr );
}
Result = CPSUI_OK;
break;
}
}
return Result;
}
LONG
WINAPI
DevicePropertySheets( PPROPSHEETUI_INFO pCPSUIInfo, LPARAM lparam )
{
LONG Result = 0;
PDEVICEPROPERTYHEADER pdphdr;
FIXME("DevicePropertySheets(%p, 0x%lx)\n", pCPSUIInfo, lparam);
if ( pCPSUIInfo )
{
PSETRESULT_INFO psri;
PPROPSHEETUI_INFO_HEADER ppsuiihdr;
PCOMPUI_USERDATA pcui_ud;
pdphdr = (PDEVICEPROPERTYHEADER)pCPSUIInfo->lParamInit;
if ( pdphdr->cbSize < sizeof(DEVICEPROPERTYHEADER) )
{
SetLastError(ERROR_INVALID_PARAMETER);
return Result;
}
switch ( pCPSUIInfo->Reason )
{
case PROPSHEETUI_REASON_INIT:
{
FIXME("DevPS : PROPSHEETUI_REASON_INIT\n");
if ( CreateUIUserData( &pCPSUIInfo->UserData, pdphdr->hPrinter ) )
{
pcui_ud = (PCOMPUI_USERDATA)pCPSUIInfo->UserData;
fpDevicePropertySheets = (PVOID)GetProcAddress( pcui_ud->hModule, "DrvDevicePropertySheets" );
if ( fpDevicePropertySheets )
{
pCPSUIInfo->pfnComPropSheet( pCPSUIInfo->hComPropSheet,
CPSFUNC_SET_FUSION_CONTEXT,
-3, // What type of handle is this?
0 ); // Not used, must be zero.
Result = pCPSUIInfo->pfnComPropSheet( pCPSUIInfo->hComPropSheet,
CPSFUNC_ADD_PFNPROPSHEETUIW,
(LPARAM)fpDevicePropertySheets,
pCPSUIInfo->lParamInit );
break;
}
FIXME("DevPS : PROPSHEETUI_REASON_INIT Fail\n");
DestroyUIUserData( &pCPSUIInfo->UserData );
}
}
break;
case PROPSHEETUI_REASON_GET_INFO_HEADER:
FIXME("DevPS : PROPSHEETUI_REASON_GET_INFO_HEADER\n");
ppsuiihdr = (PPROPSHEETUI_INFO_HEADER)lparam;
pcui_ud = (PCOMPUI_USERDATA)pCPSUIInfo->UserData;
CreatePrinterFriendlyName( pcui_ud, pdphdr->pszPrinterName );
ppsuiihdr->Flags = PSUIHDRF_NOAPPLYNOW|PSUIHDRF_PROPTITLE;
ppsuiihdr->pTitle = pcui_ud->pszPrinterName;
ppsuiihdr->hInst = hinstWinSpool;
ppsuiihdr->IconID = IDI_CPSUI_DOCUMENT;
Result = CPSUI_OK;
break;
case PROPSHEETUI_REASON_DESTROY:
FIXME("DevPS : PROPSHEETUI_REASON_DESTROY\n");
DestroyUIUserData( &pCPSUIInfo->UserData );
Result = CPSUI_OK;
break;
case PROPSHEETUI_REASON_SET_RESULT:
FIXME("DevPS : PROPSHEETUI_REASON_SET_RESULT\n");
psri = (PSETRESULT_INFO)lparam;
pCPSUIInfo->Result = psri->Result;
Result = CPSUI_OK;
break;
}
}
return Result;
}
LONG
WINAPI
CallCommonPropertySheetUI(HWND hWnd, PFNPROPSHEETUI pfnPropSheetUI, LPARAM lparam, LPDWORD pResult)
{
HMODULE hLibrary = NULL;
LONG Ret = ERR_CPSUI_GETLASTERROR;
FIXME("CallCommonPropertySheetUI(%p, %p, 0x%lx, %p)\n", hWnd, pfnPropSheetUI, lparam, pResult);
if ( ( hLibrary = LoadLibraryA( "compstui.dll" ) ) )
{
fpCommonPropertySheetUIW = (PVOID) GetProcAddress(hLibrary, "CommonPropertySheetUIW");
if ( fpCommonPropertySheetUIW )
{
Ret = fpCommonPropertySheetUIW( hWnd, pfnPropSheetUI, lparam, pResult );
}
FreeLibrary(hLibrary);
}
return Ret;
}
LONG WINAPI
DocumentPropertiesW(HWND hWnd, HANDLE hPrinter, LPWSTR pDeviceName, PDEVMODEW pDevModeOutput, PDEVMODEW pDevModeInput, DWORD fMode)
{
HANDLE hUseHandle = NULL;
DOCUMENTPROPERTYHEADER docprophdr;
LONG Result = IDOK;
FIXME("DocumentPropertiesW(%p, %p, %S, %p, %p, %lu)\n", hWnd, hPrinter, pDeviceName, pDevModeOutput, pDevModeInput, fMode);
if (hPrinter)
{
hUseHandle = hPrinter;
}
else if (!OpenPrinterW(pDeviceName, &hUseHandle, NULL))
{
ERR("No handle, and no usable printer name passed in\n");
return -1;
}
if ( !(fMode & DM_IN_BUFFER ) ||
( ( pDevModeInput && !IsValidDevmodeNoSizeW( (PDEVMODEW)pDevModeInput ) ) ) )
{
pDevModeInput = NULL;
fMode &= ~DM_IN_BUFFER;
}
docprophdr.cbSize = sizeof(DOCUMENTPROPERTYHEADER);
docprophdr.Reserved = 0;
docprophdr.hPrinter = hUseHandle;
docprophdr.pszPrinterName = pDeviceName;
docprophdr.cbOut = 0;
if ( pDevModeOutput )
{
docprophdr.pdmIn = NULL;
docprophdr.pdmOut = NULL;
docprophdr.fMode = 0;
FIXME("DPW : Call DocumentPropertySheets with pDevModeOutput %p\n",pDevModeOutput);
docprophdr.cbOut = DocumentPropertySheets( NULL, (LPARAM)&docprophdr );
}
docprophdr.pdmIn = pDevModeInput;
docprophdr.pdmOut = pDevModeOutput;
docprophdr.fMode = fMode;
if ( fMode & DM_IN_PROMPT )
{
Result = CPSUI_CANCEL;
//
// Now call the Property Sheet for Print > Properties.
//
if ( CallCommonPropertySheetUI( hWnd, (PFNPROPSHEETUI)DocumentPropertySheets, (LPARAM)&docprophdr, (LPDWORD)&Result ) < 0 )
{
FIXME("CallCommonPropertySheetUI return error\n");
Result = ERR_CPSUI_GETLASTERROR;
}
else
Result = (Result == CPSUI_OK) ? IDOK : IDCANCEL;
FIXME("CallCommonPropertySheetUI returned\n");
}
else
{
FIXME("DPW : CallDocumentPropertySheets\n");
Result = DocumentPropertySheets( NULL, (LPARAM)&docprophdr );
}
if ( Result != ERR_CPSUI_GETLASTERROR || Result != ERR_CPSUI_ALLOCMEM_FAILED )
{
if ( pDevModeOutput )
{
if ( !IsValidDevmodeNoSizeW( pDevModeOutput ) )
{
ERR("DPW : Improper pDevModeOutput size.\n");
Result = -1;
}
}
else
{
ERR("No pDevModeOutput\n");
}
}
if (hUseHandle && !hPrinter)
ClosePrinter(hUseHandle);
return Result;
}
BOOL
WINAPI
PrinterProperties( HWND hWnd, HANDLE hPrinter )
{
PRINTER_INFO_2W *pi2 = NULL;
DWORD needed = 0;
LONG Ret, Result = 0;
BOOL res;
DEVICEPROPERTYHEADER devprophdr;
FIXME("PrinterProperties(%p, %p)\n", hWnd, hPrinter);
devprophdr.cbSize = sizeof(DEVICEPROPERTYHEADER);
devprophdr.Flags = DPS_NOPERMISSION;
devprophdr.hPrinter = hPrinter;
devprophdr.pszPrinterName = NULL;
res = GetPrinterW( hPrinter, 2, NULL, 0, &needed);
if (!res && (GetLastError() == ERROR_INSUFFICIENT_BUFFER))
{
pi2 = HeapAlloc(hProcessHeap, 0, needed);
if (!pi2)
{
ERR("Failed to allocate PRINTER_INFO_2W of %u bytes\n", needed);
return FALSE;
}
res = GetPrinterW(hPrinter, 2, (LPBYTE)pi2, needed, &needed);
}
//
// Above can fail, still process w/o printer name.
//
if ( res ) devprophdr.pszPrinterName = pi2->pPrinterName;
needed = 1;
if ( ( SetPrinterDataW( hPrinter, L"PrinterPropertiesPermission", REG_DWORD, (LPBYTE)&needed, sizeof(DWORD) ) == ERROR_SUCCESS ) )
{
devprophdr.Flags &= ~DPS_NOPERMISSION;
}
Ret = CallCommonPropertySheetUI( hWnd, (PFNPROPSHEETUI)DevicePropertySheets, (LPARAM)&devprophdr, (LPDWORD)&Result );
res = (Ret >= 0);
if (!res)
{
FIXME("PrinterProperties fail ICPSUI\n");
}
if (pi2) HeapFree(hProcessHeap, 0, pi2);
return res;
}
BOOL WINAPI
EndDocPrinter(HANDLE hPrinter)
{
DWORD dwErrorCode;
PSPOOLER_HANDLE pHandle = (PSPOOLER_HANDLE)hPrinter;
TRACE("EndDocPrinter(%p)\n", hPrinter);
// Sanity checks.
if (!pHandle)
{
dwErrorCode = ERROR_INVALID_HANDLE;
goto Cleanup;
}
if (pHandle->hSPLFile != INVALID_HANDLE_VALUE)
{
// For spooled jobs, the document is finished by calling _RpcScheduleJob.
RpcTryExcept
{
dwErrorCode = _RpcScheduleJob(pHandle->hPrinter, pHandle->dwJobID);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
dwErrorCode = RpcExceptionCode();
ERR("_RpcScheduleJob failed with exception code %lu!\n", dwErrorCode);
}
RpcEndExcept;
// Close the spool file handle.
CloseHandle(pHandle->hSPLFile);
}
else
{
// In all other cases, just call _RpcEndDocPrinter.
RpcTryExcept
{
dwErrorCode = _RpcEndDocPrinter(pHandle->hPrinter);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
dwErrorCode = RpcExceptionCode();
ERR("_RpcEndDocPrinter failed with exception code %lu!\n", dwErrorCode);
}
RpcEndExcept;
}
// A new document can now be started again.
pHandle->bTrayIcon = pHandle->bJob = pHandle->bStartedDoc = FALSE;
Cleanup:
SetLastError(dwErrorCode);
return (dwErrorCode == ERROR_SUCCESS);
}
BOOL WINAPI
EndPagePrinter(HANDLE hPrinter)
{
DWORD dwErrorCode;
PSPOOLER_HANDLE pHandle = (PSPOOLER_HANDLE)hPrinter;
TRACE("EndPagePrinter(%p)\n", hPrinter);
// Sanity checks.
if (!pHandle)
{
dwErrorCode = ERROR_INVALID_HANDLE;
goto Cleanup;
}
if (pHandle->hSPLFile != INVALID_HANDLE_VALUE)
{
// For spooled jobs, we don't need to do anything.
dwErrorCode = ERROR_SUCCESS;
}
else
{
// In all other cases, just call _RpcEndPagePrinter.
RpcTryExcept
{
dwErrorCode = _RpcEndPagePrinter(pHandle->hPrinter);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
dwErrorCode = RpcExceptionCode();
ERR("_RpcEndPagePrinter failed with exception code %lu!\n", dwErrorCode);
}
RpcEndExcept;
}
Cleanup:
SetLastError(dwErrorCode);
return (dwErrorCode == ERROR_SUCCESS);
}
BOOL WINAPI
EnumPrintersA(DWORD Flags, PSTR Name, DWORD Level, PBYTE pPrinterEnum, DWORD cbBuf, PDWORD pcbNeeded, PDWORD pcReturned)
{
DWORD dwErrorCode;
DWORD cch;
PWSTR pwszName = NULL;
PSTR pszPrinterName = NULL;
PSTR pszServerName = NULL;
PSTR pszDescription = NULL;
PSTR pszName = NULL;
PSTR pszComment = NULL;
PSTR pszShareName = NULL;
PSTR pszPortName = NULL;
PSTR pszDriverName = NULL;
PSTR pszLocation = NULL;
PSTR pszSepFile = NULL;
PSTR pszPrintProcessor = NULL;
PSTR pszDatatype = NULL;
PSTR pszParameters = NULL;
DWORD i;
PPRINTER_INFO_1W ppi1w = NULL;
PPRINTER_INFO_1A ppi1a = NULL;
PPRINTER_INFO_2W ppi2w = NULL;
PPRINTER_INFO_2A ppi2a = NULL;
PPRINTER_INFO_4W ppi4w = NULL;
PPRINTER_INFO_4A ppi4a = NULL;
PPRINTER_INFO_5W ppi5w = NULL;
PPRINTER_INFO_5A ppi5a = NULL;
TRACE("EnumPrintersA(%lu, %s, %lu, %p, %lu, %p, %p)\n", Flags, Name, Level, pPrinterEnum, cbBuf, pcbNeeded, pcReturned);
// Check for invalid levels here for early error return. MSDN says that only 1, 2, 4, and 5 are allowable.
if (Level != 1 && Level != 2 && Level != 4 && Level != 5)
{
dwErrorCode = ERROR_INVALID_LEVEL;
ERR("Invalid Level!\n");
goto Cleanup;
}
if (Name)
{
// Convert pName to a Unicode string pwszName.
cch = strlen(Name);
pwszName = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(WCHAR));
if (!pwszName)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
MultiByteToWideChar(CP_ACP, 0, Name, -1, pwszName, cch + 1);
}
/* Ref: https://stackoverflow.com/questions/41147180/why-enumprintersa-and-enumprintersw-request-the-same-amount-of-memory */
if (!EnumPrintersW(Flags, pwszName, Level, pPrinterEnum, cbBuf, pcbNeeded, pcReturned))
{
dwErrorCode = GetLastError();
goto Cleanup;
}
/* We are mapping multiple different pointers to the same pPrinterEnum pointer here so that */
/* we can do in-place conversion. We read the Unicode response from the EnumPrintersW and */
/* then we write back the ANSI conversion into the same buffer for our EnumPrintersA output */
/* mapping to pPrinterEnum for Unicode (w) characters for Levels 1, 2, 4, and 5 */
ppi1w = (PPRINTER_INFO_1W)pPrinterEnum;
ppi2w = (PPRINTER_INFO_2W)pPrinterEnum;
ppi4w = (PPRINTER_INFO_4W)pPrinterEnum;
ppi5w = (PPRINTER_INFO_5W)pPrinterEnum;
/* mapping to pPrinterEnum for ANSI (a) characters for Levels 1, 2, 4, and 5 */
ppi1a = (PPRINTER_INFO_1A)pPrinterEnum;
ppi2a = (PPRINTER_INFO_2A)pPrinterEnum;
ppi4a = (PPRINTER_INFO_4A)pPrinterEnum;
ppi5a = (PPRINTER_INFO_5A)pPrinterEnum;
for (i = 0; i < *pcReturned; i++)
{
switch (Level)
{
case 1:
{
if (ppi1w[i].pDescription)
{
// Convert Unicode pDescription to a ANSI string pszDescription.
cch = wcslen(ppi1w[i].pDescription);
pszDescription = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(CHAR));
if (!pszDescription)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
WideCharToMultiByte(CP_ACP, 0, ppi1w[i].pDescription, -1, pszDescription, cch + 1, NULL, NULL);
StringCchCopyA(ppi1a[i].pDescription, cch + 1, pszDescription);
HeapFree(hProcessHeap, 0, pszDescription);
}
if (ppi1w[i].pName)
{
// Convert Unicode pName to a ANSI string pszName.
cch = wcslen(ppi1w[i].pName);
pszName = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(CHAR));
if (!pszName)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
WideCharToMultiByte(CP_ACP, 0, ppi1w[i].pName, -1, pszName, cch + 1, NULL, NULL);
StringCchCopyA(ppi1a[i].pName, cch + 1, pszName);
HeapFree(hProcessHeap, 0, pszName);
}
if (ppi1w[i].pComment)
{
// Convert Unicode pComment to a ANSI string pszComment.
cch = wcslen(ppi1w[i].pComment);
pszComment = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(CHAR));
if (!pszComment)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
WideCharToMultiByte(CP_ACP, 0, ppi1w[i].pComment, -1, pszComment, cch + 1, NULL, NULL);
StringCchCopyA(ppi1a[i].pComment, cch + 1, pszComment);
HeapFree(hProcessHeap, 0, pszComment);
}
break;
}
case 2:
{
if (ppi2w[i].pServerName)
{
// Convert Unicode pServerName to a ANSI string pszServerName.
cch = wcslen(ppi2w[i].pServerName);
pszServerName = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(CHAR));
if (!pszServerName)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
WideCharToMultiByte(CP_ACP, 0, ppi2w[i].pServerName, -1, pszServerName, cch + 1, NULL, NULL);
StringCchCopyA(ppi2a[i].pServerName, cch + 1, pszServerName);
HeapFree(hProcessHeap, 0, pszServerName);
}
if (ppi2w[i].pPrinterName)
{
// Convert Unicode pPrinterName to a ANSI string pszPrinterName.
cch = wcslen(ppi2w[i].pPrinterName);
pszPrinterName = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(CHAR));
if (!pszPrinterName)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
WideCharToMultiByte(CP_ACP, 0, ppi2w[i].pPrinterName, -1, pszPrinterName, cch + 1, NULL, NULL);
StringCchCopyA(ppi2a[i].pPrinterName, cch + 1, pszPrinterName);
HeapFree(hProcessHeap, 0, pszPrinterName);
}
if (ppi2w[i].pShareName)
{
// Convert Unicode pShareName to a ANSI string pszShareName.
cch = wcslen(ppi2w[i].pShareName);
pszShareName = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(CHAR));
if (!pszShareName)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
WideCharToMultiByte(CP_ACP, 0, ppi2w[i].pShareName, -1, pszShareName, cch + 1, NULL, NULL);
StringCchCopyA(ppi2a[i].pShareName, cch + 1, pszShareName);
HeapFree(hProcessHeap, 0, pszShareName);
}
if (ppi2w[i].pPortName)
{
// Convert Unicode pPortName to a ANSI string pszPortName.
cch = wcslen(ppi2w[i].pPortName);
pszPortName = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(CHAR));
if (!pszPortName)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
WideCharToMultiByte(CP_ACP, 0, ppi2w[i].pPortName, -1, pszPortName, cch + 1, NULL, NULL);
StringCchCopyA(ppi2a[i].pPortName, cch + 1, pszPortName);
HeapFree(hProcessHeap, 0, pszPortName);
}
if (ppi2w[i].pDriverName)
{
// Convert Unicode pDriverName to a ANSI string pszDriverName.
cch = wcslen(ppi2w[i].pDriverName);
pszDriverName = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(CHAR));
if (!pszDriverName)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
WideCharToMultiByte(CP_ACP, 0, ppi2w[i].pDriverName, -1, pszDriverName, cch + 1, NULL, NULL);
StringCchCopyA(ppi2a[i].pDriverName, cch + 1, pszDriverName);
HeapFree(hProcessHeap, 0, pszDriverName);
}
if (ppi2w[i].pComment)
{
// Convert Unicode pComment to a ANSI string pszComment.
cch = wcslen(ppi2w[i].pComment);
pszComment = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(CHAR));
if (!pszComment)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
WideCharToMultiByte(CP_ACP, 0, ppi2w[i].pComment, -1, pszComment, cch + 1, NULL, NULL);
StringCchCopyA(ppi2a[i].pComment, cch + 1, pszComment);
HeapFree(hProcessHeap, 0, pszComment);
}
if (ppi2w[i].pLocation)
{
// Convert Unicode pLocation to a ANSI string pszLocation.
cch = wcslen(ppi2w[i].pLocation);
pszLocation = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(CHAR));
if (!pszLocation)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
WideCharToMultiByte(CP_ACP, 0, ppi2w[i].pLocation, -1, pszLocation, cch + 1, NULL, NULL);
StringCchCopyA(ppi2a[i].pLocation, cch + 1, pszLocation);
HeapFree(hProcessHeap, 0, pszLocation);
}
if (ppi2w[i].pSepFile)
{
// Convert Unicode pSepFile to a ANSI string pszSepFile.
cch = wcslen(ppi2w[i].pSepFile);
pszSepFile = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(CHAR));
if (!pszSepFile)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
WideCharToMultiByte(CP_ACP, 0, ppi2w[i].pSepFile, -1, pszSepFile, cch + 1, NULL, NULL);
StringCchCopyA(ppi2a[i].pSepFile, cch + 1, pszSepFile);
HeapFree(hProcessHeap, 0, pszSepFile);
}
if (ppi2w[i].pPrintProcessor)
{
// Convert Unicode pPrintProcessor to a ANSI string pszPrintProcessor.
cch = wcslen(ppi2w[i].pPrintProcessor);
pszPrintProcessor = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(CHAR));
if (!pszPrintProcessor)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
WideCharToMultiByte(CP_ACP, 0, ppi2w[i].pPrintProcessor, -1, pszPrintProcessor, cch + 1, NULL, NULL);
StringCchCopyA(ppi2a[i].pPrintProcessor, cch + 1, pszPrintProcessor);
HeapFree(hProcessHeap, 0, pszPrintProcessor);
}
if (ppi2w[i].pDatatype)
{
// Convert Unicode pDatatype to a ANSI string pszDatatype.
cch = wcslen(ppi2w[i].pDatatype);
pszDatatype = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(CHAR));
if (!pszDatatype)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
WideCharToMultiByte(CP_ACP, 0, ppi2w[i].pDatatype, -1, pszDatatype, cch + 1, NULL, NULL);
StringCchCopyA(ppi2a[i].pDatatype, cch + 1, pszDatatype);
HeapFree(hProcessHeap, 0, pszDatatype);
}
if (ppi2w[i].pParameters)
{
// Convert Unicode pParameters to a ANSI string pszParameters.
cch = wcslen(ppi2w[i].pParameters);
pszParameters = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(CHAR));
if (!pszParameters)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
WideCharToMultiByte(CP_ACP, 0, ppi2w[i].pParameters, -1, pszParameters, cch + 1, NULL, NULL);
StringCchCopyA(ppi2a[i].pParameters, cch + 1, pszParameters);
HeapFree(hProcessHeap, 0, pszParameters);
}
if ( ppi2w[i].pDevMode )
{
RosConvertUnicodeDevModeToAnsiDevmode( ppi2w[i].pDevMode, ppi2a[i].pDevMode );
}
break;
}
case 4:
{
if (ppi4w[i].pPrinterName)
{
// Convert Unicode pPrinterName to a ANSI string pszPrinterName.
cch = wcslen(ppi4w[i].pPrinterName);
pszPrinterName = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(CHAR));
if (!pszPrinterName)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
WideCharToMultiByte(CP_ACP, 0, ppi4w[i].pPrinterName, -1, pszPrinterName, cch + 1, NULL, NULL);
StringCchCopyA(ppi4a[i].pPrinterName, cch + 1, pszPrinterName);
HeapFree(hProcessHeap, 0, pszPrinterName);
}
if (ppi4w[i].pServerName)
{
// Convert Unicode pServerName to a ANSI string pszServerName.
cch = wcslen(ppi4w[i].pServerName);
pszServerName = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(CHAR));
if (!pszServerName)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
WideCharToMultiByte(CP_ACP, 0, ppi4w[i].pServerName, -1, pszServerName, cch + 1, NULL, NULL);
StringCchCopyA(ppi4a[i].pServerName, cch + 1, pszServerName);
HeapFree(hProcessHeap, 0, pszServerName);
}
break;
}
case 5:
{
if (ppi5w[i].pPrinterName)
{
// Convert Unicode pPrinterName to a ANSI string pszPrinterName.
cch = wcslen(ppi5w[i].pPrinterName);
pszPrinterName = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(CHAR));
if (!pszPrinterName)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
WideCharToMultiByte(CP_ACP, 0, ppi5w[i].pPrinterName, -1, pszPrinterName, cch + 1, NULL, NULL);
StringCchCopyA(ppi5a[i].pPrinterName, cch + 1, pszPrinterName);
HeapFree(hProcessHeap, 0, pszPrinterName);
}
if (ppi5w[i].pPortName)
{
// Convert Unicode pPortName to a ANSI string pszPortName.
cch = wcslen(ppi5w[i].pPortName);
pszPortName = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(CHAR));
if (!pszPortName)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
WideCharToMultiByte(CP_ACP, 0, ppi5w[i].pPortName, -1, pszPortName, cch + 1, NULL, NULL);
StringCchCopyA(ppi5a[i].pPortName, cch + 1, pszPortName);
HeapFree(hProcessHeap, 0, pszPortName);
}
break;
}
} // switch
} // for
dwErrorCode = ERROR_SUCCESS;
Cleanup:
if (pwszName)
{
HeapFree(hProcessHeap, 0, pwszName);
}
SetLastError(dwErrorCode);
return (dwErrorCode == ERROR_SUCCESS);
}
BOOL WINAPI
EnumPrintersW(DWORD Flags, PWSTR Name, DWORD Level, PBYTE pPrinterEnum, DWORD cbBuf, PDWORD pcbNeeded, PDWORD pcReturned)
{
DWORD dwErrorCode;
TRACE("EnumPrintersW(%lu, %S, %lu, %p, %lu, %p, %p)\n", Flags, Name, Level, pPrinterEnum, cbBuf, pcbNeeded, pcReturned);
// Dismiss invalid levels already at this point.
if (Level == 3 || Level > 5)
{
dwErrorCode = ERROR_INVALID_LEVEL;
goto Cleanup;
}
if (cbBuf && pPrinterEnum)
ZeroMemory(pPrinterEnum, cbBuf);
// Do the RPC call
RpcTryExcept
{
dwErrorCode = _RpcEnumPrinters(Flags, Name, Level, pPrinterEnum, cbBuf, pcbNeeded, pcReturned);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
dwErrorCode = RpcExceptionCode();
ERR("_RpcEnumPrinters failed with exception code %lu!\n", dwErrorCode);
}
RpcEndExcept;
if (dwErrorCode == ERROR_SUCCESS)
{
// Replace relative offset addresses in the output by absolute pointers.
ASSERT(Level <= 9);
MarshallUpStructuresArray(cbBuf, pPrinterEnum, *pcReturned, pPrinterInfoMarshalling[Level]->pInfo, pPrinterInfoMarshalling[Level]->cbStructureSize, TRUE);
}
Cleanup:
SetLastError(dwErrorCode);
return (dwErrorCode == ERROR_SUCCESS);
}
BOOL WINAPI
FlushPrinter(HANDLE hPrinter, PVOID pBuf, DWORD cbBuf, PDWORD pcWritten, DWORD cSleep)
{
TRACE("FlushPrinter(%p, %p, %lu, %p, %lu)\n", hPrinter, pBuf, cbBuf, pcWritten, cSleep);
UNIMPLEMENTED;
return FALSE;
}
BOOL WINAPI
GetDefaultPrinterA(LPSTR pszBuffer, LPDWORD pcchBuffer)
{
DWORD dwErrorCode;
PWSTR pwszBuffer = NULL;
TRACE("GetDefaultPrinterA(%p, %p)\n", pszBuffer, pcchBuffer);
// Sanity check.
if (!pcchBuffer)
{
dwErrorCode = ERROR_INVALID_PARAMETER;
goto Cleanup;
}
// Check if an ANSI buffer was given and if so, allocate a Unicode buffer of the same size.
if (pszBuffer && *pcchBuffer)
{
pwszBuffer = HeapAlloc(hProcessHeap, 0, *pcchBuffer * sizeof(WCHAR));
if (!pwszBuffer)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
}
if (!GetDefaultPrinterW(pwszBuffer, pcchBuffer))
{
dwErrorCode = GetLastError();
goto Cleanup;
}
// We successfully got a string in pwszBuffer, so convert the Unicode string to ANSI.
WideCharToMultiByte(CP_ACP, 0, pwszBuffer, -1, pszBuffer, *pcchBuffer, NULL, NULL);
dwErrorCode = ERROR_SUCCESS;
Cleanup:
if (pwszBuffer)
HeapFree(hProcessHeap, 0, pwszBuffer);
SetLastError(dwErrorCode);
return (dwErrorCode == ERROR_SUCCESS);
}
BOOL WINAPI
GetDefaultPrinterW(LPWSTR pszBuffer, LPDWORD pcchBuffer)
{
DWORD cbNeeded;
DWORD cchInputBuffer;
DWORD dwErrorCode;
HKEY hWindowsKey = NULL;
PWSTR pwszDevice = NULL;
PWSTR pwszComma;
TRACE("GetDefaultPrinterW(%p, %p)\n", pszBuffer, pcchBuffer);
// Sanity check.
if (!pcchBuffer)
{
dwErrorCode = ERROR_INVALID_PARAMETER;
goto Cleanup;
}
cchInputBuffer = *pcchBuffer;
// Open the registry key where the default printer for the current user is stored.
dwErrorCode = (DWORD)RegOpenKeyExW(HKEY_CURRENT_USER, wszWindowsKey, 0, KEY_READ, &hWindowsKey);
if (dwErrorCode != ERROR_SUCCESS)
{
ERR("RegOpenKeyExW failed with status %lu!\n", dwErrorCode);
goto Cleanup;
}
// Determine the size of the required buffer.
dwErrorCode = (DWORD)RegQueryValueExW(hWindowsKey, wszDeviceValue, NULL, NULL, NULL, &cbNeeded);
if (dwErrorCode != ERROR_SUCCESS)
{
ERR("RegQueryValueExW failed with status %lu!\n", dwErrorCode);
goto Cleanup;
}
// Allocate it.
pwszDevice = HeapAlloc(hProcessHeap, 0, cbNeeded);
if (!pwszDevice)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
// Now get the actual value.
dwErrorCode = RegQueryValueExW(hWindowsKey, wszDeviceValue, NULL, NULL, (PBYTE)pwszDevice, &cbNeeded);
if (dwErrorCode != ERROR_SUCCESS)
{
ERR("RegQueryValueExW failed with status %lu!\n", dwErrorCode);
goto Cleanup;
}
// We get a string "<Printer Name>,winspool,<Port>:".
// Extract the printer name from it.
pwszComma = wcschr(pwszDevice, L',');
if (!pwszComma)
{
ERR("Found no or invalid default printer: %S!\n", pwszDevice);
dwErrorCode = ERROR_INVALID_NAME;
goto Cleanup;
}
// Store the length of the Printer Name (including the terminating NUL character!) in *pcchBuffer.
*pcchBuffer = pwszComma - pwszDevice + 1;
// Check if the supplied buffer is large enough.
if ( !pszBuffer || cchInputBuffer < *pcchBuffer)
{
dwErrorCode = ERROR_INSUFFICIENT_BUFFER;
goto Cleanup;
}
// Copy the default printer.
*pwszComma = 0;
CopyMemory(pszBuffer, pwszDevice, *pcchBuffer * sizeof(WCHAR));
dwErrorCode = ERROR_SUCCESS;
Cleanup:
if (hWindowsKey)
RegCloseKey(hWindowsKey);
if (pwszDevice)
HeapFree(hProcessHeap, 0, pwszDevice);
SetLastError(dwErrorCode);
return (dwErrorCode == ERROR_SUCCESS);
}
BOOL WINAPI
GetPrinterA(HANDLE hPrinter, DWORD Level, LPBYTE pPrinter, DWORD cbBuf, LPDWORD pcbNeeded)
{
DWORD dwErrorCode;
PPRINTER_INFO_1A ppi1a = (PPRINTER_INFO_1A)pPrinter;
PPRINTER_INFO_1W ppi1w = (PPRINTER_INFO_1W)pPrinter;
PPRINTER_INFO_2A ppi2a = (PPRINTER_INFO_2A)pPrinter;
PPRINTER_INFO_2W ppi2w = (PPRINTER_INFO_2W)pPrinter;
PPRINTER_INFO_4A ppi4a = (PPRINTER_INFO_4A)pPrinter;
PPRINTER_INFO_4W ppi4w = (PPRINTER_INFO_4W)pPrinter;
PPRINTER_INFO_5A ppi5a = (PPRINTER_INFO_5A)pPrinter;
PPRINTER_INFO_5W ppi5w = (PPRINTER_INFO_5W)pPrinter;
PPRINTER_INFO_7A ppi7a = (PPRINTER_INFO_7A)pPrinter;
PPRINTER_INFO_7W ppi7w = (PPRINTER_INFO_7W)pPrinter;
PPRINTER_INFO_9A ppi9a = (PPRINTER_INFO_9A)pPrinter;
PPRINTER_INFO_9W ppi9w = (PPRINTER_INFO_9W)pPrinter;
DWORD cch;
TRACE("GetPrinterA(%p, %lu, %p, %lu, %p)\n", hPrinter, Level, pPrinter, cbBuf, pcbNeeded);
// Check for invalid levels here for early error return. Should be 1-9.
if (Level < 1 || Level > 9)
{
dwErrorCode = ERROR_INVALID_LEVEL;
ERR("Invalid Level!\n");
goto Cleanup;
}
if (!GetPrinterW(hPrinter, Level, pPrinter, cbBuf, pcbNeeded))
{
dwErrorCode = GetLastError();
goto Cleanup;
}
switch (Level)
{
case 1:
{
if (ppi1w->pDescription)
{
PSTR pszDescription;
// Convert Unicode pDescription to a ANSI string pszDescription.
cch = wcslen(ppi1w->pDescription);
pszDescription = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(CHAR));
if (!pszDescription)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
WideCharToMultiByte(CP_ACP, 0, ppi1w->pDescription, -1, pszDescription, cch + 1, NULL, NULL);
StringCchCopyA(ppi1a->pDescription, cch + 1, pszDescription);
HeapFree(hProcessHeap, 0, pszDescription);
}
if (ppi1w->pName)
{
PSTR pszName;
// Convert Unicode pName to a ANSI string pszName.
cch = wcslen(ppi1w->pName);
pszName = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(CHAR));
if (!pszName)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
WideCharToMultiByte(CP_ACP, 0, ppi1w->pName, -1, pszName, cch + 1, NULL, NULL);
StringCchCopyA(ppi1a->pName, cch + 1, pszName);
HeapFree(hProcessHeap, 0, pszName);
}
if (ppi1w->pComment)
{
PSTR pszComment;
// Convert Unicode pComment to a ANSI string pszComment.
cch = wcslen(ppi1w->pComment);
pszComment = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(CHAR));
if (!pszComment)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
WideCharToMultiByte(CP_ACP, 0, ppi1w->pComment, -1, pszComment, cch + 1, NULL, NULL);
StringCchCopyA(ppi1a->pComment, cch + 1, pszComment);
HeapFree(hProcessHeap, 0, pszComment);
}
break;
}
case 2:
{
if (ppi2w->pServerName)
{
PSTR pszServerName;
// Convert Unicode pServerName to a ANSI string pszServerName.
cch = wcslen(ppi2w->pServerName);
pszServerName = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(CHAR));
if (!pszServerName)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
WideCharToMultiByte(CP_ACP, 0, ppi2w->pServerName, -1, pszServerName, cch + 1, NULL, NULL);
StringCchCopyA(ppi2a->pServerName, cch + 1, pszServerName);
HeapFree(hProcessHeap, 0, pszServerName);
}
if (ppi2w->pPrinterName)
{
PSTR pszPrinterName;
// Convert Unicode pPrinterName to a ANSI string pszPrinterName.
cch = wcslen(ppi2w->pPrinterName);
pszPrinterName = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(CHAR));
if (!pszPrinterName)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
WideCharToMultiByte(CP_ACP, 0, ppi2w->pPrinterName, -1, pszPrinterName, cch + 1, NULL, NULL);
StringCchCopyA(ppi2a->pPrinterName, cch + 1, pszPrinterName);
HeapFree(hProcessHeap, 0, pszPrinterName);
}
if (ppi2w->pShareName)
{
PSTR pszShareName;
// Convert Unicode pShareName to a ANSI string pszShareName.
cch = wcslen(ppi2w->pShareName);
pszShareName = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(CHAR));
if (!pszShareName)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
WideCharToMultiByte(CP_ACP, 0, ppi2w->pShareName, -1, pszShareName, cch + 1, NULL, NULL);
StringCchCopyA(ppi2a->pShareName, cch + 1, pszShareName);
HeapFree(hProcessHeap, 0, pszShareName);
}
if (ppi2w->pPortName)
{
PSTR pszPortName;
// Convert Unicode pPortName to a ANSI string pszPortName.
cch = wcslen(ppi2w->pPortName);
pszPortName = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(CHAR));
if (!pszPortName)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
WideCharToMultiByte(CP_ACP, 0, ppi2w->pPortName, -1, pszPortName, cch + 1, NULL, NULL);
StringCchCopyA(ppi2a->pPortName, cch + 1, pszPortName);
HeapFree(hProcessHeap, 0, pszPortName);
}
if (ppi2w->pDriverName)
{
PSTR pszDriverName;
// Convert Unicode pDriverName to a ANSI string pszDriverName.
cch = wcslen(ppi2w->pDriverName);
pszDriverName = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(CHAR));
if (!pszDriverName)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
WideCharToMultiByte(CP_ACP, 0, ppi2w->pDriverName, -1, pszDriverName, cch + 1, NULL, NULL);
StringCchCopyA(ppi2a->pDriverName, cch + 1, pszDriverName);
HeapFree(hProcessHeap, 0, pszDriverName);
}
if (ppi2w->pComment)
{
PSTR pszComment;
// Convert Unicode pComment to a ANSI string pszComment.
cch = wcslen(ppi2w->pComment);
pszComment = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(CHAR));
if (!pszComment)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
WideCharToMultiByte(CP_ACP, 0, ppi2w->pComment, -1, pszComment, cch + 1, NULL, NULL);
StringCchCopyA(ppi2a->pComment, cch + 1, pszComment);
HeapFree(hProcessHeap, 0, pszComment);
}
if (ppi2w->pLocation)
{
PSTR pszLocation;
// Convert Unicode pLocation to a ANSI string pszLocation.
cch = wcslen(ppi2w->pLocation);
pszLocation = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(CHAR));
if (!pszLocation)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
WideCharToMultiByte(CP_ACP, 0, ppi2w->pLocation, -1, pszLocation, cch + 1, NULL, NULL);
StringCchCopyA(ppi2a->pLocation, cch + 1, pszLocation);
HeapFree(hProcessHeap, 0, pszLocation);
}
if (ppi2w->pSepFile)
{
PSTR pszSepFile;
// Convert Unicode pSepFile to a ANSI string pszSepFile.
cch = wcslen(ppi2w->pSepFile);
pszSepFile = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(CHAR));
if (!pszSepFile)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
WideCharToMultiByte(CP_ACP, 0, ppi2w->pSepFile, -1, pszSepFile, cch + 1, NULL, NULL);
StringCchCopyA(ppi2a->pSepFile, cch + 1, pszSepFile);
HeapFree(hProcessHeap, 0, pszSepFile);
}
if (ppi2w->pPrintProcessor)
{
PSTR pszPrintProcessor;
// Convert Unicode pPrintProcessor to a ANSI string pszPrintProcessor.
cch = wcslen(ppi2w->pPrintProcessor);
pszPrintProcessor = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(CHAR));
if (!pszPrintProcessor)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
WideCharToMultiByte(CP_ACP, 0, ppi2w->pPrintProcessor, -1, pszPrintProcessor, cch + 1, NULL, NULL);
StringCchCopyA(ppi2a->pPrintProcessor, cch + 1, pszPrintProcessor);
HeapFree(hProcessHeap, 0, pszPrintProcessor);
}
if (ppi2w->pDatatype)
{
PSTR pszDatatype;
// Convert Unicode pDatatype to a ANSI string pszDatatype.
cch = wcslen(ppi2w->pDatatype);
pszDatatype = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(CHAR));
if (!pszDatatype)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
WideCharToMultiByte(CP_ACP, 0, ppi2w->pDatatype, -1, pszDatatype, cch + 1, NULL, NULL);
StringCchCopyA(ppi2a->pDatatype, cch + 1, pszDatatype);
HeapFree(hProcessHeap, 0, pszDatatype);
}
if (ppi2w->pParameters)
{
PSTR pszParameters;
// Convert Unicode pParameters to a ANSI string pszParameters.
cch = wcslen(ppi2w->pParameters);
pszParameters = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(CHAR));
if (!pszParameters)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
WideCharToMultiByte(CP_ACP, 0, ppi2w->pParameters, -1, pszParameters, cch + 1, NULL, NULL);
StringCchCopyA(ppi2a->pParameters, cch + 1, pszParameters);
HeapFree(hProcessHeap, 0, pszParameters);
}
if ( ppi2w->pDevMode )
{
RosConvertUnicodeDevModeToAnsiDevmode( ppi2w->pDevMode, ppi2a->pDevMode );
}
break;
}
case 4:
{
if (ppi4w->pPrinterName)
{
PSTR pszPrinterName;
// Convert Unicode pPrinterName to a ANSI string pszPrinterName.
cch = wcslen(ppi4w->pPrinterName);
pszPrinterName = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(CHAR));
if (!pszPrinterName)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
WideCharToMultiByte(CP_ACP, 0, ppi4w->pPrinterName, -1, pszPrinterName, cch + 1, NULL, NULL);
StringCchCopyA(ppi4a->pPrinterName, cch + 1, pszPrinterName);
HeapFree(hProcessHeap, 0, pszPrinterName);
}
if (ppi4w->pServerName)
{
PSTR pszServerName;
// Convert Unicode pServerName to a ANSI string pszServerName.
cch = wcslen(ppi4w->pServerName);
pszServerName = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(CHAR));
if (!pszServerName)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
WideCharToMultiByte(CP_ACP, 0, ppi4w->pServerName, -1, pszServerName, cch + 1, NULL, NULL);
StringCchCopyA(ppi4a->pServerName, cch + 1, pszServerName);
HeapFree(hProcessHeap, 0, pszServerName);
}
break;
}
case 5:
{
if (ppi5w->pPrinterName)
{
PSTR pszPrinterName;
// Convert Unicode pPrinterName to a ANSI string pszPrinterName.
cch = wcslen(ppi5w->pPrinterName);
pszPrinterName = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(CHAR));
if (!pszPrinterName)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
WideCharToMultiByte(CP_ACP, 0, ppi5w->pPrinterName, -1, pszPrinterName, cch + 1, NULL, NULL);
StringCchCopyA(ppi5a->pPrinterName, cch + 1, pszPrinterName);
HeapFree(hProcessHeap, 0, pszPrinterName);
}
if (ppi5w->pPortName)
{
PSTR pszPortName;
// Convert Unicode pPortName to a ANSI string pszPortName.
cch = wcslen(ppi5w->pPortName);
pszPortName = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(CHAR));
if (!pszPortName)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
WideCharToMultiByte(CP_ACP, 0, ppi5w->pPortName, -1, pszPortName, cch + 1, NULL, NULL);
StringCchCopyA(ppi5a->pPortName, cch + 1, pszPortName);
HeapFree(hProcessHeap, 0, pszPortName);
}
break;
}
case 7:
{
if (ppi7w->pszObjectGUID)
{
PSTR pszaObjectGUID;
// Convert Unicode pszObjectGUID to a ANSI string pszaObjectGUID.
cch = wcslen(ppi7w->pszObjectGUID);
pszaObjectGUID = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(CHAR));
if (!pszaObjectGUID)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
WideCharToMultiByte(CP_ACP, 0, ppi7w->pszObjectGUID, -1, pszaObjectGUID, cch + 1, NULL, NULL);
StringCchCopyA(ppi7a->pszObjectGUID, cch + 1, pszaObjectGUID);
HeapFree(hProcessHeap, 0, pszaObjectGUID);
}
}
break;
case 8:
case 9:
RosConvertUnicodeDevModeToAnsiDevmode(ppi9w->pDevMode, ppi9a->pDevMode);
break;
} // switch
dwErrorCode = ERROR_SUCCESS;
Cleanup:
SetLastError(dwErrorCode);
return (dwErrorCode == ERROR_SUCCESS);
}
BOOL WINAPI
GetPrinterW(HANDLE hPrinter, DWORD Level, LPBYTE pPrinter, DWORD cbBuf, LPDWORD pcbNeeded)
{
DWORD dwErrorCode;
PSPOOLER_HANDLE pHandle = (PSPOOLER_HANDLE)hPrinter;
TRACE("GetPrinterW(%p, %lu, %p, %lu, %p)\n", hPrinter, Level, pPrinter, cbBuf, pcbNeeded);
// Sanity checks.
if (!pHandle)
{
dwErrorCode = ERROR_INVALID_HANDLE;
goto Cleanup;
}
// Dismiss invalid levels already at this point.
if (Level > 9)
{
dwErrorCode = ERROR_INVALID_LEVEL;
goto Cleanup;
}
if (cbBuf && pPrinter)
ZeroMemory(pPrinter, cbBuf);
// Do the RPC call
RpcTryExcept
{
dwErrorCode = _RpcGetPrinter(pHandle->hPrinter, Level, pPrinter, cbBuf, pcbNeeded);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
dwErrorCode = RpcExceptionCode();
ERR("_RpcGetPrinter failed with exception code %lu!\n", dwErrorCode);
}
RpcEndExcept;
if (dwErrorCode == ERROR_SUCCESS)
{
// Replace relative offset addresses in the output by absolute pointers.
ASSERT(Level <= 9);
MarshallUpStructure(cbBuf, pPrinter, pPrinterInfoMarshalling[Level]->pInfo, pPrinterInfoMarshalling[Level]->cbStructureSize, TRUE);
}
Cleanup:
SetLastError(dwErrorCode);
return (dwErrorCode == ERROR_SUCCESS);
}
BOOL WINAPI
OpenPrinterA(LPSTR pPrinterName, LPHANDLE phPrinter, LPPRINTER_DEFAULTSA pDefault)
{
BOOL bReturnValue = FALSE;
DWORD cch;
PWSTR pwszPrinterName = NULL;
PRINTER_DEFAULTSW wDefault = { 0 };
TRACE("OpenPrinterA(%s, %p, %p)\n", pPrinterName, phPrinter, pDefault);
if (pPrinterName)
{
// Convert pPrinterName to a Unicode string pwszPrinterName
cch = strlen(pPrinterName);
pwszPrinterName = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(WCHAR));
if (!pwszPrinterName)
{
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
MultiByteToWideChar(CP_ACP, 0, pPrinterName, -1, pwszPrinterName, cch + 1);
}
if (pDefault)
{
wDefault.DesiredAccess = pDefault->DesiredAccess;
if (pDefault->pDatatype)
{
// Convert pDefault->pDatatype to a Unicode string wDefault.pDatatype
cch = strlen(pDefault->pDatatype);
wDefault.pDatatype = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(WCHAR));
if (!wDefault.pDatatype)
{
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
MultiByteToWideChar(CP_ACP, 0, pDefault->pDatatype, -1, wDefault.pDatatype, cch + 1);
}
if (pDefault->pDevMode)
wDefault.pDevMode = GdiConvertToDevmodeW(pDefault->pDevMode);
}
bReturnValue = OpenPrinterW(pwszPrinterName, phPrinter, &wDefault);
if ( bReturnValue )
{
PSPOOLER_HANDLE pHandle = (PSPOOLER_HANDLE)*phPrinter;
pHandle->bAnsi = TRUE;
}
Cleanup:
if (wDefault.pDatatype)
HeapFree(hProcessHeap, 0, wDefault.pDatatype);
if (wDefault.pDevMode)
HeapFree(hProcessHeap, 0, wDefault.pDevMode);
if (pwszPrinterName)
HeapFree(hProcessHeap, 0, pwszPrinterName);
return bReturnValue;
}
BOOL WINAPI
OpenPrinterW(LPWSTR pPrinterName, LPHANDLE phPrinter, LPPRINTER_DEFAULTSW pDefault)
{
DWORD dwErrorCode;
HANDLE hPrinter;
PSPOOLER_HANDLE pHandle;
PWSTR pDatatype = NULL;
WINSPOOL_DEVMODE_CONTAINER DevModeContainer = { 0 };
ACCESS_MASK AccessRequired = 0;
TRACE("OpenPrinterW(%S, %p, %p)\n", pPrinterName, phPrinter, pDefault);
// Sanity check
if (!phPrinter)
{
dwErrorCode = ERROR_INVALID_PARAMETER;
goto Cleanup;
}
// Prepare the additional parameters in the format required by _RpcOpenPrinter
if (pDefault)
{
pDatatype = pDefault->pDatatype;
DevModeContainer.cbBuf = sizeof(DEVMODEW);
DevModeContainer.pDevMode = (BYTE*)pDefault->pDevMode;
AccessRequired = pDefault->DesiredAccess;
}
// Do the RPC call
RpcTryExcept
{
dwErrorCode = _RpcOpenPrinter(pPrinterName, &hPrinter, pDatatype, &DevModeContainer, AccessRequired);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
dwErrorCode = RpcExceptionCode();
ERR("_RpcOpenPrinter failed with exception code %lu!\n", dwErrorCode);
}
RpcEndExcept;
if (dwErrorCode == ERROR_SUCCESS)
{
// Create a new SPOOLER_HANDLE structure.
pHandle = HeapAlloc(hProcessHeap, HEAP_ZERO_MEMORY, sizeof(SPOOLER_HANDLE));
if (!pHandle)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
pHandle->Sig = SPOOLER_HANDLE_SIG;
pHandle->hPrinter = hPrinter;
pHandle->hSPLFile = INVALID_HANDLE_VALUE;
pHandle->hSpoolFileHandle = INVALID_HANDLE_VALUE;
// Return it as phPrinter.
*phPrinter = (HANDLE)pHandle;
}
Cleanup:
SetLastError(dwErrorCode);
return (dwErrorCode == ERROR_SUCCESS);
}
//
// Dead API.
//
DWORD WINAPI
PrinterMessageBoxA(HANDLE hPrinter, DWORD Error, HWND hWnd, LPSTR pText, LPSTR pCaption, DWORD dwType)
{
return 50;
}
DWORD WINAPI
PrinterMessageBoxW(HANDLE hPrinter, DWORD Error, HWND hWnd, LPWSTR pText, LPWSTR pCaption, DWORD dwType)
{
return 50;
}
BOOL WINAPI
QueryColorProfile(
HANDLE hPrinter,
PDEVMODEW pdevmode,
ULONG ulQueryMode,
VOID *pvProfileData,
ULONG *pcbProfileData,
FLONG *pflProfileData )
{
PSPOOLER_HANDLE pHandle = (PSPOOLER_HANDLE)hPrinter;
BOOL Ret = FALSE;
HMODULE hLibrary;
FIXME("QueryColorProfile(%p, %p, %l, %p, %p, %p)\n", hPrinter, pdevmode, ulQueryMode, pvProfileData, pcbProfileData, pflProfileData);
if ( pHandle->bNoColorProfile )
{
Ret = (BOOL)SP_ERROR;
}
else
{
if ( pdevmode )
{
if (!IsValidDevmodeNoSizeW( pdevmode ) )
{
ERR("QueryColorProfile : Devode Invalid\n");
return FALSE;
}
}
hLibrary = LoadPrinterDriver( hPrinter );
if ( hLibrary )
{
fpQueryColorProfile = (PVOID)GetProcAddress( hLibrary, "DrvQueryColorProfile" );
if ( fpQueryColorProfile )
{
Ret = fpQueryColorProfile( hPrinter, pdevmode, ulQueryMode, pvProfileData, pcbProfileData, pflProfileData );
}
else
{
pHandle->bNoColorProfile = TRUE;
Ret = (BOOL)SP_ERROR;
}
FreeLibrary(hLibrary);
}
}
return Ret;
}
// Note from GDI32:printdrv.c
//
// QuerySpoolMode :
// BOOL return TRUE if successful.
// dlFont 0x0001 for Downloading fonts. 0x0002 unknown XPS_PASS?.
// dwVersion is version of EMFSPOOL. Must be 0x00010000. See [MS-EMFSPOOL] page 18.
//
#define QSM_DOWNLOADINGFONTS 0x0001
/*
Note from MSDN : "V4 print drivers using RAW mode to send PCL/Postscript have 0 byte spool file"
Use XPS_PASS instead of RAW to pass information directly to the print filter pipeline in
v4 and v3 XPSDrv drivers. Here's how to proceed with Windows 8:
Call GetPrinterDriver to retrieve the DRIVER_INFO_8 structure.
Check DRIVER_INFO_8::dwPrinterDriverAttributes for the PRINTER_DRIVER_XPS flag.
Choose your datatype based on the presence or absence of the flag:
If the flag is set, use XPS_PASS.
If the flag isn't set, use RAW.
*/
#define QSM_XPS_PASS 0x0002 // Guessing. PRINTER_DRIVER_XPS?
BOOL WINAPI
QuerySpoolMode( HANDLE hPrinter, PDWORD downloadFontsFlags, PDWORD dwVersion )
{
PRINTER_INFO_2W *pi2 = NULL;
DWORD needed = 0;
BOOL res;
FIXME("QuerySpoolMode(%p, %p, %p)\n", hPrinter, downloadFontsFlags, dwVersion);
res = GetPrinterW( hPrinter, 2, NULL, 0, &needed);
if (!res && (GetLastError() == ERROR_INSUFFICIENT_BUFFER))
{
pi2 = HeapAlloc(hProcessHeap, 0, needed);
if (!pi2)
{
ERR("Failed to allocate PRINTER_INFO_2W of %u bytes\n", needed);
return FALSE;
}
res = GetPrinterW(hPrinter, 2, (LPBYTE)pi2, needed, &needed);
}
if ( res )
{
*dwVersion = 0x10000;
*downloadFontsFlags = 0;
if ( pi2->pServerName )
{
*downloadFontsFlags |= QSM_DOWNLOADINGFONTS;
}
}
//
// Guessing,,,
// To do : Add GetPrinterDriver for DRIVER_INFO_8, test PRINTER_DRIVER_XPS flag,
// to set *downloadFontsFlags |= QSM_XPS_PASS;
//
// Vista+ looks for QSM_XPS_PASS to be set in GDI32.
//
HeapFree(hProcessHeap, 0, pi2);
return res;
}
//
// This requires IC support.
//
DWORD WINAPI
QueryRemoteFonts( HANDLE hPrinter, PUNIVERSAL_FONT_ID pufi, ULONG NumberOfUFIs )
{
HANDLE hIC;
DWORD Result = -1, cOut, cIn = 0;
PBYTE pOut;
FIXME("QueryRemoteFonts(%p, %p, %lu)\n", hPrinter, pufi, NumberOfUFIs);
hIC = CreatePrinterIC( hPrinter, NULL );
if ( hIC )
{
cOut = (NumberOfUFIs * sizeof(UNIVERSAL_FONT_ID)) + sizeof(DWORD); // Include "DWORD" first part to return size.
pOut = HeapAlloc( hProcessHeap, 0, cOut );
if ( pOut )
{
if ( PlayGdiScriptOnPrinterIC( hIC, (LPBYTE)&cIn, sizeof(DWORD), pOut, cOut, 0 ) )
{
cIn = *((PDWORD)pOut); // Fisrt part is the size of the UFID object.
Result = cIn; // Return the required size.
if( NumberOfUFIs < cIn )
{
cIn = NumberOfUFIs;
}
// Copy whole object back to GDI32, exclude first DWORD part.
memcpy( pufi, pOut + sizeof(DWORD), cIn * sizeof(UNIVERSAL_FONT_ID) );
}
HeapFree( hProcessHeap, 0, pOut );
}
DeletePrinterIC( hIC );
}
return Result;
}
BOOL WINAPI
ReadPrinter(HANDLE hPrinter, PVOID pBuf, DWORD cbBuf, PDWORD pNoBytesRead)
{
DWORD dwErrorCode;
PSPOOLER_HANDLE pHandle = (PSPOOLER_HANDLE)hPrinter;
TRACE("ReadPrinter(%p, %p, %lu, %p)\n", hPrinter, pBuf, cbBuf, pNoBytesRead);
// Sanity checks.
if (!pHandle)
{
dwErrorCode = ERROR_INVALID_HANDLE;
goto Cleanup;
}
// Do the RPC call
RpcTryExcept
{
dwErrorCode = _RpcReadPrinter(pHandle->hPrinter, pBuf, cbBuf, pNoBytesRead);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
dwErrorCode = RpcExceptionCode();
ERR("_RpcReadPrinter failed with exception code %lu!\n", dwErrorCode);
}
RpcEndExcept;
Cleanup:
SetLastError(dwErrorCode);
return (dwErrorCode == ERROR_SUCCESS);
}
BOOL WINAPI
ResetPrinterA(HANDLE hPrinter, PPRINTER_DEFAULTSA pDefault)
{
BOOL ret;
UNICODE_STRING pNameW;
PDEVMODEW pdmw = NULL;
PPRINTER_DEFAULTSW pdw = (PPRINTER_DEFAULTSW)pDefault;
TRACE("ResetPrinterA(%p, %p)\n", hPrinter, pDefault);
if ( pDefault->pDatatype == (LPSTR)-1 )
{
pdw->pDatatype = (LPWSTR)-1;
}
else
{
pdw->pDatatype = AsciiToUnicode( &pNameW, pDefault->pDatatype );
}
if ( pDefault->pDevMode == (LPDEVMODEA)-1)
{
pdw->pDevMode = (LPDEVMODEW)-1;
}
else
{
if ( pDefault->pDevMode )//&& IsValidDevmodeNoSizeW( pDefault->pDevMode ) )
{
RosConvertAnsiDevModeToUnicodeDevmode( pDefault->pDevMode, &pdmw );
pdw->pDevMode = pdmw;
}
}
ret = ResetPrinterW( hPrinter, pdw );
if (pdmw) HeapFree(hProcessHeap, 0, pdmw);
RtlFreeUnicodeString( &pNameW );
return ret;
}
BOOL WINAPI
ResetPrinterW(HANDLE hPrinter, PPRINTER_DEFAULTSW pDefault)
{
TRACE("ResetPrinterW(%p, %p)\n", hPrinter, pDefault);
UNIMPLEMENTED;
return FALSE;
}
BOOL WINAPI
SeekPrinter( HANDLE hPrinter, LARGE_INTEGER liDistanceToMove, PLARGE_INTEGER pliNewPointer, DWORD dwMoveMethod, BOOL bWrite )
{
DWORD dwErrorCode;
PSPOOLER_HANDLE pHandle = (PSPOOLER_HANDLE)hPrinter;
FIXME("SeekPrinter(%p, %I64u, %p, %lu, %d)\n", hPrinter, liDistanceToMove.QuadPart, pliNewPointer, dwMoveMethod, bWrite);
// Sanity checks.
if (!pHandle)
{
dwErrorCode = ERROR_INVALID_HANDLE;
goto Cleanup;
}
// Do the RPC call
RpcTryExcept
{
dwErrorCode = _RpcSeekPrinter(pHandle->hPrinter, liDistanceToMove, pliNewPointer, dwMoveMethod, bWrite);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
dwErrorCode = RpcExceptionCode();
ERR("_RpcSeekPrinter failed with exception code %lu!\n", dwErrorCode);
}
RpcEndExcept;
Cleanup:
SetLastError(dwErrorCode);
return (dwErrorCode == ERROR_SUCCESS);
}
BOOL WINAPI
SetDefaultPrinterA(LPCSTR pszPrinter)
{
BOOL bReturnValue = FALSE;
DWORD cch;
PWSTR pwszPrinter = NULL;
TRACE("SetDefaultPrinterA(%s)\n", pszPrinter);
if (pszPrinter)
{
// Convert pszPrinter to a Unicode string pwszPrinter
cch = strlen(pszPrinter);
pwszPrinter = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(WCHAR));
if (!pwszPrinter)
{
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
MultiByteToWideChar(CP_ACP, 0, pszPrinter, -1, pwszPrinter, cch + 1);
}
bReturnValue = SetDefaultPrinterW(pwszPrinter);
Cleanup:
if (pwszPrinter)
HeapFree(hProcessHeap, 0, pwszPrinter);
return bReturnValue;
}
BOOL WINAPI
SetDefaultPrinterW(LPCWSTR pszPrinter)
{
const WCHAR wszDevicesKey[] = L"Software\\Microsoft\\Windows NT\\CurrentVersion\\Devices";
DWORD cbDeviceValueData;
DWORD cbPrinterValueData = 0;
DWORD cchPrinter;
DWORD dwErrorCode;
HKEY hDevicesKey = NULL;
HKEY hWindowsKey = NULL;
PWSTR pwszDeviceValueData = NULL;
WCHAR wszPrinter[MAX_PRINTER_NAME + 1];
TRACE("SetDefaultPrinterW(%S)\n", pszPrinter);
// Open the Devices registry key.
dwErrorCode = (DWORD)RegOpenKeyExW(HKEY_CURRENT_USER, wszDevicesKey, 0, KEY_READ, &hDevicesKey);
if (dwErrorCode != ERROR_SUCCESS)
{
ERR("RegOpenKeyExW failed with status %lu!\n", dwErrorCode);
goto Cleanup;
}
// Did the caller give us a printer to set as default?
if (pszPrinter && *pszPrinter)
{
// Check if the given printer exists and query the value data size.
dwErrorCode = (DWORD)RegQueryValueExW(hDevicesKey, pszPrinter, NULL, NULL, NULL, &cbPrinterValueData);
if (dwErrorCode == ERROR_FILE_NOT_FOUND)
{
dwErrorCode = ERROR_INVALID_PRINTER_NAME;
goto Cleanup;
}
else if (dwErrorCode != ERROR_SUCCESS)
{
ERR("RegQueryValueExW failed with status %lu!\n", dwErrorCode);
goto Cleanup;
}
cchPrinter = wcslen(pszPrinter);
}
else
{
// If there is already a default printer, we're done!
cchPrinter = _countof(wszPrinter);
if (GetDefaultPrinterW(wszPrinter, &cchPrinter))
{
dwErrorCode = ERROR_SUCCESS;
goto Cleanup;
}
// Otherwise, get us the first printer from the "Devices" key to later set it as default and query the value data size.
cchPrinter = _countof(wszPrinter);
dwErrorCode = (DWORD)RegEnumValueW(hDevicesKey, 0, wszPrinter, &cchPrinter, NULL, NULL, NULL, &cbPrinterValueData);
if (dwErrorCode != ERROR_MORE_DATA)
goto Cleanup;
pszPrinter = wszPrinter;
}
// We now need to query the value data, which has the format "winspool,<Port>:"
// and make "<Printer Name>,winspool,<Port>:" out of it.
// Allocate a buffer large enough for the final data.
cbDeviceValueData = (cchPrinter + 1) * sizeof(WCHAR) + cbPrinterValueData;
pwszDeviceValueData = HeapAlloc(hProcessHeap, 0, cbDeviceValueData);
if (!pwszDeviceValueData)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
// Copy the Printer Name and a comma into it.
CopyMemory(pwszDeviceValueData, pszPrinter, cchPrinter * sizeof(WCHAR));
pwszDeviceValueData[cchPrinter] = L',';
// Append the value data, which has the format "winspool,<Port>:"
dwErrorCode = (DWORD)RegQueryValueExW(hDevicesKey, pszPrinter, NULL, NULL, (PBYTE)&pwszDeviceValueData[cchPrinter + 1], &cbPrinterValueData);
if (dwErrorCode != ERROR_SUCCESS)
goto Cleanup;
// Open the Windows registry key.
dwErrorCode = (DWORD)RegOpenKeyExW(HKEY_CURRENT_USER, wszWindowsKey, 0, KEY_SET_VALUE, &hWindowsKey);
if (dwErrorCode != ERROR_SUCCESS)
{
ERR("RegOpenKeyExW failed with status %lu!\n", dwErrorCode);
goto Cleanup;
}
// Store our new default printer.
dwErrorCode = (DWORD)RegSetValueExW(hWindowsKey, wszDeviceValue, 0, REG_SZ, (PBYTE)pwszDeviceValueData, cbDeviceValueData);
if (dwErrorCode != ERROR_SUCCESS)
{
ERR("RegSetValueExW failed with status %lu!\n", dwErrorCode);
goto Cleanup;
}
Cleanup:
if (hDevicesKey)
RegCloseKey(hDevicesKey);
if (hWindowsKey)
RegCloseKey(hWindowsKey);
if (pwszDeviceValueData)
HeapFree(hProcessHeap, 0, pwszDeviceValueData);
SetLastError(dwErrorCode);
return (dwErrorCode == ERROR_SUCCESS);
}
BOOL WINAPI
SetPrinterA(HANDLE hPrinter, DWORD Level, PBYTE pPrinter, DWORD Command)
{
BOOL Ret = FALSE;
UNICODE_STRING usBuffer;
PPRINTER_INFO_STRESS ppisa = (PPRINTER_INFO_STRESS)pPrinter;
PPRINTER_INFO_STRESS ppisw = (PPRINTER_INFO_STRESS)pPrinter;
PPRINTER_INFO_2A ppi2a = (PPRINTER_INFO_2A)pPrinter;
PPRINTER_INFO_2W ppi2w = (PPRINTER_INFO_2W)pPrinter;
PPRINTER_INFO_7A ppi7a = (PPRINTER_INFO_7A)pPrinter;
PPRINTER_INFO_7W ppi7w = (PPRINTER_INFO_7W)pPrinter;
PPRINTER_INFO_9A ppi9a = (PPRINTER_INFO_9A)pPrinter;
PPRINTER_INFO_9W ppi9w = (PPRINTER_INFO_9W)pPrinter;
PWSTR pwszPrinterName = NULL;
PWSTR pwszServerName = NULL;
PWSTR pwszShareName = NULL;
PWSTR pwszPortName = NULL;
PWSTR pwszDriverName = NULL;
PWSTR pwszComment = NULL;
PWSTR pwszLocation = NULL;
PWSTR pwszSepFile = NULL;
PWSTR pwszPrintProcessor = NULL;
PWSTR pwszDatatype = NULL;
PWSTR pwszParameters = NULL;
PDEVMODEW pdmw = NULL;
FIXME("SetPrinterA(%p, %lu, %p, %lu)\n", hPrinter, Level, pPrinter, Command);
switch ( Level )
{
case 0:
if ( Command == 0 )
{
if (ppisa->pPrinterName)
{
pwszPrinterName = AsciiToUnicode(&usBuffer, (LPCSTR)ppisa->pPrinterName);
if (!(ppisw->pPrinterName = pwszPrinterName)) goto Cleanup;
}
if (ppisa->pServerName)
{
pwszServerName = AsciiToUnicode(&usBuffer, (LPCSTR)ppisa->pServerName);
if (!(ppisw->pPrinterName = pwszServerName)) goto Cleanup;
}
}
if ( Command == PRINTER_CONTROL_SET_STATUS )
{
// Set the pPrinter parameter to a pointer to a DWORD value that specifies the new printer status.
PRINTER_INFO_6 pi6;
pi6.dwStatus = (DWORD_PTR)pPrinter;
pPrinter = (LPBYTE)&pi6;
Level = 6;
Command = 0;
}
break;
case 2:
{
if (ppi2a->pShareName)
{
pwszShareName = AsciiToUnicode(&usBuffer, ppi2a->pShareName);
if (!(ppi2w->pShareName = pwszShareName)) goto Cleanup;
}
if (ppi2a->pPortName)
{
pwszPortName = AsciiToUnicode(&usBuffer, ppi2a->pPortName);
if (!(ppi2w->pPortName = pwszPortName)) goto Cleanup;
}
if (ppi2a->pDriverName)
{
pwszDriverName = AsciiToUnicode(&usBuffer, ppi2a->pDriverName);
if (!(ppi2w->pDriverName = pwszDriverName)) goto Cleanup;
}
if (ppi2a->pComment)
{
pwszComment = AsciiToUnicode(&usBuffer, ppi2a->pComment);
if (!(ppi2w->pComment = pwszComment)) goto Cleanup;
}
if (ppi2a->pLocation)
{
pwszLocation = AsciiToUnicode(&usBuffer, ppi2a->pLocation);
if (!(ppi2w->pLocation = pwszLocation)) goto Cleanup;
}
if (ppi2a->pSepFile)
{
pwszSepFile = AsciiToUnicode(&usBuffer, ppi2a->pSepFile);
if (!(ppi2w->pSepFile = pwszSepFile)) goto Cleanup;
}
if (ppi2a->pServerName)
{
pwszPrintProcessor = AsciiToUnicode(&usBuffer, ppi2a->pPrintProcessor);
if (!(ppi2w->pPrintProcessor = pwszPrintProcessor)) goto Cleanup;
}
if (ppi2a->pDatatype)
{
pwszDatatype = AsciiToUnicode(&usBuffer, ppi2a->pDatatype);
if (!(ppi2w->pDatatype = pwszDatatype)) goto Cleanup;
}
if (ppi2a->pParameters)
{
pwszParameters = AsciiToUnicode(&usBuffer, ppi2a->pParameters);
if (!(ppi2w->pParameters = pwszParameters)) goto Cleanup;
}
if ( ppi2a->pDevMode )
{
RosConvertAnsiDevModeToUnicodeDevmode( ppi2a->pDevMode, &pdmw );
ppi2w->pDevMode = pdmw;
}
}
//
// These two strings are relitive and common to these three Levels.
// Fall through...
//
case 4:
case 5:
{
if (ppi2a->pServerName) // 4 & 5 : pPrinterName.
{
pwszServerName = AsciiToUnicode(&usBuffer, ppi2a->pServerName);
if (!(ppi2w->pPrinterName = pwszServerName)) goto Cleanup;
}
if (ppi2a->pPrinterName) // 4 : pServerName, 5 : pPortName.
{
pwszPrinterName = AsciiToUnicode(&usBuffer, ppi2a->pPrinterName);
if (!(ppi2w->pPrinterName = pwszPrinterName)) goto Cleanup;
}
}
break;
case 3:
case 6:
break;
case 7:
{
if (ppi7a->pszObjectGUID)
{
pwszPrinterName = AsciiToUnicode(&usBuffer, ppi7a->pszObjectGUID);
if (!(ppi7w->pszObjectGUID = pwszPrinterName)) goto Cleanup;
}
}
break;
case 8:
/* 8 is the global default printer info and 9 already sets it instead of the per-user one */
/* still, PRINTER_INFO_8W is the same as PRINTER_INFO_9W */
/* fall through */
case 9:
{
RosConvertAnsiDevModeToUnicodeDevmode( ppi9a->pDevMode, &pdmw );
ppi9w->pDevMode = pdmw;
}
break;
default:
FIXME( "Unsupported level %d\n", Level);
SetLastError( ERROR_INVALID_LEVEL );
}
Ret = SetPrinterW( hPrinter, Level, pPrinter, Command );
Cleanup:
if (pdmw) HeapFree(hProcessHeap, 0, pdmw);
if (pwszPrinterName) HeapFree(hProcessHeap, 0, pwszPrinterName);
if (pwszServerName) HeapFree(hProcessHeap, 0, pwszServerName);
if (pwszShareName) HeapFree(hProcessHeap, 0, pwszShareName);
if (pwszPortName) HeapFree(hProcessHeap, 0, pwszPortName);
if (pwszDriverName) HeapFree(hProcessHeap, 0, pwszDriverName);
if (pwszComment) HeapFree(hProcessHeap, 0, pwszComment);
if (pwszLocation) HeapFree(hProcessHeap, 0, pwszLocation);
if (pwszSepFile) HeapFree(hProcessHeap, 0, pwszSepFile);
if (pwszPrintProcessor) HeapFree(hProcessHeap, 0, pwszPrintProcessor);
if (pwszDatatype) HeapFree(hProcessHeap, 0, pwszDatatype);
if (pwszParameters) HeapFree(hProcessHeap, 0, pwszParameters);
return Ret;
}
BOOL WINAPI
SetPrinterW(HANDLE hPrinter, DWORD Level, PBYTE pPrinter, DWORD Command)
{
DWORD dwErrorCode;
WINSPOOL_PRINTER_CONTAINER PrinterContainer;
WINSPOOL_DEVMODE_CONTAINER DevModeContainer;
WINSPOOL_SECURITY_CONTAINER SecurityContainer;
SECURITY_DESCRIPTOR *sd = NULL;
DWORD size;
PSPOOLER_HANDLE pHandle = (PSPOOLER_HANDLE)hPrinter;
FIXME("SetPrinterW(%p, %lu, %p, %lu)\n", hPrinter, Level, pPrinter, Command);
// Sanity checks
if (!pHandle)
return ERROR_INVALID_HANDLE;
DevModeContainer.cbBuf = 0;
DevModeContainer.pDevMode = NULL;
SecurityContainer.cbBuf = 0;
SecurityContainer.pSecurity = NULL;
switch ( Level )
{
case 0:
if ( Command == PRINTER_CONTROL_SET_STATUS )
{
// Set the pPrinter parameter to a pointer to a DWORD value that specifies the new printer status.
PRINTER_INFO_6 pi6;
pi6.dwStatus = (DWORD_PTR)pPrinter;
pPrinter = (LPBYTE)&pi6;
Level = 6;
Command = 0;
}
break;
case 2:
{
PPRINTER_INFO_2W pi2w = (PPRINTER_INFO_2W)pPrinter;
if ( pi2w )
{
if ( pi2w->pDevMode )
{
if ( IsValidDevmodeNoSizeW( pi2w->pDevMode ) )
{
DevModeContainer.cbBuf = pi2w->pDevMode->dmSize + pi2w->pDevMode->dmDriverExtra;
DevModeContainer.pDevMode = (PBYTE)pi2w->pDevMode;
}
}
if ( pi2w->pSecurityDescriptor )
{
sd = get_sd( pi2w->pSecurityDescriptor, &size );
if ( sd )
{
SecurityContainer.cbBuf = size;
SecurityContainer.pSecurity = (PBYTE)sd;
}
}
}
else
{
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
}
break;
case 3:
{
PPRINTER_INFO_3 pi3 = (PPRINTER_INFO_3)pPrinter;
if ( pi3 )
{
if ( pi3->pSecurityDescriptor )
{
sd = get_sd( pi3->pSecurityDescriptor, &size );
if ( sd )
{
SecurityContainer.cbBuf = size;
SecurityContainer.pSecurity = (PBYTE)sd;
}
}
}
else
{
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
}
break;
case 4:
case 5:
case 6:
case 7:
if ( pPrinter == NULL )
{
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
break;
case 8:
/* 8 is the global default printer info and 9 already sets it instead of the per-user one */
/* still, PRINTER_INFO_8W is the same as PRINTER_INFO_9W */
/* fall through */
case 9:
{
PPRINTER_INFO_9W pi9w = (PPRINTER_INFO_9W)pPrinter;
if ( pi9w )
{
if ( pi9w->pDevMode )
{
if ( IsValidDevmodeNoSizeW( pi9w->pDevMode ) )
{
DevModeContainer.cbBuf = pi9w->pDevMode->dmSize + pi9w->pDevMode->dmDriverExtra;
DevModeContainer.pDevMode = (LPBYTE)pi9w->pDevMode;
}
}
}
}
break;
default:
FIXME( "Unsupported level %d\n", Level );
SetLastError( ERROR_INVALID_LEVEL );
return FALSE;
}
PrinterContainer.PrinterInfo.pPrinterInfo1 = (WINSPOOL_PRINTER_INFO_1*)pPrinter;
PrinterContainer.Level = Level;
// Do the RPC call
RpcTryExcept
{
dwErrorCode = _RpcSetPrinter(pHandle->hPrinter, &PrinterContainer, &DevModeContainer, &SecurityContainer, Command);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
dwErrorCode = RpcExceptionCode();
}
RpcEndExcept;
if ( sd ) HeapFree( GetProcessHeap(), 0, sd );
SetLastError(dwErrorCode);
return (dwErrorCode == ERROR_SUCCESS);
}
BOOL WINAPI
SplDriverUnloadComplete(LPWSTR pDriverFile)
{
TRACE("DriverUnloadComplete(%S)\n", pDriverFile);
UNIMPLEMENTED;
return TRUE; // return true for now.
}
BOOL WINAPI
SpoolerPrinterEvent( LPWSTR pPrinterName, INT DriverEvent, DWORD Flags, LPARAM lParam )
{
HMODULE hLibrary;
HANDLE hPrinter;
BOOL Ret = FALSE;
if ( OpenPrinterW( pPrinterName, &hPrinter, NULL ) )
{
hLibrary = LoadPrinterDriver( hPrinter );
if ( hLibrary )
{
fpPrinterEvent = (PVOID)GetProcAddress( hLibrary, "DrvPrinterEvent" );
if ( fpPrinterEvent )
{
Ret = fpPrinterEvent( pPrinterName, DriverEvent, Flags, lParam );
}
FreeLibrary(hLibrary);
}
ClosePrinter( hPrinter );
}
return Ret;
}
INT_PTR CALLBACK file_dlg_proc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
{
LPWSTR filename;
switch(msg)
{
case WM_INITDIALOG:
SetWindowLongPtrW(hwnd, DWLP_USER, lparam);
return TRUE;
case WM_COMMAND:
if(HIWORD(wparam) == BN_CLICKED)
{
if(LOWORD(wparam) == IDOK)
{
HANDLE hf;
DWORD len = SendDlgItemMessageW(hwnd, EDITBOX, WM_GETTEXTLENGTH, 0, 0);
LPWSTR *output;
filename = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
if (!filename)
{
ERR("Failed to allocate filename of %u bytes\n", (len + 1) * sizeof(WCHAR));
return FALSE;
}
GetDlgItemTextW(hwnd, EDITBOX, filename, len + 1);
if(GetFileAttributesW(filename) != INVALID_FILE_ATTRIBUTES)
{
WCHAR caption[200], message[200];
int mb_ret;
LoadStringW(hinstWinSpool, IDS_CAPTION, caption, ARRAYSIZE(caption));
LoadStringW(hinstWinSpool, IDS_FILE_EXISTS, message, ARRAYSIZE(message));
mb_ret = MessageBoxW(hwnd, message, caption, MB_OKCANCEL | MB_ICONEXCLAMATION);
if(mb_ret == IDCANCEL)
{
HeapFree(GetProcessHeap(), 0, filename);
return TRUE;
}
}
hf = CreateFileW(filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if(hf == INVALID_HANDLE_VALUE)
{
WCHAR caption[200], message[200];
LoadStringW(hinstWinSpool, IDS_CAPTION, caption, ARRAYSIZE(caption));
LoadStringW(hinstWinSpool, IDS_CANNOT_OPEN, message, ARRAYSIZE(message));
MessageBoxW(hwnd, message, caption, MB_OK | MB_ICONEXCLAMATION);
HeapFree(GetProcessHeap(), 0, filename);
return TRUE;
}
CloseHandle(hf);
DeleteFileW(filename);
output = (LPWSTR *)GetWindowLongPtrW(hwnd, DWLP_USER);
*output = filename;
EndDialog(hwnd, IDOK);
return TRUE;
}
if(LOWORD(wparam) == IDCANCEL)
{
EndDialog(hwnd, IDCANCEL);
return TRUE;
}
}
return FALSE;
}
return FALSE;
}
static const WCHAR FILE_Port[] = {'F','I','L','E',':',0};
LPWSTR WINAPI
StartDocDlgW( HANDLE hPrinter, DOCINFOW *doc )
{
LPWSTR ret = NULL;
DWORD len, attr, retDlg;
FIXME("StartDocDlgW(%p, %p)\n", hPrinter, doc);
if (doc->lpszOutput == NULL) /* Check whether default port is FILE: */
{
PRINTER_INFO_5W *pi5;
GetPrinterW(hPrinter, 5, NULL, 0, &len);
if(GetLastError() != ERROR_INSUFFICIENT_BUFFER)
return NULL;
pi5 = HeapAlloc(GetProcessHeap(), 0, len);
if (!pi5)
{
ERR("Failed to allocate PRINTER_INFO_5W of %u bytes\n", len);
return NULL;
}
GetPrinterW(hPrinter, 5, (LPBYTE)pi5, len, &len);
if (!pi5->pPortName || wcsicmp(pi5->pPortName, FILE_Port))
{
HeapFree(GetProcessHeap(), 0, pi5);
return NULL;
}
HeapFree(GetProcessHeap(), 0, pi5);
}
if (doc->lpszOutput == NULL || !wcsicmp(doc->lpszOutput, FILE_Port))
{
LPWSTR name;
retDlg = DialogBoxParamW( hinstWinSpool,
MAKEINTRESOURCEW(FILENAME_DIALOG),
GetForegroundWindow(),
file_dlg_proc,
(LPARAM)&name );
if ( retDlg == IDOK )
{
if (!(len = GetFullPathNameW(name, 0, NULL, NULL)))
{
HeapFree(GetProcessHeap(), 0, name);
return NULL;
}
ret = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
if (!ret)
{
ERR("Failed to allocate path name buffer of %u bytes\n", len * sizeof(WCHAR));
HeapFree(GetProcessHeap(), 0, name);
return NULL;
}
GetFullPathNameW(name, len, ret, NULL);
HeapFree(GetProcessHeap(), 0, name);
}
else if ( retDlg == 0 ) // FALSE, some type of error occurred.
{
ret = (LPWSTR)SP_ERROR;
}
else if ( retDlg == IDCANCEL )
{
SetLastError( ERROR_CANCELLED );
ret = (LPWSTR)SP_APPABORT;
}
return ret;
}
if (!(len = GetFullPathNameW(doc->lpszOutput, 0, NULL, NULL)))
return NULL;
ret = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
if (!ret)
{
ERR("Failed to allocate path name buffer of %u bytes\n", len * sizeof(WCHAR));
return NULL;
}
GetFullPathNameW(doc->lpszOutput, len, ret, NULL);
attr = GetFileAttributesW(ret);
if (attr != INVALID_FILE_ATTRIBUTES && (attr & FILE_ATTRIBUTE_DIRECTORY))
{
HeapFree(GetProcessHeap(), 0, ret);
ret = NULL;
}
return ret;
}
LPSTR WINAPI
StartDocDlgA( HANDLE hPrinter, DOCINFOA *doc )
{
UNICODE_STRING usBuffer;
DOCINFOW docW = { 0 };
LPWSTR retW;
LPWSTR docnameW = NULL, outputW = NULL, datatypeW = NULL;
LPSTR ret = NULL;
docW.cbSize = sizeof(docW);
if (doc->lpszDocName)
{
docnameW = AsciiToUnicode(&usBuffer, doc->lpszDocName);
if (!(docW.lpszDocName = docnameW)) goto failed;
}
if (doc->lpszOutput)
{
outputW = AsciiToUnicode(&usBuffer, doc->lpszOutput);
if (!(docW.lpszOutput = outputW)) goto failed;
}
if (doc->lpszDatatype)
{
datatypeW = AsciiToUnicode(&usBuffer, doc->lpszDatatype);
if (!(docW.lpszDatatype = datatypeW)) goto failed;
}
docW.fwType = doc->fwType;
retW = StartDocDlgW(hPrinter, &docW);
if (retW)
{
DWORD len = WideCharToMultiByte(CP_ACP, 0, retW, -1, NULL, 0, NULL, NULL);
ret = HeapAlloc(GetProcessHeap(), 0, len);
if (ret)
{
WideCharToMultiByte(CP_ACP, 0, retW, -1, ret, len, NULL, NULL);
}
else
{
ERR("Failed to allocate path name buffer of %u bytes\n", len);
}
HeapFree(GetProcessHeap(), 0, retW);
}
failed:
if (datatypeW) HeapFree(GetProcessHeap(), 0, datatypeW);
if (outputW) HeapFree(GetProcessHeap(), 0, outputW);
if (docnameW) HeapFree(GetProcessHeap(), 0, docnameW);
return ret;
}
DWORD WINAPI
StartDocPrinterA(HANDLE hPrinter, DWORD Level, PBYTE pDocInfo)
{
DOC_INFO_1W wDocInfo1 = { 0 };
DWORD cch;
DWORD dwErrorCode;
DWORD dwReturnValue = 0;
PDOC_INFO_1A pDocInfo1 = (PDOC_INFO_1A)pDocInfo;
TRACE("StartDocPrinterA(%p, %lu, %p)\n", hPrinter, Level, pDocInfo);
// Only check the minimum required for accessing pDocInfo.
// Additional sanity checks are done in StartDocPrinterW.
if (!pDocInfo1)
{
dwErrorCode = ERROR_INVALID_PARAMETER;
goto Cleanup;
}
if (Level != 1)
{
ERR("Level = %d, unsupported!\n", Level);
dwErrorCode = ERROR_INVALID_LEVEL;
goto Cleanup;
}
if (pDocInfo1->pDatatype)
{
// Convert pDocInfo1->pDatatype to a Unicode string wDocInfo1.pDatatype
cch = strlen(pDocInfo1->pDatatype);
wDocInfo1.pDatatype = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(WCHAR));
if (!wDocInfo1.pDatatype)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
MultiByteToWideChar(CP_ACP, 0, pDocInfo1->pDatatype, -1, wDocInfo1.pDatatype, cch + 1);
}
if (pDocInfo1->pDocName)
{
// Convert pDocInfo1->pDocName to a Unicode string wDocInfo1.pDocName
cch = strlen(pDocInfo1->pDocName);
wDocInfo1.pDocName = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(WCHAR));
if (!wDocInfo1.pDocName)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
MultiByteToWideChar(CP_ACP, 0, pDocInfo1->pDocName, -1, wDocInfo1.pDocName, cch + 1);
}
if (pDocInfo1->pOutputFile)
{
// Convert pDocInfo1->pOutputFile to a Unicode string wDocInfo1.pOutputFile
cch = strlen(pDocInfo1->pOutputFile);
wDocInfo1.pOutputFile = HeapAlloc(hProcessHeap, 0, (cch + 1) * sizeof(WCHAR));
if (!wDocInfo1.pOutputFile)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
MultiByteToWideChar(CP_ACP, 0, pDocInfo1->pOutputFile, -1, wDocInfo1.pOutputFile, cch + 1);
}
dwReturnValue = StartDocPrinterW(hPrinter, Level, (PBYTE)&wDocInfo1);
dwErrorCode = GetLastError();
Cleanup:
if (wDocInfo1.pDatatype)
HeapFree(hProcessHeap, 0, wDocInfo1.pDatatype);
if (wDocInfo1.pDocName)
HeapFree(hProcessHeap, 0, wDocInfo1.pDocName);
if (wDocInfo1.pOutputFile)
HeapFree(hProcessHeap, 0, wDocInfo1.pOutputFile);
SetLastError(dwErrorCode);
return dwReturnValue;
}
DWORD WINAPI
StartDocPrinterW(HANDLE hPrinter, DWORD Level, PBYTE pDocInfo)
{
DWORD cbAddJobInfo1;
DWORD cbNeeded;
DWORD dwErrorCode;
DWORD dwReturnValue = 0;
PADDJOB_INFO_1W pAddJobInfo1 = NULL;
PDOC_INFO_1W pDocInfo1 = (PDOC_INFO_1W)pDocInfo;
PSPOOLER_HANDLE pHandle = (PSPOOLER_HANDLE)hPrinter;
TRACE("StartDocPrinterW(%p, %lu, %p)\n", hPrinter, Level, pDocInfo);
// Sanity checks.
if (!pHandle)
{
dwErrorCode = ERROR_INVALID_HANDLE;
goto Cleanup;
}
if (!pDocInfo1)
{
dwErrorCode = ERROR_INVALID_PARAMETER;
goto Cleanup;
}
if (Level != 1)
{
ERR("Level = %d, unsupported!\n", Level);
dwErrorCode = ERROR_INVALID_LEVEL;
goto Cleanup;
}
if (pHandle->bStartedDoc)
{
dwErrorCode = ERROR_INVALID_PRINTER_STATE;
goto Cleanup;
}
// Check if we want to redirect output into a file.
if (pDocInfo1->pOutputFile)
{
// Do a StartDocPrinter RPC call in this case.
dwErrorCode = _StartDocPrinterWithRPC(pHandle, pDocInfo1);
}
else
{
// Allocate memory for the ADDJOB_INFO_1W structure and a path.
cbAddJobInfo1 = sizeof(ADDJOB_INFO_1W) + MAX_PATH * sizeof(WCHAR);
pAddJobInfo1 = HeapAlloc(hProcessHeap, 0, cbAddJobInfo1);
if (!pAddJobInfo1)
{
dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
ERR("HeapAlloc failed!\n");
goto Cleanup;
}
// Try to add a new job.
// This only succeeds if the printer is set to do spooled printing.
if (AddJobW((HANDLE)pHandle, 1, (PBYTE)pAddJobInfo1, cbAddJobInfo1, &cbNeeded))
{
// Do spooled printing.
dwErrorCode = _StartDocPrinterSpooled(pHandle, pDocInfo1, pAddJobInfo1);
}
else if (GetLastError() == ERROR_INVALID_ACCESS)
{
// ERROR_INVALID_ACCESS is returned when the printer is set to do direct printing.
// In this case, we do a StartDocPrinter RPC call.
dwErrorCode = _StartDocPrinterWithRPC(pHandle, pDocInfo1);
}
else
{
dwErrorCode = GetLastError();
ERR("AddJobW failed with error %lu!\n", dwErrorCode);
goto Cleanup;
}
}
if (dwErrorCode == ERROR_SUCCESS)
{
pHandle->bStartedDoc = TRUE;
dwReturnValue = pHandle->dwJobID;
if ( !pHandle->bTrayIcon )
{
UpdateTrayIcon( hPrinter, pHandle->dwJobID );
}
}
Cleanup:
if (pAddJobInfo1)
HeapFree(hProcessHeap, 0, pAddJobInfo1);
SetLastError(dwErrorCode);
return dwReturnValue;
}
BOOL WINAPI
StartPagePrinter(HANDLE hPrinter)
{
DWORD dwErrorCode;
PSPOOLER_HANDLE pHandle = (PSPOOLER_HANDLE)hPrinter;
TRACE("StartPagePrinter(%p)\n", hPrinter);
// Sanity checks.
if (!pHandle)
{
dwErrorCode = ERROR_INVALID_HANDLE;
goto Cleanup;
}
// Do the RPC call
RpcTryExcept
{
dwErrorCode = _RpcStartPagePrinter(pHandle->hPrinter);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
dwErrorCode = RpcExceptionCode();
ERR("_RpcStartPagePrinter failed with exception code %lu!\n", dwErrorCode);
}
RpcEndExcept;
Cleanup:
SetLastError(dwErrorCode);
return (dwErrorCode == ERROR_SUCCESS);
}
BOOL WINAPI
WritePrinter(HANDLE hPrinter, PVOID pBuf, DWORD cbBuf, PDWORD pcWritten)
{
DWORD dwErrorCode;
PSPOOLER_HANDLE pHandle = (PSPOOLER_HANDLE)hPrinter;
TRACE("WritePrinter(%p, %p, %lu, %p)\n", hPrinter, pBuf, cbBuf, pcWritten);
// Sanity checks.
if (!pHandle)
{
dwErrorCode = ERROR_INVALID_HANDLE;
goto Cleanup;
}
if (!pHandle->bStartedDoc)
{
dwErrorCode = ERROR_SPL_NO_STARTDOC;
goto Cleanup;
}
if (pHandle->hSPLFile != INVALID_HANDLE_VALUE)
{
// Write to the spool file. This doesn't need an RPC request.
if (!WriteFile(pHandle->hSPLFile, pBuf, cbBuf, pcWritten, NULL))
{
dwErrorCode = GetLastError();
ERR("WriteFile failed with error %lu!\n", dwErrorCode);
goto Cleanup;
}
dwErrorCode = ERROR_SUCCESS;
}
else
{
// TODO: This case (for direct printing or remote printing) has bad performance if multiple small-sized WritePrinter calls are performed.
// We may increase performance by writing into a buffer and only doing a single RPC call when the buffer is full.
// Do the RPC call
RpcTryExcept
{
dwErrorCode = _RpcWritePrinter(pHandle->hPrinter, pBuf, cbBuf, pcWritten);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
dwErrorCode = RpcExceptionCode();
ERR("_RpcWritePrinter failed with exception code %lu!\n", dwErrorCode);
}
RpcEndExcept;
}
Cleanup:
SetLastError(dwErrorCode);
return (dwErrorCode == ERROR_SUCCESS);
}
BOOL WINAPI
XcvDataW(HANDLE hXcv, PCWSTR pszDataName, PBYTE pInputData, DWORD cbInputData, PBYTE pOutputData, DWORD cbOutputData, PDWORD pcbOutputNeeded, PDWORD pdwStatus)
{
DWORD dwErrorCode, Bogus = 0;
PSPOOLER_HANDLE pHandle = (PSPOOLER_HANDLE)hXcv;
TRACE("XcvDataW(%p, %S, %p, %lu, %p, %lu, %p, %p)\n", hXcv, pszDataName, pInputData, cbInputData, pOutputData, cbOutputData, pcbOutputNeeded, pdwStatus);
if ( pcbOutputNeeded == NULL )
{
dwErrorCode = ERROR_INVALID_PARAMETER;
goto Cleanup;
}
// Sanity checks.
if (!pHandle) // ( IntProtectHandle( hXcv, FALSE ) )
{
dwErrorCode = ERROR_INVALID_HANDLE;
goto Cleanup;
}
//
// Do fixups.
//
if ( pInputData == NULL )
{
if ( !cbInputData )
{
pInputData = (PBYTE)&Bogus;
}
}
if ( pOutputData == NULL )
{
if ( !cbOutputData )
{
pOutputData = (PBYTE)&Bogus;
}
}
// Do the RPC call
RpcTryExcept
{
dwErrorCode = _RpcXcvData( pHandle->hPrinter,
pszDataName,
pInputData,
cbInputData,
pOutputData,
cbOutputData,
pcbOutputNeeded,
pdwStatus );
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
dwErrorCode = RpcExceptionCode();
ERR("_RpcXcvData failed with exception code %lu!\n", dwErrorCode);
}
RpcEndExcept;
//IntUnprotectHandle( hXcv );
Cleanup:
SetLastError(dwErrorCode);
return (dwErrorCode == ERROR_SUCCESS);
}
Reference in a new issue View git blame Copy permalink