precomp.h File Reference

#include <stdlib.h>
#include <windef.h>
#include <winbase.h>
#include <wingdi.h>
#include <winreg.h>
#include <winspool.h>
#include <winsplp.h>
#include <winuser.h>
#include <ndk/rtlfuncs.h>
#include <spoolss.h>
#include <wine/debug.h>
#include "resource.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	_LOCALMON_HANDLE
struct	_LOCALMON_PORT
struct	_LOCALMON_XCV

Macros
#define	WIN32_NO_STATUS
#define	SIGLCMMON   'FrCN'
#define	SIGLCMPORT   'FrHK'

Typedefs
typedef struct _LOCALMON_HANDLE	LOCALMON_HANDLE
typedef struct _LOCALMON_HANDLE *	PLOCALMON_HANDLE
typedef struct _LOCALMON_PORT	LOCALMON_PORT
typedef struct _LOCALMON_PORT *	PLOCALMON_PORT
typedef struct _LOCALMON_XCV	LOCALMON_XCV
typedef struct _LOCALMON_XCV *	PLOCALMON_XCV

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (localmon)
void WINAPI	LocalmonShutdown (HANDLE hMonitor)
BOOL WINAPI	LocalmonClosePort (HANDLE hPort)
BOOL WINAPI	LocalmonEndDocPort (HANDLE hPort)
BOOL WINAPI	LocalmonEnumPorts (HANDLE hMonitor, PWSTR pName, DWORD Level, PBYTE pPorts, DWORD cbBuf, PDWORD pcbNeeded, PDWORD pcReturned)
BOOL WINAPI	LocalmonGetPrinterDataFromPort (HANDLE hPort, DWORD ControlID, PWSTR pValueName, PWSTR lpInBuffer, DWORD cbInBuffer, PWSTR lpOutBuffer, DWORD cbOutBuffer, PDWORD lpcbReturned)
BOOL WINAPI	LocalmonOpenPort (HANDLE hMonitor, PWSTR pName, PHANDLE pHandle)
BOOL WINAPI	LocalmonReadPort (HANDLE hPort, PBYTE pBuffer, DWORD cbBuffer, PDWORD pcbRead)
BOOL WINAPI	LocalmonSetPortTimeOuts (HANDLE hPort, LPCOMMTIMEOUTS lpCTO, DWORD Reserved)
BOOL WINAPI	LocalmonStartDocPort (HANDLE hPort, PWSTR pPrinterName, DWORD JobId, DWORD Level, PBYTE pDocInfo)
BOOL WINAPI	LocalmonWritePort (HANDLE hPort, PBYTE pBuffer, DWORD cbBuf, PDWORD pcbWritten)
BOOL WINAPI	LocalmonAddPort (HANDLE hMonitor, LPWSTR pName, HWND hWnd, LPWSTR pMonitorName)
BOOL WINAPI	LocalmonAddPortEx (HANDLE hMonitor, LPWSTR pName, DWORD Level, LPBYTE lpBuffer, LPWSTR lpMonitorName)
BOOL WINAPI	LocalmonConfigurePort (HANDLE hMonitor, LPWSTR pName, HWND hWnd, LPWSTR pPortName)
BOOL WINAPI	LocalmonDeletePort (HANDLE hMonitor, LPWSTR pName, HWND hWnd, LPWSTR pPortName)
BOOL	DoesPortExist (PCWSTR pwszPortName)
DWORD	GetLPTTransmissionRetryTimeout (VOID)
DWORD	GetPortNameWithoutColon (PCWSTR pwszPortName, PWSTR *ppwszPortNameWithoutColon)
DWORD	GetTypeFromName (LPCWSTR name)
BOOL WINAPI	LocalmonXcvClosePort (HANDLE hXcv)
DWORD WINAPI	LocalmonXcvDataPort (HANDLE hXcv, PCWSTR pszDataName, PBYTE pInputData, DWORD cbInputData, PBYTE pOutputData, DWORD cbOutputData, PDWORD pcbOutputNeeded)
BOOL WINAPI	LocalmonXcvOpenPort (HANDLE hMonitor, PCWSTR pszObject, ACCESS_MASK GrantedAccess, PHANDLE phXcv)

Variables
DWORD	cbLocalMonitor
DWORD	cbLocalPort
PCWSTR	pwszLocalMonitor
PCWSTR	pwszLocalPort

Macro Definition Documentation

SIGLCMMON

#define SIGLCMMON   'FrCN'

Definition at line 30 of file precomp.h.

SIGLCMPORT

#define SIGLCMPORT   'FrHK'

Definition at line 31 of file precomp.h.

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 11 of file precomp.h.

Typedef Documentation

LOCALMON_HANDLE

typedef struct _LOCALMON_HANDLE LOCALMON_HANDLE

Describes the monitor handle returned by InitializePrintMonitor2. Manages all available ports in this instance.

LOCALMON_PORT

typedef struct _LOCALMON_PORT LOCALMON_PORT

Describes the port handle returned by LocalmonOpenPort. Manages a legacy port (COM/LPT) or virtual FILE: port for printing as well as its associated printer and job.

LOCALMON_XCV

typedef struct _LOCALMON_XCV LOCALMON_XCV

Describes the Xcv handle returned by LocalmonXcvOpenPort. Manages the required data for the Xcv* calls.

PLOCALMON_HANDLE

typedef struct _LOCALMON_HANDLE * PLOCALMON_HANDLE

PLOCALMON_PORT

typedef struct _LOCALMON_PORT * PLOCALMON_PORT

PLOCALMON_XCV

typedef struct _LOCALMON_XCV * PLOCALMON_XCV

Function Documentation

DoesPortExist()

BOOL DoesPortExist

(

PCWSTR

pwszPortName

)

Definition at line 24 of file tools.c.

