projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Sync with trunk r58033.
[reactos.git] / dll / win32 / localspl / localmon.c
1 /*
2 * Implementation of the Local Printmonitor
3 *
4 * Copyright 2006 Detlef Riekenberg
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include <stdarg.h>
22
23 #define COBJMACROS
24 #define NONAMELESSUNION
25
26 #include "windef.h"
27 #include "winbase.h"
28 #include "wingdi.h"
29 #include "winuser.h"
30 #include "winreg.h"
31
32 #include "winspool.h"
33 #include "ddk/winsplp.h"
34 #include "localspl_private.h"
35
36 #include "wine/debug.h"
37 #include "wine/list.h"
38 #include "wine/unicode.h"
39
40
41 WINE_DEFAULT_DEBUG_CHANNEL(localspl);
42
43 /*****************************************************/
44
45 static CRITICAL_SECTION port_handles_cs;
46 static CRITICAL_SECTION_DEBUG port_handles_cs_debug =
47 {
48 0, 0, &port_handles_cs,
49 { &port_handles_cs_debug.ProcessLocksList, &port_handles_cs_debug.ProcessLocksList },
50 0, 0, { (DWORD_PTR)(__FILE__ ": port_handles_cs") }
51 };
52 static CRITICAL_SECTION port_handles_cs = { &port_handles_cs_debug, -1, 0, 0, 0, 0 };
53
54
55 static CRITICAL_SECTION xcv_handles_cs;
56 static CRITICAL_SECTION_DEBUG xcv_handles_cs_debug =
57 {
58 0, 0, &xcv_handles_cs,
59 { &xcv_handles_cs_debug.ProcessLocksList, &xcv_handles_cs_debug.ProcessLocksList },
60 0, 0, { (DWORD_PTR)(__FILE__ ": xcv_handles_cs") }
61 };
62 static CRITICAL_SECTION xcv_handles_cs = { &xcv_handles_cs_debug, -1, 0, 0, 0, 0 };
63
64 /* ############################### */
65
66 typedef struct {
67 struct list entry;
68 DWORD type;
69 WCHAR nameW[1];
70 } port_t;
71
72 typedef struct {
73 struct list entry;
74 ACCESS_MASK GrantedAccess;
75 WCHAR nameW[1];
76 } xcv_t;
77
78 static struct list port_handles = LIST_INIT( port_handles );
79 static struct list xcv_handles = LIST_INIT( xcv_handles );
80
81 /* ############################### */
82
83 static const WCHAR cmd_AddPortW[] = {'A','d','d','P','o','r','t',0};
84 static const WCHAR cmd_DeletePortW[] = {'D','e','l','e','t','e','P','o','r','t',0};
85 static const WCHAR cmd_ConfigureLPTPortCommandOKW[] = {'C','o','n','f','i','g','u','r','e',
86 'L','P','T','P','o','r','t',
87 'C','o','m','m','a','n','d','O','K',0};
88
89 static const WCHAR cmd_GetDefaultCommConfigW[] = {'G','e','t',
90 'D','e','f','a','u','l','t',
91 'C','o','m','m','C','o','n','f','i','g',0};
92
93 static const WCHAR cmd_GetTransmissionRetryTimeoutW[] = {'G','e','t',
94 'T','r','a','n','s','m','i','s','s','i','o','n',
95 'R','e','t','r','y','T','i','m','e','o','u','t',0};
96
97 static const WCHAR cmd_MonitorUIW[] = {'M','o','n','i','t','o','r','U','I',0};
98 static const WCHAR cmd_PortIsValidW[] = {'P','o','r','t','I','s','V','a','l','i','d',0};
99 static const WCHAR cmd_SetDefaultCommConfigW[] = {'S','e','t',
100 'D','e','f','a','u','l','t',
101 'C','o','m','m','C','o','n','f','i','g',0};
102
103 static const WCHAR dllnameuiW[] = {'l','o','c','a','l','u','i','.','d','l','l',0};
104 static const WCHAR emptyW[] = {0};
105 static const WCHAR LocalPortW[] = {'L','o','c','a','l',' ','P','o','r','t',0};
106
107 static const WCHAR portname_LPT[] = {'L','P','T',0};
108 static const WCHAR portname_COM[] = {'C','O','M',0};
109 static const WCHAR portname_FILE[] = {'F','I','L','E',':',0};
110 static const WCHAR portname_CUPS[] = {'C','U','P','S',':',0};
111 static const WCHAR portname_LPR[] = {'L','P','R',':',0};
112
113 static const WCHAR TransmissionRetryTimeoutW[] = {'T','r','a','n','s','m','i','s','s','i','o','n',
114 'R','e','t','r','y','T','i','m','e','o','u','t',0};
115
116 static const WCHAR WinNT_CV_PortsW[] = {'S','o','f','t','w','a','r','e','\\',
117 'M','i','c','r','o','s','o','f','t','\\',
118 'W','i','n','d','o','w','s',' ','N','T','\\',
119 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
120 'P','o','r','t','s',0};
121
122 static const WCHAR WinNT_CV_WindowsW[] = {'S','o','f','t','w','a','r','e','\\',
123 'M','i','c','r','o','s','o','f','t','\\',
124 'W','i','n','d','o','w','s',' ','N','T','\\',
125 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
126 'W','i','n','d','o','w','s',0};
127
128
129 /******************************************************************
130 * does_port_exist (internal)
131 *
132 * returns TRUE, when the Port already exists
133 *
134 */
135 static BOOL does_port_exist(LPCWSTR myname)
136 {
137
138 LPPORT_INFO_1W pi;
139 DWORD needed = 0;
140 DWORD returned;
141 DWORD id;
142
143 TRACE("(%s)\n", debugstr_w(myname));
144
145 id = EnumPortsW(NULL, 1, NULL, 0, &needed, &returned);
146 pi = heap_alloc(needed);
147 returned = 0;
148 if (pi)
149 id = EnumPortsW(NULL, 1, (LPBYTE) pi, needed, &needed, &returned);
150
151 if (id && returned > 0) {
152 /* we got a number of valid names. */
153 for (id = 0; id < returned; id++)
154 {
155 if (lstrcmpiW(myname, pi[id].pName) == 0) {
156 TRACE("(%u) found %s\n", id, debugstr_w(pi[id].pName));
157 heap_free(pi);
158 return TRUE;
159 }
160 }
161 }
162
163 heap_free(pi);
164 return FALSE;
165 }
166
167 /******************************************************************
168 * enumerate the local Ports from the Registry (internal)
169 *
170 * See localmon_EnumPortsW.
171 *
172 * NOTES
173 * returns the needed size (in bytes) for pPorts
174 * and *lpreturned is set to number of entries returned in pPorts
175 *
176 */
177
178 static DWORD get_ports_from_reg(DWORD level, LPBYTE pPorts, DWORD cbBuf, LPDWORD lpreturned)
179 {
180 HKEY hroot = 0;
181 LPWSTR ptr;
182 LPPORT_INFO_2W out;
183 WCHAR portname[MAX_PATH];
184 WCHAR res_PortW[IDS_LOCALPORT_MAXLEN];
185 WCHAR res_MonitorW[IDS_LOCALMONITOR_MAXLEN];
186 INT reslen_PortW;
187 INT reslen_MonitorW;
188 DWORD len;
189 DWORD res;
190 DWORD needed = 0;
191 DWORD numentries;
192 DWORD entrysize;
193 DWORD id = 0;
194
195 TRACE("(%d, %p, %d, %p)\n", level, pPorts, cbBuf, lpreturned);
196
197 entrysize = (level == 1) ? sizeof(PORT_INFO_1W) : sizeof(PORT_INFO_2W);
198
199 numentries = *lpreturned; /* this is 0, when we scan the registry */
200 needed = entrysize * numentries;
201 ptr = (LPWSTR) &pPorts[needed];
202
203 if (needed > cbBuf) pPorts = NULL; /* No buffer for the structs */
204
205 numentries = 0;
206 needed = 0;
207
208 /* we do not check more parameters as done in windows */
209 if ((level < 1) || (level > 2)) {
210 goto getports_cleanup;
211 }
212
213 /* "+1" for '\0' */
214 reslen_MonitorW = LoadStringW(LOCALSPL_hInstance, IDS_LOCALMONITOR, res_MonitorW, IDS_LOCALMONITOR_MAXLEN) + 1;
215 reslen_PortW = LoadStringW(LOCALSPL_hInstance, IDS_LOCALPORT, res_PortW, IDS_LOCALPORT_MAXLEN) + 1;
216
217 res = RegOpenKeyW(HKEY_LOCAL_MACHINE, WinNT_CV_PortsW, &hroot);
218 if (res == ERROR_SUCCESS) {
219
220 /* Scan all Port-Names */
221 while (res == ERROR_SUCCESS) {
222 len = MAX_PATH;
223 portname[0] = '\0';
224 res = RegEnumValueW(hroot, id, portname, &len, NULL, NULL, NULL, NULL);
225
226 if ((res == ERROR_SUCCESS) && (portname[0])) {
227 numentries++;
228 /* calculate the required size */
229 needed += entrysize;
230 needed += (len + 1) * sizeof(WCHAR);
231 if (level > 1) {
232 needed += (reslen_MonitorW + reslen_PortW) * sizeof(WCHAR);
233 }
234
235 /* Now fill the user-buffer, if available */
236 if (pPorts && (cbBuf >= needed)){
237 out = (LPPORT_INFO_2W) pPorts;
238 pPorts += entrysize;
239 TRACE("%p: writing PORT_INFO_%dW #%d (%s)\n", out, level, numentries, debugstr_w(portname));
240 out->pPortName = ptr;
241 lstrcpyW(ptr, portname); /* Name of the Port */
242 ptr += (len + 1);
243 if (level > 1) {
244 out->pMonitorName = ptr;
245 lstrcpyW(ptr, res_MonitorW); /* Name of the Monitor */
246 ptr += reslen_MonitorW;
247
248 out->pDescription = ptr;
249 lstrcpyW(ptr, res_PortW); /* Port Description */
250 ptr += reslen_PortW;
251
252 out->fPortType = PORT_TYPE_WRITE;
253 out->Reserved = 0;
254 }
255 }
256 id++;
257 }
258 }
259 RegCloseKey(hroot);
260 }
261 else
262 {
263 ERR("failed with %d for %s\n", res, debugstr_w(WinNT_CV_PortsW));
264 SetLastError(res);
265 }
266
267 getports_cleanup:
268 *lpreturned = numentries;
269 TRACE("need %d byte for %d entries (%d)\n", needed, numentries, GetLastError());
270 return needed;
271 }
272
273 /*****************************************************
274 * get_type_from_name (internal)
275 *
276 */
277
278 static DWORD get_type_from_name(LPCWSTR name)
279 {
280 HANDLE hfile;
281
282 if (!strncmpW(name, portname_LPT, sizeof(portname_LPT) / sizeof(WCHAR) -1))
283 return PORT_IS_LPT;
284
285 if (!strncmpW(name, portname_COM, sizeof(portname_COM) / sizeof(WCHAR) -1))
286 return PORT_IS_COM;
287
288 if (!strcmpW(name, portname_FILE))
289 return PORT_IS_FILE;
290
291 if (name[0] == '/')
292 return PORT_IS_UNIXNAME;
293
294 if (name[0] == '|')
295 return PORT_IS_PIPE;
296
297 if (!strncmpW(name, portname_CUPS, sizeof(portname_CUPS) / sizeof(WCHAR) -1))
298 return PORT_IS_CUPS;
299
300 if (!strncmpW(name, portname_LPR, sizeof(portname_LPR) / sizeof(WCHAR) -1))
301 return PORT_IS_LPR;
302
303 /* Must be a file or a directory. Does the file exist ? */
304 hfile = CreateFileW(name, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
305 TRACE("%p for OPEN_EXISTING on %s\n", hfile, debugstr_w(name));
306 if (hfile == INVALID_HANDLE_VALUE) {
307 /* Can we create the file? */
308 hfile = CreateFileW(name, GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_FLAG_DELETE_ON_CLOSE, NULL);
309 TRACE("%p for OPEN_ALWAYS\n", hfile);
310 }
311 if (hfile != INVALID_HANDLE_VALUE) {
312 CloseHandle(hfile);
313 return PORT_IS_FILENAME;
314 }
315 /* We can't use the name. use GetLastError() for the reason */
316 return PORT_IS_UNKNOWN;
317 }
318
319 /*****************************************************
320 * get_type_from_local_name (internal)
321 *
322 */
323
324 static DWORD get_type_from_local_name(LPCWSTR nameW)
325 {
326 LPPORT_INFO_1W pi;
327 LPWSTR myname = NULL;
328 DWORD needed = 0;
329 DWORD numentries = 0;
330 DWORD id = 0;
331
332 TRACE("(%s)\n", debugstr_w(myname));
333
334 needed = get_ports_from_reg(1, NULL, 0, &numentries);
335 pi = heap_alloc(needed);
336 if (pi)
337 needed = get_ports_from_reg(1, (LPBYTE) pi, needed, &numentries);
338
339 if (pi && needed && numentries > 0) {
340 /* we got a number of valid ports. */
341
342 while ((myname == NULL) && (id < numentries))
343 {
344 if (lstrcmpiW(nameW, pi[id].pName) == 0) {
345 TRACE("(%u) found %s\n", id, debugstr_w(pi[id].pName));
346 myname = pi[id].pName;
347 }
348 id++;
349 }
350 }
351
352 id = (myname) ? get_type_from_name(myname) : PORT_IS_UNKNOWN;
353
354 heap_free(pi);
355 return id;
356
357 }
358 /******************************************************************************
359 * localmon_AddPortExW [exported through MONITOREX]
360 *
361 * Add a Port, without presenting a user interface
362 *
363 * PARAMS
364 * pName [I] Servername or NULL (local Computer)
365 * level [I] Structure-Level (1) for pBuffer
366 * pBuffer [I] PTR to the Input-Data (PORT_INFO_1)
367 * pMonitorName [I] Name of the Monitor that manage the Port
368 *
369 * RETURNS
370 * Success: TRUE
371 * Failure: FALSE
372 *
373 * NOTES
374 * Level 2 is documented on MSDN for Portmonitors, but not supported by the
375 * "Local Port" Portmonitor (localspl.dll / localmon.dll)
376 */
377 static BOOL WINAPI localmon_AddPortExW(LPWSTR pName, DWORD level, LPBYTE pBuffer, LPWSTR pMonitorName)
378 {
379 PORT_INFO_1W * pi;
380 HKEY hroot;
381 DWORD res;
382
383 pi = (PORT_INFO_1W *) pBuffer;
384 TRACE("(%s, %d, %p, %s) => %s\n", debugstr_w(pName), level, pBuffer,
385 debugstr_w(pMonitorName), debugstr_w(pi ? pi->pName : NULL));
386
387
388 if ((pMonitorName == NULL) || (lstrcmpiW(pMonitorName, LocalPortW) != 0 ) ||
389 (pi == NULL) || (pi->pName == NULL) || (pi->pName[0] == '\0') ) {
390 SetLastError(ERROR_INVALID_PARAMETER);
391 return FALSE;
392 }
393
394 if (level != 1) {
395 SetLastError(ERROR_INVALID_LEVEL);
396 return FALSE;
397 }
398
399 res = RegOpenKeyW(HKEY_LOCAL_MACHINE, WinNT_CV_PortsW, &hroot);
400 if (res == ERROR_SUCCESS) {
401 if (does_port_exist(pi->pName)) {
402 RegCloseKey(hroot);
403 TRACE("=> FALSE with %u\n", ERROR_INVALID_PARAMETER);
404 SetLastError(ERROR_INVALID_PARAMETER);
405 return FALSE;
406 }
407 res = RegSetValueExW(hroot, pi->pName, 0, REG_SZ, (const BYTE *) emptyW, sizeof(emptyW));
408 RegCloseKey(hroot);
409 }
410 if (res != ERROR_SUCCESS) SetLastError(ERROR_INVALID_PARAMETER);
411 TRACE("=> %u with %u\n", (res == ERROR_SUCCESS), GetLastError());
412 return (res == ERROR_SUCCESS);
413 }
414
415 /*****************************************************
416 * localmon_ClosePort [exported through MONITOREX]
417 *
418 * Close a
419 *
420 * PARAMS
421 * hPort [i] The Handle to close
422 *
423 * RETURNS
424 * Success: TRUE
425 * Failure: FALSE
426 *
427 */
428 static BOOL WINAPI localmon_ClosePort(HANDLE hPort)
429 {
430 port_t * port = hPort;
431
432 TRACE("(%p)\n", port);
433 EnterCriticalSection(&port_handles_cs);
434 list_remove(&port->entry);
435 LeaveCriticalSection(&port_handles_cs);
436 heap_free(port);
437 return TRUE;
438 }
439
440 /*****************************************************
441 * localmon_EnumPortsW [exported through MONITOREX]
442 *
443 * Enumerate all local Ports
444 *
445 * PARAMS
446 * pName [I] Servername (ignored)
447 * level [I] Structure-Level (1 or 2)
448 * pPorts [O] PTR to Buffer that receives the Result
449 * cbBuf [I] Size of Buffer at pPorts
450 * pcbNeeded [O] PTR to DWORD that receives the size in Bytes used / required for pPorts
451 * pcReturned [O] PTR to DWORD that receives the number of Ports in pPorts
452 *
453 * RETURNS
454 * Success: TRUE
455 * Failure: FALSE and in pcbNeeded the Bytes required for pPorts, if cbBuf is too small
456 *
457 * NOTES
458 *| Windows ignores pName
459 *| Windows crash the app, when pPorts, pcbNeeded or pcReturned are NULL
460 *| Windows >NT4.0 does not check for illegal levels (TRUE is returned)
461 *
462 * ToDo
463 * "HCU\Software\Wine\Spooler\<portname>" - redirection
464 *
465 */
466 static BOOL WINAPI localmon_EnumPortsW(LPWSTR pName, DWORD level, LPBYTE pPorts,
467 DWORD cbBuf, LPDWORD pcbNeeded, LPDWORD pcReturned)
468 {
469 BOOL res = FALSE;
470 DWORD needed;
471 DWORD numentries;
472
473 TRACE("(%s, %d, %p, %d, %p, %p)\n",
474 debugstr_w(pName), level, pPorts, cbBuf, pcbNeeded, pcReturned);
475
476 numentries = 0;
477 needed = get_ports_from_reg(level, NULL, 0, &numentries);
478 /* we calculated the needed buffersize. now do the error-checks */
479 if (cbBuf < needed) {
480 SetLastError(ERROR_INSUFFICIENT_BUFFER);
481 goto cleanup;
482 }
483
484 /* fill the buffer with the Port-Names */
485 needed = get_ports_from_reg(level, pPorts, cbBuf, &numentries);
486 res = TRUE;
487
488 if (pcReturned) *pcReturned = numentries;
489
490 cleanup:
491 if (pcbNeeded) *pcbNeeded = needed;
492
493 TRACE("returning %d with %d (%d byte for %d entries)\n",
494 res, GetLastError(), needed, numentries);
495
496 return (res);
497 }
498
499 /*****************************************************
500 * localmon_OpenPort [exported through MONITOREX]
501 *
502 * Open a Data-Channel for a Port
503 *
504 * PARAMS
505 * pName [i] Name of selected Object
506 * phPort [o] The resulting Handle is stored here
507 *
508 * RETURNS
509 * Success: TRUE
510 * Failure: FALSE
511 *
512 */
513 static BOOL WINAPI localmon_OpenPortW(LPWSTR pName, PHANDLE phPort)
514 {
515 port_t * port;
516 DWORD len;
517 DWORD type;
518
519 TRACE("%s, %p)\n", debugstr_w(pName), phPort);
520
521 /* an empty name is invalid */
522 if (!pName[0]) return FALSE;
523
524 /* does the port exist? */
525 type = get_type_from_local_name(pName);
526 if (!type) return FALSE;
527
528 len = (lstrlenW(pName) + 1) * sizeof(WCHAR);
529 port = heap_alloc(sizeof(port_t) + len);
530 if (!port) return FALSE;
531
532 port->type = type;
533 memcpy(port->nameW, pName, len);
534 *phPort = port;
535
536 EnterCriticalSection(&port_handles_cs);
537 list_add_tail(&port_handles, &port->entry);
538 LeaveCriticalSection(&port_handles_cs);
539
540 TRACE("=> %p\n", port);
541 return TRUE;
542 }
543
544 /*****************************************************
545 * localmon_XcvClosePort [exported through MONITOREX]
546 *
547 * Close a Communication-Channel
548 *
549 * PARAMS
550 * hXcv [i] The Handle to close
551 *
552 * RETURNS
553 * Success: TRUE
554 * Failure: FALSE
555 *
556 */
557 static BOOL WINAPI localmon_XcvClosePort(HANDLE hXcv)
558 {
559 xcv_t * xcv = hXcv;
560
561 TRACE("(%p)\n", xcv);
562 /* No checks are done in Windows */
563 EnterCriticalSection(&xcv_handles_cs);
564 list_remove(&xcv->entry);
565 LeaveCriticalSection(&xcv_handles_cs);
566 heap_free(xcv);
567 return TRUE;
568 }
569
570 /*****************************************************
571 * localmon_XcvDataPort [exported through MONITOREX]
572 *
573 * Execute command through a Communication-Channel
574 *
575 * PARAMS
576 * hXcv [i] The Handle to work with
577 * pszDataName [i] Name of the command to execute
578 * pInputData [i] Buffer for extra Input Data (needed only for some commands)
579 * cbInputData [i] Size in Bytes of Buffer at pInputData
580 * pOutputData [o] Buffer to receive additional Data (needed only for some commands)
581 * cbOutputData [i] Size in Bytes of Buffer at pOutputData
582 * pcbOutputNeeded [o] PTR to receive the minimal Size in Bytes of the Buffer at pOutputData
583 *
584 * RETURNS
585 * Success: ERROR_SUCCESS
586 * Failure: win32 error code
587 *
588 * NOTES
589 *
590 * Minimal List of commands, that every Printmonitor DLL should support:
591 *
592 *| "MonitorUI" : Return the Name of the Userinterface-DLL as WSTR in pOutputData
593 *| "AddPort" : Add a Port (Name as WSTR in pInputData)
594 *| "DeletePort": Delete a Port (Name as WSTR in pInputData)
595 *
596 *
597 */
598 static DWORD WINAPI localmon_XcvDataPort(HANDLE hXcv, LPCWSTR pszDataName, PBYTE pInputData, DWORD cbInputData,
599 PBYTE pOutputData, DWORD cbOutputData, PDWORD pcbOutputNeeded)
600 {
601 WCHAR buffer[16]; /* buffer for a decimal number */
602 LPWSTR ptr;
603 DWORD res;
604 DWORD needed;
605 HKEY hroot;
606
607 TRACE("(%p, %s, %p, %d, %p, %d, %p)\n", hXcv, debugstr_w(pszDataName),
608 pInputData, cbInputData, pOutputData, cbOutputData, pcbOutputNeeded);
609
610 if (!lstrcmpW(pszDataName, cmd_AddPortW)) {
611 TRACE("InputData (%d): %s\n", cbInputData, debugstr_w( (LPWSTR) pInputData));
612 res = RegOpenKeyW(HKEY_LOCAL_MACHINE, WinNT_CV_PortsW, &hroot);
613 if (res == ERROR_SUCCESS) {
614 if (does_port_exist((LPWSTR) pInputData)) {
615 RegCloseKey(hroot);
616 TRACE("=> %u\n", ERROR_ALREADY_EXISTS);
617 return ERROR_ALREADY_EXISTS;
618 }
619 res = RegSetValueExW(hroot, (LPWSTR) pInputData, 0, REG_SZ, (const BYTE *) emptyW, sizeof(emptyW));
620 RegCloseKey(hroot);
621 }
622 TRACE("=> %u\n", res);
623 return res;
624 }
625
626
627 if (!lstrcmpW(pszDataName, cmd_ConfigureLPTPortCommandOKW)) {
628 TRACE("InputData (%d): %s\n", cbInputData, debugstr_w( (LPWSTR) pInputData));
629 res = RegCreateKeyW(HKEY_LOCAL_MACHINE, WinNT_CV_WindowsW, &hroot);
630 if (res == ERROR_SUCCESS) {
631 res = RegSetValueExW(hroot, TransmissionRetryTimeoutW, 0, REG_SZ, pInputData, cbInputData);
632 RegCloseKey(hroot);
633 }
634 return res;
635 }
636
637 if (!lstrcmpW(pszDataName, cmd_DeletePortW)) {
638 TRACE("InputData (%d): %s\n", cbInputData, debugstr_w( (LPWSTR) pInputData));
639 res = RegOpenKeyW(HKEY_LOCAL_MACHINE, WinNT_CV_PortsW, &hroot);
640 if (res == ERROR_SUCCESS) {
641 res = RegDeleteValueW(hroot, (LPWSTR) pInputData);
642 RegCloseKey(hroot);
643 TRACE("=> %u with %u\n", res, GetLastError() );
644 return res;
645 }
646 return ERROR_FILE_NOT_FOUND;
647 }
648
649 if (!lstrcmpW(pszDataName, cmd_GetDefaultCommConfigW)) {
650 TRACE("InputData (%d): %s\n", cbInputData, debugstr_w( (LPWSTR) pInputData));
651 *pcbOutputNeeded = cbOutputData;
652 res = GetDefaultCommConfigW((LPWSTR) pInputData, (LPCOMMCONFIG) pOutputData, pcbOutputNeeded);
653 TRACE("got %u with %u\n", res, GetLastError() );
654 return res ? ERROR_SUCCESS : GetLastError();
655 }
656
657 if (!lstrcmpW(pszDataName, cmd_GetTransmissionRetryTimeoutW)) {
658 * pcbOutputNeeded = sizeof(DWORD);
659 if (cbOutputData >= sizeof(DWORD)) {
660 /* the w2k resource kit documented a default of 90, but that's wrong */
661 *((LPDWORD) pOutputData) = 45;
662
663 res = RegOpenKeyW(HKEY_LOCAL_MACHINE, WinNT_CV_WindowsW, &hroot);
664 if (res == ERROR_SUCCESS) {
665 needed = sizeof(buffer) - sizeof(WCHAR);
666 res = RegQueryValueExW(hroot, TransmissionRetryTimeoutW, NULL, NULL, (LPBYTE) buffer, &needed);
667 if ((res == ERROR_SUCCESS) && (buffer[0])) {
668 *((LPDWORD) pOutputData) = strtoulW(buffer, NULL, 0);
669 }
670 RegCloseKey(hroot);
671 }
672 return ERROR_SUCCESS;
673 }
674 return ERROR_INSUFFICIENT_BUFFER;
675 }
676
677
678 if (!lstrcmpW(pszDataName, cmd_MonitorUIW)) {
679 * pcbOutputNeeded = sizeof(dllnameuiW);
680 if (cbOutputData >= sizeof(dllnameuiW)) {
681 memcpy(pOutputData, dllnameuiW, sizeof(dllnameuiW));
682 return ERROR_SUCCESS;
683 }
684 return ERROR_INSUFFICIENT_BUFFER;
685 }
686
687 if (!lstrcmpW(pszDataName, cmd_PortIsValidW)) {
688 TRACE("InputData (%d): %s\n", cbInputData, debugstr_w( (LPWSTR) pInputData));
689 res = get_type_from_name((LPCWSTR) pInputData);
690 TRACE("detected as %u\n", res);
691 /* names, that we have recognized, are valid */
692 if (res) return ERROR_SUCCESS;
693
694 /* ERROR_ACCESS_DENIED, ERROR_PATH_NOT_FOUND or something else */
695 TRACE("=> %u\n", GetLastError());
696 return GetLastError();
697 }
698
699 if (!lstrcmpW(pszDataName, cmd_SetDefaultCommConfigW)) {
700 /* get the portname from the Handle */
701 ptr = strchrW(((xcv_t *)hXcv)->nameW, ' ');
702 if (ptr) {
703 ptr++; /* skip the space */
704 }
705 else
706 {
707 ptr = ((xcv_t *)hXcv)->nameW;
708 }
709 lstrcpynW(buffer, ptr, sizeof(buffer)/sizeof(WCHAR));
710 if (buffer[0]) buffer[lstrlenW(buffer)-1] = '\0'; /* remove the ':' */
711 res = SetDefaultCommConfigW(buffer, (LPCOMMCONFIG) pInputData, cbInputData);
712 TRACE("got %u with %u\n", res, GetLastError() );
713 return res ? ERROR_SUCCESS : GetLastError();
714 }
715
716 FIXME("command not supported: %s\n", debugstr_w(pszDataName));
717 return ERROR_INVALID_PARAMETER;
718 }
719
720 /*****************************************************
721 * localmon_XcvOpenPort [exported through MONITOREX]
722 *
723 * Open a Communication-Channel
724 *
725 * PARAMS
726 * pName [i] Name of selected Object
727 * GrantedAccess [i] Access-Rights to use
728 * phXcv [o] The resulting Handle is stored here
729 *
730 * RETURNS
731 * Success: TRUE
732 * Failure: FALSE
733 *
734 */
735 static BOOL WINAPI localmon_XcvOpenPort(LPCWSTR pName, ACCESS_MASK GrantedAccess, PHANDLE phXcv)
736 {
737 DWORD len;
738 xcv_t * xcv;
739
740 TRACE("%s, 0x%x, %p)\n", debugstr_w(pName), GrantedAccess, phXcv);
741 /* No checks for any field is done in Windows */
742 len = (lstrlenW(pName) + 1) * sizeof(WCHAR);
743 xcv = heap_alloc( sizeof(xcv_t) + len);
744 if (xcv) {
745 xcv->GrantedAccess = GrantedAccess;
746 memcpy(xcv->nameW, pName, len);
747 *phXcv = xcv;
748 EnterCriticalSection(&xcv_handles_cs);
749 list_add_tail(&xcv_handles, &xcv->entry);
750 LeaveCriticalSection(&xcv_handles_cs);
751 TRACE("=> %p\n", xcv);
752 return TRUE;
753 }
754 else
755 {
756 *phXcv = NULL;
757 return FALSE;
758 }
759 }
760
761 /*****************************************************
762 * InitializePrintMonitor (LOCALSPL.@)
763 *
764 * Initialize the Monitor for the Local Ports
765 *
766 * PARAMS
767 * regroot [I] Registry-Path, where the settings are stored
768 *
769 * RETURNS
770 * Success: Pointer to a MONITOREX Structure
771 * Failure: NULL
772 *
773 * NOTES
774 * The fixed location "HKLM\Software\Microsoft\Windows NT\CurrentVersion\Ports"
775 * is used to store the Ports (IniFileMapping from "win.ini", Section "Ports").
776 * Native localspl.dll fails, when no valid Port-Entry is present.
777 *
778 */
779
780 LPMONITOREX WINAPI InitializePrintMonitor(LPWSTR regroot)
781 {
782 static MONITOREX mymonitorex =
783 {
784 sizeof(MONITOREX) - sizeof(DWORD),
785 {
786 localmon_EnumPortsW,
787 localmon_OpenPortW,
788 NULL, /* localmon_OpenPortExW */
789 NULL, /* localmon_StartDocPortW */
790 NULL, /* localmon_WritePortW */
791 NULL, /* localmon_ReadPortW */
792 NULL, /* localmon_EndDocPortW */
793 localmon_ClosePort,
794 NULL, /* Use AddPortUI in localui.dll */
795 localmon_AddPortExW,
796 NULL, /* Use ConfigurePortUI in localui.dll */
797 NULL, /* Use DeletePortUI in localui.dll */
798 NULL, /* localmon_GetPrinterDataFromPort */
799 NULL, /* localmon_SetPortTimeOuts */
800 localmon_XcvOpenPort,
801 localmon_XcvDataPort,
802 localmon_XcvClosePort
803 }
804 };
805
806 TRACE("(%s)\n", debugstr_w(regroot));
807 /* Parameter "regroot" is ignored on NT4.0 (localmon.dll) */
808 if (!regroot || !regroot[0]) {
809 SetLastError(ERROR_INVALID_PARAMETER);
810 return NULL;
811 }
812 TRACE("=> %p\n", &mymonitorex);
813 /* Native windows returns always the same pointer on success */
814 return &mymonitorex;
815 }
A free Windows-compatible Operating System