#include <limits.h>
#include <stdlib.h>
#include <wchar.h>
#include <lmcons.h>
#include <rpc.h>
#include <strsafe.h>
#include <windef.h>
#include <winbase.h>
#include <wingdi.h>
#include <winreg.h>
#include <winspool.h>
#include <winsplp.h>
#include <winddiui.h>
#include <dsrole.h>
#include <secext.h>
#include <ndk/rtlfuncs.h>
#include <skiplist.h>
#include <spoolss.h>
#include <wine/debug.h>

Include dependency graph for precomp.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_LOCAL_PRINT_MONITOR

struct	_LOCAL_PORT

struct	_LOCAL_PRINT_PROCESSOR

struct	_LOCAL_PRINTER

struct	_LOCAL_JOB

struct	_LOCAL_PRINTER_HANDLE

struct	_LOCAL_PORT_HANDLE

struct	_LOCAL_XCV_HANDLE

struct	_LOCAL_HANDLE

struct	_SHD_HEADER

struct	_PRINTENV_T

Macros
#define	WIN32_NO_STATUS

#define	SKIPLIST_LEVELS 16

#define	IS_VALID_JOB_ID(ID) (ID >= 1 && ID <= 99999)

#define	IS_VALID_PRIORITY(P) (P >= MIN_PRIORITY && P <= MAX_PRIORITY)

#define	SHD_WIN2003_SIGNATURE 0x4968

Typedefs
typedef BOOL(WINAPI *	PClosePrintProcessor) (HANDLE)

typedef BOOL(WINAPI *	PControlPrintProcessor) (HANDLE, DWORD)

typedef BOOL(WINAPI *	PEnumPrintProcessorDatatypesW) (LPWSTR, LPWSTR, DWORD, LPBYTE, DWORD, LPDWORD, LPDWORD)

typedef DWORD(WINAPI *	PGetPrintProcessorCapabilities) (LPWSTR, DWORD, LPBYTE, DWORD, LPDWORD)

typedef HANDLE(WINAPI *	POpenPrintProcessor) (LPWSTR, PPRINTPROCESSOROPENDATA)

typedef BOOL(WINAPI *	PPrintDocumentOnPrintProcessor) (HANDLE, LPWSTR)

typedef LPMONITOREX(WINAPI *	PInitializePrintMonitor) (PWSTR)

typedef LPMONITOR2(WINAPI *	PInitializePrintMonitor2) (PMONITORINIT, PHANDLE)

typedef PMONITORUI(WINAPI *	PInitializePrintMonitorUI) (VOID)

typedef struct _LOCAL_HANDLE	LOCAL_HANDLE

typedef struct _LOCAL_HANDLE *	PLOCAL_HANDLE

typedef struct _LOCAL_JOB	LOCAL_JOB

typedef struct _LOCAL_JOB *	PLOCAL_JOB

typedef struct _LOCAL_PORT	LOCAL_PORT

typedef struct _LOCAL_PORT *	PLOCAL_PORT

typedef struct _LOCAL_PORT_HANDLE	LOCAL_PORT_HANDLE

typedef struct _LOCAL_PORT_HANDLE *	PLOCAL_PORT_HANDLE

typedef struct _LOCAL_PRINT_MONITOR	LOCAL_PRINT_MONITOR

typedef struct _LOCAL_PRINT_MONITOR *	PLOCAL_PRINT_MONITOR

typedef struct _LOCAL_PRINT_PROCESSOR	LOCAL_PRINT_PROCESSOR

typedef struct _LOCAL_PRINT_PROCESSOR *	PLOCAL_PRINT_PROCESSOR

typedef struct _LOCAL_PRINTER	LOCAL_PRINTER

typedef struct _LOCAL_PRINTER *	PLOCAL_PRINTER

typedef struct _LOCAL_PRINTER_HANDLE	LOCAL_PRINTER_HANDLE

typedef struct _LOCAL_PRINTER_HANDLE *	PLOCAL_PRINTER_HANDLE

typedef struct _LOCAL_XCV_HANDLE	LOCAL_XCV_HANDLE

typedef struct _LOCAL_XCV_HANDLE *	PLOCAL_XCV_HANDLE

typedef struct _SHD_HEADER	SHD_HEADER

typedef struct _SHD_HEADER *	PSHD_HEADER

typedef struct _PRINTENV_T	PRINTENV_T

typedef struct _PRINTENV_T *	PPRINTENV_T

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (localspl)

BOOL	InitializeFormList (VOID)

BOOL WINAPI	LocalAddForm (HANDLE hPrinter, DWORD Level, PBYTE pForm)

BOOL WINAPI	LocalDeleteForm (HANDLE hPrinter, PWSTR pFormName)

BOOL WINAPI	LocalEnumForms (HANDLE hPrinter, DWORD Level, PBYTE pForm, DWORD cbBuf, PDWORD pcbNeeded, PDWORD pcReturned)

BOOL WINAPI	LocalGetForm (HANDLE hPrinter, PWSTR pFormName, DWORD Level, PBYTE pForm, DWORD cbBuf, PDWORD pcbNeeded)

BOOL WINAPI	LocalSetForm (HANDLE hPrinter, PWSTR pFormName, DWORD Level, PBYTE pForm)

DWORD WINAPI	CreateJob (PLOCAL_PRINTER_HANDLE pPrinterHandle)

void	FreeJob (PLOCAL_JOB pJob)

DWORD	GetJobFilePath (PCWSTR pwszExtension, DWORD dwJobID, PWSTR pwszOutput)

BOOL	InitializeGlobalJobList (VOID)

void	InitializePrinterJobList (PLOCAL_PRINTER pPrinter)

BOOL WINAPI	LocalAddJob (HANDLE hPrinter, DWORD Level, LPBYTE pData, DWORD cbBuf, LPDWORD pcbNeeded)

BOOL WINAPI	LocalEnumJobs (HANDLE hPrinter, DWORD FirstJob, DWORD NoJobs, DWORD Level, PBYTE pStart, DWORD cbBuf, LPDWORD pcbNeeded, LPDWORD pcReturned)

BOOL WINAPI	LocalGetJob (HANDLE hPrinter, DWORD JobId, DWORD Level, PBYTE pStart, DWORD cbBuf, LPDWORD pcbNeeded)

BOOL WINAPI	LocalScheduleJob (HANDLE hPrinter, DWORD dwJobID)

BOOL WINAPI	LocalSetJob (HANDLE hPrinter, DWORD JobId, DWORD Level, PBYTE pJobInfo, DWORD Command)

PLOCAL_JOB	ReadJobShadowFile (PCWSTR pwszFilePath)

BOOL	WriteJobShadowFile (PWSTR pwszFilePath, const PLOCAL_JOB pJob)

PLOCAL_PRINT_MONITOR	FindPrintMonitor (PCWSTR pwszName)

BOOL	InitializePrintMonitorList (void)

BOOL WINAPI	LocalEnumMonitors (PWSTR pName, DWORD Level, PBYTE pMonitors, DWORD cbBuf, PDWORD pcbNeeded, PDWORD pcReturned)

BOOL WINAPI	LocalAddMonitor (PWSTR pName, DWORD Level, PBYTE pMonitors)

BOOL WINAPI	LocalDeleteMonitor (PWSTR pName, PWSTR pEnvironment, PWSTR pMonitorName)

PLOCAL_PORT	FindPort (PCWSTR pwszName)

BOOL	InitializePortList (void)

BOOL WINAPI	LocalEnumPorts (PWSTR pName, DWORD Level, PBYTE pPorts, DWORD cbBuf, PDWORD pcbNeeded, PDWORD pcReturned)

BOOL WINAPI	LocalAddPortEx (PWSTR pName, DWORD Level, PBYTE lpBuffer, PWSTR lpMonitorName)

BOOL WINAPI	LocalAddPort (LPWSTR pName, HWND hWnd, LPWSTR pMonitorName)

BOOL WINAPI	LocalConfigurePort (PWSTR pName, HWND hWnd, PWSTR pPortName)

BOOL WINAPI	LocalDeletePort (PWSTR pName, HWND hWnd, PWSTR pPortName)

BOOL WINAPI	LocalSetPort (PWSTR pName, PWSTR pPortName, DWORD dwLevel, PBYTE pPortInfo)

BOOL	CreatePortEntry (PCWSTR pwszName, PLOCAL_PRINT_MONITOR pPrintMonitor)

DWORD WINAPI	LocalGetPrinterData (HANDLE hPrinter, PWSTR pValueName, PDWORD pType, PBYTE pData, DWORD nSize, PDWORD pcbNeeded)

DWORD WINAPI	LocalGetPrinterDataEx (HANDLE hPrinter, PCWSTR pKeyName, PCWSTR pValueName, PDWORD pType, PBYTE pData, DWORD nSize, PDWORD pcbNeeded)

DWORD WINAPI	LocalSetPrinterData (HANDLE hPrinter, PWSTR pValueName, DWORD Type, PBYTE pData, DWORD cbData)

DWORD WINAPI	LocalSetPrinterDataEx (HANDLE hPrinter, LPCWSTR pKeyName, LPCWSTR pValueName, DWORD Type, LPBYTE pData, DWORD cbData)

BOOL	InitializePrinterDrivers (VOID)

BOOL WINAPI	LocalAddPrinterDriver (LPWSTR pName, DWORD level, LPBYTE pDriverInfo)

BOOL WINAPI	LocalAddPrinterDriverEx (LPWSTR pName, DWORD level, LPBYTE pDriverInfo, DWORD dwFileCopyFlags)

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

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

BOOL WINAPI	LocalGetPrinterDriverEx (HANDLE hPrinter, LPWSTR pEnvironment, DWORD Level, LPBYTE pDriverInfo, DWORD cbBuf, LPDWORD pcbNeeded, DWORD dwClientMajorVersion, DWORD dwClientMinorVersion, PDWORD pdwServerMajorVersion, PDWORD pdwServerMinorVersion)

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

PPRINTENV_T	validate_envW (LPCWSTR env)

BOOL	InitializePrinterList (void)

BOOL WINAPI	LocalEnumPrinters (DWORD Flags, LPWSTR Name, DWORD Level, LPBYTE pPrinterEnum, DWORD cbBuf, LPDWORD pcbNeeded, LPDWORD pcReturned)

BOOL WINAPI	LocalGetPrinter (HANDLE hPrinter, DWORD Level, LPBYTE pPrinter, DWORD cbBuf, LPDWORD pcbNeeded)

BOOL WINAPI	LocalOpenPrinter (PWSTR lpPrinterName, HANDLE *phPrinter, PPRINTER_DEFAULTSW pDefault)

DWORD WINAPI	LocalPrinterMessageBox (HANDLE hPrinter, DWORD Error, HWND hWnd, LPWSTR pText, LPWSTR pCaption, DWORD dwType)

BOOL WINAPI	LocalReadPrinter (HANDLE hPrinter, PVOID pBuf, DWORD cbBuf, PDWORD pNoBytesRead)

DWORD WINAPI	LocalStartDocPrinter (HANDLE hPrinter, DWORD Level, LPBYTE pDocInfo)

BOOL WINAPI	LocalStartPagePrinter (HANDLE hPrinter)

BOOL WINAPI	LocalWritePrinter (HANDLE hPrinter, LPVOID pBuf, DWORD cbBuf, LPDWORD pcWritten)

BOOL WINAPI	LocalEndPagePrinter (HANDLE hPrinter)

BOOL WINAPI	LocalEndDocPrinter (HANDLE hPrinter)

BOOL WINAPI	LocalClosePrinter (HANDLE hPrinter)

VOID	BroadcastChange (PLOCAL_HANDLE pHandle)

DWORD WINAPI	PrintingThreadProc (PLOCAL_JOB pJob)

BOOL	FindDatatype (const PLOCAL_PRINT_PROCESSOR pPrintProcessor, PCWSTR pwszDatatype)

PLOCAL_PRINT_PROCESSOR	FindPrintProcessor (PCWSTR pwszName)

BOOL	InitializePrintProcessorList (void)

BOOL WINAPI	LocalEnumPrintProcessorDatatypes (LPWSTR pName, LPWSTR pPrintProcessorName, DWORD Level, LPBYTE pDatatypes, DWORD cbBuf, LPDWORD pcbNeeded, LPDWORD pcReturned)

BOOL WINAPI	LocalEnumPrintProcessors (LPWSTR pName, LPWSTR pEnvironment, DWORD Level, LPBYTE pPrintProcessorInfo, DWORD cbBuf, LPDWORD pcbNeeded, LPDWORD pcReturned)

BOOL WINAPI	LocalGetPrintProcessorDirectory (LPWSTR pName, LPWSTR pEnvironment, DWORD Level, LPBYTE pPrintProcessorInfo, DWORD cbBuf, LPDWORD pcbNeeded)

BOOL WINAPI	LocalGetSpoolFileInfo (HANDLE hPrinter, LPWSTR *pSpoolDir, LPHANDLE phFile, HANDLE hSpoolerProcess, HANDLE hAppProcess)

BOOL WINAPI	LocalCommitSpoolData (HANDLE hPrinter, DWORD cbCommit)

BOOL WINAPI	LocalCloseSpoolFileHandle (HANDLE hPrinter)

PWSTR	AllocAndRegQueryWSZ (HKEY hKey, PCWSTR pwszValueName)

PDEVMODEW	DuplicateDevMode (PDEVMODEW pInput)

LONG	copy_servername_from_name (LPCWSTR name, LPWSTR target)

BOOL WINAPI	LocalXcvData (HANDLE hXcv, const WCHAR pszDataName, BYTE pInputData, DWORD cbInputData, BYTE pOutputData, DWORD cbOutputData, DWORD pcbOutputNeeded, DWORD *pdwStatus)

Macro Definition Documentation

◆ IS_VALID_JOB_ID

#define IS_VALID_JOB_ID ( ID ) (ID >= 1 && ID <= 99999)

Definition at line 38 of file precomp.h.

◆ IS_VALID_PRIORITY

#define IS_VALID_PRIORITY ( P ) (P >= MIN_PRIORITY && P <= MAX_PRIORITY)

Definition at line 39 of file precomp.h.

◆ SHD_WIN2003_SIGNATURE

#define SHD_WIN2003_SIGNATURE 0x4968

Definition at line 42 of file precomp.h.

◆ SKIPLIST_LEVELS

#define SKIPLIST_LEVELS 16

Definition at line 30 of file precomp.h.

◆ WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 11 of file precomp.h.

Typedef Documentation

◆ LOCAL_HANDLE

typedef struct _LOCAL_HANDLE LOCAL_HANDLE

Definition at line 56 of file precomp.h.

◆ LOCAL_JOB

typedef struct _LOCAL_JOB LOCAL_JOB

Definition at line 57 of file precomp.h.

◆ LOCAL_PORT

typedef struct _LOCAL_PORT LOCAL_PORT

Definition at line 58 of file precomp.h.

◆ LOCAL_PORT_HANDLE

typedef struct _LOCAL_PORT_HANDLE LOCAL_PORT_HANDLE

Definition at line 59 of file precomp.h.

◆ LOCAL_PRINT_MONITOR

typedef struct _LOCAL_PRINT_MONITOR LOCAL_PRINT_MONITOR

Definition at line 60 of file precomp.h.

◆ LOCAL_PRINT_PROCESSOR

typedef struct _LOCAL_PRINT_PROCESSOR LOCAL_PRINT_PROCESSOR

Definition at line 61 of file precomp.h.

◆ LOCAL_PRINTER

typedef struct _LOCAL_PRINTER LOCAL_PRINTER

Definition at line 62 of file precomp.h.

◆ LOCAL_PRINTER_HANDLE

typedef struct _LOCAL_PRINTER_HANDLE LOCAL_PRINTER_HANDLE

Definition at line 63 of file precomp.h.

◆ LOCAL_XCV_HANDLE

typedef struct _LOCAL_XCV_HANDLE LOCAL_XCV_HANDLE

Definition at line 64 of file precomp.h.

◆ PClosePrintProcessor

typedef BOOL(WINAPI * PClosePrintProcessor) (HANDLE)

Definition at line 45 of file precomp.h.

◆ PControlPrintProcessor

typedef BOOL(WINAPI * PControlPrintProcessor) (HANDLE, DWORD)

Definition at line 46 of file precomp.h.

◆ PEnumPrintProcessorDatatypesW

typedef BOOL(WINAPI * PEnumPrintProcessorDatatypesW) (LPWSTR, LPWSTR, DWORD, LPBYTE, DWORD, LPDWORD, LPDWORD)

Definition at line 47 of file precomp.h.

◆ PGetPrintProcessorCapabilities

typedef DWORD(WINAPI * PGetPrintProcessorCapabilities) (LPWSTR, DWORD, LPBYTE, DWORD, LPDWORD)

Definition at line 48 of file precomp.h.

◆ PInitializePrintMonitor

typedef LPMONITOREX(WINAPI * PInitializePrintMonitor) (PWSTR)

Definition at line 51 of file precomp.h.

◆ PInitializePrintMonitor2

typedef LPMONITOR2(WINAPI * PInitializePrintMonitor2) (PMONITORINIT, PHANDLE)

Definition at line 52 of file precomp.h.

◆ PInitializePrintMonitorUI

typedef PMONITORUI(WINAPI * PInitializePrintMonitorUI) (VOID)

Definition at line 53 of file precomp.h.

◆ PLOCAL_HANDLE

typedef struct _LOCAL_HANDLE * PLOCAL_HANDLE

Definition at line 56 of file precomp.h.

◆ PLOCAL_JOB

typedef struct _LOCAL_JOB * PLOCAL_JOB

Definition at line 57 of file precomp.h.

◆ PLOCAL_PORT

typedef struct _LOCAL_PORT * PLOCAL_PORT

Definition at line 58 of file precomp.h.

◆ PLOCAL_PORT_HANDLE

typedef struct _LOCAL_PORT_HANDLE * PLOCAL_PORT_HANDLE

Definition at line 59 of file precomp.h.

◆ PLOCAL_PRINT_MONITOR

typedef struct _LOCAL_PRINT_MONITOR * PLOCAL_PRINT_MONITOR

Definition at line 60 of file precomp.h.

◆ PLOCAL_PRINT_PROCESSOR

typedef struct _LOCAL_PRINT_PROCESSOR * PLOCAL_PRINT_PROCESSOR

Definition at line 61 of file precomp.h.

◆ PLOCAL_PRINTER

typedef struct _LOCAL_PRINTER * PLOCAL_PRINTER

Definition at line 62 of file precomp.h.

◆ PLOCAL_PRINTER_HANDLE

typedef struct _LOCAL_PRINTER_HANDLE * PLOCAL_PRINTER_HANDLE

Definition at line 63 of file precomp.h.

◆ PLOCAL_XCV_HANDLE

typedef struct _LOCAL_XCV_HANDLE * PLOCAL_XCV_HANDLE

Definition at line 64 of file precomp.h.

◆ POpenPrintProcessor

typedef HANDLE(WINAPI * POpenPrintProcessor) (LPWSTR, PPRINTPROCESSOROPENDATA)

Definition at line 49 of file precomp.h.

◆ PPrintDocumentOnPrintProcessor

typedef BOOL(WINAPI * PPrintDocumentOnPrintProcessor) (HANDLE, LPWSTR)