{
    BOOL bReturnValue = FALSE;
    DWORD cbNeeded;
    DWORD dwErrorCode;
    DWORD dwReturned;
    DWORD i;
    PPORT_INFO_1W p;
    PPORT_INFO_1W pPortInfo1 = NULL;
 
    // Determine the required buffer size.
    EnumPortsW(NULL, 1, NULL, 0, &cbNeeded, &dwReturned);
    if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
    {
        dwErrorCode = GetLastError();
        ERR("EnumPortsW failed with error %lu!\n", dwErrorCode);
        goto Cleanup;
    }
 
    // Allocate a buffer large enough.
    pPortInfo1 = DllAllocSplMem(cbNeeded);
    if (!pPortInfo1)
    {
        dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
        ERR("DllAllocSplMem failed with error %lu!\n", GetLastError());
        goto Cleanup;
    }
 
    // Now get the actual port information.
    if (!EnumPortsW(NULL, 1, (PBYTE)pPortInfo1, cbNeeded, &cbNeeded, &dwReturned))
    {
        dwErrorCode = GetLastError();
        ERR("EnumPortsW failed with error %lu!\n", dwErrorCode);
        goto Cleanup;
    }
 
    // We were successful! Loop through all returned ports.
    dwErrorCode = ERROR_SUCCESS;
    p = pPortInfo1;
 
    for (i = 0; i < dwReturned; i++)
    {
        // Check if this existing port matches our queried one.
        if (wcsicmp(p->pName, pwszPortName) == 0)
        {
            bReturnValue = TRUE;
            goto Cleanup;
        }
 
        p++;
    }
 
Cleanup:
    if (pPortInfo1)
        DllFreeSplMem(pPortInfo1);
 
    SetLastError(dwErrorCode);
    return bReturnValue;
}

Referenced by _HandleAddPort(), _HandlePortExists(), LocalmonAddPort(), and LocalmonAddPortEx().

GetLPTTransmissionRetryTimeout()

DWORD GetLPTTransmissionRetryTimeout

(

VOID

)

Definition at line 85 of file tools.c.

{
    DWORD cbBuffer;
    DWORD dwReturnValue = 90;       // Use 90 seconds as default if we fail to read from registry.
    HKEY hKey;
    LSTATUS lStatus;
 
    // Six digits is the most you can enter in Windows' LocalUI.dll.
    // Larger values make it crash, so introduce a limit here.
    WCHAR wszBuffer[6 + 1];
 
    // Open the key where our value is stored.
    lStatus = RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Windows", 0, KEY_READ, &hKey);
    if (lStatus != ERROR_SUCCESS)
    {
        ERR("RegOpenKeyExW failed with status %ld!\n", lStatus);
        goto Cleanup;
    }
 
    // Query the value.
    cbBuffer = sizeof(wszBuffer);
    lStatus = RegQueryValueExW(hKey, L"TransmissionRetryTimeout", NULL, NULL, (PBYTE)wszBuffer, &cbBuffer);
    if (lStatus != ERROR_SUCCESS)
    {
        ERR("RegQueryValueExW failed with status %ld!\n", lStatus);
        goto Cleanup;
    }
 
    // Return it converted to a DWORD.
    dwReturnValue = wcstoul(wszBuffer, NULL, 10);
 
Cleanup:
    if (hKey)
        RegCloseKey(hKey);
 
    return dwReturnValue;
}

Referenced by _HandleGetTransmissionRetryTimeout(), and _SetTransmissionRetryTimeout().

GetPortNameWithoutColon()

DWORD GetPortNameWithoutColon	(	PCWSTR	pwszPortName,
		PWSTR *	ppwszPortNameWithoutColon
	)

Definition at line 142 of file tools.c.

{
    DWORD cchPortNameWithoutColon;
 
    // Compute the string length of pwszPortNameWithoutColon.
    cchPortNameWithoutColon = wcslen(pwszPortName) - 1;
 
    // Check if pwszPortName really has a colon as the last character.
    if (pwszPortName[cchPortNameWithoutColon] != L':')
        return ERROR_INVALID_PARAMETER;
 
    // Allocate the output buffer.
    *ppwszPortNameWithoutColon = DllAllocSplMem((cchPortNameWithoutColon + 1) * sizeof(WCHAR));
    if (!*ppwszPortNameWithoutColon)
    {
        ERR("DllAllocSplMem failed with error %lu!\n", GetLastError());
        return ERROR_NOT_ENOUGH_MEMORY;
    }
 
    // Copy the port name without colon into the buffer.
    // The buffer is already zero-initialized, so no additional null-termination is necessary.
    CopyMemory(*ppwszPortNameWithoutColon, pwszPortName, cchPortNameWithoutColon * sizeof(WCHAR));
 
    return ERROR_SUCCESS;
}

Referenced by _ClosePortHandles(), _CreateNonspooledPort(), and _HandleSetDefaultCommConfig().

GetTypeFromName()

DWORD GetTypeFromName

(

LPCWSTR

name

)

Definition at line 215 of file tools.c.

