system/wine
system/wine
1
0
Fork 0
mirror of git://source.winehq.org/git/wine.git synced 2024-10-15 04:27:17 +00:00
Code Issues Packages Projects Releases Wiki Activity

localspl: Convert MONITOREX structure to MONITOR2 during port monitor initialization.

Browse source
This commit is contained in:
Piotr Caban 2022-11-26 23:08:41 +01:00 committed by Alexandre Julliard
parent b1391caf64
commit f89a5fd458
1 changed files with 85 additions and 111 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

196
dlls/localspl/provider.c
View file

@ -193,14 +193,7 @@ typedef struct {
LPWSTR dllname;
PMONITORUI monitorUI;
MONITOR2 monitor;
BOOL (WINAPI *old_EnumPorts)(LPWSTR,DWORD,LPBYTE,DWORD,LPDWORD,LPDWORD);
BOOL (WINAPI *old_OpenPort)(LPWSTR,PHANDLE);
BOOL (WINAPI *old_OpenPortEx)(LPWSTR,LPWSTR,PHANDLE,struct _MONITOR *);
BOOL (WINAPI *old_AddPort)(LPWSTR,HWND,LPWSTR);
BOOL (WINAPI *old_AddPortEx)(LPWSTR,DWORD,LPBYTE,LPWSTR);
BOOL (WINAPI *old_ConfigurePort)(LPWSTR,HWND,LPWSTR);
BOOL (WINAPI *old_DeletePort)(LPWSTR,HWND,LPWSTR);
BOOL (WINAPI *old_XcvOpenPort)(LPCWSTR,ACCESS_MASK,PHANDLE);
const MONITOREX *monitorex;
HANDLE hmon;
HMODULE hdll;
DWORD refcount;
@ -529,6 +522,48 @@ static MONITORREG monreg =
QueryValue
};
static BOOL WINAPI monitor2_EnumPorts(HANDLE hmon, WCHAR *name, DWORD level,
BYTE *buf, DWORD size, DWORD *needed, DWORD *count)
{
return ((MONITOREX*)hmon)->Monitor.pfnEnumPorts(name, level,
buf, size, needed, count);
}
static BOOL WINAPI monitor2_OpenPort(HANDLE hmon, WCHAR *name, HANDLE *hport)
{
return ((MONITOREX*)hmon)->Monitor.pfnOpenPort(name, hport);
}
static BOOL WINAPI monitor2_AddPort(HANDLE hmon, WCHAR *name,
HWND hwnd, WCHAR *monitor_name)
{
return ((MONITOREX*)hmon)->Monitor.pfnAddPort(name, hwnd, monitor_name);
}
static BOOL WINAPI monitor2_AddPortEx(HANDLE hmon, WCHAR *name, DWORD level,
BYTE *buf, WCHAR *monitor_name)
{
return ((MONITOREX*)hmon)->Monitor.pfnAddPortEx(name, level, buf, monitor_name);
}
static BOOL WINAPI monitor2_ConfigurePort(HANDLE hmon, WCHAR *name,
HWND hwnd, WCHAR *port_name)
{
return ((MONITOREX*)hmon)->Monitor.pfnConfigurePort(name, hwnd, port_name);
}
static BOOL WINAPI monitor2_DeletePort(HANDLE hmon, WCHAR *name,
HWND hwnd, WCHAR *port_name)
{
return ((MONITOREX*)hmon)->Monitor.pfnDeletePort(name, hwnd, port_name);
}
static BOOL WINAPI monitor2_XcvOpenPort(HANDLE hmon, const WCHAR *obj,
ACCESS_MASK granted_access, HANDLE *hxcv)
{
return ((MONITOREX*)hmon)->Monitor.pfnXcvOpenPort(obj, granted_access, hxcv);
}
/******************************************************************
* monitor_load [internal]
*
@ -664,35 +699,39 @@ static monitor_t * monitor_load(LPCWSTR name, LPWSTR dllname)
}
}
else if (pInitializePrintMonitor && regroot) {
MONITOREX *pmonitorEx;
pmonitorEx = pInitializePrintMonitor(regroot);
pm->monitorex = pInitializePrintMonitor(regroot);
TRACE("%p: LPMONITOREX from %s,InitializePrintMonitor(%s)\n",
pmonitorEx, debugstr_w(driver), debugstr_w(regroot));
if (pmonitorEx)
pm->monitorex, debugstr_w(driver), debugstr_w(regroot));
if (pm->monitorex)
{
/* Layout of MONITOREX and MONITOR2 mostly matches */
memcpy(&pm->monitor, pmonitorEx, min(pmonitorEx->dwMonitorSize + sizeof(void *), sizeof(pm->monitor)));
/* MONITOREX.dwMonitorSize doesn't include the size field, while MONITOR2.cbSize does */
pm->monitor.cbSize += sizeof(void *);
pm->hmon = (HANDLE)pm->monitorex;
pm->old_EnumPorts = pmonitorEx->Monitor.pfnEnumPorts;
pm->old_OpenPort = pmonitorEx->Monitor.pfnOpenPort;
pm->old_OpenPortEx = pmonitorEx->Monitor.pfnOpenPortEx;
pm->old_AddPort = pmonitorEx->Monitor.pfnAddPort;
pm->old_AddPortEx = pmonitorEx->Monitor.pfnAddPortEx;
pm->old_ConfigurePort = pmonitorEx->Monitor.pfnConfigurePort;
pm->old_DeletePort = pmonitorEx->Monitor.pfnDeletePort;
pm->old_XcvOpenPort = pmonitorEx->Monitor.pfnXcvOpenPort;
pm->monitor.pfnEnumPorts = NULL;
pm->monitor.pfnOpenPort = NULL;
pm->monitor.pfnOpenPortEx = NULL;
pm->monitor.pfnAddPort = NULL;
pm->monitor.pfnAddPortEx = NULL;
pm->monitor.pfnConfigurePort = NULL;
pm->monitor.pfnDeletePort = NULL;
pm->monitor.pfnXcvOpenPort = NULL;
pm->monitor.cbSize = sizeof(pm->monitor);
if (pm->monitorex->Monitor.pfnEnumPorts)
pm->monitor.pfnEnumPorts = monitor2_EnumPorts;
if (pm->monitorex->Monitor.pfnOpenPort)
pm->monitor.pfnOpenPort = monitor2_OpenPort;
pm->monitor.pfnStartDocPort = pm->monitorex->Monitor.pfnStartDocPort;
pm->monitor.pfnWritePort = pm->monitorex->Monitor.pfnWritePort;
pm->monitor.pfnReadPort = pm->monitorex->Monitor.pfnReadPort;
pm->monitor.pfnEndDocPort = pm->monitorex->Monitor.pfnEndDocPort;
pm->monitor.pfnClosePort = pm->monitorex->Monitor.pfnClosePort;
if (pm->monitorex->Monitor.pfnAddPort)
pm->monitor.pfnAddPort = monitor2_AddPort;
if (pm->monitorex->Monitor.pfnAddPortEx)
pm->monitor.pfnAddPortEx = monitor2_AddPortEx;
if (pm->monitorex->Monitor.pfnConfigurePort)
pm->monitor.pfnConfigurePort = monitor2_ConfigurePort;
if (pm->monitorex->Monitor.pfnDeletePort)
pm->monitor.pfnDeletePort = monitor2_DeletePort;
pm->monitor.pfnGetPrinterDataFromPort =
pm->monitorex->Monitor.pfnGetPrinterDataFromPort;
pm->monitor.pfnSetPortTimeOuts = pm->monitorex->Monitor.pfnSetPortTimeOuts;
if (pm->monitorex->Monitor.pfnXcvOpenPort)
pm->monitor.pfnXcvOpenPort = monitor2_XcvOpenPort;
pm->monitor.pfnXcvDataPort = pm->monitorex->Monitor.pfnXcvDataPort;
pm->monitor.pfnXcvClosePort = pm->monitorex->Monitor.pfnXcvClosePort;
}
}
@ -787,8 +826,6 @@ static monitor_t * monitor_loadui(monitor_t * pm)
/* building (",XcvMonitor %s",pm->name) not needed yet */
if (pm->monitor.pfnXcvOpenPort)
res = pm->monitor.pfnXcvOpenPort(pm->hmon, L"", SERVER_ACCESS_ADMINISTER, &hXcv);
else if (pm->old_XcvOpenPort)
res = pm->old_XcvOpenPort(L"", SERVER_ACCESS_ADMINISTER, &hXcv);
TRACE("got %lu with %p\n", res, hXcv);
if (res) {
res = pm->monitor.pfnXcvDataPort(hXcv, L"MonitorUI", NULL, 0, (BYTE *) buffer, sizeof(buffer), &len);
@ -1105,19 +1142,6 @@ static DWORD get_local_printprocessors(LPWSTR regpathW, LPBYTE pPPInfo, DWORD cb
return needed;
}
static BOOL wrap_EnumPorts(monitor_t *pm, LPWSTR name, DWORD level, LPBYTE buffer,
DWORD size, LPDWORD needed, LPDWORD returned)
{
if (pm->monitor.pfnEnumPorts)
return pm->monitor.pfnEnumPorts(pm->hmon, name, level, buffer, size, needed, returned);
if (pm->old_EnumPorts)
return pm->old_EnumPorts(name, level, buffer, size, needed, returned);
WARN("EnumPorts is not implemented by monitor\n");
return FALSE;
}
/******************************************************************
* enumerate the local Ports from all loaded monitors (internal)
*
@ -1154,16 +1178,18 @@ static DWORD get_ports_from_all_monitors(DWORD level, LPBYTE pPorts, DWORD cbBuf
LIST_FOR_EACH_ENTRY(pm, &monitor_handles, monitor_t, entry)
{
if (pm->monitor.pfnEnumPorts || pm->old_EnumPorts) {
if (pm->monitor.pfnEnumPorts) {
pi_needed = 0;
pi_returned = 0;
res = wrap_EnumPorts(pm, NULL, level, pi_buffer, pi_allocated, &pi_needed, &pi_returned);
res = pm->monitor.pfnEnumPorts(pm->hmon, NULL, level, pi_buffer,
pi_allocated, &pi_needed, &pi_returned);
if (!res && (GetLastError() == ERROR_INSUFFICIENT_BUFFER)) {
/* Do not use realloc (we do not need the old data in the buffer) */
free(pi_buffer);
pi_buffer = malloc(pi_needed);
pi_allocated = (pi_buffer) ? pi_needed : 0;
res = wrap_EnumPorts(pm, NULL, level, pi_buffer, pi_allocated, &pi_needed, &pi_returned);
res = pm->monitor.pfnEnumPorts(pm->hmon, NULL, level,
pi_buffer, pi_allocated, &pi_needed, &pi_returned);
}
TRACE("(%s) got %ld with %ld (need %ld byte for %ld entries)\n",
debugstr_w(pm->name), res, GetLastError(), pi_needed, pi_returned);
@ -1451,10 +1477,6 @@ static HANDLE printer_alloc_handle(LPCWSTR name, LPPRINTER_DEFAULTSW pDefault)
printer->pm->monitor.pfnXcvOpenPort(printer->pm->hmon, &printername[len],
pDefault ? pDefault->DesiredAccess : 0,
&printer->hXcv);
else if (printer->pm->old_XcvOpenPort)
printer->pm->old_XcvOpenPort(&printername[len],
pDefault ? pDefault->DesiredAccess : 0,
&printer->hXcv);
if (printer->hXcv == NULL) {
printer_free(printer);
SetLastError(ERROR_INVALID_PARAMETER);
@ -1773,18 +1795,6 @@ static BOOL WINAPI fpAddMonitor(LPWSTR pName, DWORD Level, LPBYTE pMonitors)
return (res);
}
static BOOL wrap_AddPort(monitor_t *pm, LPWSTR name, HWND hwnd, LPWSTR monitor_name)
{
if (pm->monitor.pfnAddPort)
return pm->monitor.pfnAddPort(pm->hmon, name, hwnd, monitor_name);
if (pm->old_AddPort)
return pm->old_AddPort(name, hwnd, monitor_name);
WARN("AddPort is not implemented by monitor\n");
return FALSE;
}
/******************************************************************************
* fpAddPort [exported through PRINTPROVIDOR]
*
@ -1823,8 +1833,8 @@ static BOOL WINAPI fpAddPort(LPWSTR pName, HWND hWnd, LPWSTR pMonitorName)
}
pm = monitor_load(pMonitorName, NULL);
if (pm && (pm->monitor.pfnAddPort || pm->old_AddPort)) {
res = wrap_AddPort(pm, pName, hWnd, pMonitorName);
if (pm && pm->monitor.pfnAddPort) {
res = pm->monitor.pfnAddPort(pm->hmon, pName, hWnd, pMonitorName);
TRACE("got %ld with %lu (%s)\n", res, GetLastError(), debugstr_w(pm->dllname));
}
else
@ -1851,18 +1861,6 @@ static BOOL WINAPI fpAddPort(LPWSTR pName, HWND hWnd, LPWSTR pMonitorName)
return res;
}
static BOOL wrap_AddPortEx(monitor_t *pm, LPWSTR name, DWORD level, LPBYTE buffer, LPWSTR monitor_name)
{
if (pm->monitor.pfnAddPortEx)
return pm->monitor.pfnAddPortEx(pm->hmon, name, level, buffer, monitor_name);
if (pm->old_AddPortEx)
return pm->old_AddPortEx(name, level, buffer, monitor_name);
WARN("AddPortEx is not implemented by monitor\n");
return FALSE;
}
/******************************************************************************
* fpAddPortEx [exported through PRINTPROVIDOR]
*
@ -1912,9 +1910,9 @@ static BOOL WINAPI fpAddPortEx(LPWSTR pName, DWORD level, LPBYTE pBuffer, LPWSTR
/* load the Monitor */
pm = monitor_load(pMonitorName, NULL);
if (pm && (pm->monitor.pfnAddPortEx || pm->old_AddPortEx))
if (pm && pm->monitor.pfnAddPortEx)
{
res = wrap_AddPortEx(pm, pName, level, pBuffer, pMonitorName);
res = pm->monitor.pfnAddPortEx(pm->hmon, pName, level, pBuffer, pMonitorName);
TRACE("got %ld with %lu (%s)\n", res, GetLastError(), debugstr_w(pm->dllname));
}
else
@ -1989,18 +1987,6 @@ static BOOL WINAPI fpClosePrinter(HANDLE hPrinter)
return FALSE;
}
static BOOL wrap_ConfigurePort(monitor_t *pm, LPWSTR name, HWND hwnd, LPWSTR port_name)
{
if (pm->monitor.pfnConfigurePort)
return pm->monitor.pfnConfigurePort(pm->hmon, name, hwnd, port_name);
if (pm->old_ConfigurePort)
return pm->old_ConfigurePort(name, hwnd, port_name);
WARN("ConfigurePort is not implemented by monitor\n");
return FALSE;
}
/******************************************************************************
* fpConfigurePort [exported through PRINTPROVIDOR]
*
@ -2039,11 +2025,11 @@ static BOOL WINAPI fpConfigurePort(LPWSTR pName, HWND hWnd, LPWSTR pPortName)
}
pm = monitor_load_by_port(pPortName);
if (pm && (pm->monitor.pfnConfigurePort || pm->old_ConfigurePort))
if (pm && pm->monitor.pfnConfigurePort)
{
TRACE("use %s for %s (monitor %p: %s)\n", debugstr_w(pm->name),
debugstr_w(pPortName), pm, debugstr_w(pm->dllname));
res = wrap_ConfigurePort(pm, pName, hWnd, pPortName);
res = pm->monitor.pfnConfigurePort(pm->hmon, pName, hWnd, pPortName);
TRACE("got %ld with %lu\n", res, GetLastError());
}
else
@ -2145,18 +2131,6 @@ static BOOL WINAPI fpDeleteMonitor(LPWSTR pName, LPWSTR pEnvironment, LPWSTR pMo
return FALSE;
}
static BOOL wrap_DeletePort(monitor_t *pm, LPWSTR name, HWND hwnd, LPWSTR port_name)
{
if (pm->monitor.pfnDeletePort)
return pm->monitor.pfnDeletePort(pm->hmon, name, hwnd, port_name);
if (pm->old_ConfigurePort)
return pm->old_DeletePort(name, hwnd, port_name);
WARN("DeletePort is not implemented by monitor\n");
return FALSE;
}
/*****************************************************************************
* fpDeletePort [exported through PRINTPROVIDOR]
*
@ -2195,11 +2169,11 @@ static BOOL WINAPI fpDeletePort(LPWSTR pName, HWND hWnd, LPWSTR pPortName)
}
pm = monitor_load_by_port(pPortName);
if (pm && (pm->monitor.pfnDeletePort || pm->old_DeletePort))
if (pm && pm->monitor.pfnDeletePort)
{
TRACE("use %s for %s (monitor %p: %s)\n", debugstr_w(pm->name),
debugstr_w(pPortName), pm, debugstr_w(pm->dllname));
res = wrap_DeletePort(pm, pName, hWnd, pPortName);
res = pm->monitor.pfnDeletePort(pm->hmon, pName, hWnd, pPortName);
TRACE("got %ld with %lu\n", res, GetLastError());
}
else