Definition at line 50 of file precomp.h.

◆ PPRINTENV_T

typedef struct _PRINTENV_T * PPRINTENV_T

◆ PRINTENV_T

typedef struct _PRINTENV_T PRINTENV_T

◆ PSHD_HEADER

typedef struct _SHD_HEADER * PSHD_HEADER

Definition at line 65 of file precomp.h.

◆ SHD_HEADER

typedef struct _SHD_HEADER SHD_HEADER

Definition at line 65 of file precomp.h.

Function Documentation

◆ AllocAndRegQueryWSZ()

PWSTR AllocAndRegQueryWSZ	(	HKEY	hKey,
		PCWSTR	pwszValueName
	)

Definition at line 26 of file tools.c.

{
    DWORD cbNeeded;
    LONG lStatus;
    PWSTR pwszValue;
 
    // Determine the size of the required buffer.
    lStatus = RegQueryValueExW(hKey, pwszValueName, NULL, NULL, NULL, &cbNeeded);
    if (lStatus != ERROR_SUCCESS)
    {
        ERR("RegQueryValueExW failed with status %ld!\n", lStatus);
        return NULL;
    }
 
    // Allocate it.
    pwszValue = DllAllocSplMem(cbNeeded);
    if (!pwszValue)
    {
        ERR("DllAllocSplMem failed!\n");
        return NULL;
    }
 
    // Now get the actual value.
    lStatus = RegQueryValueExW(hKey, pwszValueName, NULL, NULL, (PBYTE)pwszValue, &cbNeeded);
    if (lStatus != ERROR_SUCCESS)
    {
        ERR("RegQueryValueExW failed with status %ld!\n", lStatus);
        DllFreeSplMem(pwszValue);
        return NULL;
    }
 
    return pwszValue;
}

Referenced by InitializePrinterList(), and InitializePrintMonitorList().

◆ BroadcastChange()

VOID BroadcastChange ( PLOCAL_HANDLE pHandle )

Definition at line 350 of file printers.c.

{
    PLOCAL_PRINTER pPrinter;
    PSKIPLIST_NODE pNode;
    DWORD cchMachineName = 0;
    WCHAR wszMachineName[MAX_PATH] = {0}; // if not local, use Machine Name then Printer Name... pPrinter->pJob->pwszMachineName?
 
    for (pNode = PrinterList.Head.Next[0]; pNode; pNode = pNode->Next[0])
    {
        pPrinter = (PLOCAL_PRINTER)pNode->Element;
 
        StringCchCopyW( &wszMachineName[cchMachineName], sizeof(wszMachineName), pPrinter->pwszPrinterName );
 
        PostMessageW( HWND_BROADCAST, WM_DEVMODECHANGE, 0, (LPARAM)&wszMachineName );
    }
}

Referenced by LocalAddForm(), LocalDeleteForm(), and LocalSetForm().

◆ copy_servername_from_name()

LONG copy_servername_from_name	(	LPCWSTR	name,
		LPWSTR	target
	)

Definition at line 89 of file tools.c.

{
    LPCWSTR server;
    LPWSTR  ptr;
    WCHAR   buffer[MAX_COMPUTERNAME_LENGTH +1];
    DWORD   len;
    DWORD   serverlen;
 
    if (target) *target = '\0';
 
    if (name == NULL) return 0;
    if ((name[0] != '\\') || (name[1] != '\\')) return 0;
 
    server = &name[2];
    /* skip over both backslash, find separator '\' */
    ptr = wcschr(server, '\\');
    serverlen = (ptr) ? ptr - server : lstrlenW(server);
 
    /* servername is empty */
    if (serverlen == 0) return 0;
 
    FIXME("found %s\n", debugstr_wn(server, serverlen));
 
    if (serverlen > MAX_COMPUTERNAME_LENGTH) return -(LONG)serverlen;
 
    if (target)
    {
        memcpy(target, server, serverlen * sizeof(WCHAR));
        target[serverlen] = '\0';
    }
 
    len = ARRAYSIZE(buffer);
    if (GetComputerNameW(buffer, &len))
    {
        if ((serverlen == len) && (_wcsnicmp(server, buffer, len) == 0))
        {
            /* The requested Servername is our computername */
            return 0;
        }
    }
    return serverlen;
}

Referenced by LocalAddMonitor(), LocalAddPort(), LocalAddPortEx(), LocalAddPrinterDriver(), LocalAddPrinterDriverEx(), LocalConfigurePort(), LocalDeleteMonitor(), LocalDeletePort(), and LocalSetPort().

◆ CreateJob()

DWORD WINAPI CreateJob ( PLOCAL_PRINTER_HANDLE pPrinterHandle )

Definition at line 257 of file jobs.c.

{
    const WCHAR wszDoubleBackslash[] = L"\\";
    const DWORD cchDoubleBackslash = _countof(wszDoubleBackslash) - 1;
 
    DWORD cchMachineName;
    DWORD cchUserName;
    DWORD dwErrorCode;
    PLOCAL_JOB pJob;
    RPC_BINDING_HANDLE hServerBinding = NULL;
    RPC_WSTR pwszBinding = NULL;
    RPC_WSTR pwszMachineName = NULL;
 
    TRACE("CreateJob(%p)\n", pPrinterHandle);
 
    // Create a new job.
    pJob = DllAllocSplMem(sizeof(LOCAL_JOB));
    if (!pJob)
    {
        dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
        ERR("DllAllocSplMem failed!\n");
        goto Cleanup;
    }
 
    // Reserve an ID for this job.
    if (!_GetNextJobID(&pJob->dwJobID))
    {
        dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
        goto Cleanup;
    }
 
    // Copy over defaults to the LOCAL_JOB structure.
    pJob->pPrinter = pPrinterHandle->pPrinter;
    pJob->pPrintProcessor = pPrinterHandle->pPrinter->pPrintProcessor;
    pJob->dwPriority = DEF_PRIORITY;
    pJob->dwStatus = JOB_STATUS_SPOOLING;
    pJob->pwszDatatype = AllocSplStr(pPrinterHandle->pwszDatatype);
    pJob->pwszDocumentName = AllocSplStr(wszDefaultDocumentName);
    pJob->pDevMode = DuplicateDevMode(pPrinterHandle->pDevMode);
    GetSystemTime(&pJob->stSubmitted);
 
    // Get the user name for the Job.
    cchUserName = UNLEN + 1;
    pJob->pwszUserName = DllAllocSplMem(cchUserName * sizeof(WCHAR));
    if (!GetUserNameW(pJob->pwszUserName, &cchUserName))
    {
        dwErrorCode = GetLastError();
        ERR("GetUserNameW failed with error %lu!\n", dwErrorCode);
        goto Cleanup;
    }
 
    // FIXME: For now, pwszNotifyName equals pwszUserName.
    pJob->pwszNotifyName = AllocSplStr(pJob->pwszUserName);
 
    // Get the name of the machine that submitted the Job over RPC.
    dwErrorCode = RpcBindingServerFromClient(NULL, &hServerBinding);
    if (dwErrorCode != RPC_S_OK)
    {
        ERR("RpcBindingServerFromClient failed with status %lu!\n", dwErrorCode);
        goto Cleanup;
    }
 
    dwErrorCode = RpcBindingToStringBindingW(hServerBinding, &pwszBinding);
    if (dwErrorCode != RPC_S_OK)
    {
        ERR("RpcBindingToStringBindingW failed with status %lu!\n", dwErrorCode);
        goto Cleanup;
    }
 
    dwErrorCode = RpcStringBindingParseW(pwszBinding, NULL, NULL, &pwszMachineName, NULL, NULL);
    if (dwErrorCode != RPC_S_OK)
    {
        ERR("RpcStringBindingParseW failed with status %lu!\n", dwErrorCode);
        goto Cleanup;
    }
 
    cchMachineName = wcslen(pwszMachineName);
    pJob->pwszMachineName = DllAllocSplMem((cchMachineName + cchDoubleBackslash + 1) * sizeof(WCHAR));
    CopyMemory(pJob->pwszMachineName, wszDoubleBackslash, cchDoubleBackslash * sizeof(WCHAR));
    CopyMemory(&pJob->pwszMachineName[cchDoubleBackslash], pwszMachineName, (cchMachineName + 1) * sizeof(WCHAR));
 
    // Add the job to the Global Job List.
    if (!InsertElementSkiplist(&GlobalJobList, pJob))
    {
        dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
        ERR("InsertElementSkiplist failed for job %lu for the GlobalJobList!\n", pJob->dwJobID);
        goto Cleanup;
    }
 
    // Add the job at the end of the Printer's Job List.
    // As all new jobs are created with default priority, we can be sure that it would always be inserted at the end.
    if (!InsertTailElementSkiplist(&pJob->pPrinter->JobList, pJob))
    {
        dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
        ERR("InsertTailElementSkiplist failed for job %lu for the Printer's Job List!\n", pJob->dwJobID);
        goto Cleanup;
    }
 
    // We were successful!
    pPrinterHandle->bStartedDoc = TRUE;
    pPrinterHandle->pJob = pJob;
    dwErrorCode = ERROR_SUCCESS;
 
    // Don't let the cleanup routine free this.
    pJob = NULL;
 
Cleanup:
    if (pJob)
        DllFreeSplMem(pJob);
 
    if (pwszMachineName)
        RpcStringFreeW(&pwszMachineName);
 
    if (pwszBinding)
        RpcStringFreeW(&pwszBinding);
 
    if (hServerBinding)
        RpcBindingFree(&hServerBinding);
 
    return dwErrorCode;
}

Referenced by LocalAddJob(), and LocalStartDocPrinter().

◆ CreatePortEntry()

BOOL CreatePortEntry	(	PCWSTR	pwszName,
		PLOCAL_PRINT_MONITOR	pPrintMonitor
	)

Definition at line 37 of file ports.c.

{
    PLOCAL_PORT pPort;
    DWORD cbPortName = (wcslen( pwszName ) + 1) * sizeof(WCHAR);
 
    // Create a new LOCAL_PORT structure for it.
    pPort = DllAllocSplMem(sizeof(LOCAL_PORT) + cbPortName);
    if (!pPort)
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }
 
    pPort->pPrintMonitor = pPrintMonitor;
    pPort->pwszName = wcscpy( (PWSTR)(pPort+1), pwszName );
 
    // Insert it into the list and advance to the next port.
    InsertTailList(&_PortList, &pPort->Entry);
 
    return TRUE;
}

Referenced by _HandleAddPort(), LocalAddPort(), and LocalAddPortEx().

◆ DuplicateDevMode()

PDEVMODEW DuplicateDevMode ( PDEVMODEW pInput )

Definition at line 61 of file tools.c.

{
    PDEVMODEW pOutput;
 
    // Allocate a buffer for this DevMode.
    pOutput = DllAllocSplMem(pInput->dmSize + pInput->dmDriverExtra);
    if (!pOutput)
    {
        ERR("DllAllocSplMem failed!\n");
        return NULL;
    }
 
    // Copy it.
    CopyMemory(pOutput, pInput, pInput->dmSize + pInput->dmDriverExtra);
 
    return pOutput;
}

Referenced by _LocalOpenPrinterHandle(), CreateJob(), and ReadJobShadowFile().

◆ FindDatatype()

BOOL FindDatatype	(	const PLOCAL_PRINT_PROCESSOR	pPrintProcessor,
		PCWSTR	pwszDatatype
	)

Definition at line 80 of file printprocessors.c.

{
    DWORD i;
    PDATATYPES_INFO_1W pCurrentDatatype = pPrintProcessor->pDatatypesInfo1;
 
    TRACE("FindDatatype(%p, %S)\n", pPrintProcessor, pwszDatatype);
 
    if (!pwszDatatype)
        return FALSE;
 
    for (i = 0; i < pPrintProcessor->dwDatatypeCount; i++)
    {
        if (_wcsicmp(pCurrentDatatype->pName, pwszDatatype) == 0)
            return TRUE;
 
        ++pCurrentDatatype;
    }
 
    return FALSE;
}

Referenced by _LocalOpenPrinterHandle(), _LocalSetJobLevel1(), _LocalSetJobLevel2(), InitializePrinterList(), and LocalStartDocPrinter().

◆ FindPort()

PLOCAL_PORT FindPort ( PCWSTR pwszName )

Definition at line 15 of file ports.c.

{
    PLIST_ENTRY pEntry;
    PLOCAL_PORT pPort;
 
    TRACE("FindPort(%S)\n", pwszName);
 
    if (!pwszName)
        return NULL;
 
    for (pEntry = _PortList.Flink; pEntry != &_PortList; pEntry = pEntry->Flink)
    {
        pPort = CONTAINING_RECORD(pEntry, LOCAL_PORT, Entry);
 
        if (_wcsicmp(pPort->pwszName, pwszName) == 0)
            return pPort;
    }
 
    return NULL;
}

Referenced by _HandleDeletePort(), _LocalOpenPortHandle(), _LocalOpenXcvHandle(), InitializePrinterList(), LocalAddPort(), LocalAddPortEx(), LocalConfigurePort(), LocalDeletePort(), and LocalSetPort().

◆ FindPrintMonitor()

PLOCAL_PRINT_MONITOR FindPrintMonitor ( PCWSTR pwszName )

Definition at line 28 of file monitors.c.

{
    PLIST_ENTRY pEntry;
    PLOCAL_PRINT_MONITOR pPrintMonitor;
 
    TRACE("FindPrintMonitor(%S)\n", pwszName);
 
    if (!pwszName)
        return NULL;
 
    for (pEntry = PrintMonitorList.Flink; pEntry != &PrintMonitorList; pEntry = pEntry->Flink)
    {
        pPrintMonitor = CONTAINING_RECORD(pEntry, LOCAL_PRINT_MONITOR, Entry);
 
        if (_wcsicmp(pPrintMonitor->pwszName, pwszName) == 0)
            return pPrintMonitor;
    }
 
    return NULL;
}

Referenced by _LocalOpenXcvHandle(), LocalAddPort(), LocalAddPortEx(), and LocalDeleteMonitor().

◆ FindPrintProcessor()

PLOCAL_PRINT_PROCESSOR FindPrintProcessor ( PCWSTR pwszName )

Definition at line 102 of file printprocessors.c.

{
    PLIST_ENTRY pEntry;
    PLOCAL_PRINT_PROCESSOR pPrintProcessor;
 
    TRACE("FindPrintProcessor(%S)\n", pwszName);
 
    if (!pwszName)
        return NULL;
 
    for (pEntry = _PrintProcessorList.Flink; pEntry != &_PrintProcessorList; pEntry = pEntry->Flink)
    {
        pPrintProcessor = CONTAINING_RECORD(pEntry, LOCAL_PRINT_PROCESSOR, Entry);
 
        if (_wcsicmp(pPrintProcessor->pwszName, pwszName) == 0)
            return pPrintProcessor;
    }
 
    return NULL;
}

Referenced by _LocalSetJobLevel2(), InitializePrinterList(), LocalEnumPrintProcessorDatatypes(), and ReadJobShadowFile().

◆ FreeJob()

void FreeJob ( PLOCAL_JOB pJob )

Definition at line 1452 of file jobs.c.

{
    PWSTR pwszSHDFile;
 
    TRACE("FreeJob(%p)\n", pJob);
 
    // Remove the Job from both Job Lists.
    DeleteElementSkiplist(&pJob->pPrinter->JobList, pJob);
    DeleteElementSkiplist(&GlobalJobList, pJob);
 
    // Try to delete the corresponding .SHD file.
    pwszSHDFile = DllAllocSplMem(GetJobFilePath(L"SHD", 0, NULL));
    if (pwszSHDFile && GetJobFilePath(L"SHD", pJob->dwJobID, pwszSHDFile))
        DeleteFileW(pwszSHDFile);
 
    // Free memory for the mandatory fields.
    DllFreeSplMem(pJob->pDevMode);
    DllFreeSplStr(pJob->pwszDatatype);
    DllFreeSplStr(pJob->pwszDocumentName);
    DllFreeSplStr(pJob->pwszMachineName);
    DllFreeSplStr(pJob->pwszNotifyName);
    DllFreeSplStr(pJob->pwszUserName);
 
    // Free memory for the optional fields if they are present.
    if (pJob->pwszOutputFile)
        DllFreeSplStr(pJob->pwszOutputFile);
 
    if (pJob->pwszPrintProcessorParameters)
        DllFreeSplStr(pJob->pwszPrintProcessorParameters);
 
    if (pJob->pwszStatus)
        DllFreeSplStr(pJob->pwszStatus);
 
    // Finally free the job structure itself.
    DllFreeSplMem(pJob);
}

Referenced by _LocalClosePrinterHandle(), and LocalSetJob().

◆ GetJobFilePath()

DWORD GetJobFilePath	(	PCWSTR	pwszExtension,
		DWORD	dwJobID,
		PWSTR	pwszOutput
	)

Definition at line 146 of file jobs.c.

{
    TRACE("GetJobFilePath(%S, %lu, %p)\n", pwszExtension, dwJobID, pwszOutput);
 
    if (pwszOutput)
    {
        CopyMemory(pwszOutput, wszJobDirectory, cchJobDirectory * sizeof(WCHAR));
        swprintf(&pwszOutput[cchJobDirectory], L"\\%05lu.%s", dwJobID, pwszExtension);
    }
 
    // pwszExtension may be L"SPL" or L"SHD", same length for both!
    return (cchJobDirectory + sizeof("\\?????.SPL")) * sizeof(WCHAR);
}

Referenced by _LocalOpenPrinterHandle(), FreeJob(), InitializeGlobalJobList(), LocalAddJob(), LocalScheduleJob(), LocalSetJob(), and PrintingThreadProc().

◆ InitializeFormList()

BOOL InitializeFormList ( VOID )

Definition at line 228 of file forms.c.