{
    HANDLE  hfile;
 
    if (!wcsncmp(name, L"LPT", ARRAYSIZE(L"LPT") - 1) )
        return PORT_IS_LPT;
 
    if (!wcsncmp(name, L"COM", ARRAYSIZE(L"COM") - 1) )
        return PORT_IS_COM;
 
    if (!lstrcmpW(name, L"FILE:") )
        return PORT_IS_FILE;
 
//    if (name[0] == '/')
//        return PORT_IS_UNIXNAME;
 
//    if (name[0] == '|')
//        return PORT_IS_PIPE;
 
    if ( _IsNEPort( name ) )
        return PORT_IS_VNET;
 
    if (!wcsncmp(name, L"XPS", ARRAYSIZE(L"XPS") - 1))
        return PORT_IS_XPS;
 
    /* Must be a file or a directory. Does the file exist ? */
    hfile = CreateFileW(name, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 
    FIXME("%p for OPEN_EXISTING on %s\n", hfile, debugstr_w(name));
 
    if (hfile == INVALID_HANDLE_VALUE)
    {
        /* Can we create the file? */
        hfile = CreateFileW(name, GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_FLAG_DELETE_ON_CLOSE, NULL);
        FIXME("%p for OPEN_ALWAYS\n", hfile);
    }
 
    if (hfile != INVALID_HANDLE_VALUE)
    {
        CloseHandle(hfile); FIXME("PORT_IS_FILENAME %d\n",PORT_IS_FILENAME);
        return PORT_IS_FILENAME;
    }
    FIXME("PORT_IS_UNKNOWN %d\n",PORT_IS_UNKNOWN);
    /* We can't use the name. use GetLastError() for the reason */
    return PORT_IS_UNKNOWN;
}

Referenced by _HandlePortIsValid().

LocalmonAddPort()

BOOL WINAPI LocalmonAddPort	(	HANDLE	hMonitor,
		LPWSTR	pName,
		HWND	hWnd,
		LPWSTR	pMonitorName
	)

Definition at line 1137 of file ports.c.

{
    DWORD res, cbPortName;
    HKEY hroot;
    PLOCALMON_HANDLE pLocalmon = (PLOCALMON_HANDLE)hMonitor;
    PLOCALMON_PORT pPort;
    WCHAR PortName[MAX_PATH] = {0}; // Need to use a Dialog to get name.
 
    FIXME("LocalmonAddPort : %s\n", debugstr_w( (LPWSTR) pMonitorName ) );
 
    res = RegOpenKeyW(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows NT\\CurrentVersion\\Ports", &hroot);
    if (res == ERROR_SUCCESS)
    {
        if ( DoesPortExist( PortName ) )
        {
            RegCloseKey(hroot);
            FIXME("=> %u\n", ERROR_ALREADY_EXISTS);
            res = ERROR_ALREADY_EXISTS;
            goto Cleanup;
        }
 
        cbPortName = (wcslen( PortName ) + 1) * sizeof(WCHAR);
 
        // Create a new LOCALMON_PORT structure for it.
        pPort = DllAllocSplMem(sizeof(LOCALMON_PORT) + cbPortName);
        if (!pPort)
        {
            res = ERROR_NOT_ENOUGH_MEMORY;
            RegCloseKey( hroot );
            goto Cleanup;
        }
 
        pPort->Sig = SIGLCMPORT;
        pPort->hFile = INVALID_HANDLE_VALUE;
        pPort->pLocalmon = pLocalmon;
        pPort->pwszPortName = wcscpy( (PWSTR)(pPort+1), PortName );
 
        // Insert it into the Registry list.
        InsertTailList(&pLocalmon->RegistryPorts, &pPort->Entry);
 
        res = RegSetValueExW(hroot, PortName, 0, REG_SZ, (const BYTE *) L"", sizeof(L""));
        RegCloseKey(hroot);
    }
 
    FIXME("=> %u\n", res);
 
Cleanup:
    SetLastError(res);
    return (res == ERROR_SUCCESS);
}

LocalmonAddPortEx()

BOOL WINAPI LocalmonAddPortEx	(	HANDLE	hMonitor,
		LPWSTR	pName,
		DWORD	Level,
		LPBYTE	lpBuffer,
		LPWSTR	lpMonitorName
	)

Definition at line 1054 of file ports.c.

{
    PLOCALMON_HANDLE pLocalmon = (PLOCALMON_HANDLE)hMonitor;
    PLOCALMON_PORT pPort;
    HKEY hKey;
    DWORD dwErrorCode, cbPortName;
    PORT_INFO_1W * pi = (PORT_INFO_1W *) lpBuffer;
 
    FIXME("LocalmonAddPortEx(%p, %lu, %p, %s) => %s\n", hMonitor, Level, lpBuffer, debugstr_w(lpMonitorName), debugstr_w(pi ? pi->pName : NULL));
 
    // Sanity checks
    if ( !pLocalmon )
    {
        dwErrorCode = ERROR_INVALID_PARAMETER;
        goto Cleanup;
    }
 
    if ( ( lpMonitorName == NULL )                          ||
         ( lstrcmpiW( lpMonitorName, L"Local Port" ) != 0 ) ||
         ( pi == NULL )                                     ||
         ( pi->pName == NULL )                              ||
         ( pi->pName[0] == '\0' ) )
    {
        ERR("Fail Monitor Port Name\n");
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    if ( Level != 1 )
    {
        SetLastError(ERROR_INVALID_LEVEL);
        return FALSE;
    }
 
    dwErrorCode = RegOpenKeyW( HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows NT\\CurrentVersion\\Ports", &hKey );
    if ( dwErrorCode == ERROR_SUCCESS )
    {
        if ( DoesPortExist( pi->pName ) )
        {
            RegCloseKey( hKey) ;
            FIXME("Port Exist => FALSE with %u\n", ERROR_INVALID_PARAMETER);
            SetLastError(ERROR_INVALID_PARAMETER);
            return FALSE;
        }
 
        cbPortName = (wcslen( pi->pName ) + 1) * sizeof(WCHAR);
 
        // Create a new LOCALMON_PORT structure for it.
        pPort = DllAllocSplMem(sizeof(LOCALMON_PORT) + cbPortName);
        if (!pPort)
        {
            dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
            RegCloseKey( hKey );
            goto Cleanup;
        }
 
        pPort->Sig = SIGLCMPORT;
        pPort->hFile = INVALID_HANDLE_VALUE;
        pPort->pLocalmon = pLocalmon;
        pPort->pwszPortName = wcscpy( (PWSTR)(pPort+1), pi->pName );
 
        // Insert it into the Registry list.
        InsertTailList(&pLocalmon->RegistryPorts, &pPort->Entry);
 
        dwErrorCode = RegSetValueExW( hKey, pi->pName, 0, REG_SZ, (const BYTE *) L"", sizeof(L"") );
        RegCloseKey( hKey );
    }
 
Cleanup:
    if (dwErrorCode != ERROR_SUCCESS) SetLastError(ERROR_INVALID_PARAMETER);
 
    FIXME("LocalmonAddPortEx => %u with %u\n", (dwErrorCode == ERROR_SUCCESS), GetLastError());
 
    return (dwErrorCode == ERROR_SUCCESS);
}

LocalmonClosePort()

BOOL WINAPI LocalmonClosePort

(

HANDLE

hPort

)

Definition at line 456 of file ports.c.

{
    PLOCALMON_PORT pPort = (PLOCALMON_PORT)hPort;
 
    TRACE("LocalmonClosePort(%p)\n", hPort);
 
    // Sanity checks
    if (!pPort)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    // Close the file handle, free memory for pwszMapping and delete any NONSPOOLED port.
    _ClosePortHandles(pPort);
 
    // Close any open printer handle.
    if (pPort->hPrinter)
    {
        ClosePrinter(pPort->hPrinter);
        pPort->hPrinter = NULL;
    }
 
    // Free virtual FILE: ports which were created in LocalmonOpenPort.
    if (pPort->PortType == PortType_FILE)
    {
        EnterCriticalSection(&pPort->pLocalmon->Section);
        RemoveEntryList(&pPort->Entry);
        LeaveCriticalSection(&pPort->pLocalmon->Section);
        DllFreeSplMem(pPort);
    }
 
    SetLastError(ERROR_SUCCESS);
    return TRUE;
}

Referenced by LocalmonShutdown().

LocalmonConfigurePort()

BOOL WINAPI LocalmonConfigurePort	(	HANDLE	hMonitor,
		LPWSTR	pName,
		HWND	hWnd,
		LPWSTR	pPortName
	)

Definition at line 1189 of file ports.c.

{
    FIXME("LocalmonConfigurePort : %s\n", debugstr_w( pPortName ) );
    return FALSE;
}

LocalmonDeletePort()

BOOL WINAPI LocalmonDeletePort	(	HANDLE	hMonitor,
		LPWSTR	pName,
		HWND	hWnd,
		LPWSTR	pPortName
	)

Definition at line 1197 of file ports.c.

{
    DWORD res;
    HKEY hroot;
    PLOCALMON_HANDLE pLocalmon = (PLOCALMON_HANDLE)hMonitor;
    PLOCALMON_PORT pPort;
 
    FIXME("LocalmonDeletePort : %s\n", debugstr_w( pPortName ) );
 
    res = RegOpenKeyW(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows NT\\CurrentVersion\\Ports", &hroot);
    if ( res == ERROR_SUCCESS )
    {
        res = RegDeleteValueW(hroot, pPortName );
 
        RegCloseKey(hroot);
 
        pPort = _FindPort( pLocalmon, pPortName );
        if ( pPort )
        {
            EnterCriticalSection(&pPort->pLocalmon->Section);
            RemoveEntryList(&pPort->Entry);
            LeaveCriticalSection(&pPort->pLocalmon->Section);
 
            DllFreeSplMem(pPort);
        }
 
        FIXME("=> %u with %u\n", res, GetLastError() );
    }
 
    SetLastError(res);
    return (res == ERROR_SUCCESS);
}

LocalmonEndDocPort()

BOOL WINAPI LocalmonEndDocPort

(

HANDLE

hPort

)

Definition at line 493 of file ports.c.

{
    PLOCALMON_PORT pPort = (PLOCALMON_PORT)hPort;
 
    TRACE("LocalmonEndDocPort(%p)\n", hPort);
 
    // Sanity checks
    if (!pPort)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    // Ending a document requires starting it first :-P
    if (pPort->bStartedDoc)
    {
        // Close all ports opened in StartDocPort.
        // That is, all but physical LPT ports (opened in OpenPort).
        if (pPort->PortType != PortType_PhysicalLPT)
            _ClosePortHandles(pPort);
 
        // Report our progress.
        SetJobW(pPort->hPrinter, pPort->dwJobID, 0, NULL, JOB_CONTROL_SENT_TO_PRINTER);
 
        // We're done with the printer.
        ClosePrinter(pPort->hPrinter);
        pPort->hPrinter = NULL;
 
        // A new document can now be started again.
        pPort->bStartedDoc = FALSE;
    }
 
    SetLastError(ERROR_SUCCESS);
    return TRUE;
}

LocalmonEnumPorts()

BOOL WINAPI LocalmonEnumPorts	(	HANDLE	hMonitor,
		PWSTR	pName,
		DWORD	Level,
		PBYTE	pPorts,
		DWORD	cbBuf,
		PDWORD	pcbNeeded,
		PDWORD	pcReturned
	)

Definition at line 530 of file ports.c.

{
    DWORD dwErrorCode;
    PBYTE pPortInfoEnd;
    PLIST_ENTRY pEntry;
    PLOCALMON_HANDLE pLocalmon = (PLOCALMON_HANDLE)hMonitor;
    PLOCALMON_PORT pPort;
 
    TRACE("LocalmonEnumPorts(%p, %S, %lu, %p, %lu, %p, %p)\n", hMonitor, pName, Level, pPorts, cbBuf, pcbNeeded, pcReturned);
 
    // Windows Server 2003's Local Port Monitor does absolutely no sanity checks here, not even for the Level parameter.
    // As we implement a more modern MONITOR2-based Port Monitor, check at least our hMonitor.
    if (!pLocalmon)
    {
        dwErrorCode = ERROR_INVALID_HANDLE;
        goto Cleanup;
    }
 
    // Begin counting.
    *pcbNeeded = 0;
    *pcReturned = 0;
 
    EnterCriticalSection(&pLocalmon->Section);
 
    // Count the required buffer size and the number of ports.
    for (pEntry = pLocalmon->RegistryPorts.Flink; pEntry != &pLocalmon->RegistryPorts; pEntry = pEntry->Flink)
    {
        pPort = CONTAINING_RECORD(pEntry, LOCALMON_PORT, Entry);
 
        if (Level == 1)
            _LocalmonGetPortLevel1(pPort, NULL, NULL, pcbNeeded);
        else if (Level == 2)
            _LocalmonGetPortLevel2(pPort, NULL, NULL, pcbNeeded);
    }
 
    // Check if the supplied buffer is large enough.
    if (cbBuf < *pcbNeeded)
    {
        LeaveCriticalSection(&pLocalmon->Section);
        dwErrorCode = ERROR_INSUFFICIENT_BUFFER;
        goto Cleanup;
    }
 
    // Copy over the Port information.
    pPortInfoEnd = &pPorts[*pcbNeeded];
 
    for (pEntry = pLocalmon->RegistryPorts.Flink; pEntry != &pLocalmon->RegistryPorts; pEntry = pEntry->Flink)
    {
        pPort = CONTAINING_RECORD(pEntry, LOCALMON_PORT, Entry);
 
        if (Level == 1)
            _LocalmonGetPortLevel1(pPort, (PPORT_INFO_1W*)&pPorts, &pPortInfoEnd, NULL);
        else if (Level == 2)
            _LocalmonGetPortLevel2(pPort, (PPORT_INFO_2W*)&pPorts, &pPortInfoEnd, NULL);
 
        (*pcReturned)++;
    }
 
    LeaveCriticalSection(&pLocalmon->Section);
    dwErrorCode = ERROR_SUCCESS;
 
Cleanup:
    SetLastError(dwErrorCode);
    return (dwErrorCode == ERROR_SUCCESS);
}

LocalmonGetPrinterDataFromPort()

BOOL WINAPI LocalmonGetPrinterDataFromPort	(	HANDLE	hPort,
		DWORD	ControlID,
		PWSTR	pValueName,
		PWSTR	lpInBuffer,
		DWORD	cbInBuffer,
		PWSTR	lpOutBuffer,
		DWORD	cbOutBuffer,
		PDWORD	lpcbReturned
	)

Definition at line 630 of file ports.c.

{
    BOOL bOpenedPort = FALSE;
    DWORD dwErrorCode;
    PLOCALMON_PORT pPort = (PLOCALMON_PORT)hPort;
 
    TRACE("LocalmonGetPrinterDataFromPort(%p, %lu, %p, %p, %lu, %p, %lu, %p)\n", hPort, ControlID, pValueName, lpInBuffer, cbInBuffer, lpOutBuffer, cbOutBuffer, lpcbReturned);
 
    // Sanity checks
    if (!pPort || !ControlID || !lpcbReturned)
    {
        dwErrorCode = ERROR_INVALID_PARAMETER;
        goto Cleanup;
    }
 
    // If this is a serial port, a temporary file handle may be opened.
    if (pPort->PortType == PortType_PhysicalCOM)
    {
        if (_CreateNonspooledPort(pPort))
        {
            bOpenedPort = TRUE;
        }
        else if (GetLastError() != ERROR_SUCCESS)
        {
            dwErrorCode = GetLastError();
            goto Cleanup;
        }
    }
    else if (pPort->hFile == INVALID_HANDLE_VALUE)
    {
        // All other port types need to be opened already.
        dwErrorCode = ERROR_INVALID_PARAMETER;
        goto Cleanup;
    }
 
    // Pass the parameters to DeviceIoControl.
    if (!DeviceIoControl(pPort->hFile, ControlID, lpInBuffer, cbInBuffer, lpOutBuffer, cbOutBuffer, lpcbReturned, NULL))
    {
        dwErrorCode = GetLastError();
        ERR("DeviceIoControl failed with error %lu!\n", dwErrorCode);
        goto Cleanup;
    }
 
    dwErrorCode = ERROR_SUCCESS;
 
Cleanup:
    if (bOpenedPort)
        _ClosePortHandles(pPort);
 
    SetLastError(dwErrorCode);
    return (dwErrorCode == ERROR_SUCCESS);
}

LocalmonOpenPort()

BOOL WINAPI LocalmonOpenPort	(	HANDLE	hMonitor,
		PWSTR	pName,
		PHANDLE	pHandle
	)

Definition at line 684 of file ports.c.

{
    DWORD dwErrorCode;
    PLOCALMON_HANDLE pLocalmon = (PLOCALMON_HANDLE)hMonitor;
    PLOCALMON_PORT pPort;
 
    TRACE("LocalmonOpenPort(%p, %S, %p)\n", hMonitor, pName, pHandle);
 
    // Sanity checks
    if (!pLocalmon || !pName || !pHandle)
    {
        dwErrorCode = ERROR_INVALID_PARAMETER;
        goto Cleanup;
    }
 
    EnterCriticalSection(&pLocalmon->Section);
 
    // Check if this is a FILE: port.
    if (_wcsicmp(pName, L"FILE:") == 0)
    {
        // For FILE:, we create a virtual port for each request.
        pPort = DllAllocSplMem(sizeof(LOCALMON_PORT));
        pPort->pLocalmon = pLocalmon;
        pPort->PortType = PortType_FILE;
        pPort->hFile = INVALID_HANDLE_VALUE;
 
        // Add it to the list of file ports.
        InsertTailList(&pLocalmon->FilePorts, &pPort->Entry);
    }
    else
    {
        // Check if the port name is valid.
        pPort = _FindPort(pLocalmon, pName);
        if (!pPort)
        {
            LeaveCriticalSection(&pLocalmon->Section);
            dwErrorCode = ERROR_UNKNOWN_PORT;
            goto Cleanup;
        }
 
        // Even if this API is called OpenPort, port file handles aren't always opened here :-P
        // Windows only does this for physical LPT ports here to enable bidirectional communication with the printer outside of jobs (using ReadPort and WritePort).
        // The others are only opened per job in StartDocPort.
        if (_IsLegacyPort(pName, L"LPT"))
        {
            // Try to create a NONSPOOLED port and open it.
            if (_CreateNonspooledPort(pPort))
            {
                // Set the transmission retry timeout for the ReadPort and WritePort calls.
                // This also checks if this port is a physical one.
                if (_SetTransmissionRetryTimeout(pPort))
                {
                    // This is definitely a physical LPT port!
                    pPort->PortType = PortType_PhysicalLPT;
                }
                else
                {
                    // This is no physical port, so don't keep its handle open.
                    _ClosePortHandles(pPort);
                }
            }
            else if (GetLastError() != ERROR_SUCCESS)
            {
                LeaveCriticalSection(&pLocalmon->Section);
                dwErrorCode = GetLastError();
                goto Cleanup;
            }
        }
        else if (_IsLegacyPort(pName, L"COM"))
        {
            // COM ports can't be redirected over the network, so this is a physical one.
            pPort->PortType = PortType_PhysicalCOM;
        }
    }
 
    LeaveCriticalSection(&pLocalmon->Section);
 
    // Return our fetched LOCALMON_PORT structure in the handle.
    *pHandle = (PHANDLE)pPort;
    dwErrorCode = ERROR_SUCCESS;
 
Cleanup:
    SetLastError(dwErrorCode);
    return (dwErrorCode == ERROR_SUCCESS);
}

LocalmonReadPort()

BOOL WINAPI LocalmonReadPort	(	HANDLE	hPort,
		PBYTE	pBuffer,
		DWORD	cbBuffer,
		PDWORD	pcbRead
	)

Definition at line 843 of file ports.c.

{
    BOOL bOpenedPort = FALSE;
    DWORD dwErrorCode;
    PLOCALMON_PORT pPort = (PLOCALMON_PORT)hPort;
 
    TRACE("LocalmonReadPort(%p, %p, %lu, %p)\n", hPort, pBuffer, cbBuffer, pcbRead);
 
    // Sanity checks
    if (!pPort || (cbBuffer && !pBuffer) || !pcbRead)
    {
        dwErrorCode = ERROR_INVALID_PARAMETER;
        goto Cleanup;
    }
 
    // Reading is only supported for physical ports.
    if (pPort->PortType != PortType_PhysicalCOM && pPort->PortType != PortType_PhysicalLPT)
    {
        dwErrorCode = ERROR_INVALID_HANDLE;
        goto Cleanup;
    }
 
    // If this is a serial port, a temporary file handle may be opened.
    if (pPort->PortType == PortType_PhysicalCOM)
    {
        if (_CreateNonspooledPort(pPort))
        {
            bOpenedPort = TRUE;
        }
        else if (GetLastError() != ERROR_SUCCESS)
        {
            dwErrorCode = GetLastError();
            goto Cleanup;
        }
    }
 
    // Pass the parameters to ReadFile.
    if (!ReadFile(pPort->hFile, pBuffer, cbBuffer, pcbRead, NULL))
    {
        dwErrorCode = GetLastError();
        ERR("ReadFile failed with error %lu!\n", dwErrorCode);
        goto Cleanup;
    }
 
Cleanup:
    if (bOpenedPort)
        _ClosePortHandles(pPort);
 
    SetLastError(dwErrorCode);
    return (dwErrorCode == ERROR_SUCCESS);
}

LocalmonSetPortTimeOuts()

BOOL WINAPI LocalmonSetPortTimeOuts	(	HANDLE	hPort,
		LPCOMMTIMEOUTS	lpCTO,
		DWORD	Reserved
	)

Definition at line 789 of file ports.c.

{
    BOOL bOpenedPort = FALSE;
    DWORD dwErrorCode;
    PLOCALMON_PORT pPort = (PLOCALMON_PORT)hPort;
 
    TRACE("LocalmonSetPortTimeOuts(%p, %p, %lu)\n", hPort, lpCTO, Reserved);
 
    // Sanity checks
    if (!pPort || !lpCTO)
    {
        dwErrorCode = ERROR_INVALID_PARAMETER;
        goto Cleanup;
    }
 
    // If this is a serial port, a temporary file handle may be opened.
    if (pPort->PortType == PortType_PhysicalCOM)
    {
        if (_CreateNonspooledPort(pPort))
        {
            bOpenedPort = TRUE;
        }
        else if (GetLastError() != ERROR_SUCCESS)
        {
            dwErrorCode = GetLastError();
            goto Cleanup;
        }
    }
    else if (pPort->hFile == INVALID_HANDLE_VALUE)
    {
        // All other port types need to be opened already.
        dwErrorCode = ERROR_INVALID_PARAMETER;
        goto Cleanup;
    }
 
    // Finally pass the parameters to SetCommTimeouts.
    if (!SetCommTimeouts(pPort->hFile, lpCTO))
    {
        dwErrorCode = GetLastError();
        ERR("SetCommTimeouts failed with error %lu!\n", dwErrorCode);
        goto Cleanup;
    }
 
    dwErrorCode = ERROR_SUCCESS;
 
Cleanup:
    if (bOpenedPort)
        _ClosePortHandles(pPort);
 
    SetLastError(dwErrorCode);
    return (dwErrorCode == ERROR_SUCCESS);
}

LocalmonShutdown()

void WINAPI LocalmonShutdown

(

HANDLE

hMonitor

)

Definition at line 112 of file main.c.

{
    PLOCALMON_HANDLE pLocalmon;
    PLOCALMON_PORT pPort;
    PLOCALMON_XCV pXcv;
    PLIST_ENTRY pEntry;
 
    TRACE("LocalmonShutdown(%p)\n", hMonitor);
 
    pLocalmon = (PLOCALMON_HANDLE)hMonitor;
 
    if ( pLocalmon->Sig != SIGLCMMON )
    {
        ERR("LocalmonShutdown : Invalid Monitor Handle\n",hMonitor);
        return;
    }
 
    // Close all virtual file ports.
    if (!IsListEmpty(&pLocalmon->FilePorts))
    {
        for (pEntry = pLocalmon->FilePorts.Flink; pEntry != &pLocalmon->FilePorts; pEntry = pEntry->Flink)
        {
           pPort = CONTAINING_RECORD(&pLocalmon->FilePorts.Flink, LOCALMON_PORT, Entry);
           LocalmonClosePort((HANDLE)pPort);
        }
    }
 
    // Do the same for the open Xcv ports.
    if (!IsListEmpty(&pLocalmon->XcvHandles))
    {
        for (pEntry = pLocalmon->XcvHandles.Flink; pEntry != &pLocalmon->XcvHandles; pEntry = pEntry->Flink)
        {
            pXcv = CONTAINING_RECORD(pEntry, LOCALMON_XCV, Entry);
            LocalmonXcvClosePort((HANDLE)pXcv);
        }
    }
 
    // Now close all registry ports, remove them from the list and free their memory.
    if (!IsListEmpty(&pLocalmon->RegistryPorts))
    {
        for (pEntry = pLocalmon->RegistryPorts.Flink; pEntry != &pLocalmon->RegistryPorts; pEntry = pEntry->Flink)
        {
            pPort = CONTAINING_RECORD(pEntry, LOCALMON_PORT, Entry);
            if ( LocalmonClosePort((HANDLE)pPort) ) continue;
            RemoveEntryList(&pPort->Entry);
            DllFreeSplMem(pPort);
        }
    }
 
    // Finally clean the LOCALMON_HANDLE structure itself.
    DeleteCriticalSection(&pLocalmon->Section);
    DllFreeSplMem(pLocalmon);
}

LocalmonStartDocPort()

BOOL WINAPI LocalmonStartDocPort	(	HANDLE	hPort,
		PWSTR	pPrinterName,
		DWORD	JobId,
		DWORD	Level,
		PBYTE	pDocInfo
	)

Definition at line 896 of file ports.c.

{
    DWORD dwErrorCode;
    PDOC_INFO_1W pDocInfo1 = (PDOC_INFO_1W)pDocInfo;        // DOC_INFO_1W is the least common denominator for both DOC_INFO levels.
    PLOCALMON_PORT pPort = (PLOCALMON_PORT)hPort;
 
    TRACE("LocalmonStartDocPort(%p, %S, %lu, %lu, %p)\n", hPort, pPrinterName, JobId, Level, pDocInfo);
 
    // Sanity checks
    if (!pPort || !pPrinterName || (pPort->PortType == PortType_FILE && (!pDocInfo1 || !pDocInfo1->pOutputFile || !*pDocInfo1->pOutputFile)))
    {
        dwErrorCode = ERROR_INVALID_PARAMETER;
        goto Cleanup;
    }
 
    if (Level > 2)
    {
        dwErrorCode = ERROR_INVALID_LEVEL;
        goto Cleanup;
    }
 
    // Calling StartDocPort multiple times isn't considered a failure, but we don't need to do anything then.
    if (pPort->bStartedDoc)
    {
        dwErrorCode = ERROR_SUCCESS;
        goto Cleanup;
    }
 
    // Open a handle to the given printer for later reporting our progress using SetJobW.
    if (!OpenPrinterW(pPrinterName, &pPort->hPrinter, NULL))
    {
        dwErrorCode = GetLastError();
        ERR("OpenPrinterW failed with error %lu!\n", dwErrorCode);
        goto Cleanup;
    }
 
    // We need our Job ID for SetJobW as well.
    pPort->dwJobID = JobId;
 
    // Check the port type.
    if (pPort->PortType == PortType_PhysicalLPT)
    {
        // Update the NONSPOOLED mapping if the port mapping has changed since our OpenPort call.
        if (!_CreateNonspooledPort(pPort) && GetLastError() != ERROR_SUCCESS)
        {
            dwErrorCode = GetLastError();
            goto Cleanup;
        }
 
        // Update the transmission retry timeout as well.
        _SetTransmissionRetryTimeout(pPort);
    }
    else if(pPort->PortType == PortType_FILE)
    {
        // This is a FILE: port. Open the output file given in the Document Info.
        pPort->hFile = CreateFileW(pDocInfo1->pOutputFile, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, 0, NULL);
        if (pPort->hFile == INVALID_HANDLE_VALUE)
        {
            dwErrorCode = GetLastError();
            goto Cleanup;
        }
    }
    else
    {
        // This can be:
        //    - a physical COM port
        //    - a non-physical LPT port (e.g. with "net use LPT1 ...")
        //    - any other port (e.g. a file or a shared printer installed as a local port)
        //
        // For all these cases, we try to create a NONSPOOLED port per job.
        // If _CreateNonspooledPort reports that no NONSPOOLED port is necessary, we can just open the port name.
        if (!_CreateNonspooledPort(pPort))
        {
            if (GetLastError() == ERROR_SUCCESS)
            {
                pPort->hFile = CreateFileW(pPort->pwszPortName, GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, 0, NULL);
                if (pPort->hFile == INVALID_HANDLE_VALUE)
                {
                    dwErrorCode = GetLastError();
                    goto Cleanup;
                }
            }
            else
            {
                dwErrorCode = GetLastError();
                goto Cleanup;
            }
        }
    }
 
    // We were successful!
    dwErrorCode = ERROR_SUCCESS;
    pPort->bStartedDoc = TRUE;
 
Cleanup:
    SetLastError(dwErrorCode);
    return (dwErrorCode == ERROR_SUCCESS);
}

LocalmonWritePort()

BOOL WINAPI LocalmonWritePort	(	HANDLE	hPort,
		PBYTE	pBuffer,
		DWORD	cbBuf,
		PDWORD	pcbWritten
	)

Definition at line 996 of file ports.c.

{
    BOOL bOpenedPort = FALSE;
    DWORD dwErrorCode;
    PLOCALMON_PORT pPort = (PLOCALMON_PORT)hPort;
 
    TRACE("LocalmonWritePort(%p, %p, %lu, %p)\n", hPort, pBuffer, cbBuf, pcbWritten);
 
    // Sanity checks
    if (!pPort || (cbBuf && !pBuffer) || !pcbWritten)
    {
        dwErrorCode = ERROR_INVALID_PARAMETER;
        goto Cleanup;
    }
 
    // If this is a serial port, a temporary file handle may be opened.
    if (pPort->PortType == PortType_PhysicalCOM)
    {
        if (_CreateNonspooledPort(pPort))
        {
            bOpenedPort = TRUE;
        }
        else if (GetLastError() != ERROR_SUCCESS)
        {
            dwErrorCode = GetLastError();
            goto Cleanup;
        }
    }
    else if (pPort->hFile == INVALID_HANDLE_VALUE)
    {
        // All other port types need to be opened already.
        dwErrorCode = ERROR_INVALID_PARAMETER;
        goto Cleanup;
    }
 
    // Pass the parameters to WriteFile.
    if (!WriteFile(pPort->hFile, pBuffer, cbBuf, pcbWritten, NULL))
    {
        dwErrorCode = GetLastError();
        ERR("WriteFile failed with error %lu!\n", dwErrorCode);
        goto Cleanup;
    }
 
    // If something was written down, we consider that a success, otherwise it's a timeout.
    if (*pcbWritten)
        dwErrorCode = ERROR_SUCCESS;
    else
        dwErrorCode = ERROR_TIMEOUT;
 
Cleanup:
    if (bOpenedPort)
        _ClosePortHandles(pPort);
 
    SetLastError(dwErrorCode);
    return (dwErrorCode == ERROR_SUCCESS);
}

LocalmonXcvClosePort()

BOOL WINAPI LocalmonXcvClosePort

(

HANDLE

hXcv

)

Definition at line 502 of file xcv.c.

{
    PLOCALMON_XCV pXcv = (PLOCALMON_XCV)hXcv;
 
    TRACE("LocalmonXcvClosePort(%p)\n", hXcv);
 
    // Sanity checks
    if (!pXcv)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    // Remove it from the list and free the memory.
    EnterCriticalSection(&pXcv->pLocalmon->Section);
    RemoveEntryList(&pXcv->Entry);
    LeaveCriticalSection(&pXcv->pLocalmon->Section);
    DllFreeSplMem(pXcv);
 
    SetLastError(ERROR_SUCCESS);
    return TRUE;
}

Referenced by LocalmonShutdown().

LocalmonXcvDataPort()

DWORD WINAPI LocalmonXcvDataPort	(	HANDLE	hXcv,
		PCWSTR	pszDataName,
		PBYTE	pInputData,
		DWORD	cbInputData,
		PBYTE	pOutputData,
		DWORD	cbOutputData,
		PDWORD	pcbOutputNeeded
	)

Definition at line 526 of file xcv.c.

{
    FIXME("LocalmonXcvDataPort(%p, %S, %p, %lu, %p, %lu, %p)\n", hXcv, pszDataName, pInputData, cbInputData, pOutputData, cbOutputData, pcbOutputNeeded);
 
    // Sanity checks
    if (!pszDataName)
        return ERROR_INVALID_PARAMETER;
 
    // Call the appropriate handler for the requested data name.
    if (wcscmp(pszDataName, L"AddPort") == 0)
        return _HandleAddPort((PLOCALMON_XCV)hXcv, pInputData, pcbOutputNeeded);
 
    if (wcscmp(pszDataName, L"ConfigureLPTPortCommandOK") == 0)
        return _HandleConfigureLPTPortCommandOK((PLOCALMON_XCV)hXcv, pInputData, pcbOutputNeeded);
 
    if (wcscmp(pszDataName, L"DeletePort") == 0)
        return _HandleDeletePort((PLOCALMON_XCV)hXcv, pInputData, pcbOutputNeeded);
 
    if (wcscmp(pszDataName, L"GetDefaultCommConfig") == 0)
        return _HandleGetDefaultCommConfig(pInputData, pOutputData, cbOutputData, pcbOutputNeeded);
 
    if (wcscmp(pszDataName, L"GetTransmissionRetryTimeout") == 0)
        return _HandleGetTransmissionRetryTimeout(pOutputData, cbOutputData, pcbOutputNeeded);
 
    if (wcscmp(pszDataName, L"MonitorUI") == 0)
        return _HandleMonitorUI(pOutputData, cbOutputData, pcbOutputNeeded);
 
    if (wcscmp(pszDataName, L"PortExists") == 0)
        return _HandlePortExists(pInputData, pOutputData, cbOutputData, pcbOutputNeeded);
 
    if (wcscmp(pszDataName, L"PortIsValid") == 0)
        return _HandlePortIsValid(pInputData, pOutputData, cbOutputData, pcbOutputNeeded);
 
    if (wcscmp(pszDataName, L"SetDefaultCommConfig") == 0)
        return _HandleSetDefaultCommConfig((PLOCALMON_XCV)hXcv, pInputData, pcbOutputNeeded);
 
    return ERROR_INVALID_PARAMETER;
}

LocalmonXcvOpenPort()

BOOL WINAPI LocalmonXcvOpenPort	(	HANDLE	hMonitor,
		PCWSTR	pszObject,
		ACCESS_MASK	GrantedAccess,
		PHANDLE	phXcv
	)

Definition at line 566 of file xcv.c.

{
    DWORD cbObject = 0;
    DWORD dwErrorCode;
    PLOCALMON_HANDLE pLocalmon = (PLOCALMON_HANDLE)hMonitor;
    PLOCALMON_XCV pXcv;
 
    FIXME("LocalmonXcvOpenPort(%p, %S, %lu, %p)\n", hMonitor, pwszObject, GrantedAccess, phXcv);
 
    // Sanity checks
    if (!pLocalmon || !phXcv)
    {
        dwErrorCode = ERROR_INVALID_PARAMETER;
        goto Cleanup;
    }
 
    if (pwszObject)
        cbObject = (wcslen(pwszObject) + 1) * sizeof(WCHAR);
 
    // Create a new LOCALMON_XCV structure and fill the relevant fields.
    pXcv = DllAllocSplMem(sizeof(LOCALMON_XCV) + cbObject);
    if (!pXcv)
    {
        dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
        ERR("DllAllocSplMem failed with error %lu!\n", GetLastError());
        goto Cleanup;
    }
 
    pXcv->pLocalmon = pLocalmon;
    pXcv->GrantedAccess = GrantedAccess;
 
    if (cbObject)
    {
        pXcv->pwszObject = (PWSTR)((PBYTE)pXcv + sizeof(LOCALMON_XCV));
        CopyMemory(pXcv->pwszObject, pwszObject, cbObject);
    }
 
    InsertTailList(&pLocalmon->XcvHandles, &pXcv->Entry);
 
    // Return it as the Xcv handle.
    *phXcv = (HANDLE)pXcv;
    dwErrorCode = ERROR_SUCCESS;
 
Cleanup:
    SetLastError(dwErrorCode);
    return (dwErrorCode == ERROR_SUCCESS);
}

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

localmon

)

Variable Documentation

cbLocalMonitor

DWORD cbLocalMonitor

extern

Definition at line 11 of file main.c.

Referenced by _LoadResources(), and _LocalmonGetPortLevel2().

cbLocalPort

DWORD cbLocalPort

extern

Definition at line 12 of file main.c.

Referenced by _LoadResources(), and _LocalmonGetPortLevel2().

pwszLocalMonitor

PCWSTR pwszLocalMonitor

extern

Definition at line 13 of file main.c.

Referenced by _LoadResources(), and _LocalmonGetPortLevel2().

pwszLocalPort

PCWSTR pwszLocalPort

extern

Definition at line 14 of file main.c.

Referenced by _LoadResources(), and _LocalmonGetPortLevel2().