{
    DWORD dwErrorCode;
    PFORM_INFO_LIST pfil;
    REGISTRYFORMINFO rfi;
 
    FIXME("InitializeFormList\n");
 
    dwErrorCode = (DWORD)RegCreateKeyExW( HKEY_LOCAL_MACHINE,
                                         L"SYSTEM\\CurrentControlSet\\Control\\Print\\Forms",
                                          0,
                                          NULL,
                                          REG_OPTION_VOLATILE,
                                          KEY_ALL_ACCESS,
                                          NULL,
                                         &hFormCKey,
                                          NULL ); // KEY_OPENED_EXISTING_KEY );
 
    if ( dwErrorCode != ERROR_SUCCESS && dwErrorCode != ERROR_ALREADY_EXISTS )
    {
        ERR("RegCreateKeyExW failed for the Forms with error %lu!\n", dwErrorCode);
        goto Cleanup;
    }
 
    // Open some registry keys and leave them open. We need them multiple times throughout the Local Spooler.
    dwErrorCode = (DWORD)RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"SYSTEM\\CurrentControlSet\\Control\\Print\\Forms", 0, KEY_ALL_ACCESS, &hFormsKey);
    if (dwErrorCode != ERROR_SUCCESS)
    {
        ERR("RegOpenKeyExW failed for \"Forms\" with error %lu!\n", dwErrorCode);
        goto Cleanup;
    }
 
    _dwLastForm = 1;
 
    InitializeListHead(&FormList);
 
    {
        int i = 0, Size;
        while ( BuiltInForms[ i ].pName != NULL )
        {
            TRACE("InitializeFormList L s %S\n",BuiltInForms[ i ].pName );
 
            Size = sizeof(FORM_INFO_LIST) + ((wcslen(BuiltInForms[ i ].pName) + 1) * sizeof(WCHAR));
 
            pfil = DllAllocSplMem( Size );
 
            pfil->pName         = wcscpy( (PWSTR)(pfil+1), BuiltInForms[ i ].pName );
            pfil->Flags         = BuiltInForms[ i ].Flags;
            pfil->Size          = BuiltInForms[ i ].Size;
            pfil->ImageableArea = BuiltInForms[ i ].ImageableArea;
            pfil->Sig           = FORMINFOSIG;
            pfil->Index         = _dwLastForm++;
            pfil->pKeyword      = NULL;
            pfil->StringType    = STRING_NONE;
            pfil->pMuiDll       = NULL;
            pfil->dwResourceId  = 0;
            pfil->pDisplayName  = NULL;
            pfil->wLangId       = 0;
 
            InsertTailList( &FormList, &pfil->List );
 
            rfi.Size          = pfil->Size;
            rfi.ImageableArea = pfil->ImageableArea;
            rfi.Index         = pfil->Index;
            rfi.Flags         = pfil->Flags;
 
            dwErrorCode = RegSetValueExW( hFormsKey, pfil->pName, 0, REG_BINARY, (PBYTE)&rfi, sizeof( rfi ) );
            if ( dwErrorCode == ERROR_SUCCESS )
            {
                TRACE("Init : RQVEW : %S added\n",pfil->pName);
            }
 
            i++;
        }
    }
 
Cleanup:
    return TRUE;
}

Referenced by _InitializeLocalSpooler().

◆ InitializeGlobalJobList()

BOOL InitializeGlobalJobList ( VOID )

Definition at line 161 of file jobs.c.

{
    const WCHAR wszPath[] = L"\\?????.SHD";
    const DWORD cchPath = _countof(wszPath) - 1;
 
    DWORD dwErrorCode;
    DWORD dwJobID;
    HANDLE hFind;
    PLOCAL_JOB pJob = NULL;
    PWSTR p;
    WCHAR wszFullPath[MAX_PATH];
    WIN32_FIND_DATAW FindData;
 
    TRACE("InitializeGlobalJobList()\n");
 
    // This one is incremented in _GetNextJobID.
    _dwLastJobID = 0;
 
    // Initialize an empty list for all jobs of all local printers.
    // We will search it by Job ID (supply a pointer to a DWORD in LookupElementSkiplist).
    InitializeSkiplist(&GlobalJobList, DllAllocSplMem, _GlobalJobListCompareRoutine, (PSKIPLIST_FREE_ROUTINE)DllFreeSplMem);
 
    // Construct the full path search pattern.
    CopyMemory(wszFullPath, wszJobDirectory, cchJobDirectory * sizeof(WCHAR));
    CopyMemory(&wszFullPath[cchJobDirectory], wszPath, (cchPath + 1) * sizeof(WCHAR));
 
    // Use the search pattern to look for unfinished jobs serialized in shadow files (.SHD)
    hFind = FindFirstFileW(wszFullPath, &FindData);
    if (hFind == INVALID_HANDLE_VALUE)
    {
        // No unfinished jobs found.
        dwErrorCode = ERROR_SUCCESS;
        goto Cleanup;
    }
 
    do
    {
        // Skip possible subdirectories.
        if (FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
            continue;
 
        // Extract the Job ID and verify the file name format at the same time.
        // This includes all valid names (like "00005.SHD") and excludes invalid ones (like "10ABC.SHD").
        dwJobID = wcstoul(FindData.cFileName, &p, 10);
        if (!IS_VALID_JOB_ID(dwJobID))
            continue;
 
        if (_wcsicmp(p, L".SHD") != 0)
            continue;
 
        // This shadow file has a valid name. Construct the full path and try to load it.
        GetJobFilePath(L"SHD", dwJobID, wszFullPath);
        pJob = ReadJobShadowFile(wszFullPath);
        if (!pJob)
            continue;
 
        // Add it to the Global Job List.
        if (!InsertElementSkiplist(&GlobalJobList, pJob))
        {
            dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
            ERR("InsertElementSkiplist failed for job %lu for the GlobalJobList!\n", pJob->dwJobID);
            goto Cleanup;
        }
 
        // Add it to the Printer's Job List.
        if (!InsertElementSkiplist(&pJob->pPrinter->JobList, pJob))
        {
            dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
            ERR("InsertElementSkiplist failed for job %lu for the Printer's Job List!\n", pJob->dwJobID);
            goto Cleanup;
        }
    }
    while (FindNextFileW(hFind, &FindData));
 
    dwErrorCode = ERROR_SUCCESS;
 
Cleanup:
    // Outside the loop
    if (hFind)
        FindClose(hFind);
 
    SetLastError(dwErrorCode);
    return (dwErrorCode == ERROR_SUCCESS);
}

Referenced by _InitializeLocalSpooler().

◆ InitializePortList()

BOOL InitializePortList ( void )

Definition at line 60 of file ports.c.

{
    BOOL bReturnValue;
    DWORD cbNeeded;
    DWORD cbPortName;
    DWORD dwErrorCode;
    DWORD dwReturned;
    DWORD i;
    PLOCAL_PORT pPort;
    PLOCAL_PRINT_MONITOR pPrintMonitor;
    PLIST_ENTRY pEntry;
    PPORT_INFO_1W p;
    PPORT_INFO_1W pPortInfo1 = NULL;
 
    TRACE("InitializePortList()\n");
 
    // Initialize an empty list for our Ports.
    InitializeListHead(&_PortList);
 
    // Loop through all Print Monitors.
    for (pEntry = PrintMonitorList.Flink; pEntry != &PrintMonitorList; pEntry = pEntry->Flink)
    {
        // Cleanup from the previous run.
        if (pPortInfo1)
        {
            DllFreeSplMem(pPortInfo1);
            pPortInfo1 = NULL;
        }
 
        pPrintMonitor = CONTAINING_RECORD(pEntry, LOCAL_PRINT_MONITOR, Entry);
 
        // Determine the required buffer size for EnumPorts.
        if (pPrintMonitor->bIsLevel2)
            bReturnValue = ((PMONITOR2)pPrintMonitor->pMonitor)->pfnEnumPorts(pPrintMonitor->hMonitor, NULL, 1, NULL, 0, &cbNeeded, &dwReturned);
        else
            bReturnValue = ((LPMONITOREX)pPrintMonitor->pMonitor)->Monitor.pfnEnumPorts(NULL, 1, NULL, 0, &cbNeeded, &dwReturned);
 
        // Check the returned error code.
        if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
        {
            ERR("Print Monitor \"%S\" failed with error %lu on EnumPorts!\n", pPrintMonitor->pwszName, GetLastError());
            continue;
        }
 
        // Allocate a buffer large enough.
        pPortInfo1 = DllAllocSplMem(cbNeeded);
        if (!pPortInfo1)
        {
            dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
            ERR("DllAllocSplMem failed!\n");
            goto Cleanup;
        }
 
        // Get the ports handled by this monitor.
        if (pPrintMonitor->bIsLevel2)
            bReturnValue = ((PMONITOR2)pPrintMonitor->pMonitor)->pfnEnumPorts(pPrintMonitor->hMonitor, NULL, 1, (PBYTE)pPortInfo1, cbNeeded, &cbNeeded, &dwReturned);
        else
            bReturnValue = ((LPMONITOREX)pPrintMonitor->pMonitor)->Monitor.pfnEnumPorts(NULL, 1, (PBYTE)pPortInfo1, cbNeeded, &cbNeeded, &dwReturned);
 
        // Check the return value.
        if (!bReturnValue)
        {
            ERR("Print Monitor \"%S\" failed with error %lu on EnumPorts!\n", pPrintMonitor->pwszName, GetLastError());
            continue;
        }
 
        // Loop through all returned ports.
        p = pPortInfo1;
 
        for (i = 0; i < dwReturned; i++)
        {
            cbPortName = (wcslen(p->pName) + 1) * sizeof(WCHAR);
 
            // Create a new LOCAL_PORT structure for it.
            pPort = DllAllocSplMem(sizeof(LOCAL_PORT) + cbPortName);
            if (!pPort)
            {
                dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
                ERR("DllAllocSplMem failed!\n");
                goto Cleanup;
            }
 
            pPort->pPrintMonitor = pPrintMonitor;
            pPort->pwszName = (PWSTR)((PBYTE)pPort + sizeof(LOCAL_PORT));
            CopyMemory(pPort->pwszName, p->pName, cbPortName);
 
            // Insert it into the list and advance to the next port.
            InsertTailList(&_PortList, &pPort->Entry);
            p++;
        }
    }
 
    dwErrorCode = ERROR_SUCCESS;
 
Cleanup:
    // Inside the loop
    if (pPortInfo1)
        DllFreeSplMem(pPortInfo1);
 
    SetLastError(dwErrorCode);
    return (dwErrorCode == ERROR_SUCCESS);
}

Referenced by _InitializeLocalSpooler().

◆ InitializePrinterDrivers()

BOOL InitializePrinterDrivers ( VOID )

Definition at line 77 of file printerdrivers.c.

{
    WCHAR szSysDir[MAX_PATH];
    DWORD cbBuf;
 
    if (wszLocalSplFile[0] && wszPrintUiFile[0])
        return TRUE;
 
    if (!GetSystemDirectoryW(szSysDir, _countof(szSysDir)))
    {
        ERR("GetSystemDirectoryW failed\n");
        return FALSE;
    }
 
    StringCbCopyW(wszLocalSplFile, sizeof(wszLocalSplFile), szSysDir);
    StringCbCatW(wszLocalSplFile, sizeof(wszLocalSplFile), L"\\localspl.dll");
 
    StringCbCopyW(wszPrintUiFile, sizeof(wszPrintUiFile), szSysDir);
    StringCbCatW(wszPrintUiFile, sizeof(wszPrintUiFile), L"\\printui.dll");
 
    if (!LocalGetPrinterDriverDirectory(NULL, (PWSTR)wszCurrentEnvironment, 1, (PBYTE)szSysDir, (DWORD)sizeof(szSysDir), &cbBuf))
    {
        ERR("LocalGetPrinterDriverDirectory failed\n");
        return FALSE;
    }
 
    StringCbCopyW(wszDriverPath, sizeof(wszDriverPath), szSysDir);
    StringCbCatW(wszDriverPath, sizeof(wszDriverPath), version3_subdirW);
    StringCbCatW(wszDriverPath, sizeof(wszDriverPath), backslashW);
 
    // HAX! need to get it from the Reg Key L"Driver"!
    StringCbCatW(wszDriverPath, sizeof(wszDriverPath), L"UniDrv.dll");
 
    FIXME("DriverPath : %S\n",wszDriverPath);
 
    return TRUE;
}

Referenced by _InitializeLocalSpooler().

◆ InitializePrinterJobList()

void InitializePrinterJobList ( PLOCAL_PRINTER pPrinter )

Definition at line 247 of file jobs.c.

{
    TRACE("InitializePrinterJobList(%p)\n", pPrinter);
 
    // Initialize an empty list for this printer's jobs.
    // This one is only for sorting the jobs. If you need to lookup a job, search the GlobalJobList by Job ID.
    InitializeSkiplist(&pPrinter->JobList, DllAllocSplMem, _PrinterJobListCompareRoutine, (PSKIPLIST_FREE_ROUTINE)DllFreeSplMem);
}

Referenced by InitializePrinterList().

◆ InitializePrinterList()

BOOL InitializePrinterList ( void )

Definition at line 107 of file printers.c.

{
    DWORD cbData;
    DWORD cchPrinterName;
    DWORD dwErrorCode;
    DWORD dwSubKeys;
    DWORD i;
    HKEY hSubKey = NULL;
    PLOCAL_PORT pPort;
    PLOCAL_PRINTER pPrinter = NULL;
    PLOCAL_PRINT_PROCESSOR pPrintProcessor;
    PWSTR pwszPort = NULL;
    PWSTR pwszPrintProcessor = NULL;
    WCHAR wszPrinterName[MAX_PRINTER_NAME + 1];
 
    TRACE("InitializePrinterList()\n");
 
    // Initialize an empty list for our printers.
    InitializeSkiplist(&PrinterList, DllAllocSplMem, _PrinterListCompareRoutine, (PSKIPLIST_FREE_ROUTINE)DllFreeSplMem);
 
    // Get the number of subkeys of the printers registry key. Each subkey is a local printer there.
    dwErrorCode = (DWORD)RegQueryInfoKeyW(hPrintersKey, NULL, NULL, NULL, &dwSubKeys, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
    if (dwErrorCode != ERROR_SUCCESS)
    {
        ERR("RegQueryInfoKeyW failed with status %lu!\n", dwErrorCode);
        goto Cleanup;
    }
 
    // Loop through all available local printers.
    for (i = 0; i < dwSubKeys; i++)
    {
        // Cleanup tasks from the previous run
        if (hSubKey)
        {
            RegCloseKey(hSubKey);
            hSubKey = NULL;
        }
 
        if (pPrinter)
        {
            if (pPrinter->pDefaultDevMode)
                DllFreeSplMem(pPrinter->pDefaultDevMode);
 
            if (pPrinter->pwszDefaultDatatype)
                DllFreeSplStr(pPrinter->pwszDefaultDatatype);
 
            if (pPrinter->pwszDescription)
                DllFreeSplStr(pPrinter->pwszDescription);
 
            if (pPrinter->pwszPrinterDriver)
                DllFreeSplStr(pPrinter->pwszPrinterDriver);
 
            if (pPrinter->pwszPrinterName)
                DllFreeSplStr(pPrinter->pwszPrinterName);
 
            DllFreeSplMem(pPrinter);
            pPrinter = NULL;
        }
 
        if (pwszPrintProcessor)
        {
            DllFreeSplStr(pwszPrintProcessor);
            pwszPrintProcessor = NULL;
        }
 
        // Get the name of this printer.
        cchPrinterName = _countof(wszPrinterName);
        dwErrorCode = (DWORD)RegEnumKeyExW(hPrintersKey, i, wszPrinterName, &cchPrinterName, NULL, NULL, NULL, NULL);
        if (dwErrorCode == ERROR_MORE_DATA)
        {
            // This printer name exceeds the maximum length and is invalid.
            continue;
        }
        else if (dwErrorCode != ERROR_SUCCESS)
        {
            ERR("RegEnumKeyExW failed for iteration %lu with status %lu!\n", i, dwErrorCode);
            continue;
        }
 
        // Open this Printer's registry key.
        dwErrorCode = (DWORD)RegOpenKeyExW(hPrintersKey, wszPrinterName, 0, KEY_READ, &hSubKey);
        if (dwErrorCode != ERROR_SUCCESS)
        {
            ERR("RegOpenKeyExW failed for Printer \"%S\" with status %lu!\n", wszPrinterName, dwErrorCode);
            continue;
        }
 
        // Get the Print Processor.
        pwszPrintProcessor = AllocAndRegQueryWSZ(hSubKey, L"Print Processor");
        if (!pwszPrintProcessor)
            continue;
 
        // Try to find it in the Print Processor List.
        pPrintProcessor = FindPrintProcessor(pwszPrintProcessor);
        if (!pPrintProcessor)
        {
            ERR("Invalid Print Processor \"%S\" for Printer \"%S\"!\n", pwszPrintProcessor, wszPrinterName);
            continue;
        }
 
        // Get the Port.
        pwszPort = AllocAndRegQueryWSZ(hSubKey, L"Port");
        if (!pwszPort)
            continue;
 
        // Try to find it in the Port List.
        pPort = FindPort(pwszPort);
        if (!pPort)
        {
            ERR("Invalid Port \"%S\" for Printer \"%S\"!\n", pwszPort, wszPrinterName);
            continue;
        }
 
        // Create a new LOCAL_PRINTER structure for it.
        pPrinter = DllAllocSplMem(sizeof(LOCAL_PRINTER));
        if (!pPrinter)
        {
            dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
            ERR("DllAllocSplMem failed!\n");
            goto Cleanup;
        }
 
        pPrinter->pwszPrinterName = AllocSplStr(wszPrinterName);
        pPrinter->pPrintProcessor = pPrintProcessor;
        pPrinter->pPort = pPort;
        InitializePrinterJobList(pPrinter);
 
        // Get the location.
        pPrinter->pwszLocation = AllocAndRegQueryWSZ(hSubKey, L"Location");
        if (!pPrinter->pwszLocation)
            continue;
 
        // Get the printer driver.
        pPrinter->pwszPrinterDriver = AllocAndRegQueryWSZ(hSubKey, L"Printer Driver");
        if (!pPrinter->pwszPrinterDriver)
            continue;
 
        // Get the description.
        pPrinter->pwszDescription = AllocAndRegQueryWSZ(hSubKey, L"Description");
        if (!pPrinter->pwszDescription)
            continue;
 
        // Get the default datatype.
        pPrinter->pwszDefaultDatatype = AllocAndRegQueryWSZ(hSubKey, L"Datatype");
        if (!pPrinter->pwszDefaultDatatype)
            continue;
 
        // Verify that it's valid.
        if (!FindDatatype(pPrintProcessor, pPrinter->pwszDefaultDatatype))
        {
            ERR("Invalid default datatype \"%S\" for Printer \"%S\"!\n", pPrinter->pwszDefaultDatatype, wszPrinterName);
            continue;
        }
 
        // Determine the size of the DevMode.
        dwErrorCode = (DWORD)RegQueryValueExW(hSubKey, L"Default DevMode", NULL, NULL, NULL, &cbData);
        if (dwErrorCode != ERROR_SUCCESS)
        {
            ERR("Couldn't query the size of the DevMode for Printer \"%S\", status is %lu, cbData is %lu!\n", wszPrinterName, dwErrorCode, cbData);
            continue;
        }
 
        // Allocate enough memory for the DevMode.
        pPrinter->pDefaultDevMode = DllAllocSplMem(cbData);
        if (!pPrinter->pDefaultDevMode)
        {
            dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
            ERR("DllAllocSplMem failed!\n");
            goto Cleanup;
        }
 
        // Get the default DevMode.
        dwErrorCode = (DWORD)RegQueryValueExW(hSubKey, L"Default DevMode", NULL, NULL, (PBYTE)pPrinter->pDefaultDevMode, &cbData);
        if (dwErrorCode != ERROR_SUCCESS)
        {
            ERR("Couldn't query a DevMode for Printer \"%S\", status is %lu, cbData is %lu!\n", wszPrinterName, dwErrorCode, cbData);
            continue;
        }
 
        // Get the Attributes.
        cbData = sizeof(DWORD);
        dwErrorCode = (DWORD)RegQueryValueExW(hSubKey, L"Attributes", NULL, NULL, (PBYTE)&pPrinter->dwAttributes, &cbData);
        if (dwErrorCode != ERROR_SUCCESS)
        {
            ERR("Couldn't query Attributes for Printer \"%S\", status is %lu!\n", wszPrinterName, dwErrorCode);
            continue;
        }
 
        // Get the Status.
        cbData = sizeof(DWORD);
        dwErrorCode = (DWORD)RegQueryValueExW(hSubKey, L"Status", NULL, NULL, (PBYTE)&pPrinter->dwStatus, &cbData);
        if (dwErrorCode != ERROR_SUCCESS)
        {
            ERR("Couldn't query Status for Printer \"%S\", status is %lu!\n", wszPrinterName, dwErrorCode);
            continue;
        }
 
        // Add this printer to the printer list.
        if (!InsertElementSkiplist(&PrinterList, pPrinter))
        {
            ERR("InsertElementSkiplist failed for Printer \"%S\"!\n", pPrinter->pwszPrinterName);
            goto Cleanup;
        }
 
        // Don't let the cleanup routines free this.
        pPrinter = NULL;
    }
 
    dwErrorCode = ERROR_SUCCESS;
 
Cleanup:
    // Inside the loop
    if (hSubKey)
        RegCloseKey(hSubKey);
 
    if (pPrinter)
    {
        if (pPrinter->pDefaultDevMode)
            DllFreeSplMem(pPrinter->pDefaultDevMode);
 
        if (pPrinter->pwszDefaultDatatype)
            DllFreeSplStr(pPrinter->pwszDefaultDatatype);
 
        if (pPrinter->pwszDescription)
            DllFreeSplStr(pPrinter->pwszDescription);
 
        if (pPrinter->pwszPrinterDriver)
            DllFreeSplStr(pPrinter->pwszPrinterDriver);
 
        if (pPrinter->pwszPrinterName)
            DllFreeSplStr(pPrinter->pwszPrinterName);
 
        DllFreeSplMem(pPrinter);
    }
 
    if (pwszPrintProcessor)
        DllFreeSplStr(pwszPrintProcessor);
 
    SetLastError(dwErrorCode);
    return (dwErrorCode == ERROR_SUCCESS);
}

Referenced by _InitializeLocalSpooler().

◆ InitializePrintMonitorList()

BOOL InitializePrintMonitorList ( void )

Definition at line 126 of file monitors.c.

{
    const WCHAR wszMonitorsPath[] = L"SYSTEM\\CurrentControlSet\\Control\\Print\\Monitors";
    const DWORD cchMonitorsPath = _countof(wszMonitorsPath) - 1;
 
    DWORD cchMaxSubKey;
    DWORD cchPrintMonitorName;
    DWORD dwErrorCode;
    DWORD dwSubKeys;
    DWORD i;
    HINSTANCE hinstPrintMonitor = NULL;
    HKEY hKey = NULL;
    HKEY hSubKey = NULL;
    MONITORINIT MonitorInit;
    PInitializePrintMonitor pfnInitializePrintMonitor;
    PInitializePrintMonitor2 pfnInitializePrintMonitor2;
    PLOCAL_PRINT_MONITOR pPrintMonitor = NULL;
    PWSTR pwszRegistryPath = NULL;
 
    TRACE("InitializePrintMonitorList()\n");
 
    // Initialize an empty list for our Print Monitors.
    InitializeListHead(&PrintMonitorList);
 
    // Open the key containing Print Monitors.
    dwErrorCode = (DWORD)RegOpenKeyExW(HKEY_LOCAL_MACHINE, wszMonitorsPath, 0, KEY_READ, &hKey);
    if (dwErrorCode != ERROR_SUCCESS)
    {
        ERR("RegOpenKeyExW failed with status %lu!\n", dwErrorCode);
        goto Cleanup;
    }
 
    // Get the number of Print Providers and maximum sub key length.
    dwErrorCode = (DWORD)RegQueryInfoKeyW(hKey, NULL, NULL, NULL, &dwSubKeys, &cchMaxSubKey, NULL, NULL, NULL, NULL, NULL, NULL);
    if (dwErrorCode != ERROR_SUCCESS)
    {
        ERR("RegQueryInfoKeyW failed with status %lu!\n", dwErrorCode);
        goto Cleanup;
    }
 
    // Loop through all available Print Providers.
    for (i = 0; i < dwSubKeys; i++)
    {
        // Cleanup tasks from the previous run
        if (hSubKey)
        {
            RegCloseKey(hSubKey);
            hSubKey = NULL;
        }
 
        if (pwszRegistryPath)
        {
            DllFreeSplMem(pwszRegistryPath);
            pwszRegistryPath = NULL;
        }
 
        if (pPrintMonitor)
        {
            if (pPrintMonitor->pwszFileName)
                DllFreeSplMem(pPrintMonitor->pwszFileName);
 
            if (pPrintMonitor->pwszName)
                DllFreeSplMem(pPrintMonitor->pwszName);
 
            DllFreeSplMem(pPrintMonitor);
            pPrintMonitor = NULL;
        }
 
        // Create a new LOCAL_PRINT_MONITOR structure for it.
        pPrintMonitor = DllAllocSplMem(sizeof(LOCAL_PRINT_MONITOR));
        if (!pPrintMonitor)
        {
            dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
            ERR("DllAllocSplMem failed!\n");
            goto Cleanup;
        }
 
        memset( pPrintMonitor, 0, sizeof(LOCAL_PRINT_MONITOR));
 
        // Allocate memory for the Print Monitor Name.
        pPrintMonitor->pwszName = DllAllocSplMem((cchMaxSubKey + 1) * sizeof(WCHAR));
        if (!pPrintMonitor->pwszName)
        {
            dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
            ERR("DllAllocSplMem failed!\n");
            goto Cleanup;
        }
 
        // Get the name of this Print Monitor.
        cchPrintMonitorName = cchMaxSubKey + 1;
        dwErrorCode = (DWORD)RegEnumKeyExW(hKey, i, pPrintMonitor->pwszName, &cchPrintMonitorName, NULL, NULL, NULL, NULL);
        if (dwErrorCode != ERROR_SUCCESS)
        {
            ERR("RegEnumKeyExW failed for iteration %lu with status %lu!\n", i, dwErrorCode);
            continue;
        }
 
        // Open this Print Monitor's registry key.
        dwErrorCode = (DWORD)RegOpenKeyExW(hKey, pPrintMonitor->pwszName, 0, KEY_READ, &hSubKey);
        if (dwErrorCode != ERROR_SUCCESS)
        {
            ERR("RegOpenKeyExW failed for Print Provider \"%S\" with status %lu!\n", pPrintMonitor->pwszName, dwErrorCode);
            continue;
        }
 
        // Get the file name of the Print Monitor.
        pPrintMonitor->pwszFileName = AllocAndRegQueryWSZ(hSubKey, L"Driver");
        if (!pPrintMonitor->pwszFileName)
            continue;
 
        // Try to load it.
        hinstPrintMonitor = LoadLibraryW(pPrintMonitor->pwszFileName);
        if (!hinstPrintMonitor)
        {
            ERR("LoadLibraryW failed for \"%S\" with error %lu!\n", pPrintMonitor->pwszFileName, GetLastError());
            continue;
        }
 
        pPrintMonitor->hModule = hinstPrintMonitor;
 
        // Try to find a Level 2 initialization routine first.
        pfnInitializePrintMonitor2 = (PInitializePrintMonitor2)GetProcAddress(hinstPrintMonitor, "InitializePrintMonitor2");
        if (pfnInitializePrintMonitor2)
        {
            // Prepare a MONITORINIT structure.
            MonitorInit.cbSize = sizeof(MONITORINIT);
            MonitorInit.bLocal = TRUE;
 
            // TODO: Fill the other fields.
            MonitorInit.hckRegistryRoot = hKey;
            MonitorInit.pMonitorReg = &MonReg;
 
            // Call the Level 2 initialization routine.
            pPrintMonitor->pMonitor = (PMONITOR2)pfnInitializePrintMonitor2(&MonitorInit, &pPrintMonitor->hMonitor);
            if (!pPrintMonitor->pMonitor)
            {
                ERR("InitializePrintMonitor2 failed for \"%S\" with error %lu!\n", pPrintMonitor->pwszFileName, GetLastError());
                continue;
            }
            FIXME("InitializePrintMonitor2 loaded.\n");
            pPrintMonitor->bIsLevel2 = TRUE;
        }
        else
        {
            // Try to find a Level 1 initialization routine then.
            pfnInitializePrintMonitor = (PInitializePrintMonitor)GetProcAddress(hinstPrintMonitor, "InitializePrintMonitor");
            if (pfnInitializePrintMonitor)
            {
                // Construct the registry path.
                pwszRegistryPath = DllAllocSplMem((cchMonitorsPath + 1 + cchPrintMonitorName + 1) * sizeof(WCHAR));
                if (!pwszRegistryPath)
                {
                    dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
                    ERR("DllAllocSplMem failed!\n");
                    goto Cleanup;
                }
 
                CopyMemory(pwszRegistryPath, wszMonitorsPath, cchMonitorsPath * sizeof(WCHAR));
                pwszRegistryPath[cchMonitorsPath] = L'\\';
                CopyMemory(&pwszRegistryPath[cchMonitorsPath + 1], pPrintMonitor->pwszName, (cchPrintMonitorName + 1) * sizeof(WCHAR));
 
                // Call the Level 1 initialization routine.
                pPrintMonitor->pMonitor = (LPMONITOREX)pfnInitializePrintMonitor(pwszRegistryPath);
                if (!pPrintMonitor->pMonitor)
                {
                    ERR("InitializePrintMonitor failed for \"%S\" with error %lu!\n", pPrintMonitor->pwszFileName, GetLastError());
                    continue;
                }
            }
            else
            {
                ERR("No initialization routine found for \"%S\"!\n", pPrintMonitor->pwszFileName);
                continue;
            }
        }
 
        // Add this Print Monitor to the list.
        InsertTailList(&PrintMonitorList, &pPrintMonitor->Entry);
        FIXME("InitializePrintMonitorList Handle %p\n",pPrintMonitor->hMonitor);
        pPrintMonitor->refcount++;
 
        // Don't let the cleanup routine free this.
        pPrintMonitor = NULL;
    }
 
    dwErrorCode = ERROR_SUCCESS;
 
Cleanup:
    // Inside the loop
    if (hSubKey)
        RegCloseKey(hSubKey);
 
    if (pwszRegistryPath)
        DllFreeSplMem(pwszRegistryPath);
 
    if (pPrintMonitor)
    {
        if (pPrintMonitor->pwszFileName)
            DllFreeSplMem(pPrintMonitor->pwszFileName);
 
        if (pPrintMonitor->pwszName)
            DllFreeSplMem(pPrintMonitor->pwszName);
 
        DllFreeSplMem(pPrintMonitor);
    }
 
    // Outside the loop
    if (hKey)
        RegCloseKey(hKey);
 
    SetLastError(dwErrorCode);
    return (dwErrorCode == ERROR_SUCCESS);
}

Referenced by _InitializeLocalSpooler().

◆ InitializePrintProcessorList()

BOOL InitializePrintProcessorList ( void )

Definition at line 129 of file printprocessors.c.

{
    DWORD cbDatatypes;
    DWORD cbFileName;
    DWORD cchPrintProcessorPath;
    DWORD cchMaxSubKey;
    DWORD cchPrintProcessorName;
    DWORD dwErrorCode;
    DWORD dwSubKeys;
    DWORD i;
    HINSTANCE hinstPrintProcessor;
    HKEY hKey = NULL;
    HKEY hSubKey = NULL;
    HKEY hSubSubKey = NULL;
    PLOCAL_PRINT_PROCESSOR pPrintProcessor = NULL;
    WCHAR wszFileName[MAX_PATH];
    WCHAR wszPrintProcessorPath[MAX_PATH];
 
    TRACE("InitializePrintProcessorList()\n");
 
    // Initialize an empty list for our Print Processors.
    InitializeListHead(&_PrintProcessorList);
 
    // Prepare the path to the Print Processor directory.
    if (!LocalGetPrintProcessorDirectory(NULL, (PWSTR)wszCurrentEnvironment, 1, (PBYTE)wszPrintProcessorPath, sizeof(wszPrintProcessorPath), &cchPrintProcessorPath))
    {
        dwErrorCode = GetLastError();
        goto Cleanup;
    }
 
    // LocalGetPrintProcessorDirectory returns the number of copied bytes. Convert this into a number of characters without the terminating null-character.
    cchPrintProcessorPath /= sizeof(WCHAR);
    --cchPrintProcessorPath;
 
    // Append a trailing backslash.
    wszPrintProcessorPath[cchPrintProcessorPath] = L'\\';
    ++cchPrintProcessorPath;
 
    // Open the environment registry key.
    dwErrorCode = _OpenEnvironment(wszCurrentEnvironment, &hKey);
    if (dwErrorCode != ERROR_SUCCESS)
        goto Cleanup;
 
    // Open the "Print Processors" subkey.
    dwErrorCode = (DWORD)RegOpenKeyExW(hKey, L"Print Processors", 0, KEY_READ, &hSubKey);
    if (dwErrorCode != ERROR_SUCCESS)
    {
        ERR("RegOpenKeyExW failed with status %lu!\n", dwErrorCode);
        goto Cleanup;
    }
 
    // Get the number of Print Processors and maximum sub key length.
    dwErrorCode = (DWORD)RegQueryInfoKeyW(hSubKey, NULL, NULL, NULL, &dwSubKeys, &cchMaxSubKey, NULL, NULL, NULL, NULL, NULL, NULL);
    if (dwErrorCode != ERROR_SUCCESS)
    {
        ERR("RegQueryInfoKeyW failed with status %lu!\n", dwErrorCode);
        goto Cleanup;
    }
 
    // Loop through all available local Print Processors.
    for (i = 0; i < dwSubKeys; i++)
    {
        // Cleanup tasks from the previous run
        if (hSubSubKey)
        {
            RegCloseKey(hSubSubKey);
            hSubSubKey = NULL;
        }
 
        if (pPrintProcessor)
        {
            if (pPrintProcessor->pwszName)
                DllFreeSplStr(pPrintProcessor->pwszName);
 
            if (pPrintProcessor->pDatatypesInfo1)
                DllFreeSplMem(pPrintProcessor->pDatatypesInfo1);
 
            DllFreeSplMem(pPrintProcessor);
            pPrintProcessor = NULL;
        }
 
        // Create a new LOCAL_PRINT_PROCESSOR structure for it.
        pPrintProcessor = DllAllocSplMem(sizeof(LOCAL_PRINT_PROCESSOR));
        if (!pPrintProcessor)
        {
            dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
            ERR("DllAllocSplMem failed!\n");
            goto Cleanup;
        }
 
        // Allocate memory for the Print Monitor Name.
        pPrintProcessor->pwszName = DllAllocSplMem((cchMaxSubKey + 1) * sizeof(WCHAR));
        if (!pPrintProcessor->pwszName)
        {
            dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
            ERR("DllAllocSplMem failed!\n");
            goto Cleanup;
        }
 
        // Get the name of this Print Processor.
        cchPrintProcessorName = cchMaxSubKey + 1;
        dwErrorCode = (DWORD)RegEnumKeyExW(hSubKey, i, pPrintProcessor->pwszName, &cchPrintProcessorName, NULL, NULL, NULL, NULL);
        if (dwErrorCode != ERROR_SUCCESS)
        {
            ERR("RegEnumKeyExW failed with status %ld!\n", dwErrorCode);
            continue;
        }
 
        // Open this Print Processor's registry key.
        dwErrorCode = (DWORD)RegOpenKeyExW(hSubKey, pPrintProcessor->pwszName, 0, KEY_READ, &hSubSubKey);
        if (dwErrorCode != ERROR_SUCCESS)
        {
            ERR("RegOpenKeyExW failed for Print Processor \"%S\" with status %lu!\n", pPrintProcessor->pwszName, dwErrorCode);
            continue;
        }
 
        // Get the file name of the Print Processor.
        cbFileName = sizeof(wszFileName);
        dwErrorCode = (DWORD)RegQueryValueExW(hSubSubKey, L"Driver", NULL, NULL, (PBYTE)wszFileName, &cbFileName);
        if (dwErrorCode != ERROR_SUCCESS)
        {
            ERR("RegQueryValueExW failed for Print Processor \"%S\" with status %lu!\n", pPrintProcessor->pwszName, dwErrorCode);
            continue;
        }
 
        // Verify that our buffer is large enough.
        if (cchPrintProcessorPath + cbFileName / sizeof(WCHAR) > MAX_PATH)
        {
            ERR("Print Processor directory \"%S\" for Print Processor \"%S\" is too long!\n", wszFileName, pPrintProcessor->pwszName);
            continue;
        }
 
        // Construct the full path to the Print Processor.
        CopyMemory(&wszPrintProcessorPath[cchPrintProcessorPath], wszFileName, cbFileName);
 
        // Try to load it.
        hinstPrintProcessor = LoadLibraryW(wszPrintProcessorPath);
        if (!hinstPrintProcessor)
        {
            ERR("LoadLibraryW failed for \"%S\" with error %lu!\n", wszPrintProcessorPath, GetLastError());
            continue;
        }
 
        // Get and verify all its function pointers.
        pPrintProcessor->pfnClosePrintProcessor = (PClosePrintProcessor)GetProcAddress(hinstPrintProcessor, "ClosePrintProcessor");
        if (!pPrintProcessor->pfnClosePrintProcessor)
        {
            ERR("Print Processor \"%S\" exports no ClosePrintProcessor!\n", wszPrintProcessorPath);
            continue;
        }
 
        pPrintProcessor->pfnControlPrintProcessor = (PControlPrintProcessor)GetProcAddress(hinstPrintProcessor, "ControlPrintProcessor");
        if (!pPrintProcessor->pfnControlPrintProcessor)
        {
            ERR("Print Processor \"%S\" exports no ControlPrintProcessor!\n", wszPrintProcessorPath);
            continue;
        }
 
        pPrintProcessor->pfnEnumPrintProcessorDatatypesW = (PEnumPrintProcessorDatatypesW)GetProcAddress(hinstPrintProcessor, "EnumPrintProcessorDatatypesW");
        if (!pPrintProcessor->pfnEnumPrintProcessorDatatypesW)
        {
            ERR("Print Processor \"%S\" exports no EnumPrintProcessorDatatypesW!\n", wszPrintProcessorPath);
            continue;
        }
 
        pPrintProcessor->pfnGetPrintProcessorCapabilities = (PGetPrintProcessorCapabilities)GetProcAddress(hinstPrintProcessor, "GetPrintProcessorCapabilities");
        if (!pPrintProcessor->pfnGetPrintProcessorCapabilities)
        {
            ERR("Print Processor \"%S\" exports no GetPrintProcessorCapabilities!\n", wszPrintProcessorPath);
            continue;
        }
 
        pPrintProcessor->pfnOpenPrintProcessor = (POpenPrintProcessor)GetProcAddress(hinstPrintProcessor, "OpenPrintProcessor");
        if (!pPrintProcessor->pfnOpenPrintProcessor)
        {
            ERR("Print Processor \"%S\" exports no OpenPrintProcessor!\n", wszPrintProcessorPath);
            continue;
        }
 
        pPrintProcessor->pfnPrintDocumentOnPrintProcessor = (PPrintDocumentOnPrintProcessor)GetProcAddress(hinstPrintProcessor, "PrintDocumentOnPrintProcessor");
        if (!pPrintProcessor->pfnPrintDocumentOnPrintProcessor)
        {
            ERR("Print Processor \"%S\" exports no PrintDocumentOnPrintProcessor!\n", wszPrintProcessorPath);
            continue;
        }
 
        // Get all supported datatypes.
        pPrintProcessor->pfnEnumPrintProcessorDatatypesW(NULL, NULL, 1, NULL, 0, &cbDatatypes, &pPrintProcessor->dwDatatypeCount);
        pPrintProcessor->pDatatypesInfo1 = DllAllocSplMem(cbDatatypes);
        if (!pPrintProcessor->pDatatypesInfo1)
        {
            dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
            ERR("DllAllocSplMem failed!\n");
            goto Cleanup;
        }
 
        if (!pPrintProcessor->pfnEnumPrintProcessorDatatypesW(NULL, NULL, 1, (PBYTE)pPrintProcessor->pDatatypesInfo1, cbDatatypes, &cbDatatypes, &pPrintProcessor->dwDatatypeCount))
        {
            ERR("EnumPrintProcessorDatatypesW failed for Print Processor \"%S\" with error %lu!\n", wszPrintProcessorPath, GetLastError());
            continue;
        }
 
        // Add the Print Processor to the list.
        InsertTailList(&_PrintProcessorList, &pPrintProcessor->Entry);
 
        // Don't let the cleanup routines free this.
        pPrintProcessor = NULL;
    }
 
    dwErrorCode = ERROR_SUCCESS;
 
Cleanup:
    // Inside the loop
    if (hSubSubKey)
        RegCloseKey(hSubSubKey);
 
    if (pPrintProcessor)
    {
        if (pPrintProcessor->pwszName)
            DllFreeSplStr(pPrintProcessor->pwszName);
 
        if (pPrintProcessor->pDatatypesInfo1)
            DllFreeSplMem(pPrintProcessor->pDatatypesInfo1);
 
        DllFreeSplMem(pPrintProcessor);
    }
 
    // Outside the loop
    if (hSubKey)
        RegCloseKey(hSubKey);
 
    if (hKey)
        RegCloseKey(hKey);
 
    SetLastError(dwErrorCode);
    return (dwErrorCode == ERROR_SUCCESS);
}

Referenced by _InitializeLocalSpooler().

◆ LocalAddForm()

BOOL WINAPI LocalAddForm	(	HANDLE	hPrinter,
		DWORD	Level,
		PBYTE	pForm
	)

Definition at line 409 of file forms.c.

{
    DWORD dwErrorCode, Size, cbNeeded;
    PFORM_INFO_LIST pfil;
    PLOCAL_HANDLE pHandle;
    REGISTRYFORMINFO rfi;
    PFORM_INFO_1W pfi1w = (PFORM_INFO_1W)pForm;
    PFORM_INFO_2W pfi2w = (PFORM_INFO_2W)pForm;
 
    FIXME("AddForm(%p, %lu, %p)\n", hPrinter, Level, pForm);
 
    // Check if this is a printer handle.
    pHandle = (PLOCAL_HANDLE)hPrinter;
    if (pHandle->HandleType != HandleType_Printer)
    {
        dwErrorCode = ERROR_INVALID_HANDLE;
        goto Cleanup;
    }
 
    // Only support 1 & 2
    if (Level < 1 || Level > 2)
    {
        // The caller supplied an invalid level.
        dwErrorCode = ERROR_INVALID_LEVEL;
        goto Cleanup;
    }
 
    pfil = FindForm( pfi1w->pName, NULL );
    if ( pfil )
    {
        dwErrorCode = ERROR_FILE_EXISTS;
        goto Cleanup;
    }
 
    dwErrorCode = RegQueryValueExW( hFormsKey, pfi1w->pName, NULL, NULL, NULL, &cbNeeded );
    if ( dwErrorCode == ERROR_SUCCESS )
    {
        dwErrorCode = ERROR_FILE_EXISTS;
        goto Cleanup;
    }
 
    if ( wcslen(pfi1w->pName) > FORMMAXNAMESIZE ) // Limit REG Name size.
    {
        dwErrorCode = ERROR_INVALID_PARAMETER;
        goto Cleanup;
    }
 
    Size = sizeof(FORM_INFO_LIST) + ((MAX_PATH + 1) * sizeof(WCHAR));
 
    pfil = DllAllocSplMem( Size );
    if ( !pfil )
    {
        dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
        goto Cleanup;
    }
 
    pfil->Sig           = FORMINFOSIG;
    pfil->Index         = _dwLastForm++;
    pfil->pName         = wcscpy( (PWSTR)(pfil+1), pfi1w->pName );
    pfil->Flags         = pfi1w->Flags;
    pfil->Size          = pfi1w->Size;
    pfil->ImageableArea = pfi1w->ImageableArea;
    pfil->StringType    = STRING_NONE;
 
    if ( Level > 1 )
    {
        pfil->pKeyword     = pfi2w->pKeyword;
        pfil->pMuiDll      = pfi2w->pMuiDll;
        pfil->pDisplayName = pfi2w->pDisplayName;
        pfil->StringType   = pfi2w->StringType;
        pfil->dwResourceId = pfi2w->dwResourceId;
    }
 
    rfi.Size          = pfil->Size;
    rfi.ImageableArea = pfil->ImageableArea;
    rfi.Index         = pfil->Index;
    rfi.Flags         = pfil->Flags;
 
    dwErrorCode = RegSetValueExW( hFormsKey, pfil->pName, 0, REG_BINARY, (PBYTE)&rfi, sizeof( rfi ) );
 
    BroadcastChange(pHandle);
 
    InsertTailList( &FormList, &pfil->List );
 
Cleanup:
    SetLastError(dwErrorCode);
    return (dwErrorCode == ERROR_SUCCESS);
}

◆ LocalAddJob()

BOOL WINAPI LocalAddJob	(	HANDLE	hPrinter,
		DWORD	Level,
		LPBYTE	pData,
		DWORD	cbBuf,
		LPDWORD	pcbNeeded
	)

◆ LocalAddMonitor()

BOOL WINAPI LocalAddMonitor	(	PWSTR	pName,
		DWORD	Level,
		PBYTE	pMonitors
	)

Definition at line 636 of file monitors.c.

{
    PPRINTENV_T env;
    LPMONITOR_INFO_2W mi2w;
    HKEY hroot = NULL;
    HKEY hentry = NULL;
    DWORD disposition;
    BOOL res = FALSE;
    const WCHAR wszMonitorsPath[] = L"SYSTEM\\CurrentControlSet\\Control\\Print\\Monitors\\";
 
    mi2w = (LPMONITOR_INFO_2W) pMonitors;
 
    FIXME("LocalAddMonitor(%s, %d, %p): %s %s %s\n", debugstr_w(pName), Level, pMonitors,
        debugstr_w(mi2w->pName), debugstr_w(mi2w->pEnvironment), debugstr_w(mi2w->pDLLName));
 
    if (copy_servername_from_name(pName, NULL))
    {
        FIXME("server %s not supported\n", debugstr_w(pName));
        SetLastError(ERROR_ACCESS_DENIED);
        return FALSE;
    }
 
    if (!mi2w->pName || (!mi2w->pName[0]) )
    {
        FIXME("pName not valid : %s\n", debugstr_w(mi2w->pName));
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    env = validate_envW(mi2w->pEnvironment);
    if (!env)
        return FALSE;   /* ERROR_INVALID_ENVIRONMENT */
 
    if (!mi2w->pDLLName || (!mi2w->pDLLName[0]) )
    {
        FIXME("pDLLName not valid : %s\n", debugstr_w(mi2w->pDLLName));
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    if (RegCreateKeyW(HKEY_LOCAL_MACHINE, wszMonitorsPath, &hroot) != ERROR_SUCCESS) {
        ERR("unable to create key %s\n", debugstr_w(wszMonitorsPath));
        return FALSE;
    }
 
    if (RegCreateKeyExW(hroot, mi2w->pName, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE | KEY_QUERY_VALUE, NULL, &hentry, &disposition) == ERROR_SUCCESS)
    {
        /* Some installers set options for the port before calling AddMonitor.
           We query the "Driver" entry to verify that the monitor is installed,
           before we return an error.
           When a user installs two print monitors at the same time with the
           same name, a race condition is possible but silently ignored. */
 
        DWORD   namesize = 0;
 
        if ((disposition == REG_OPENED_EXISTING_KEY) &&
            (RegQueryValueExW(hentry, L"Driver", NULL, NULL, NULL, &namesize) == ERROR_SUCCESS))
        {
            FIXME("monitor %s already exists\n", debugstr_w(mi2w->pName));
            /* 9x use ERROR_ALREADY_EXISTS */
            SetLastError(ERROR_PRINT_MONITOR_ALREADY_INSTALLED);
        }
        else
        {
            INT len = (lstrlenW(mi2w->pDLLName) +1) * sizeof(WCHAR);
 
            res = (RegSetValueExW(hentry, L"Driver", 0, REG_SZ, (LPBYTE) mi2w->pDLLName, len) == ERROR_SUCCESS);
 
            /* Load and initialize the monitor. SetLastError() is called on failure */
 
            res = AddPrintMonitorList( mi2w->pName, mi2w->pDLLName );
 
            if ( !res )
            {
                RegDeleteKeyW(hroot, mi2w->pName);
            }
            else
                SetLastError(ERROR_SUCCESS); /* Monitor installer depends on this */
        }
 
        RegCloseKey(hentry);
    }
 
    RegCloseKey(hroot);
    return res;
}

◆ LocalAddPort()

BOOL WINAPI LocalAddPort	(	LPWSTR	pName,
		HWND	hWnd,
		LPWSTR	pMonitorName
	)

Definition at line 286 of file ports.c.

{
    DWORD lres;
    BOOL res = FALSE;
    PLOCAL_PRINT_MONITOR pPrintMonitor;
 
    FIXME("LocalAddPort(%S, %p, %s)\n", pName, hWnd, debugstr_w(pMonitorName));
 
    lres = copy_servername_from_name(pName, NULL);
    if (lres)
    {
        FIXME("server %s not supported\n", debugstr_w(pName));
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    /* an empty Monitorname is Invalid */
    if (!pMonitorName[0])
    {
        SetLastError(ERROR_NOT_SUPPORTED);
        return FALSE;
    }
 
    pPrintMonitor = FindPrintMonitor( pMonitorName );
    if (!pPrintMonitor )
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    if ( pPrintMonitor->bIsLevel2 && ((PMONITOR2)pPrintMonitor->pMonitor)->pfnAddPort )
    {
        res = ((PMONITOR2)pPrintMonitor->pMonitor)->pfnAddPort(pPrintMonitor->hMonitor, pName, hWnd, pMonitorName);
    }
    else if ( !pPrintMonitor->bIsLevel2 && ((LPMONITOREX)pPrintMonitor->pMonitor)->Monitor.pfnAddPort )
    {
        res = ((LPMONITOREX)pPrintMonitor->pMonitor)->Monitor.pfnAddPort(pName, hWnd, pMonitorName);
    }
    else
    {
        SetLastError(ERROR_INVALID_PARAMETER);
    }
 
    if ( res )
    {
        DWORD cbNeeded, cReturned, i;
        PPORT_INFO_1 pPorts;
 
        //
        // Play it safe,,, we know its Monitor2.... This is ReactOS.
        //
        if ( LocalEnumPorts( pName, 1, NULL, 0, &cbNeeded, &cReturned ) )
        {
            pPorts = DllAllocSplMem( cbNeeded );
            if (pPorts)
            {
                if ( LocalEnumPorts( pName, 1, (PBYTE)pPorts, cbNeeded, &cbNeeded, &cReturned ) )
                {
                    for ( i = 0; i < cReturned; i++ )
                    {
                        if ( !FindPort( pPorts[i].pName ) )
                        {
                            CreatePortEntry( pPorts[i].pName, pPrintMonitor );
                        }
                    }
                }
                DllFreeSplMem( pPorts );
            }
        }
    }
 
    return res;
}

◆ LocalAddPortEx()

BOOL WINAPI LocalAddPortEx	(	PWSTR	pName,
		DWORD	Level,
		PBYTE	lpBuffer,
		PWSTR	lpMonitorName
	)

Definition at line 217 of file ports.c.

{
    DWORD lres;
    BOOL res = FALSE;
    PLOCAL_PORT pPort;
    PLOCAL_PRINT_MONITOR pPrintMonitor;
    PORT_INFO_1W * pi = (PORT_INFO_1W *) lpBuffer;
 
    FIXME("LocalAddPortEx(%S, %lu, %p, %S)\n", pName, Level, lpBuffer, lpMonitorName);
 
    lres = copy_servername_from_name(pName, NULL);
    if ( lres )
    {
        FIXME("server %s not supported\n", debugstr_w(pName));
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    if ( Level != 1 )
    {
        SetLastError(ERROR_INVALID_LEVEL);
        return FALSE;
    }
 
    if ((!pi) || (!lpMonitorName) || (!lpMonitorName[0]))
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    pPrintMonitor = FindPrintMonitor( lpMonitorName );
    if (!pPrintMonitor )
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    pPort = FindPort( pi->pName );
    if ( pPort )
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    if ( pPrintMonitor->bIsLevel2 && ((PMONITOR2)pPrintMonitor->pMonitor)->pfnAddPortEx )
    {
        res = ((PMONITOR2)pPrintMonitor->pMonitor)->pfnAddPortEx(pPrintMonitor->hMonitor, pName, Level, lpBuffer, lpMonitorName);
    }
    else if ( !pPrintMonitor->bIsLevel2 && ((LPMONITOREX)pPrintMonitor->pMonitor)->Monitor.pfnAddPortEx )
    {
        res = ((LPMONITOREX)pPrintMonitor->pMonitor)->Monitor.pfnAddPortEx(pName, Level, lpBuffer, lpMonitorName);
    }
    else
    {
        SetLastError(ERROR_INVALID_PARAMETER);
    }
 
    if ( res )
    {
        res = CreatePortEntry( pi->pName, pPrintMonitor );
    }
 
    return res;
}

◆ LocalAddPrinterDriver()

BOOL WINAPI LocalAddPrinterDriver	(	LPWSTR	pName,
		DWORD	level,
		LPBYTE	pDriverInfo
	)

Definition at line 1133 of file printerdrivers.c.

{
    LONG lres;
 
    TRACE("(%s, %d, %p, 0x%x)\n", debugstr_w(pName), level, pDriverInfo);
 
    lres = copy_servername_from_name(pName, NULL);
 
    if (lres)
    {
        FIXME("server %s not supported\n", debugstr_w(pName));
        SetLastError(ERROR_ACCESS_DENIED);
        return FALSE;
    }
 
    // Should be APD_COPY_NEW_FILES. Cheap wine.
 
    return myAddPrinterDriverEx(level, pDriverInfo, APD_COPY_NEW_FILES, TRUE);
}

◆ LocalAddPrinterDriverEx()

BOOL WINAPI LocalAddPrinterDriverEx	(	LPWSTR	pName,
		DWORD	level,
		LPBYTE	pDriverInfo,
		DWORD	dwFileCopyFlags
	)

Definition at line 1110 of file printerdrivers.c.

{
    LONG lres;
 
    TRACE("(%s, %d, %p, 0x%x)\n", debugstr_w(pName), level, pDriverInfo, dwFileCopyFlags);
 
    lres = copy_servername_from_name(pName, NULL);
 
    if (lres)
    {
        FIXME("server %s not supported\n", debugstr_w(pName));
        SetLastError(ERROR_ACCESS_DENIED);
        return FALSE;
    }
 
    if ((dwFileCopyFlags & ~APD_COPY_FROM_DIRECTORY) != APD_COPY_ALL_FILES)
    {
        TRACE("Flags 0x%x ignored (using APD_COPY_ALL_FILES)\n", dwFileCopyFlags & ~APD_COPY_FROM_DIRECTORY);
    }
 
    return myAddPrinterDriverEx(level, pDriverInfo, dwFileCopyFlags, TRUE);
}

◆ LocalClosePrinter()

BOOL WINAPI LocalClosePrinter ( HANDLE hPrinter )

Definition at line 1960 of file printers.c.

{
    PLOCAL_HANDLE pHandle = (PLOCAL_HANDLE)hPrinter;
 
    FIXME("LocalClosePrinter(%p)\n", hPrinter);
 
    if (!pHandle)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    if (pHandle->HandleType == HandleType_Port)
    {
        _LocalClosePortHandle(pHandle->pSpecificHandle);
    }
    else if (pHandle->HandleType == HandleType_Printer)
    {
        _LocalClosePrinterHandle(pHandle->pSpecificHandle);
    }
    else if (pHandle->HandleType == HandleType_PrintServer)
    {
        // Nothing to do.
    }
    else if (pHandle->HandleType == HandleType_Xcv)
    {
        _LocalCloseXcvHandle(pHandle->pSpecificHandle);
    }
    FIXME("LocalClosePrinter 1\n");
    // Free memory for the handle and the specific handle (if any).
    if (pHandle->pSpecificHandle)
        DllFreeSplMem(pHandle->pSpecificHandle);
    FIXME("LocalClosePrinter 2\n");
    DllFreeSplMem(pHandle);
    FIXME("LocalClosePrinter 3\n");
    return TRUE;
}

◆ LocalCloseSpoolFileHandle()

BOOL WINAPI LocalCloseSpoolFileHandle ( HANDLE hPrinter )

Definition at line 30 of file spoolfile.c.

{
    FIXME("LocalCloseSpoolFileHandle(%p)\n", hPrinter);
    return FALSE;
}

◆ LocalCommitSpoolData()

BOOL WINAPI LocalCommitSpoolData	(	HANDLE	hPrinter,
		DWORD	cbCommit
	)

Definition at line 23 of file spoolfile.c.

{
    FIXME("LocalCommitSpoolData(%p, %lu)\n", hPrinter, cbCommit);
    return FALSE;
}

◆ LocalConfigurePort()

BOOL WINAPI LocalConfigurePort	(	PWSTR	pName,
		HWND	hWnd,
		PWSTR	pPortName
	)

Definition at line 361 of file ports.c.

{
    LONG lres;
    DWORD res;
    PLOCAL_PORT pPrintPort;
    PLOCAL_PRINT_MONITOR pPrintMonitor;
 
    FIXME("LocalConfigurePort(%S, %p, %S)\n", pName, hWnd, pPortName);
 
    lres = copy_servername_from_name(pName, NULL);
    if (lres)
    {
        FIXME("server %s not supported\n", debugstr_w(pName));
        SetLastError(ERROR_INVALID_NAME);
        return FALSE;
    }
 
    /* an empty Portname is Invalid, but can popup a Dialog */
    if (!pPortName[0])
    {
        SetLastError(ERROR_NOT_SUPPORTED);
        return FALSE;
    }
 
    pPrintPort = FindPort(pPortName);
    if (!pPrintPort )
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    pPrintMonitor = pPrintPort->pPrintMonitor;
 
    if ( pPrintMonitor->bIsLevel2 && ((PMONITOR2)pPrintMonitor->pMonitor)->pfnConfigurePort )
    {
        res = ((PMONITOR2)pPrintMonitor->pMonitor)->pfnConfigurePort(pPrintMonitor->hMonitor, pName, hWnd, pPortName);
    }
    else if ( !pPrintMonitor->bIsLevel2 && ((LPMONITOREX)pPrintMonitor->pMonitor)->Monitor.pfnConfigurePort )
    {
        res = ((LPMONITOREX)pPrintMonitor->pMonitor)->Monitor.pfnConfigurePort(pName, hWnd, pPortName);
    }
    else
    {
        SetLastError(ERROR_INVALID_PARAMETER);
    }
 
    return res;
}

◆ LocalDeleteForm()

BOOL WINAPI LocalDeleteForm	(	HANDLE	hPrinter,
		PWSTR	pFormName
	)

Definition at line 499 of file forms.c.

{
    DWORD dwErrorCode, cbNeeded;
    PFORM_INFO_LIST pfil;
    REGISTRYFORMINFO rfi;
    PLOCAL_HANDLE pHandle;
 
    FIXME("DeleteForm(%p, %S)\n", hPrinter, pFormName);
 
    // Check if this is a printer handle.
    pHandle = (PLOCAL_HANDLE)hPrinter;
    if (pHandle->HandleType != HandleType_Printer)
    {
        dwErrorCode = ERROR_INVALID_HANDLE;
        goto Cleanup;
    }
 
    pfil = FindForm( pFormName, NULL );
    if ( !pfil )
    {
        dwErrorCode = ERROR_INVALID_PARAMETER;
        goto Cleanup;
    }
 
    dwErrorCode = RegQueryValueExW( hFormsKey, pFormName, NULL, NULL, (PBYTE)&rfi, &cbNeeded );
    if ( dwErrorCode != ERROR_SUCCESS )
    {
        goto Cleanup;
    }
 
    dwErrorCode = RegDeleteValueW(hFormsKey, pFormName);
    if ( dwErrorCode != ERROR_SUCCESS )
    {
        goto Cleanup;
    }
 
    RemoveEntryList(&pfil->List);
 
    DllFreeSplMem(pfil);
 
    BroadcastChange(pHandle);
 
    dwErrorCode = ERROR_SUCCESS;
 
Cleanup:
    SetLastError(dwErrorCode);
    return (dwErrorCode == ERROR_SUCCESS);
}

◆ LocalDeleteMonitor()

BOOL WINAPI LocalDeleteMonitor	(	PWSTR	pName,
		PWSTR	pEnvironment,
		PWSTR	pMonitorName
	)

Definition at line 724 of file monitors.c.

{
    HKEY hroot = NULL;
    LONG lres;
    PLOCAL_PRINT_MONITOR pPrintMonitor;
    const WCHAR wszMonitorsPath[] = L"SYSTEM\\CurrentControlSet\\Control\\Print\\Monitors\\";
 
    FIXME("LocalDeleteMonitor(%s, %s, %s)\n",debugstr_w(pName),debugstr_w(pEnvironment),
           debugstr_w(pMonitorName));
 
    lres = copy_servername_from_name(pName, NULL);
    if (lres)
    {
        FIXME("server %s not supported\n", debugstr_w(pName));
        SetLastError(ERROR_INVALID_NAME);
        return FALSE;
    }
 
    /*  pEnvironment is ignored in Windows for the local Computer */
    if (!pMonitorName || !pMonitorName[0])
    {
        ERR("pMonitorName %s is invalid\n", debugstr_w(pMonitorName));
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    pPrintMonitor = FindPrintMonitor( pMonitorName );
    if ( pPrintMonitor )
    {
       if ( pPrintMonitor->refcount ) pPrintMonitor->refcount--;
 
       if ( pPrintMonitor->refcount == 0 )
       {       /* Unload the monitor if it's loaded */
       RemoveEntryList(&pPrintMonitor->Entry);
 
       if ( pPrintMonitor->bIsLevel2 )
       {
           PMONITOR2 pm2 = pPrintMonitor->pMonitor;
           if ( pm2 && pm2->pfnShutdown )
           {
               pm2->pfnShutdown(pPrintMonitor->hMonitor);
           }
       }
 
       if ( pPrintMonitor->hModule )
           FreeLibrary(pPrintMonitor->hModule);
 
       if (pPrintMonitor->pwszFileName)
           DllFreeSplStr(pPrintMonitor->pwszFileName);
 
       if (pPrintMonitor->pwszName)
           DllFreeSplStr(pPrintMonitor->pwszName);
 
       DllFreeSplMem(pPrintMonitor);
       pPrintMonitor = NULL;
       }
    }
    else
    {
       FIXME("Could not find %s\n", debugstr_w(pMonitorName));
    }
 
    if (RegCreateKeyW(HKEY_LOCAL_MACHINE, wszMonitorsPath, &hroot) != ERROR_SUCCESS)
    {
        ERR("unable to create key %s\n", debugstr_w(wszMonitorsPath));
        return FALSE;
    }
 
    if (RegDeleteTreeW(hroot, pMonitorName) == ERROR_SUCCESS)
    {
        FIXME("%s deleted\n", debugstr_w(pMonitorName));
        RegCloseKey(hroot);
        return TRUE;
    }
 
    FIXME("%s does not exist\n", debugstr_w(pMonitorName));
    RegCloseKey(hroot);
 
    /* NT: ERROR_UNKNOWN_PRINT_MONITOR (3000), 9x: ERROR_INVALID_PARAMETER (87) */
    SetLastError(ERROR_UNKNOWN_PRINT_MONITOR);
    return FALSE;
}

◆ LocalDeletePort()

BOOL WINAPI LocalDeletePort	(	PWSTR	pName,
		HWND	hWnd,
		PWSTR	pPortName
	)

Definition at line 411 of file ports.c.

{
    LONG lres;
    DWORD res = FALSE;
    PLOCAL_PORT pPrintPort;
    PLOCAL_PRINT_MONITOR pPrintMonitor;
 
    FIXME("LocalDeletePort(%S, %p, %S)\n", pName, hWnd, pPortName);
 
    lres = copy_servername_from_name(pName, NULL);
    if (lres)
    {
        FIXME("server %s not supported\n", debugstr_w(pName));
        SetLastError(ERROR_INVALID_NAME);
        return FALSE;
    }
 
    if (!pPortName[0])
    {
        SetLastError(ERROR_NOT_SUPPORTED);
        return FALSE;
    }
 
    pPrintPort = FindPort(pPortName);
    if (!pPrintPort )
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    pPrintMonitor = pPrintPort->pPrintMonitor;
 
    if ( pPrintMonitor->bIsLevel2 && ((PMONITOR2)pPrintMonitor->pMonitor)->pfnDeletePort )
    {
        res = ((PMONITOR2)pPrintMonitor->pMonitor)->pfnDeletePort(pPrintMonitor->hMonitor, pName, hWnd, pPortName);
    }
    else if ( !pPrintMonitor->bIsLevel2 && ((LPMONITOREX)pPrintMonitor->pMonitor)->Monitor.pfnDeletePort )
    {
        res = ((LPMONITOREX)pPrintMonitor->pMonitor)->Monitor.pfnDeletePort(pName, hWnd, pPortName);
    }
 
    RemoveEntryList(&pPrintPort->Entry);
 
    DllFreeSplMem(pPrintPort);
 
    return res;
}

◆ LocalEndDocPrinter()

BOOL WINAPI LocalEndDocPrinter ( HANDLE hPrinter )

Definition at line 1857 of file printers.c.

{
    BOOL bReturnValue;
    DWORD dwErrorCode;
    PLOCAL_HANDLE pHandle = (PLOCAL_HANDLE)hPrinter;
    PLOCAL_PORT_HANDLE pPortHandle;
    PLOCAL_PRINTER_HANDLE pPrinterHandle;
 
    TRACE("LocalEndDocPrinter(%p)\n", hPrinter);
 
    // Sanity checks.
    if (!pHandle)
    {
        dwErrorCode = ERROR_INVALID_HANDLE;
        goto Cleanup;
    }
 
    // Port handles are an entirely different thing.
    if (pHandle->HandleType == HandleType_Port)
    {
        pPortHandle = (PLOCAL_PORT_HANDLE)pHandle->pSpecificHandle;
 
        // Call the monitor's EndDocPort function.
        if (pPortHandle->pPort->pPrintMonitor->bIsLevel2)
            bReturnValue = ((PMONITOR2)pPortHandle->pPort->pPrintMonitor->pMonitor)->pfnEndDocPort(pPortHandle->hPort);
        else
            bReturnValue = ((LPMONITOREX)pPortHandle->pPort->pPrintMonitor->pMonitor)->Monitor.pfnEndDocPort(pPortHandle->hPort);
 
        if (!bReturnValue)
        {
            // The EndDocPort function failed. Return its last error.
            dwErrorCode = GetLastError();
            goto Cleanup;
        }
 
        // We were successful!
        dwErrorCode = ERROR_SUCCESS;
        goto Cleanup;
    }
 
    // The remaining function deals with Printer handles only.
    if (pHandle->HandleType != HandleType_Printer)
    {
        dwErrorCode = ERROR_INVALID_HANDLE;
        goto Cleanup;
    }
 
    pPrinterHandle = (PLOCAL_PRINTER_HANDLE)pHandle->pSpecificHandle;
 
    // We require StartDocPrinter or AddJob to be called first.
    if (!pPrinterHandle->bStartedDoc)
    {
        dwErrorCode = ERROR_SPL_NO_STARTDOC;
        goto Cleanup;
    }
 
    // TODO: Something like ScheduleJob
 
    // Finish the job.
    pPrinterHandle->bStartedDoc = FALSE;
    pPrinterHandle->pJob = NULL;
    dwErrorCode = ERROR_SUCCESS;
 
Cleanup:
    SetLastError(dwErrorCode);
    return (dwErrorCode == ERROR_SUCCESS);
}

◆ LocalEndPagePrinter()

BOOL WINAPI LocalEndPagePrinter ( HANDLE hPrinter )

Definition at line 1834 of file printers.c.

{
    DWORD dwErrorCode;
    PLOCAL_HANDLE pHandle = (PLOCAL_HANDLE)hPrinter;
 
    TRACE("LocalEndPagePrinter(%p)\n", hPrinter);
 
    // Sanity checks.
    if (!pHandle || pHandle->HandleType != HandleType_Printer)
    {
        dwErrorCode = ERROR_INVALID_HANDLE;
        goto Cleanup;
    }
 
    // This function doesn't do anything else for now.
    dwErrorCode = ERROR_SUCCESS;
 
Cleanup:
    SetLastError(dwErrorCode);
    return (dwErrorCode == ERROR_SUCCESS);
}

◆ LocalEnumForms()

BOOL WINAPI LocalEnumForms	(	HANDLE	hPrinter,
		DWORD	Level,
		PBYTE	pForm,
		DWORD	cbBuf,
		PDWORD	pcbNeeded,
		PDWORD	pcReturned
	)

Definition at line 549 of file forms.c.

{
    DWORD dwErrorCode;
    PFORM_INFO_LIST pfil = NULL;
    PBYTE pEnd = &pForm[cbBuf];
    PLOCAL_HANDLE pHandle;
    PLIST_ENTRY ListEntry;
 
    FIXME("EnumForms(%p, %lu, %p, %lu, %p, %p)\n", hPrinter, Level, pForm, cbBuf, pcbNeeded, pcReturned);
 
    // Check if this is a printer handle.
    pHandle = (PLOCAL_HANDLE)hPrinter;
    if (pHandle->HandleType != HandleType_Printer)
    {
        dwErrorCode = ERROR_INVALID_HANDLE;
        goto Cleanup;
    }
 
    // Only support 1 & 2
    if (Level < 1 || Level > 2)
    {
        // The caller supplied an invalid level.
        dwErrorCode = ERROR_INVALID_LEVEL;
        goto Cleanup;
    }
 
    // Count the required buffer size.
    *pcbNeeded = 0;
 
    ListEntry = FormList.Flink;
 
    if (IsListEmpty(ListEntry))
    {
        dwErrorCode = ERROR_INVALID_PARAMETER;
        goto Cleanup;
    }
 
    while ( ListEntry != &FormList )
    {
        pfil = CONTAINING_RECORD(ListEntry, FORM_INFO_LIST, List);
        ListEntry = ListEntry->Flink;
 
        pfnGetFormLevels[Level](pfil, NULL, NULL, pcbNeeded);
    }
 
    // Check if the supplied buffer is large enough.
    if (cbBuf < *pcbNeeded)
    {
        ERR("Insuffisient Buffer size\n");
        dwErrorCode = ERROR_INSUFFICIENT_BUFFER;
        goto Cleanup;
    }
 
    // Copy over the information.
    pEnd = &pForm[*pcbNeeded];
 
    ListEntry = FormList.Flink;
 
    while ( ListEntry != &FormList )
    {
        pfil = CONTAINING_RECORD(ListEntry, FORM_INFO_LIST, List);
        ListEntry = ListEntry->Flink;
 
        pfnGetFormLevels[Level](pfil, &pForm, &pEnd, NULL);
        (*pcReturned)++;
    }
 
    dwErrorCode = ERROR_SUCCESS;
 
Cleanup:
    SetLastError(dwErrorCode);
    return (dwErrorCode == ERROR_SUCCESS);
}

◆ LocalEnumJobs()

BOOL WINAPI LocalEnumJobs	(	HANDLE	hPrinter,
		DWORD	FirstJob,
		DWORD	NoJobs,
		DWORD	Level,
		PBYTE	pStart,
		DWORD	cbBuf,
		LPDWORD	pcbNeeded,
		LPDWORD	pcReturned
	)

Definition at line 1022 of file jobs.c.

{
    DWORD dwErrorCode;
    DWORD i;
    PBYTE pEnd;
    PLOCAL_HANDLE pHandle;
    PLOCAL_JOB pJob;
    PSKIPLIST_NODE pFirstJobNode;
    PSKIPLIST_NODE pNode;
    PLOCAL_PRINTER_HANDLE pPrinterHandle;
 
    TRACE("LocalEnumJobs(%p, %lu, %lu, %lu, %p, %lu, %p, %p)\n", hPrinter, FirstJob, NoJobs, Level, pStart, cbBuf, pcbNeeded, pcReturned);
 
    // Check if this is a printer handle.
    pHandle = (PLOCAL_HANDLE)hPrinter;
    if (pHandle->HandleType != HandleType_Printer)
    {
        dwErrorCode = ERROR_INVALID_HANDLE;
        goto Cleanup;
    }
 
    pPrinterHandle = (PLOCAL_PRINTER_HANDLE)pHandle->pSpecificHandle;
 
    // Check the level.
    if (Level > 2)
    {
        dwErrorCode = ERROR_INVALID_LEVEL;
        goto Cleanup;
    }
 
    // Begin counting.
    *pcbNeeded = 0;
    *pcReturned = 0;
 
    // Lookup the node of the first job requested by the caller in the Printer's Job List.
    pFirstJobNode = LookupNodeByIndexSkiplist(&pPrinterHandle->pPrinter->JobList, FirstJob);
 
    // Count the required buffer size and the number of jobs.
    i = 0;
    pNode = pFirstJobNode;
 
    while (i < NoJobs && pNode)
    {
        pJob = (PLOCAL_JOB)pNode->Element;
 
        if (Level == 1)
            _LocalGetJobLevel1(pJob, NULL, NULL, pcbNeeded);
        else if (Level == 2)
            _LocalGetJobLevel2(pJob, NULL, NULL, pcbNeeded);
 
        // We stop either when there are no more jobs in the list or when the caller didn't request more, whatever comes first.
        i++;
        pNode = pNode->Next[0];
    }
 
    // Check if the supplied buffer is large enough.
    if (cbBuf < *pcbNeeded)
    {
        dwErrorCode = ERROR_INSUFFICIENT_BUFFER;
        goto Cleanup;
    }
 
    // Copy over the Job information.
    i = 0;
    pNode = pFirstJobNode;
    pEnd = &pStart[*pcbNeeded];
 
    while (i < NoJobs && pNode)
    {
        pJob = (PLOCAL_JOB)pNode->Element;
 
        if (Level == 1)
            _LocalGetJobLevel1(pJob, (PJOB_INFO_1W*)&pStart, &pEnd, NULL);
        else if (Level == 2)
            _LocalGetJobLevel2(pJob, (PJOB_INFO_2W*)&pStart, &pEnd, NULL);
 
        // We stop either when there are no more jobs in the list or when the caller didn't request more, whatever comes first.
        i++;
        pNode = pNode->Next[0];
    }
 
    *pcReturned = i;
    dwErrorCode = ERROR_SUCCESS;
 
Cleanup:
    SetLastError(dwErrorCode);
    return (dwErrorCode == ERROR_SUCCESS);
}

◆ LocalEnumMonitors()

BOOL WINAPI LocalEnumMonitors	(	PWSTR	pName,
		DWORD	Level,
		PBYTE	pMonitors,
		DWORD	cbBuf,
		PDWORD	pcbNeeded,
		PDWORD	pcReturned
	)

Definition at line 396 of file monitors.c.

{
    DWORD dwErrorCode;
    PBYTE pMonitorInfoEnd;
    PLIST_ENTRY pEntry;
    PLOCAL_PRINT_MONITOR pPrintMonitor;
 
    TRACE("LocalEnumMonitors(%S, %lu, %p, %lu, %p, %p)\n", pName, Level, pMonitors, cbBuf, pcbNeeded, pcReturned);
 
    // Sanity checks.
    if (Level > 2)
    {
        dwErrorCode = ERROR_INVALID_LEVEL;
        goto Cleanup;
    }
 
    // Begin counting.
    *pcbNeeded = 0;
    *pcReturned = 0;
 
    // Count the required buffer size and the number of monitors.
    for (pEntry = PrintMonitorList.Flink; pEntry != &PrintMonitorList; pEntry = pEntry->Flink)
    {
        pPrintMonitor = CONTAINING_RECORD(pEntry, LOCAL_PRINT_MONITOR, Entry);
 
        if (Level == 1)
            _LocalGetMonitorLevel1(pPrintMonitor, NULL, NULL, pcbNeeded);
        else if (Level == 2)
            _LocalGetMonitorLevel2(pPrintMonitor, NULL, NULL, pcbNeeded);
    }
 
    // Check if the supplied buffer is large enough.
    if (cbBuf < *pcbNeeded)
    {
        dwErrorCode = ERROR_INSUFFICIENT_BUFFER;
        goto Cleanup;
    }
 
    // Copy over the Monitor information.
    pMonitorInfoEnd = &pMonitors[*pcbNeeded];
 
    for (pEntry = PrintMonitorList.Flink; pEntry != &PrintMonitorList; pEntry = pEntry->Flink)
    {
        pPrintMonitor = CONTAINING_RECORD(pEntry, LOCAL_PRINT_MONITOR, Entry);
 
        if (Level == 1)
            _LocalGetMonitorLevel1(pPrintMonitor, (PMONITOR_INFO_1W*)&pMonitors, &pMonitorInfoEnd, NULL);
        else if (Level == 2)
            _LocalGetMonitorLevel2(pPrintMonitor, (PMONITOR_INFO_2W*)&pMonitors, &pMonitorInfoEnd, NULL);
 
        (*pcReturned)++;
    }
 
    dwErrorCode = ERROR_SUCCESS;
 
Cleanup:
    SetLastError(dwErrorCode);
    return (dwErrorCode == ERROR_SUCCESS);
}

◆ LocalEnumPorts()

BOOL WINAPI LocalEnumPorts	(	PWSTR	pName,
		DWORD	Level,
		PBYTE	pPorts,
		DWORD	cbBuf,
		PDWORD	pcbNeeded,
		PDWORD	pcReturned
	)

Definition at line 164 of file ports.c.

{
    BOOL bReturnValue = TRUE;
    DWORD cbCallBuffer;
    DWORD cbNeeded;
    DWORD dwReturned;
    PBYTE pCallBuffer;
    PLOCAL_PRINT_MONITOR pPrintMonitor;
    PLIST_ENTRY pEntry;
 
    TRACE("LocalEnumPorts(%S, %lu, %p, %lu, %p, %p)\n", pName, Level, pPorts, cbBuf, pcbNeeded, pcReturned);
 
    // Begin counting.
    *pcbNeeded = 0;
    *pcReturned = 0;
 
    // At the beginning, we have the full buffer available.
    cbCallBuffer = cbBuf;
    pCallBuffer = pPorts;
 
    // Loop through all Print Monitors.
    for (pEntry = PrintMonitorList.Flink; pEntry != &PrintMonitorList; pEntry = pEntry->Flink)
    {
        pPrintMonitor = CONTAINING_RECORD(pEntry, LOCAL_PRINT_MONITOR, Entry);
 
        // Call the EnumPorts function of this Print Monitor.
        cbNeeded = 0;
        dwReturned = 0;
 
        if (pPrintMonitor->bIsLevel2)
            bReturnValue = ((PMONITOR2)pPrintMonitor->pMonitor)->pfnEnumPorts(pPrintMonitor->hMonitor, pName, Level, pCallBuffer, cbCallBuffer, &cbNeeded, &dwReturned);
        else
            bReturnValue = ((LPMONITOREX)pPrintMonitor->pMonitor)->Monitor.pfnEnumPorts(pName, Level, pCallBuffer, cbCallBuffer, &cbNeeded, &dwReturned);
 
        // Add the returned counts to the total values.
        *pcbNeeded += cbNeeded;
        *pcReturned += dwReturned;
 
        // Reduce the available buffer size for the next call without risking an underflow.
        if (cbNeeded < cbCallBuffer)
            cbCallBuffer -= cbNeeded;
        else
            cbCallBuffer = 0;
 
        // Advance the buffer if the caller provided it.
        if (pCallBuffer)
            pCallBuffer += cbNeeded;
    }
 
    return bReturnValue;
}

Referenced by LocalAddPort().

◆ LocalEnumPrinterDrivers()

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

Definition at line 600 of file printerdrivers.c.

{
    DWORD dwErrorCode;
    PSKIPLIST_NODE pNode;
    PBYTE pEnd;
    PLOCAL_PRINTER pPrinter;
 
    FIXME("LocalEnumPrinterDrivers(%S, %S, %lu, %p, %lu, %p, %p)\n", pName, pEnvironment, Level, pDriverInfo, cbBuf, pcbNeeded, pcReturned);
 
    // Only support 8 levels and not 7
    if (Level < 1 || Level == 7 || Level > 8)
    {
        // The caller supplied an invalid level.
        dwErrorCode = ERROR_INVALID_LEVEL;
        goto Cleanup;
    }
 
    // Count the required buffer size.
    *pcbNeeded = 0;
 
    // Count the required buffer size and the number of printers.
    for (pNode = PrinterList.Head.Next[0]; pNode; pNode = pNode->Next[0])
    {
        pPrinter = (PLOCAL_PRINTER)pNode->Element;
 
        pfnPrinterDriverLevels[Level](pPrinter, NULL, NULL, pcbNeeded);
    }
 
    // Check if the supplied buffer is large enough.
    if (cbBuf < *pcbNeeded)
    {
        dwErrorCode = ERROR_INSUFFICIENT_BUFFER;
        goto Cleanup;
    }
 
    // Copy over the Printer information.
    pEnd = &pDriverInfo[*pcbNeeded];
 
    for (pNode = PrinterList.Head.Next[0]; pNode; pNode = pNode->Next[0])
    {
        pPrinter = (PLOCAL_PRINTER)pNode->Element;
 
        pfnPrinterDriverLevels[Level](pPrinter, &pDriverInfo, &pEnd, NULL);
        (*pcReturned)++;
    }
 
    dwErrorCode = ERROR_SUCCESS;
 
Cleanup:
    SetLastError(dwErrorCode);
    return (dwErrorCode == ERROR_SUCCESS);
}

◆ LocalEnumPrinters()

BOOL WINAPI LocalEnumPrinters	(	DWORD	Flags,
		LPWSTR	Name,
		DWORD	Level,
		LPBYTE	pPrinterEnum,
		DWORD	cbBuf,
		LPDWORD	pcbNeeded,
		LPDWORD	pcReturned
	)

Definition at line 884 of file printers.c.

{
    DWORD cchComputerName = 0;
    DWORD dwErrorCode;
    PBYTE pPrinterInfoEnd;
    PSKIPLIST_NODE pNode;
    WCHAR wszComputerName[2 + MAX_COMPUTERNAME_LENGTH + 1 + 1] = { 0 };
    PLOCAL_PRINTER pPrinter;
 
    FIXME("LocalEnumPrinters(%lu, %S, %lu, %p, %lu, %p, %p)\n", Flags, Name, Level, pPrinterEnum, cbBuf, pcbNeeded, pcReturned);
 
    // Do no sanity checks or assertions for pcbNeeded and pcReturned here.
    // This is verified and required by localspl_apitest!
 
    // Begin counting.
    *pcbNeeded = 0;
    *pcReturned = 0;
 
    if (Flags & PRINTER_ENUM_CONNECTIONS || Flags & PRINTER_ENUM_REMOTE || Flags & PRINTER_ENUM_NETWORK)
    {
        // If the flags for the Network Print Provider are given, bail out with ERROR_INVALID_NAME.
        // This is the internal way for a Print Provider to signal that it doesn't handle this request.
        dwErrorCode = ERROR_INVALID_NAME;
        goto Cleanup;
    }
 
    if (!(Flags & PRINTER_ENUM_LOCAL || Flags & PRINTER_ENUM_NAME))
    {
        // The Local Print Provider is the right destination for the request, but without any of these flags,
        // there is no information that can be returned.
        // So just signal a successful request.
        dwErrorCode = ERROR_SUCCESS;
        goto Cleanup;
    }
 
    if (Level == 3 || Level > 5)
    {
        // The caller supplied an invalid level for EnumPrinters.
        dwErrorCode = ERROR_INVALID_LEVEL;
        goto Cleanup;
    }
 
    if (Level == 1 && Flags & PRINTER_ENUM_NAME && !Name)
    {
        // The caller wants information about this Print Provider.
        // spoolss packs this into an array of information about all Print Providers.
        dwErrorCode = _DumpLevel1PrintProviderInformation(pPrinterEnum, cbBuf, pcbNeeded, pcReturned);
        goto Cleanup;
    }
 
    // Check the supplied Name parameter (if any).
    // This may return a Computer Name string we later prepend to the output.
    dwErrorCode = _LocalEnumPrintersCheckName(Flags, Name, wszComputerName, &cchComputerName);
    if (dwErrorCode != ERROR_SUCCESS)
        goto Cleanup;
 
    // Count the required buffer size and the number of printers.
    for (pNode = PrinterList.Head.Next[0]; pNode; pNode = pNode->Next[0])
    {
        pPrinter = (PLOCAL_PRINTER)pNode->Element;
 
        // TODO: If PRINTER_ENUM_SHARED is given, add this Printer if it's shared instead of just ignoring it.
        if (Flags & PRINTER_ENUM_SHARED)
        {
            FIXME("Printer Sharing is not supported yet, returning no printers!\n");
            continue;
        }
 
        pfnGetPrinterLevels[Level](pPrinter, NULL, NULL, pcbNeeded, cchComputerName, wszComputerName);
    }
 
    // Check if the supplied buffer is large enough.
    if (cbBuf < *pcbNeeded)
    {
        dwErrorCode = ERROR_INSUFFICIENT_BUFFER;
        goto Cleanup;
    }
 
    // Copy over the Printer information.
    pPrinterInfoEnd = &pPrinterEnum[*pcbNeeded];
 
    for (pNode = PrinterList.Head.Next[0]; pNode; pNode = pNode->Next[0])
    {
        pPrinter = (PLOCAL_PRINTER)pNode->Element;
 
        // TODO: If PRINTER_ENUM_SHARED is given, add this Printer if it's shared instead of just ignoring it.
        if (Flags & PRINTER_ENUM_SHARED)
            continue;
 
        pfnGetPrinterLevels[Level](pPrinter, &pPrinterEnum, &pPrinterInfoEnd, NULL, cchComputerName, wszComputerName);
        (*pcReturned)++;
    }
 
    dwErrorCode = ERROR_SUCCESS;
 
Cleanup:
    SetLastError(dwErrorCode);
    return (dwErrorCode == ERROR_SUCCESS);
}

◆ LocalEnumPrintProcessorDatatypes()

BOOL WINAPI LocalEnumPrintProcessorDatatypes	(	LPWSTR	pName,
		LPWSTR	pPrintProcessorName,
		DWORD	Level,
		LPBYTE	pDatatypes,
		DWORD	cbBuf,
		LPDWORD	pcbNeeded,
		LPDWORD	pcReturned
	)

Definition at line 402 of file printprocessors.c.

{
    DWORD dwErrorCode;
    PLOCAL_PRINT_PROCESSOR pPrintProcessor;
 
    TRACE("LocalEnumPrintProcessorDatatypes(%S, %S, %lu, %p, %lu, %p, %p)\n", pName, pPrintProcessorName, Level, pDatatypes, cbBuf, pcbNeeded, pcReturned);
 
    // Sanity checks
    if (Level != 1)
    {
        dwErrorCode = ERROR_INVALID_LEVEL;
        goto Cleanup;
    }
 
    // Try to find the Print Processor.
    pPrintProcessor = FindPrintProcessor(pPrintProcessorName);
    if (!pPrintProcessor)
    {
        dwErrorCode = ERROR_UNKNOWN_PRINTPROCESSOR;
        goto Cleanup;
    }
 
    // Call its EnumPrintProcessorDatatypesW function.
    if (pPrintProcessor->pfnEnumPrintProcessorDatatypesW(pName, pPrintProcessorName, Level, pDatatypes, cbBuf, pcbNeeded, pcReturned))
        dwErrorCode = ERROR_SUCCESS;
    else
        dwErrorCode = GetLastError();
 
Cleanup:
    SetLastError(dwErrorCode);
    return (dwErrorCode == ERROR_SUCCESS);
}

◆ LocalEnumPrintProcessors()

BOOL WINAPI LocalEnumPrintProcessors	(	LPWSTR	pName,
		LPWSTR	pEnvironment,
		DWORD	Level,
		LPBYTE	pPrintProcessorInfo,
		DWORD	cbBuf,
		LPDWORD	pcbNeeded,
		LPDWORD	pcReturned
	)

Definition at line 471 of file printprocessors.c.

{
    DWORD cchMaxSubKey;
    DWORD cchPrintProcessor;
    DWORD dwErrorCode;
    DWORD dwPrintProcessorCount;
    DWORD i;
    HKEY hKey = NULL;
    HKEY hSubKey = NULL;
    PBYTE pCurrentOutputPrintProcessor;
    PBYTE pCurrentOutputPrintProcessorInfo;
    PRINTPROCESSOR_INFO_1W PrintProcessorInfo1;
    PWSTR pwszTemp = NULL;
 
    TRACE("LocalEnumPrintProcessors(%S, %S, %lu, %p, %lu, %p, %p)\n", pName, pEnvironment, Level, pPrintProcessorInfo, cbBuf, pcbNeeded, pcReturned);
 
    // Sanity checks
    if (Level != 1)
    {
        dwErrorCode = ERROR_INVALID_LEVEL;
        goto Cleanup;
    }
 
    if (!pcbNeeded || !pcReturned)
    {
        // This error is also caught by RPC and returned as RPC_X_NULL_REF_POINTER.
        dwErrorCode = ERROR_INVALID_PARAMETER;
        goto Cleanup;
    }
 
    // Verify pEnvironment and open its registry key.
    // We use the registry and not the PrintProcessorList here, because the caller may request information about a different environment.
    dwErrorCode = _OpenEnvironment(pEnvironment, &hKey);
    if (dwErrorCode != ERROR_SUCCESS)
        goto Cleanup;
 
    // Open the "Print Processors" subkey.
    dwErrorCode = (DWORD)RegOpenKeyExW(hKey, L"Print Processors", 0, KEY_READ, &hSubKey);
    if (dwErrorCode != ERROR_SUCCESS)
    {
        ERR("RegOpenKeyExW failed with status %lu!\n", dwErrorCode);
        goto Cleanup;
    }
 
    // Get the number of Print Processors and maximum sub key length.
    dwErrorCode = (DWORD)RegQueryInfoKeyW(hSubKey, NULL, NULL, NULL, &dwPrintProcessorCount, &cchMaxSubKey, NULL, NULL, NULL, NULL, NULL, NULL);
    if (dwErrorCode != ERROR_SUCCESS)
    {
        ERR("RegQueryInfoKeyW failed with status %lu!\n", dwErrorCode);
        goto Cleanup;
    }
 
    // Allocate a temporary buffer to let RegEnumKeyExW succeed.
    pwszTemp = DllAllocSplMem((cchMaxSubKey + 1) * sizeof(WCHAR));
    if (!pwszTemp)
    {
        dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
        ERR("DllAllocSplMem failed!\n");
        goto Cleanup;
    }
 
    // Determine the required size of the output buffer.
    *pcbNeeded = 0;
 
    for (i = 0; i < dwPrintProcessorCount; i++)
    {
        // RegEnumKeyExW sucks! Unlike similar API functions, it only returns the actual numbers of characters copied when you supply a buffer large enough.
        // So use pwszTemp with its size cchMaxSubKey for this.
        cchPrintProcessor = cchMaxSubKey + 1;
        dwErrorCode = (DWORD)RegEnumKeyExW(hSubKey, i, pwszTemp, &cchPrintProcessor, NULL, NULL, NULL, NULL);
        if (dwErrorCode != ERROR_SUCCESS)
        {
            ERR("RegEnumKeyExW failed with status %lu!\n", dwErrorCode);
            goto Cleanup;
        }
 
        *pcbNeeded += sizeof(PRINTPROCESSOR_INFO_1W) + (cchPrintProcessor + 1) * sizeof(WCHAR);
    }
 
    // Check if the supplied buffer is large enough.
    if (cbBuf < *pcbNeeded)
    {
        dwErrorCode = ERROR_INSUFFICIENT_BUFFER;
        goto Cleanup;
    }
 
    // Put the Print Processor strings right after the last PRINTPROCESSOR_INFO_1W structure.
    pCurrentOutputPrintProcessorInfo = pPrintProcessorInfo;
    pCurrentOutputPrintProcessor = pPrintProcessorInfo + dwPrintProcessorCount * sizeof(PRINTPROCESSOR_INFO_1W);
 
    // Copy over all Print Processors.
    for (i = 0; i < dwPrintProcessorCount; i++)
    {
        // This isn't really correct, but doesn't cause any harm, because we've extensively checked the size of the supplied buffer above.
        cchPrintProcessor = cchMaxSubKey + 1;
 
        // Copy the Print Processor name.
        dwErrorCode = (DWORD)RegEnumKeyExW(hSubKey, i, (PWSTR)pCurrentOutputPrintProcessor, &cchPrintProcessor, NULL, NULL, NULL, NULL);
        if (dwErrorCode != ERROR_SUCCESS)
        {
            ERR("RegEnumKeyExW failed with status %lu!\n", dwErrorCode);
            goto Cleanup;
        }
 
        // Fill and copy the PRINTPROCESSOR_INFO_1W structure belonging to this Print Processor.
        PrintProcessorInfo1.pName = (PWSTR)pCurrentOutputPrintProcessor;
        CopyMemory(pCurrentOutputPrintProcessorInfo, &PrintProcessorInfo1, sizeof(PRINTPROCESSOR_INFO_1W));
 
        // Advance to the next PRINTPROCESSOR_INFO_1W location and string location in the output buffer.
        pCurrentOutputPrintProcessor += (cchPrintProcessor + 1) * sizeof(WCHAR);
        pCurrentOutputPrintProcessorInfo += sizeof(PRINTPROCESSOR_INFO_1W);
    }
 
    // We've finished successfully!
    *pcReturned = dwPrintProcessorCount;
    dwErrorCode = ERROR_SUCCESS;
 
Cleanup:
    if (pwszTemp)
        DllFreeSplMem(pwszTemp);
 
    if (hSubKey)
        RegCloseKey(hSubKey);
 
    if (hKey)
        RegCloseKey(hKey);
 
    SetLastError(dwErrorCode);
    return (dwErrorCode == ERROR_SUCCESS);
}

◆ LocalGetForm()

BOOL WINAPI LocalGetForm	(	HANDLE	hPrinter,
		PWSTR	pFormName,
		DWORD	Level,
		PBYTE	pForm,
		DWORD	cbBuf,
		PDWORD	pcbNeeded
	)

Definition at line 624 of file forms.c.

{
    DWORD dwErrorCode;
    PFORM_INFO_LIST pfil;
    PBYTE pEnd = &pForm[cbBuf];
    PLOCAL_HANDLE pHandle;
 
    FIXME("GetForm(%p, %S, %lu, %p, %lu, %p)\n", hPrinter, pFormName, Level, pForm, cbBuf, pcbNeeded);
 
    // Check if this is a printer handle.
    pHandle = (PLOCAL_HANDLE)hPrinter;
    if (pHandle->HandleType != HandleType_Printer)
    {
        dwErrorCode = ERROR_INVALID_HANDLE;
        goto Cleanup;
    }
 
    // Only support 1 & 2
    if (Level < 1 || Level > 2)
    {
        // The caller supplied an invalid level.
        dwErrorCode = ERROR_INVALID_LEVEL;
        goto Cleanup;
    }
 
    pfil = FindForm( pFormName, NULL );
    if ( !pfil )
    {
        dwErrorCode = ERROR_INVALID_PARAMETER;
        goto Cleanup;
    }
 
    // Count the required buffer size.
    *pcbNeeded = 0;
 
    pfnGetFormLevels[Level](pfil, NULL, NULL, pcbNeeded);
 
    // Check if the supplied buffer is large enough.
    if (cbBuf < *pcbNeeded)
    {
        ERR("Insuffisient Buffer size\n");
        dwErrorCode = ERROR_INSUFFICIENT_BUFFER;
        goto Cleanup;
    }
 
    // Copy over the information.
    pEnd = &pForm[*pcbNeeded];
 
    pfnGetFormLevels[Level](pfil, &pForm, &pEnd, NULL);
 
    dwErrorCode = ERROR_SUCCESS;
 
Cleanup:
    SetLastError(dwErrorCode);
    return (dwErrorCode == ERROR_SUCCESS);
}

◆ LocalGetJob()

BOOL WINAPI LocalGetJob	(	HANDLE	hPrinter,
		DWORD	JobId,
		DWORD	Level,
		PBYTE	pStart,
		DWORD	cbBuf,
		LPDWORD	pcbNeeded
	)

Definition at line 655 of file jobs.c.

{
    DWORD dwErrorCode;
    PBYTE pEnd = &pStart[cbBuf];
    PLOCAL_HANDLE pHandle;
    PLOCAL_JOB pJob;
    PLOCAL_PRINTER_HANDLE pPrinterHandle;
 
    TRACE("LocalGetJob(%p, %lu, %lu, %p, %lu, %p)\n", hPrinter, JobId, Level, pStart, cbBuf, pcbNeeded);
 
    // Check if this is a printer handle.
    pHandle = (PLOCAL_HANDLE)hPrinter;
    if (pHandle->HandleType != HandleType_Printer)
    {
        dwErrorCode = ERROR_INVALID_HANDLE;
        goto Cleanup;
    }
 
    pPrinterHandle = (PLOCAL_PRINTER_HANDLE)pHandle->pSpecificHandle;
 
    // Get the desired job.
    pJob = LookupElementSkiplist(&GlobalJobList, &JobId, NULL);
    if (!pJob || pJob->pPrinter != pPrinterHandle->pPrinter)
    {
        dwErrorCode = ERROR_INVALID_PARAMETER;
        goto Cleanup;
    }
 
    if (Level > 2)
    {
        // The caller supplied an invalid level for GetJob.
        dwErrorCode = ERROR_INVALID_LEVEL;
        goto Cleanup;
    }
 
    // Count the required buffer size.
    *pcbNeeded = 0;
 
    if (Level == 1)
        _LocalGetJobLevel1(pJob, NULL, NULL, pcbNeeded);
    else if (Level == 2)
        _LocalGetJobLevel2(pJob, NULL, NULL, pcbNeeded);
 
    // Check if the supplied buffer is large enough.
    if (cbBuf < *pcbNeeded)
    {
        dwErrorCode = ERROR_INSUFFICIENT_BUFFER;
        goto Cleanup;
    }
 
    // Copy over the Job information.
    pEnd = &pStart[*pcbNeeded];
 
    if (Level == 1)
        _LocalGetJobLevel1(pJob, (PJOB_INFO_1W*)&pStart, &pEnd, NULL);
    else if (Level == 2)
        _LocalGetJobLevel2(pJob, (PJOB_INFO_2W*)&pStart, &pEnd, NULL);
 
    dwErrorCode = ERROR_SUCCESS;
 
Cleanup:
    SetLastError(dwErrorCode);
    return (dwErrorCode == ERROR_SUCCESS);
}

◆ LocalGetPrinter()

BOOL WINAPI LocalGetPrinter	(	HANDLE	hPrinter,
		DWORD	Level,
		LPBYTE	pPrinter,
		DWORD	cbBuf,
		LPDWORD	pcbNeeded
	)

Definition at line 985 of file printers.c.

{
    // We never prepend a Computer Name to the output, but need to provide an empty string,
    // because this variable is passed to StringCbCopyExW.
    const WCHAR wszDummyComputerName[] = L"";
 
    DWORD dwErrorCode;
    PBYTE pPrinterEnd;
    PLOCAL_HANDLE pHandle = (PLOCAL_HANDLE)hPrinter;
    PLOCAL_PRINTER_HANDLE pPrinterHandle;
 
    TRACE("LocalGetPrinter(%p, %lu, %p, %lu, %p)\n", hPrinter, Level, pPrinter, cbBuf, pcbNeeded);
 
    // Sanity checks.
    if (!pHandle)
    {
        dwErrorCode = ERROR_INVALID_HANDLE;
        goto Cleanup;
    }
 
    // Check if this is a printer handle.
    if (pHandle->HandleType != HandleType_Printer)
    {
        dwErrorCode = ERROR_INVALID_HANDLE;
        goto Cleanup;
    }
 
    pPrinterHandle = (PLOCAL_PRINTER_HANDLE)pHandle->pSpecificHandle;
 
    if (Level > 9)
    {
        // The caller supplied an invalid level for GetPrinter.
        dwErrorCode = ERROR_INVALID_LEVEL;
        goto Cleanup;
    }
 
    // Count the required buffer size.
    *pcbNeeded = 0;
    pfnGetPrinterLevels[Level](pPrinterHandle->pPrinter, NULL, NULL, pcbNeeded, 0, wszDummyComputerName);
 
    // Check if the supplied buffer is large enough.
    if (cbBuf < *pcbNeeded)
    {
        dwErrorCode = ERROR_INSUFFICIENT_BUFFER;
        goto Cleanup;
    }
 
    // Copy over the Printer information.
    pPrinterEnd = &pPrinter[*pcbNeeded];
    pfnGetPrinterLevels[Level](pPrinterHandle->pPrinter, &pPrinter, &pPrinterEnd, NULL, 0, wszDummyComputerName);
    dwErrorCode = ERROR_SUCCESS;
 
Cleanup:
    SetLastError(dwErrorCode);
    return (dwErrorCode == ERROR_SUCCESS);
}

◆ LocalGetPrinterData()

DWORD WINAPI LocalGetPrinterData	(	HANDLE	hPrinter,
		PWSTR	pValueName,
		PDWORD	pType,
		PBYTE	pData,
		DWORD	nSize,
		PDWORD	pcbNeeded
	)

Definition at line 11 of file printerdata.c.

{
    TRACE("LocalGetPrinterData(%p, %S, %p, %p, %lu, %p)\n", hPrinter, pValueName, pType, pData, nSize, pcbNeeded);
 
    // The ReactOS Printing Stack forwards all GetPrinterData calls to GetPrinterDataEx as soon as possible.
    // This function may only be called if localspl.dll is used together with Windows Printing Stack components.
    WARN("This function should never be called!\n");
    return LocalGetPrinterDataEx(hPrinter, L"PrinterDriverData", pValueName, pType, pData, nSize, pcbNeeded);
}

◆ LocalGetPrinterDataEx()

DWORD WINAPI LocalGetPrinterDataEx	(	HANDLE	hPrinter,
		PCWSTR	pKeyName,
		PCWSTR	pValueName,
		PDWORD	pType,
		PBYTE	pData,
		DWORD	nSize,
		PDWORD	pcbNeeded
	)

Definition at line 314 of file printerdata.c.

{
    BYTE Temp;
    DWORD dwErrorCode;
    DWORD dwTemp;
    PLOCAL_HANDLE pHandle = (PLOCAL_HANDLE)hPrinter;
 
    TRACE("LocalGetPrinterDataEx(%p, %S, %S, %p, %p, %lu, %p)\n", hPrinter, pKeyName, pValueName, pType, pData, nSize, pcbNeeded);
 
    // Even if GetPrinterDataExW in winspool ensures that the RPC function is never called without a valid pointer for pType,
    // it's officially optional. Windows' fpGetPrinterDataEx also works with NULL for pType!
    // Ensure here that it is always set to simplify the code later.
    if (!pType)
        pType = &dwTemp;
 
    // pData is later fed to RegQueryValueExW in many cases. When calling it with zero buffer size, RegQueryValueExW returns a
    // different error code based on whether pData is NULL or something else.
    // Ensure here that ERROR_MORE_DATA is always returned.
    if (!pData)
        pData = &Temp;
 
    if (!pHandle)
    {
        dwErrorCode = ERROR_INVALID_HANDLE;
    }
    else if (!pcbNeeded)
    {
        dwErrorCode = ERROR_INVALID_PARAMETER;
    }
    else if (pHandle->HandleType == HandleType_Printer)
    {
        dwErrorCode = _LocalGetPrinterHandleData(pHandle->pSpecificHandle, pKeyName, pValueName, pType, pData, nSize, pcbNeeded);
    }
    else if (pHandle->HandleType == HandleType_PrintServer)
    {
        dwErrorCode = _LocalGetPrintServerHandleData(pValueName, pType, pData, nSize, pcbNeeded);
    }
    else
    {
        dwErrorCode = ERROR_INVALID_HANDLE;
    }
 
    SetLastError(dwErrorCode);
    return dwErrorCode;
}

Referenced by LocalGetPrinterData().

◆ LocalGetPrinterDriver()

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

Definition at line 530 of file printerdrivers.c.

{
    DWORD dwErrorCode;
    PBYTE pEnd = &pDriverInfo[cbBuf];
    PLOCAL_HANDLE pHandle;
    PLOCAL_PRINTER_HANDLE pPrinterHandle;
 
    TRACE("LocalGetPrinterDriver(%p, %lu, %lu, %p, %lu, %p)\n", hPrinter, pEnvironment, Level, pDriverInfo, cbBuf, pcbNeeded);
 
    // Check if this is a printer handle.
    pHandle = (PLOCAL_HANDLE)hPrinter;
    if (pHandle->HandleType != HandleType_Printer)
    {
        dwErrorCode = ERROR_INVALID_HANDLE;
        goto Cleanup;
    }
 
    pPrinterHandle = (PLOCAL_PRINTER_HANDLE)pHandle->pSpecificHandle;
 
    // Only support 8 levels and not 7
    if (Level < 1 || Level == 7 || Level > 8)
    {
        // The caller supplied an invalid level.
        dwErrorCode = ERROR_INVALID_LEVEL;
        goto Cleanup;
    }
 
    // Count the required buffer size.
    *pcbNeeded = 0;
 
    pfnPrinterDriverLevels[Level](pPrinterHandle->pPrinter, NULL, NULL, pcbNeeded);
 
    // Check if the supplied buffer is large enough.
    if (cbBuf < *pcbNeeded)
    {
        ERR("Insuffisient Buffer size\n");
        dwErrorCode = ERROR_INSUFFICIENT_BUFFER;
        goto Cleanup;
    }
 
    // Copy over the information.
    pEnd = &pDriverInfo[*pcbNeeded];
 
    pfnPrinterDriverLevels[Level](pPrinterHandle->pPrinter, &pDriverInfo, &pEnd, NULL);
 
    dwErrorCode = ERROR_SUCCESS;
 
Cleanup:
    SetLastError(dwErrorCode);
    return (dwErrorCode == ERROR_SUCCESS);
}

Referenced by LocalGetPrinterDriverEx().

◆ LocalGetPrinterDriverDirectory()

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

Definition at line 778 of file printerdrivers.c.

{
    DWORD needed;
    const PRINTENV_T * env = NULL;
    WCHAR * const dir = (WCHAR *)pDriverDirectory;
 
    FIXME("LocalGetPrinterDriverDirectory(%S, %S, %lu, %p, %lu, %p)\n", pName, pEnvironment, Level, pDriverDirectory, cbBuf, pcbNeeded);
 
    if (pName != NULL && pName[0])
    {
        FIXME("server %s not supported\n", debugstr_w(pName));
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    env = validate_envW(pEnvironment);
    if (!env) return FALSE;  /* pEnvironment invalid or unsupported */
 
    /* GetSystemDirectoryW returns number of WCHAR including the '\0' */
    needed = GetSystemDirectoryW(NULL, 0);
    /* add the Size for the Subdirectories */
    needed += lstrlenW(spoolW);
    needed += lstrlenW(driversW);
    needed += lstrlenW(env->subdir);
    needed *= sizeof(WCHAR);  /* return-value is size in Bytes */
 
    *pcbNeeded = needed;
 
    if (needed > cbBuf)
    {
        SetLastError(ERROR_INSUFFICIENT_BUFFER);
        return FALSE;
    }
 
    if (dir == NULL)
    {
        /* ERROR_INVALID_USER_BUFFER is NT, ERROR_INVALID_PARAMETER is win9x */
        SetLastError(ERROR_INVALID_USER_BUFFER);
        return FALSE;
    }
 
    GetSystemDirectoryW( dir, cbBuf / sizeof(WCHAR) );
    /* add the Subdirectories */
    lstrcatW( dir, spoolW );
    CreateDirectoryW( dir, NULL );
    lstrcatW( dir, driversW );
    CreateDirectoryW( dir, NULL );
    lstrcatW( dir, env->subdir );
    CreateDirectoryW( dir, NULL );
 
    FIXME( "=> %s\n", debugstr_w( dir ) );
    return TRUE;
}

Referenced by driver_load(), InitializePrinterDrivers(), and myAddPrinterDriverEx().

◆ LocalGetPrinterDriverEx()

BOOL WINAPI LocalGetPrinterDriverEx	(	HANDLE	hPrinter,
		LPWSTR	pEnvironment,
		DWORD	Level,
		LPBYTE	pDriverInfo,
		DWORD	cbBuf,
		LPDWORD	pcbNeeded,
		DWORD	dwClientMajorVersion,
		DWORD	dwClientMinorVersion,
		PDWORD	pdwServerMajorVersion,
		PDWORD	pdwServerMinorVersion
	)

Definition at line 582 of file printerdrivers.c.

{
    FIXME("LocalGetPrinterDriverEx(%p, %lu, %lu, %p, %lu, %p, %lu, %lu, %p, %p)\n", hPrinter, pEnvironment, Level, pDriverInfo, cbBuf, pcbNeeded, dwClientMajorVersion, dwClientMinorVersion, pdwServerMajorVersion, pdwServerMinorVersion);
    return LocalGetPrinterDriver( hPrinter, pEnvironment, Level, pDriverInfo, cbBuf, pcbNeeded );
}

◆ LocalGetPrintProcessorDirectory()

BOOL WINAPI LocalGetPrintProcessorDirectory	(	LPWSTR	pName,
		LPWSTR	pEnvironment,
		DWORD	Level,
		LPBYTE	pPrintProcessorInfo,
		DWORD	cbBuf,
		LPDWORD	pcbNeeded
	)

◆ LocalGetSpoolFileInfo()

BOOL WINAPI LocalGetSpoolFileInfo	(	HANDLE	hPrinter,
		LPWSTR *	pSpoolDir,
		LPHANDLE	phFile,
		HANDLE	hSpoolerProcess,
		HANDLE	hAppProcess
	)

Definition at line 11 of file spoolfile.c.

{
    FIXME("LocalGetSpoolFileInfo(%p, %S, %p, %p, %p)\n", hPrinter, pSpoolDir, phFile, hSpoolerProcess, hAppProcess);
    return FALSE;
}

◆ LocalOpenPrinter()

BOOL WINAPI LocalOpenPrinter	(	PWSTR	lpPrinterName,
		HANDLE *	phPrinter,
		PPRINTER_DEFAULTSW	pDefault
	)

Definition at line 1398 of file printers.c.

{
    DWORD cchComputerName;
    DWORD cchFirstParameter;
    DWORD dwErrorCode;
    PWSTR p = lpPrinterName;
    PWSTR pwszFirstParameter = NULL;
    PWSTR pwszSecondParameter;
    WCHAR wszComputerName[MAX_COMPUTERNAME_LENGTH + 1];
 
    TRACE("LocalOpenPrinter(%S, %p, %p)\n", lpPrinterName, phPrinter, pDefault);
 
    ASSERT(phPrinter);
    *phPrinter = NULL;
 
    if (!lpPrinterName)
    {
        // The caller wants a Print Server handle and provided a NULL string.
        dwErrorCode = _LocalOpenPrintServerHandle(phPrinter);
        goto Cleanup;
    }
 
    // Skip any server name in the first parameter.
    // Does lpPrinterName begin with two backslashes to indicate a server name?
    if (lpPrinterName[0] == L'\\' && lpPrinterName[1] == L'\\')
    {
        // Skip these two backslashes.
        lpPrinterName += 2;
 
        // Look for the terminating null character or closing backslash.
        p = lpPrinterName;
        while (*p != L'\0' && *p != L'\\')
            p++;
 
        // Get the local computer name for comparison.
        cchComputerName = _countof(wszComputerName);
        if (!GetComputerNameW(wszComputerName, &cchComputerName))
        {
            dwErrorCode = GetLastError();
            ERR("GetComputerNameW failed with error %lu!\n", dwErrorCode);
            goto Cleanup;
        }
 
        // Now compare this string excerpt with the local computer name.
        // The input parameter may not be writable, so we can't null-terminate the input string at this point.
        

Variables
SKIPLIST	GlobalJobList

const WCHAR	wszCurrentEnvironment []

const DWORD	cbCurrentEnvironment

const DWORD	dwSpoolerMajorVersion

const DWORD	dwSpoolerMinorVersion

const WCHAR	wszDefaultDocumentName []

HKEY	hPrintKey

HKEY	hPrintersKey

PCWSTR	wszPrintProviderInfo [3]

WCHAR	wszJobDirectory [MAX_PATH]

DWORD	cchJobDirectory

WCHAR	wszSpoolDirectory [MAX_PATH]

DWORD	cchSpoolDirectory

LIST_ENTRY	PrintMonitorList

SKIPLIST	PrinterList

Classes

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ IS_VALID_JOB_ID

◆ IS_VALID_PRIORITY

◆ SHD_WIN2003_SIGNATURE

◆ SKIPLIST_LEVELS

◆ WIN32_NO_STATUS

Typedef Documentation

◆ LOCAL_HANDLE

◆ LOCAL_JOB

◆ LOCAL_PORT

◆ LOCAL_PORT_HANDLE

◆ LOCAL_PRINT_MONITOR

◆ LOCAL_PRINT_PROCESSOR

◆ LOCAL_PRINTER

◆ LOCAL_PRINTER_HANDLE

◆ LOCAL_XCV_HANDLE

◆ PClosePrintProcessor

◆ PControlPrintProcessor

◆ PEnumPrintProcessorDatatypesW

◆ PGetPrintProcessorCapabilities

◆ PInitializePrintMonitor

◆ PInitializePrintMonitor2

◆ PInitializePrintMonitorUI

◆ PLOCAL_HANDLE

◆ PLOCAL_JOB

◆ PLOCAL_PORT

◆ PLOCAL_PORT_HANDLE

◆ PLOCAL_PRINT_MONITOR

◆ PLOCAL_PRINT_PROCESSOR

◆ PLOCAL_PRINTER

◆ PLOCAL_PRINTER_HANDLE

◆ PLOCAL_XCV_HANDLE

◆ POpenPrintProcessor

◆ PPrintDocumentOnPrintProcessor

◆ PPRINTENV_T

◆ PRINTENV_T

◆ PSHD_HEADER

◆ SHD_HEADER

Function Documentation

◆ AllocAndRegQueryWSZ()

◆ BroadcastChange()

◆ copy_servername_from_name()

◆ CreateJob()

◆ CreatePortEntry()

◆ DuplicateDevMode()

◆ FindDatatype()

◆ FindPort()

◆ FindPrintMonitor()

◆ FindPrintProcessor()

◆ FreeJob()

◆ GetJobFilePath()

◆ InitializeFormList()

◆ InitializeGlobalJobList()

◆ InitializePortList()

◆ InitializePrinterDrivers()

◆ InitializePrinterJobList()

◆ InitializePrinterList()

◆ InitializePrintMonitorList()

◆ InitializePrintProcessorList()

◆ LocalAddForm()

◆ LocalAddJob()

◆ LocalAddMonitor()

◆ LocalAddPort()

◆ LocalAddPortEx()

◆ LocalAddPrinterDriver()

◆ LocalAddPrinterDriverEx()

◆ LocalClosePrinter()

◆ LocalCloseSpoolFileHandle()

◆ LocalCommitSpoolData()

◆ LocalConfigurePort()

◆ LocalDeleteForm()

◆ LocalDeleteMonitor()

◆ LocalDeletePort()

◆ LocalEndDocPrinter()

◆ LocalEndPagePrinter()