[LOCALSPL_WINETEST] Sync with Wine Staging 3.3. CORE-14434
[reactos.git] / modules / rostests / winetests / localspl / localmon.c
1 /*
2 * Unit test suite for localspl API functions: local print monitor
3 *
4 * Copyright 2006-2007 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
22 #include <stdarg.h>
23
24 #include "windef.h"
25 #include "winbase.h"
26 #include "winerror.h"
27 #include "wingdi.h"
28 #include "winreg.h"
29
30 #include "winspool.h"
31 #include "ddk/winsplp.h"
32
33 #include "wine/test.h"
34
35
36 /* ##### */
37
38 static HMODULE hdll;
39 static HMODULE hlocalmon;
40 static LPMONITOREX (WINAPI *pInitializePrintMonitor)(LPWSTR);
41
42 static LPMONITOREX pm;
43 static BOOL (WINAPI *pEnumPorts)(LPWSTR, DWORD, LPBYTE, DWORD, LPDWORD, LPDWORD);
44 static BOOL (WINAPI *pOpenPort)(LPWSTR, PHANDLE);
45 static BOOL (WINAPI *pOpenPortEx)(LPWSTR, LPWSTR, PHANDLE, struct _MONITOR *);
46 static BOOL (WINAPI *pStartDocPort)(HANDLE, LPWSTR, DWORD, DWORD, LPBYTE);
47 static BOOL (WINAPI *pWritePort)(HANDLE hPort, LPBYTE, DWORD, LPDWORD);
48 static BOOL (WINAPI *pReadPort)(HANDLE hPort, LPBYTE, DWORD, LPDWORD);
49 static BOOL (WINAPI *pEndDocPort)(HANDLE);
50 static BOOL (WINAPI *pClosePort)(HANDLE);
51 static BOOL (WINAPI *pAddPort)(LPWSTR, HWND, LPWSTR);
52 static BOOL (WINAPI *pAddPortEx)(LPWSTR, DWORD, LPBYTE, LPWSTR);
53 static BOOL (WINAPI *pConfigurePort)(LPWSTR, HWND, LPWSTR);
54 static BOOL (WINAPI *pDeletePort)(LPWSTR, HWND, LPWSTR);
55 static BOOL (WINAPI *pGetPrinterDataFromPort)(HANDLE, DWORD, LPWSTR, LPWSTR, DWORD, LPWSTR, DWORD, LPDWORD);
56 static BOOL (WINAPI *pSetPortTimeOuts)(HANDLE, LPCOMMTIMEOUTS, DWORD);
57 static BOOL (WINAPI *pXcvOpenPort)(LPCWSTR, ACCESS_MASK, PHANDLE phXcv);
58 static DWORD (WINAPI *pXcvDataPort)(HANDLE, LPCWSTR, PBYTE, DWORD, PBYTE, DWORD, PDWORD);
59 static BOOL (WINAPI *pXcvClosePort)(HANDLE);
60
61 static HANDLE hXcv;
62 static HANDLE hXcv_noaccess;
63
64 /* ########################### */
65
66 static const WCHAR cmd_AddPortW[] = {'A','d','d','P','o','r','t',0};
67 static const WCHAR cmd_ConfigureLPTPortCommandOKW[] = {'C','o','n','f','i','g','u','r','e',
68 'L','P','T','P','o','r','t',
69 'C','o','m','m','a','n','d','O','K',0};
70 static const WCHAR cmd_DeletePortW[] = {'D','e','l','e','t','e','P','o','r','t',0};
71 static const WCHAR cmd_GetTransmissionRetryTimeoutW[] = {'G','e','t',
72 'T','r','a','n','s','m','i','s','s','i','o','n',
73 'R','e','t','r','y','T','i','m','e','o','u','t',0};
74
75 static const WCHAR cmd_MonitorUIW[] = {'M','o','n','i','t','o','r','U','I',0};
76 static const WCHAR cmd_MonitorUI_lcaseW[] = {'m','o','n','i','t','o','r','u','i',0};
77 static const WCHAR cmd_PortIsValidW[] = {'P','o','r','t','I','s','V','a','l','i','d',0};
78 static WCHAR does_not_existW[] = {'d','o','e','s','_','n','o','t','_','e','x','i','s','t',0};
79 static const CHAR emptyA[] = "";
80 static WCHAR emptyW[] = {0};
81 static WCHAR LocalPortW[] = {'L','o','c','a','l',' ','P','o','r','t',0};
82 static WCHAR Monitors_LocalPortW[] = {
83 'S','y','s','t','e','m','\\',
84 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
85 'C','o','n','t','r','o','l','\\',
86 'P','r','i','n','t','\\',
87 'M','o','n','i','t','o','r','s','\\',
88 'L','o','c','a','l',' ','P','o','r','t',0};
89
90 static const CHAR num_0A[] = "0";
91 static WCHAR num_0W[] = {'0',0};
92 static const CHAR num_1A[] = "1";
93 static WCHAR num_1W[] = {'1',0};
94 static const CHAR num_999999A[] = "999999";
95 static WCHAR num_999999W[] = {'9','9','9','9','9','9',0};
96 static const CHAR num_1000000A[] = "1000000";
97 static WCHAR num_1000000W[] = {'1','0','0','0','0','0','0',0};
98
99 static const WCHAR portname_comW[] = {'C','O','M',0};
100 static WCHAR portname_com1W[] = {'C','O','M','1',':',0};
101 static WCHAR portname_com2W[] = {'C','O','M','2',':',0};
102 static WCHAR portname_fileW[] = {'F','I','L','E',':',0};
103 static const WCHAR portname_lptW[] = {'L','P','T',0};
104 static WCHAR portname_lpt1W[] = {'L','P','T','1',':',0};
105 static WCHAR portname_lpt2W[] = {'L','P','T','2',':',0};
106 static WCHAR server_does_not_existW[] = {'\\','\\','d','o','e','s','_','n','o','t','_','e','x','i','s','t',0};
107
108 static const CHAR TransmissionRetryTimeoutA[] = {'T','r','a','n','s','m','i','s','s','i','o','n',
109 'R','e','t','r','y','T','i','m','e','o','u','t',0};
110
111 static const CHAR WinNT_CV_WindowsA[] = {'S','o','f','t','w','a','r','e','\\',
112 'M','i','c','r','o','s','o','f','t','\\',
113 'W','i','n','d','o','w','s',' ','N','T','\\',
114 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
115 'W','i','n','d','o','w','s',0};
116 static WCHAR wineW[] = {'W','i','n','e',0};
117
118 static WCHAR tempdirW[MAX_PATH];
119 static WCHAR tempfileW[MAX_PATH];
120
121 #define PORTNAME_PREFIX 3
122 #define PORTNAME_MINSIZE 5
123 #define PORTNAME_MAXSIZE 10
124 static WCHAR have_com[PORTNAME_MAXSIZE];
125 static WCHAR have_lpt[PORTNAME_MAXSIZE];
126 static WCHAR have_file[PORTNAME_MAXSIZE];
127
128 /* ########################### */
129
130 static DWORD delete_port(LPWSTR portname)
131 {
132 DWORD res;
133
134 if (pDeletePort) {
135 res = pDeletePort(NULL, 0, portname);
136 }
137 else
138 {
139 res = pXcvDataPort(hXcv, cmd_DeletePortW, (PBYTE) portname, (lstrlenW(portname) + 1) * sizeof(WCHAR), NULL, 0, NULL);
140 }
141 return res;
142 }
143
144 /* ########################### */
145
146 static void find_installed_ports(void)
147 {
148 PORT_INFO_1W * pi = NULL;
149 WCHAR nameW[PORTNAME_MAXSIZE];
150 DWORD needed;
151 DWORD returned;
152 DWORD res;
153 DWORD id;
154
155 have_com[0] = '\0';
156 have_lpt[0] = '\0';
157 have_file[0] = '\0';
158
159 if (!pEnumPorts) return;
160
161 res = pEnumPorts(NULL, 1, NULL, 0, &needed, &returned);
162 if (!res && (GetLastError() == ERROR_INSUFFICIENT_BUFFER)) {
163 pi = HeapAlloc(GetProcessHeap(), 0, needed);
164 }
165 res = pEnumPorts(NULL, 1, (LPBYTE) pi, needed, &needed, &returned);
166
167 if (!res) {
168 skip("no ports found\n");
169 HeapFree(GetProcessHeap(), 0, pi);
170 return;
171 }
172
173 id = 0;
174 while (id < returned) {
175 res = lstrlenW(pi[id].pName);
176 if ((res >= PORTNAME_MINSIZE) && (res < PORTNAME_MAXSIZE) &&
177 (pi[id].pName[res-1] == ':')) {
178 /* copy only the prefix ("LPT" or "COM") */
179 memcpy(&nameW, pi[id].pName, PORTNAME_PREFIX * sizeof(WCHAR));
180 nameW[PORTNAME_PREFIX] = '\0';
181
182 if (!have_com[0] && (lstrcmpiW(nameW, portname_comW) == 0)) {
183 memcpy(&have_com, pi[id].pName, (res+1) * sizeof(WCHAR));
184 }
185
186 if (!have_lpt[0] && (lstrcmpiW(nameW, portname_lptW) == 0)) {
187 memcpy(&have_lpt, pi[id].pName, (res+1) * sizeof(WCHAR));
188 }
189
190 if (!have_file[0] && (lstrcmpiW(pi[id].pName, portname_fileW) == 0)) {
191 memcpy(&have_file, pi[id].pName, (res+1) * sizeof(WCHAR));
192 }
193 }
194 id++;
195 }
196
197 HeapFree(GetProcessHeap(), 0, pi);
198 }
199
200 /* ########################### */
201
202 static void test_AddPort(void)
203 {
204 DWORD res;
205
206 /* moved to localui.dll since w2k */
207 if (!pAddPort) return;
208
209 if (0)
210 {
211 /* NT4 crash on this test */
212 pAddPort(NULL, 0, NULL);
213 }
214
215 /* Testing-Results (localmon.dll from NT4.0):
216 - The Servername is ignored
217 - Case of MonitorName is ignored
218 */
219
220 SetLastError(0xdeadbeef);
221 res = pAddPort(NULL, 0, emptyW);
222 ok(!res, "returned %d with %u (expected '0')\n", res, GetLastError());
223
224 SetLastError(0xdeadbeef);
225 res = pAddPort(NULL, 0, does_not_existW);
226 ok(!res, "returned %d with %u (expected '0')\n", res, GetLastError());
227
228 }
229
230 /* ########################### */
231
232 static void test_AddPortEx(void)
233 {
234 PORT_INFO_2W pi;
235 DWORD res;
236
237 if (!pAddPortEx) {
238 skip("AddPortEx\n");
239 return;
240 }
241 if ((!pDeletePort) && (!hXcv)) {
242 skip("No API to delete a Port\n");
243 return;
244 }
245
246 /* start test with clean ports */
247 delete_port(tempfileW);
248
249 pi.pPortName = tempfileW;
250 if (0) {
251 /* tests crash with native localspl.dll in w2k,
252 but works with native localspl.dll in wine */
253 SetLastError(0xdeadbeef);
254 res = pAddPortEx(NULL, 1, (LPBYTE) &pi, LocalPortW);
255 trace("returned %u with %u\n", res, GetLastError() );
256 ok( res, "got %u with %u (expected '!= 0')\n", res, GetLastError());
257
258 /* port already exists: */
259 SetLastError(0xdeadbeef);
260 res = pAddPortEx(NULL, 1, (LPBYTE) &pi, LocalPortW);
261 trace("returned %u with %u\n", res, GetLastError() );
262 ok( !res && (GetLastError() == ERROR_INVALID_PARAMETER),
263 "got %u with %u (expected '0' with ERROR_INVALID_PARAMETER)\n",
264 res, GetLastError());
265 delete_port(tempfileW);
266
267
268 /* NULL for pMonitorName is documented for Printmonitors, but
269 localspl.dll fails always with ERROR_INVALID_PARAMETER */
270 SetLastError(0xdeadbeef);
271 res = pAddPortEx(NULL, 1, (LPBYTE) &pi, NULL);
272 trace("returned %u with %u\n", res, GetLastError() );
273 ok( !res && (GetLastError() == ERROR_INVALID_PARAMETER),
274 "got %u with %u (expected '0' with ERROR_INVALID_PARAMETER)\n",
275 res, GetLastError());
276 if (res) delete_port(tempfileW);
277
278
279 SetLastError(0xdeadbeef);
280 res = pAddPortEx(NULL, 1, (LPBYTE) &pi, emptyW);
281 trace("returned %u with %u\n", res, GetLastError() );
282 ok( !res && (GetLastError() == ERROR_INVALID_PARAMETER),
283 "got %u with %u (expected '0' with ERROR_INVALID_PARAMETER)\n",
284 res, GetLastError());
285 if (res) delete_port(tempfileW);
286
287
288 SetLastError(0xdeadbeef);
289 res = pAddPortEx(NULL, 1, (LPBYTE) &pi, does_not_existW);
290 trace("returned %u with %u\n", res, GetLastError() );
291 ok( !res && (GetLastError() == ERROR_INVALID_PARAMETER),
292 "got %u with %u (expected '0' with ERROR_INVALID_PARAMETER)\n",
293 res, GetLastError());
294 if (res) delete_port(tempfileW);
295 }
296
297 pi.pPortName = NULL;
298 SetLastError(0xdeadbeef);
299 res = pAddPortEx(NULL, 1, (LPBYTE) &pi, LocalPortW);
300 ok( !res && (GetLastError() == ERROR_INVALID_PARAMETER),
301 "got %u with %u (expected '0' with ERROR_INVALID_PARAMETER)\n",
302 res, GetLastError());
303
304 /* level 2 is documented as supported for Printmonitors,
305 but localspl.dll fails always with ERROR_INVALID_LEVEL */
306
307 pi.pPortName = tempfileW;
308 pi.pMonitorName = LocalPortW;
309 pi.pDescription = wineW;
310 pi.fPortType = PORT_TYPE_WRITE;
311
312 SetLastError(0xdeadbeef);
313 res = pAddPortEx(NULL, 2, (LPBYTE) &pi, LocalPortW);
314 ok( !res && (GetLastError() == ERROR_INVALID_LEVEL),
315 "got %u with %u (expected '0' with ERROR_INVALID_LEVEL)\n",
316 res, GetLastError());
317 if (res) delete_port(tempfileW);
318
319
320 /* invalid levels */
321 SetLastError(0xdeadbeef);
322 res = pAddPortEx(NULL, 0, (LPBYTE) &pi, LocalPortW);
323 ok( !res && (GetLastError() == ERROR_INVALID_LEVEL),
324 "got %u with %u (expected '0' with ERROR_INVALID_LEVEL)\n",
325 res, GetLastError());
326 if (res) delete_port(tempfileW);
327
328
329 SetLastError(0xdeadbeef);
330 res = pAddPortEx(NULL, 3, (LPBYTE) &pi, LocalPortW);
331 ok( !res && (GetLastError() == ERROR_INVALID_LEVEL),
332 "got %u with %u (expected '0' with ERROR_INVALID_LEVEL)\n",
333 res, GetLastError());
334 if (res) delete_port(tempfileW);
335
336 /* cleanup */
337 delete_port(tempfileW);
338 }
339
340 /* ########################### */
341
342 static void test_ClosePort(void)
343 {
344 HANDLE hPort;
345 HANDLE hPort2;
346 LPWSTR nameW = NULL;
347 DWORD res;
348 DWORD res2;
349
350
351 if (!pOpenPort || !pClosePort) return;
352
353 if (have_com[0]) {
354 nameW = have_com;
355
356 hPort = (HANDLE) 0xdeadbeef;
357 res = pOpenPort(nameW, &hPort);
358 hPort2 = (HANDLE) 0xdeadbeef;
359 res2 = pOpenPort(nameW, &hPort2);
360
361 if (res2 && (hPort2 != hPort)) {
362 SetLastError(0xdeadbeef);
363 res2 = pClosePort(hPort2);
364 ok(res2, "got %u with %u (expected '!= 0')\n", res2, GetLastError());
365 }
366
367 if (res) {
368 SetLastError(0xdeadbeef);
369 res = pClosePort(hPort);
370 ok(res, "got %u with %u (expected '!= 0')\n", res, GetLastError());
371 }
372 }
373
374
375 if (have_lpt[0]) {
376 nameW = have_lpt;
377
378 hPort = (HANDLE) 0xdeadbeef;
379 res = pOpenPort(nameW, &hPort);
380 hPort2 = (HANDLE) 0xdeadbeef;
381 res2 = pOpenPort(nameW, &hPort2);
382
383 if (res2 && (hPort2 != hPort)) {
384 SetLastError(0xdeadbeef);
385 res2 = pClosePort(hPort2);
386 ok(res2, "got %u with %u (expected '!= 0')\n", res2, GetLastError());
387 }
388
389 if (res) {
390 SetLastError(0xdeadbeef);
391 res = pClosePort(hPort);
392 ok(res, "got %u with %u (expected '!= 0')\n", res, GetLastError());
393 }
394 }
395
396
397 if (have_file[0]) {
398 nameW = have_file;
399
400 hPort = (HANDLE) 0xdeadbeef;
401 res = pOpenPort(nameW, &hPort);
402 hPort2 = (HANDLE) 0xdeadbeef;
403 res2 = pOpenPort(nameW, &hPort2);
404
405 if (res2 && (hPort2 != hPort)) {
406 SetLastError(0xdeadbeef);
407 res2 = pClosePort(hPort2);
408 ok(res2, "got %u with %u (expected '!= 0')\n", res2, GetLastError());
409 }
410
411 if (res) {
412 SetLastError(0xdeadbeef);
413 res = pClosePort(hPort);
414 ok(res, "got %u with %u (expected '!= 0')\n", res, GetLastError());
415 }
416
417 }
418
419 if (0) {
420 /* an invalid HANDLE crash native localspl.dll */
421
422 SetLastError(0xdeadbeef);
423 res = pClosePort(NULL);
424 trace("got %u with %u\n", res, GetLastError());
425
426 SetLastError(0xdeadbeef);
427 res = pClosePort( (HANDLE) 0xdeadbeef);
428 trace("got %u with %u\n", res, GetLastError());
429
430 SetLastError(0xdeadbeef);
431 res = pClosePort(INVALID_HANDLE_VALUE);
432 trace("got %u with %u\n", res, GetLastError());
433 }
434
435 }
436
437 /* ########################### */
438
439 static void test_ConfigurePort(void)
440 {
441 DWORD res;
442
443 /* moved to localui.dll since w2k */
444 if (!pConfigurePort) return;
445
446 if (0)
447 {
448 /* NT4 crash on this test */
449 pConfigurePort(NULL, 0, NULL);
450 }
451
452 /* Testing-Results (localmon.dll from NT4.0):
453 - Case of Portname is ignored
454 - "COM1:" and "COM01:" are the same (Compared by value)
455 - Portname without ":" => Dialog "Nothing to configure" comes up; Success
456 - "LPT1:", "LPT0:" and "LPT:" are the same (Numbers in "LPT:" are ignored)
457 - Empty Servername (LPT1:) => Dialog comes up (Servername is ignored)
458 - "FILE:" => Dialog "Nothing to configure" comes up; Success
459 - Empty Portname => => Dialog "Nothing to configure" comes up; Success
460 - Port "does_not_exist" => Dialog "Nothing to configure" comes up; Success
461 */
462 if (winetest_interactive > 0) {
463
464 SetLastError(0xdeadbeef);
465 res = pConfigurePort(NULL, 0, portname_com1W);
466 trace("returned %d with %u\n", res, GetLastError());
467
468 SetLastError(0xdeadbeef);
469 res = pConfigurePort(NULL, 0, portname_lpt1W);
470 trace("returned %d with %u\n", res, GetLastError());
471
472 SetLastError(0xdeadbeef);
473 res = pConfigurePort(NULL, 0, portname_fileW);
474 trace("returned %d with %u\n", res, GetLastError());
475 }
476 }
477
478 /* ########################### */
479
480 static void test_DeletePort(void)
481 {
482 DWORD res;
483
484 /* moved to localui.dll since w2k */
485 if (!pDeletePort) return;
486
487 if (0)
488 {
489 /* NT4 crash on this test */
490 pDeletePort(NULL, 0, NULL);
491 }
492
493 /* Testing-Results (localmon.dll from NT4.0):
494 - Case of Portname is ignored (returned '1' on Success)
495 - "COM1:" and "COM01:" are different (Compared as string)
496 - server_does_not_exist (LPT1:) => Port deleted, Success (Servername is ignored)
497 - Empty Portname => => FALSE (LastError not changed)
498 - Port "does_not_exist" => FALSE (LastError not changed)
499 */
500
501 SetLastError(0xdeadbeef);
502 res = pDeletePort(NULL, 0, emptyW);
503 ok(!res, "returned %d with %u (expected '0')\n", res, GetLastError());
504
505 SetLastError(0xdeadbeef);
506 res = pDeletePort(NULL, 0, does_not_existW);
507 ok(!res, "returned %d with %u (expected '0')\n", res, GetLastError());
508
509 }
510
511 /* ########################### */
512
513 static void test_EnumPorts(void)
514 {
515 DWORD res;
516 DWORD level;
517 LPBYTE buffer;
518 DWORD cbBuf;
519 DWORD pcbNeeded;
520 DWORD pcReturned;
521
522 if (!pEnumPorts) return;
523
524 /* valid levels are 1 and 2 */
525 for(level = 0; level < 4; level++) {
526
527 cbBuf = 0xdeadbeef;
528 pcReturned = 0xdeadbeef;
529 SetLastError(0xdeadbeef);
530 res = pEnumPorts(NULL, level, NULL, 0, &cbBuf, &pcReturned);
531
532 /* use only a short test, when we test with an invalid level */
533 if(!level || (level > 2)) {
534 /* NT4 fails with ERROR_INVALID_LEVEL (as expected)
535 XP succeeds with ERROR_SUCCESS () */
536 ok( (cbBuf == 0) && (pcReturned == 0),
537 "(%d) returned %d with %u and %d, %d (expected 0, 0)\n",
538 level, res, GetLastError(), cbBuf, pcReturned);
539 continue;
540 }
541
542 ok( !res && (GetLastError() == ERROR_INSUFFICIENT_BUFFER),
543 "(%d) returned %d with %u and %d, %d (expected '0' with "
544 "ERROR_INSUFFICIENT_BUFFER)\n",
545 level, res, GetLastError(), cbBuf, pcReturned);
546
547 buffer = HeapAlloc(GetProcessHeap(), 0, cbBuf * 2);
548 if (buffer == NULL) continue;
549
550 pcbNeeded = 0xdeadbeef;
551 pcReturned = 0xdeadbeef;
552 SetLastError(0xdeadbeef);
553 res = pEnumPorts(NULL, level, buffer, cbBuf, &pcbNeeded, &pcReturned);
554 ok( res, "(%d) returned %d with %u and %d, %d (expected '!= 0')\n",
555 level, res, GetLastError(), pcbNeeded, pcReturned);
556 /* We can compare the returned Data with the Registry / "win.ini",[Ports] here */
557
558 pcbNeeded = 0xdeadbeef;
559 pcReturned = 0xdeadbeef;
560 SetLastError(0xdeadbeef);
561 res = pEnumPorts(NULL, level, buffer, cbBuf+1, &pcbNeeded, &pcReturned);
562 ok( res, "(%d) returned %d with %u and %d, %d (expected '!= 0')\n",
563 level, res, GetLastError(), pcbNeeded, pcReturned);
564
565 pcbNeeded = 0xdeadbeef;
566 pcReturned = 0xdeadbeef;
567 SetLastError(0xdeadbeef);
568 res = pEnumPorts(NULL, level, buffer, cbBuf-1, &pcbNeeded, &pcReturned);
569 ok( !res && (GetLastError() == ERROR_INSUFFICIENT_BUFFER),
570 "(%d) returned %d with %u and %d, %d (expected '0' with "
571 "ERROR_INSUFFICIENT_BUFFER)\n",
572 level, res, GetLastError(), pcbNeeded, pcReturned);
573
574 if (0)
575 {
576 /* The following tests crash this app with native localmon/localspl */
577 pEnumPorts(NULL, level, NULL, cbBuf, &pcbNeeded, &pcReturned);
578 pEnumPorts(NULL, level, buffer, cbBuf, NULL, &pcReturned);
579 pEnumPorts(NULL, level, buffer, cbBuf, &pcbNeeded, NULL);
580 }
581
582 /* The Servername is ignored */
583 pcbNeeded = 0xdeadbeef;
584 pcReturned = 0xdeadbeef;
585 SetLastError(0xdeadbeef);
586 res = pEnumPorts(emptyW, level, buffer, cbBuf+1, &pcbNeeded, &pcReturned);
587 ok( res, "(%d) returned %d with %u and %d, %d (expected '!= 0')\n",
588 level, res, GetLastError(), pcbNeeded, pcReturned);
589
590 pcbNeeded = 0xdeadbeef;
591 pcReturned = 0xdeadbeef;
592 SetLastError(0xdeadbeef);
593 res = pEnumPorts(server_does_not_existW, level, buffer, cbBuf+1, &pcbNeeded, &pcReturned);
594 ok( res, "(%d) returned %d with %u and %d, %d (expected '!= 0')\n",
595 level, res, GetLastError(), pcbNeeded, pcReturned);
596
597 HeapFree(GetProcessHeap(), 0, buffer);
598 }
599 }
600
601 /* ########################### */
602
603
604 static void test_InitializePrintMonitor(void)
605 {
606 LPMONITOREX res;
607
608 SetLastError(0xdeadbeef);
609 res = pInitializePrintMonitor(NULL);
610 /* The Parameter was unchecked before w2k */
611 ok( res || (GetLastError() == ERROR_INVALID_PARAMETER),
612 "returned %p with %u\n (expected '!= NULL' or: NULL with "
613 "ERROR_INVALID_PARAMETER)\n", res, GetLastError());
614
615 SetLastError(0xdeadbeef);
616 res = pInitializePrintMonitor(emptyW);
617 ok( res || (GetLastError() == ERROR_INVALID_PARAMETER),
618 "returned %p with %u\n (expected '!= NULL' or: NULL with "
619 "ERROR_INVALID_PARAMETER)\n", res, GetLastError());
620
621
622 /* Every call with a non-empty string returns the same Pointer */
623 SetLastError(0xdeadbeef);
624 res = pInitializePrintMonitor(Monitors_LocalPortW);
625 ok( res == pm,
626 "returned %p with %u (expected %p)\n", res, GetLastError(), pm);
627 }
628
629
630 /* ########################### */
631
632 static void test_OpenPort(void)
633 {
634 HANDLE hPort;
635 HANDLE hPort2;
636 LPWSTR nameW = NULL;
637 DWORD res;
638 DWORD res2;
639
640 if (!pOpenPort || !pClosePort) return;
641
642 if (have_com[0]) {
643 nameW = have_com;
644
645 hPort = (HANDLE) 0xdeadbeef;
646 SetLastError(0xdeadbeef);
647 res = pOpenPort(nameW, &hPort);
648 ok( res, "got %u with %u and %p (expected '!= 0')\n",
649 res, GetLastError(), hPort);
650
651 /* the same HANDLE is returned for a second OpenPort in native localspl */
652 hPort2 = (HANDLE) 0xdeadbeef;
653 SetLastError(0xdeadbeef);
654 res2 = pOpenPort(nameW, &hPort2);
655 ok( res2, "got %u with %u and %p (expected '!= 0')\n",
656 res2, GetLastError(), hPort2);
657
658 if (res) pClosePort(hPort);
659 if (res2 && (hPort2 != hPort)) pClosePort(hPort2);
660 }
661
662 if (have_lpt[0]) {
663 nameW = have_lpt;
664
665 hPort = (HANDLE) 0xdeadbeef;
666 SetLastError(0xdeadbeef);
667 res = pOpenPort(nameW, &hPort);
668 ok( res || (GetLastError() == ERROR_ACCESS_DENIED),
669 "got %u with %u and %p (expected '!= 0' or '0' with ERROR_ACCESS_DENIED)\n",
670 res, GetLastError(), hPort);
671
672 /* the same HANDLE is returned for a second OpenPort in native localspl */
673 hPort2 = (HANDLE) 0xdeadbeef;
674 SetLastError(0xdeadbeef);
675 res2 = pOpenPort(nameW, &hPort2);
676 ok( res2 || (GetLastError() == ERROR_ACCESS_DENIED),
677 "got %u with %u and %p (expected '!= 0' or '0' with ERROR_ACCESS_DENIED)\n",
678 res2, GetLastError(), hPort2);
679
680 if (res) pClosePort(hPort);
681 if (res2 && (hPort2 != hPort)) pClosePort(hPort2);
682 }
683
684 if (have_file[0]) {
685 nameW = have_file;
686
687 hPort = (HANDLE) 0xdeadbeef;
688 SetLastError(0xdeadbeef);
689 res = pOpenPort(nameW, &hPort);
690 ok( res, "got %u with %u and %p (expected '!= 0')\n",
691 res, GetLastError(), hPort);
692
693 /* a different HANDLE is returned for a second OpenPort */
694 hPort2 = (HANDLE) 0xdeadbeef;
695 SetLastError(0xdeadbeef);
696 res2 = pOpenPort(nameW, &hPort2);
697 ok( res2 && (hPort2 != hPort),
698 "got %u with %u and %p (expected '!= 0' and '!= %p')\n",
699 res2, GetLastError(), hPort2, hPort);
700
701 if (res) pClosePort(hPort);
702 if (res2 && (hPort2 != hPort)) pClosePort(hPort2);
703 }
704
705 if (0) {
706 /* this test crash native localspl (w2k+xp) */
707 if (nameW) {
708 hPort = (HANDLE) 0xdeadbeef;
709 SetLastError(0xdeadbeef);
710 res = pOpenPort(nameW, NULL);
711 trace("got %u with %u and %p\n", res, GetLastError(), hPort);
712 }
713 }
714
715 hPort = (HANDLE) 0xdeadbeef;
716 SetLastError(0xdeadbeef);
717 res = pOpenPort(does_not_existW, &hPort);
718 ok (!res && (hPort == (HANDLE) 0xdeadbeef),
719 "got %u with 0x%x and %p (expected '0' and 0xdeadbeef)\n", res, GetLastError(), hPort);
720 if (res) pClosePort(hPort);
721
722 hPort = (HANDLE) 0xdeadbeef;
723 SetLastError(0xdeadbeef);
724 res = pOpenPort(emptyW, &hPort);
725 ok (!res && (hPort == (HANDLE) 0xdeadbeef),
726 "got %u with 0x%x and %p (expected '0' and 0xdeadbeef)\n", res, GetLastError(), hPort);
727 if (res) pClosePort(hPort);
728
729
730 /* NULL as name crash native localspl (w2k+xp) */
731 if (0) {
732 hPort = (HANDLE) 0xdeadbeef;
733 SetLastError(0xdeadbeef);
734 res = pOpenPort(NULL, &hPort);
735 trace("got %u with %u and %p\n", res, GetLastError(), hPort);
736 }
737
738 }
739
740 /* ########################### */
741
742 static void test_XcvClosePort(void)
743 {
744 DWORD res;
745 HANDLE hXcv2;
746
747
748 if (0)
749 {
750 /* crash with native localspl.dll (w2k+xp) */
751 pXcvClosePort(NULL);
752 pXcvClosePort(INVALID_HANDLE_VALUE);
753 }
754
755
756 SetLastError(0xdeadbeef);
757 hXcv2 = (HANDLE) 0xdeadbeef;
758 res = pXcvOpenPort(emptyW, SERVER_ACCESS_ADMINISTER, &hXcv2);
759 ok(res, "returned %d with %u and %p (expected '!= 0')\n", res, GetLastError(), hXcv2);
760
761 if (res) {
762 SetLastError(0xdeadbeef);
763 res = pXcvClosePort(hXcv2);
764 ok(res, "returned %d with %u (expected '!= 0')\n", res, GetLastError());
765
766 if (0)
767 {
768 /* test for "Double Free": crash with native localspl.dll (w2k+xp) */
769 pXcvClosePort(hXcv2);
770 }
771 }
772 }
773
774 /* ########################### */
775
776 static void test_XcvDataPort_AddPort(void)
777 {
778 DWORD res;
779
780 /*
781 * The following tests crash with native localspl.dll on w2k and xp,
782 * but it works, when the native dll (w2k and xp) is used in wine.
783 * also tested (same crash): replacing emptyW with portname_lpt1W
784 * and replacing "NULL, 0, NULL" with "buffer, MAX_PATH, &needed"
785 *
786 * We need to use a different API (AddPortEx) instead
787 */
788 if (0)
789 {
790 /* create a Port for a normal, writable file */
791 SetLastError(0xdeadbeef);
792 res = pXcvDataPort(hXcv, cmd_AddPortW, (PBYTE) tempfileW, (lstrlenW(tempfileW) + 1) * sizeof(WCHAR), NULL, 0, NULL);
793 ok( res == ERROR_SUCCESS, "returned %d with %u (expected ERROR_SUCCESS)\n", res, GetLastError());
794
795 /* add our testport again */
796 SetLastError(0xdeadbeef);
797 res = pXcvDataPort(hXcv, cmd_AddPortW, (PBYTE) tempfileW, (lstrlenW(tempfileW) + 1) * sizeof(WCHAR), NULL, 0, NULL);
798 ok( res == ERROR_ALREADY_EXISTS, "returned %d with %u (expected ERROR_ALREADY_EXISTS)\n", res, GetLastError());
799
800 /* create a well-known Port */
801 SetLastError(0xdeadbeef);
802 res = pXcvDataPort(hXcv, cmd_AddPortW, (PBYTE) portname_lpt1W, (lstrlenW(portname_lpt1W) + 1) * sizeof(WCHAR), NULL, 0, NULL);
803 ok( res == ERROR_ALREADY_EXISTS, "returned %d with %u (expected ERROR_ALREADY_EXISTS)\n", res, GetLastError());
804
805 /* ERROR_ALREADY_EXISTS is also returned from native localspl.dll on wine,
806 when "RPT1:" was already installed for redmonnt.dll:
807 res = pXcvDataPort(hXcv, cmd_AddPortW, (PBYTE) portname_rpt1W, ...
808 */
809
810 /* cleanup */
811 SetLastError(0xdeadbeef);
812 res = pXcvDataPort(hXcv, cmd_DeletePortW, (PBYTE) tempfileW, (lstrlenW(tempfileW) + 1) * sizeof(WCHAR), NULL, 0, NULL);
813 ok( res == ERROR_SUCCESS, "returned %d with %u (expected ERROR_SUCCESS)\n", res, GetLastError());
814 }
815
816 }
817
818 /* ########################### */
819
820 static void test_XcvDataPort_ConfigureLPTPortCommandOK(void)
821 {
822 CHAR org_value[16];
823 CHAR buffer[16];
824 HKEY hroot = NULL;
825 DWORD res;
826 DWORD needed;
827
828
829 /* Read the original value from the registry */
830 res = RegOpenKeyExA(HKEY_LOCAL_MACHINE, WinNT_CV_WindowsA, 0, KEY_ALL_ACCESS, &hroot);
831 if (res == ERROR_ACCESS_DENIED) {
832 skip("ACCESS_DENIED\n");
833 return;
834 }
835
836 if (res != ERROR_SUCCESS) {
837 /* unable to open the registry: skip the test */
838 skip("got %d\n", res);
839 return;
840 }
841 org_value[0] = '\0';
842 needed = sizeof(org_value)-1 ;
843 res = RegQueryValueExA(hroot, TransmissionRetryTimeoutA, NULL, NULL, (PBYTE) org_value, &needed);
844 ok( (res == ERROR_SUCCESS) || (res == ERROR_FILE_NOT_FOUND),
845 "returned %u and %u for \"%s\" (expected ERROR_SUCCESS or "
846 "ERROR_FILE_NOT_FOUND)\n", res, needed, org_value);
847
848 RegDeleteValueA(hroot, TransmissionRetryTimeoutA);
849
850 /* set to "0" */
851 needed = (DWORD) 0xdeadbeef;
852 SetLastError(0xdeadbeef);
853 res = pXcvDataPort(hXcv, cmd_ConfigureLPTPortCommandOKW, (PBYTE) num_0W, sizeof(num_0W), NULL, 0, &needed);
854 if (res == ERROR_INVALID_PARAMETER) {
855 skip("'ConfigureLPTPortCommandOK' not supported\n");
856 return;
857 }
858 ok( res == ERROR_SUCCESS, "returned %d with %u (expected ERROR_SUCCESS)\n", res, GetLastError());
859 needed = sizeof(buffer)-1 ;
860 res = RegQueryValueExA(hroot, TransmissionRetryTimeoutA, NULL, NULL, (PBYTE) buffer, &needed);
861 ok( (res == ERROR_SUCCESS) && (lstrcmpA(buffer, num_0A) == 0),
862 "returned %d and '%s' (expected ERROR_SUCCESS and '%s')\n",
863 res, buffer, num_0A);
864
865
866 /* set to "1" */
867 needed = (DWORD) 0xdeadbeef;
868 SetLastError(0xdeadbeef);
869 res = pXcvDataPort(hXcv, cmd_ConfigureLPTPortCommandOKW, (PBYTE) num_1W, sizeof(num_1W), NULL, 0, &needed);
870 ok( res == ERROR_SUCCESS, "returned %d with %u (expected ERROR_SUCCESS)\n", res, GetLastError());
871 needed = sizeof(buffer)-1 ;
872 res = RegQueryValueExA(hroot, TransmissionRetryTimeoutA, NULL, NULL, (PBYTE) buffer, &needed);
873 ok( (res == ERROR_SUCCESS) && (lstrcmpA(buffer, num_1A) == 0),
874 "returned %d and '%s' (expected ERROR_SUCCESS and '%s')\n",
875 res, buffer, num_1A);
876
877 /* set to "999999" */
878 needed = (DWORD) 0xdeadbeef;
879 SetLastError(0xdeadbeef);
880 res = pXcvDataPort(hXcv, cmd_ConfigureLPTPortCommandOKW, (PBYTE) num_999999W, sizeof(num_999999W), NULL, 0, &needed);
881 ok( res == ERROR_SUCCESS, "returned %d with %u (expected ERROR_SUCCESS)\n", res, GetLastError());
882 needed = sizeof(buffer)-1 ;
883 res = RegQueryValueExA(hroot, TransmissionRetryTimeoutA, NULL, NULL, (PBYTE) buffer, &needed);
884 ok( (res == ERROR_SUCCESS) && (lstrcmpA(buffer, num_999999A) == 0),
885 "returned %d and '%s' (expected ERROR_SUCCESS and '%s')\n",
886 res, buffer, num_999999A);
887
888 /* set to "1000000" */
889 needed = (DWORD) 0xdeadbeef;
890 SetLastError(0xdeadbeef);
891 res = pXcvDataPort(hXcv, cmd_ConfigureLPTPortCommandOKW, (PBYTE) num_1000000W, sizeof(num_1000000W), NULL, 0, &needed);
892 ok( res == ERROR_SUCCESS, "returned %d with %u (expected ERROR_SUCCESS)\n", res, GetLastError());
893 needed = sizeof(buffer)-1 ;
894 res = RegQueryValueExA(hroot, TransmissionRetryTimeoutA, NULL, NULL, (PBYTE) buffer, &needed);
895 ok( (res == ERROR_SUCCESS) && (lstrcmpA(buffer, num_1000000A) == 0),
896 "returned %d and '%s' (expected ERROR_SUCCESS and '%s')\n",
897 res, buffer, num_1000000A);
898
899 /* using cmd_ConfigureLPTPortCommandOKW with does_not_existW:
900 the string "does_not_exist" is written to the registry */
901
902
903 /* restore the original value */
904 RegDeleteValueA(hroot, TransmissionRetryTimeoutA);
905 if (org_value[0]) {
906 res = RegSetValueExA(hroot, TransmissionRetryTimeoutA, 0, REG_SZ, (PBYTE)org_value, lstrlenA(org_value)+1);
907 ok(res == ERROR_SUCCESS, "unable to restore original value (got %u): %s\n", res, org_value);
908 }
909
910 RegCloseKey(hroot);
911
912 }
913
914 /* ########################### */
915
916 static void test_XcvDataPort_DeletePort(void)
917 {
918 DWORD res;
919 DWORD needed;
920
921
922 /* cleanup: just to make sure */
923 needed = (DWORD) 0xdeadbeef;
924 SetLastError(0xdeadbeef);
925 res = pXcvDataPort(hXcv, cmd_DeletePortW, (PBYTE) tempfileW, (lstrlenW(tempfileW) + 1) * sizeof(WCHAR), NULL, 0, &needed);
926 ok( !res || (res == ERROR_FILE_NOT_FOUND),
927 "returned %d with %u (expected ERROR_SUCCESS or ERROR_FILE_NOT_FOUND)\n",
928 res, GetLastError());
929
930
931 /* ToDo: cmd_AddPortW for tempfileW, then cmd_DeletePortW for the existing Port */
932
933
934 /* try to delete a nonexistent Port */
935 needed = (DWORD) 0xdeadbeef;
936 SetLastError(0xdeadbeef);
937 res = pXcvDataPort(hXcv, cmd_DeletePortW, (PBYTE) tempfileW, (lstrlenW(tempfileW) + 1) * sizeof(WCHAR), NULL, 0, &needed);
938 ok( res == ERROR_FILE_NOT_FOUND,
939 "returned %d with %u (expected ERROR_FILE_NOT_FOUND)\n", res, GetLastError());
940
941 /* emptyW as Portname: ERROR_FILE_NOT_FOUND is returned */
942 /* NULL as Portname: Native localspl.dll crashed */
943
944 }
945
946 /* ########################### */
947
948 static void test_XcvDataPort_GetTransmissionRetryTimeout(void)
949 {
950 CHAR org_value[16];
951 HKEY hroot = NULL;
952 DWORD buffer[2];
953 DWORD res;
954 DWORD needed;
955 DWORD len;
956
957
958 /* ask for needed size */
959 needed = (DWORD) 0xdeadbeef;
960 SetLastError(0xdeadbeef);
961 res = pXcvDataPort(hXcv, cmd_GetTransmissionRetryTimeoutW, NULL, 0, NULL, 0, &needed);
962 if (res == ERROR_INVALID_PARAMETER) {
963 skip("'GetTransmissionRetryTimeout' not supported\n");
964 return;
965 }
966 len = sizeof(DWORD);
967 ok( (res == ERROR_INSUFFICIENT_BUFFER) && (needed == len),
968 "returned %d with %u and %u (expected ERROR_INSUFFICIENT_BUFFER "
969 "and '%u')\n", res, GetLastError(), needed, len);
970 len = needed;
971
972 /* Read the original value from the registry */
973 res = RegOpenKeyExA(HKEY_LOCAL_MACHINE, WinNT_CV_WindowsA, 0, KEY_ALL_ACCESS, &hroot);
974 if (res == ERROR_ACCESS_DENIED) {
975 skip("ACCESS_DENIED\n");
976 return;
977 }
978
979 if (res != ERROR_SUCCESS) {
980 /* unable to open the registry: skip the test */
981 skip("got %d\n", res);
982 return;
983 }
984
985 org_value[0] = '\0';
986 needed = sizeof(org_value)-1 ;
987 res = RegQueryValueExA(hroot, TransmissionRetryTimeoutA, NULL, NULL, (PBYTE) org_value, &needed);
988 ok( (res == ERROR_SUCCESS) || (res == ERROR_FILE_NOT_FOUND),
989 "returned %u and %u for \"%s\" (expected ERROR_SUCCESS or "
990 "ERROR_FILE_NOT_FOUND)\n", res, needed, org_value);
991
992 /* Get default value (documented as 90 in the w2k reskit, but that is wrong) */
993 RegDeleteValueA(hroot, TransmissionRetryTimeoutA);
994 needed = (DWORD) 0xdeadbeef;
995 buffer[0] = 0xdeadbeef;
996 SetLastError(0xdeadbeef);
997 res = pXcvDataPort(hXcv, cmd_GetTransmissionRetryTimeoutW, NULL, 0, (PBYTE) buffer, len, &needed);
998 ok( (res == ERROR_SUCCESS) && (buffer[0] == 45),
999 "returned %d with %u and %u for %d\n (expected ERROR_SUCCESS "
1000 "for '45')\n", res, GetLastError(), needed, buffer[0]);
1001
1002 /* the default timeout is returned, when the value is empty */
1003 res = RegSetValueExA(hroot, TransmissionRetryTimeoutA, 0, REG_SZ, (PBYTE)emptyA, 1);
1004 ok(res == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", GetLastError());
1005 needed = (DWORD) 0xdeadbeef;
1006 buffer[0] = 0xdeadbeef;
1007 SetLastError(0xdeadbeef);
1008 res = pXcvDataPort(hXcv, cmd_GetTransmissionRetryTimeoutW, NULL, 0, (PBYTE) buffer, len, &needed);
1009 ok( (res == ERROR_SUCCESS) && (buffer[0] == 45),
1010 "returned %d with %u and %u for %d\n (expected ERROR_SUCCESS "
1011 "for '45')\n", res, GetLastError(), needed, buffer[0]);
1012
1013 /* the dialog is limited (1 - 999999), but that is done somewhere else */
1014 res = RegSetValueExA(hroot, TransmissionRetryTimeoutA, 0, REG_SZ, (PBYTE)num_0A, lstrlenA(num_0A)+1);
1015 ok(res == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", GetLastError());
1016 needed = (DWORD) 0xdeadbeef;
1017 buffer[0] = 0xdeadbeef;
1018 SetLastError(0xdeadbeef);
1019 res = pXcvDataPort(hXcv, cmd_GetTransmissionRetryTimeoutW, NULL, 0, (PBYTE) buffer, len, &needed);
1020 ok( (res == ERROR_SUCCESS) && (buffer[0] == 0),
1021 "returned %d with %u and %u for %d\n (expected ERROR_SUCCESS "
1022 "for '0')\n", res, GetLastError(), needed, buffer[0]);
1023
1024
1025 res = RegSetValueExA(hroot, TransmissionRetryTimeoutA, 0, REG_SZ, (PBYTE)num_1A, lstrlenA(num_1A)+1);
1026 ok(res == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", GetLastError());
1027 needed = (DWORD) 0xdeadbeef;
1028 buffer[0] = 0xdeadbeef;
1029 SetLastError(0xdeadbeef);
1030 res = pXcvDataPort(hXcv, cmd_GetTransmissionRetryTimeoutW, NULL, 0, (PBYTE) buffer, len, &needed);
1031 ok( (res == ERROR_SUCCESS) && (buffer[0] == 1),
1032 "returned %d with %u and %u for %d\n (expected 'ERROR_SUCCESS' "
1033 "for '1')\n", res, GetLastError(), needed, buffer[0]);
1034
1035 res = RegSetValueExA(hroot, TransmissionRetryTimeoutA, 0, REG_SZ, (PBYTE)num_999999A, lstrlenA(num_999999A)+1);
1036 ok(res == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", GetLastError());
1037 needed = (DWORD) 0xdeadbeef;
1038 buffer[0] = 0xdeadbeef;
1039 SetLastError(0xdeadbeef);
1040 res = pXcvDataPort(hXcv, cmd_GetTransmissionRetryTimeoutW, NULL, 0, (PBYTE) buffer, len, &needed);
1041 ok( (res == ERROR_SUCCESS) && (buffer[0] == 999999),
1042 "returned %d with %u and %u for %d\n (expected ERROR_SUCCESS "
1043 "for '999999')\n", res, GetLastError(), needed, buffer[0]);
1044
1045
1046 res = RegSetValueExA(hroot, TransmissionRetryTimeoutA, 0, REG_SZ, (PBYTE)num_1000000A, lstrlenA(num_1000000A)+1);
1047 ok(res == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", GetLastError());
1048 needed = (DWORD) 0xdeadbeef;
1049 buffer[0] = 0xdeadbeef;
1050 SetLastError(0xdeadbeef);
1051 res = pXcvDataPort(hXcv, cmd_GetTransmissionRetryTimeoutW, NULL, 0, (PBYTE) buffer, len, &needed);
1052 ok( (res == ERROR_SUCCESS) && (buffer[0] == 1000000),
1053 "returned %d with %u and %u for %d\n (expected ERROR_SUCCESS "
1054 "for '1000000')\n", res, GetLastError(), needed, buffer[0]);
1055
1056 /* restore the original value */
1057 RegDeleteValueA(hroot, TransmissionRetryTimeoutA);
1058 if (org_value[0]) {
1059 res = RegSetValueExA(hroot, TransmissionRetryTimeoutA, 0, REG_SZ, (PBYTE)org_value, lstrlenA(org_value)+1);
1060 ok(res == ERROR_SUCCESS, "unable to restore original value (got %u): %s\n", res, org_value);
1061 }
1062
1063 RegCloseKey(hroot);
1064 }
1065
1066 /* ########################### */
1067
1068 static void test_XcvDataPort_MonitorUI(void)
1069 {
1070 DWORD res;
1071 BYTE buffer[MAX_PATH + 2];
1072 DWORD needed;
1073 DWORD len;
1074
1075
1076 /* ask for needed size */
1077 needed = (DWORD) 0xdeadbeef;
1078 SetLastError(0xdeadbeef);
1079 res = pXcvDataPort(hXcv, cmd_MonitorUIW, NULL, 0, NULL, 0, &needed);
1080 if (res == ERROR_INVALID_PARAMETER) {
1081 skip("'MonitorUI' nor supported\n");
1082 return;
1083 }
1084 ok( (res == ERROR_INSUFFICIENT_BUFFER) && (needed <= MAX_PATH),
1085 "returned %d with %u and 0x%x (expected 'ERROR_INSUFFICIENT_BUFFER' "
1086 " and '<= MAX_PATH')\n", res, GetLastError(), needed);
1087
1088 if (needed > MAX_PATH) {
1089 skip("buffer overflow (%u)\n", needed);
1090 return;
1091 }
1092 len = needed;
1093
1094 /* the command is required */
1095 needed = (DWORD) 0xdeadbeef;
1096 SetLastError(0xdeadbeef);
1097 res = pXcvDataPort(hXcv, emptyW, NULL, 0, NULL, 0, &needed);
1098 ok( res == ERROR_INVALID_PARAMETER, "returned %d with %u and 0x%x "
1099 "(expected 'ERROR_INVALID_PARAMETER')\n", res, GetLastError(), needed);
1100
1101 if (0) {
1102 /* crash with native localspl.dll (w2k+xp) */
1103 pXcvDataPort(hXcv, NULL, NULL, 0, buffer, MAX_PATH, &needed);
1104 pXcvDataPort(hXcv, cmd_MonitorUIW, NULL, 0, NULL, len, &needed);
1105 pXcvDataPort(hXcv, cmd_MonitorUIW, NULL, 0, buffer, len, NULL);
1106 }
1107
1108
1109 /* hXcv is ignored for the command "MonitorUI" */
1110 needed = (DWORD) 0xdeadbeef;
1111 SetLastError(0xdeadbeef);
1112 res = pXcvDataPort(NULL, cmd_MonitorUIW, NULL, 0, buffer, len, &needed);
1113 ok( res == ERROR_SUCCESS, "returned %d with %u and 0x%x "
1114 "(expected 'ERROR_SUCCESS')\n", res, GetLastError(), needed);
1115
1116
1117 /* pszDataName is case-sensitive */
1118 memset(buffer, 0, len);
1119 needed = (DWORD) 0xdeadbeef;
1120 SetLastError(0xdeadbeef);
1121 res = pXcvDataPort(hXcv, cmd_MonitorUI_lcaseW, NULL, 0, buffer, len, &needed);
1122 ok( res == ERROR_INVALID_PARAMETER, "returned %d with %u and 0x%x "
1123 "(expected 'ERROR_INVALID_PARAMETER')\n", res, GetLastError(), needed);
1124
1125 /* off by one: larger */
1126 needed = (DWORD) 0xdeadbeef;
1127 SetLastError(0xdeadbeef);
1128 res = pXcvDataPort(hXcv, cmd_MonitorUIW, NULL, 0, buffer, len+1, &needed);
1129 ok( res == ERROR_SUCCESS, "returned %d with %u and 0x%x "
1130 "(expected 'ERROR_SUCCESS')\n", res, GetLastError(), needed);
1131
1132
1133 /* off by one: smaller */
1134 /* the buffer is not modified for NT4, w2k, XP */
1135 needed = (DWORD) 0xdeadbeef;
1136 SetLastError(0xdeadbeef);
1137 res = pXcvDataPort(hXcv, cmd_MonitorUIW, NULL, 0, buffer, len-1, &needed);
1138 ok( res == ERROR_INSUFFICIENT_BUFFER, "returned %d with %u and 0x%x "
1139 "(expected 'ERROR_INSUFFICIENT_BUFFER')\n", res, GetLastError(), needed);
1140
1141 /* Normal use. The DLL-Name without a Path is returned */
1142 memset(buffer, 0, len);
1143 needed = (DWORD) 0xdeadbeef;
1144 SetLastError(0xdeadbeef);
1145 res = pXcvDataPort(hXcv, cmd_MonitorUIW, NULL, 0, buffer, len, &needed);
1146 ok( res == ERROR_SUCCESS, "returned %d with %u and 0x%x "
1147 "(expected 'ERROR_SUCCESS')\n", res, GetLastError(), needed);
1148
1149
1150 /* small check without access-rights: */
1151 if (!hXcv_noaccess) return;
1152
1153 /* The ACCESS_MASK is ignored for "MonitorUI" */
1154 memset(buffer, 0, len);
1155 needed = (DWORD) 0xdeadbeef;
1156 SetLastError(0xdeadbeef);
1157 res = pXcvDataPort(hXcv_noaccess, cmd_MonitorUIW, NULL, 0, buffer, sizeof(buffer), &needed);
1158 ok( res == ERROR_SUCCESS, "returned %d with %u and 0x%x "
1159 "(expected 'ERROR_SUCCESS')\n", res, GetLastError(), needed);
1160 }
1161
1162 /* ########################### */
1163
1164 static void test_XcvDataPort_PortIsValid(void)
1165 {
1166 DWORD res;
1167 DWORD needed;
1168
1169 /* normal use: "LPT1:" */
1170 needed = (DWORD) 0xdeadbeef;
1171 SetLastError(0xdeadbeef);
1172 res = pXcvDataPort(hXcv, cmd_PortIsValidW, (PBYTE) portname_lpt1W, sizeof(portname_lpt1W), NULL, 0, &needed);
1173 if (res == ERROR_INVALID_PARAMETER) {
1174 skip("'PostIsValid' not supported\n");
1175 return;
1176 }
1177 ok( res == ERROR_SUCCESS, "returned %d with %u (expected ERROR_SUCCESS)\n", res, GetLastError());
1178
1179
1180 if (0) {
1181 /* crash with native localspl.dll (w2k+xp) */
1182 pXcvDataPort(hXcv, cmd_PortIsValidW, NULL, 0, NULL, 0, &needed);
1183 }
1184
1185
1186 /* hXcv is ignored for the command "PortIsValid" */
1187 needed = (DWORD) 0xdeadbeef;
1188 SetLastError(0xdeadbeef);
1189 res = pXcvDataPort(NULL, cmd_PortIsValidW, (PBYTE) portname_lpt1W, sizeof(portname_lpt1W), NULL, 0, NULL);
1190 ok( res == ERROR_SUCCESS, "returned %d with %u (expected ERROR_SUCCESS)\n", res, GetLastError());
1191
1192 /* needed is ignored */
1193 needed = (DWORD) 0xdeadbeef;
1194 SetLastError(0xdeadbeef);
1195 res = pXcvDataPort(hXcv, cmd_PortIsValidW, (PBYTE) portname_lpt1W, sizeof(portname_lpt1W), NULL, 0, NULL);
1196 ok( res == ERROR_SUCCESS, "returned %d with %u (expected ERROR_SUCCESS)\n", res, GetLastError());
1197
1198
1199 /* cbInputData is ignored */
1200 needed = (DWORD) 0xdeadbeef;
1201 SetLastError(0xdeadbeef);
1202 res = pXcvDataPort(hXcv, cmd_PortIsValidW, (PBYTE) portname_lpt1W, 0, NULL, 0, &needed);
1203 ok( res == ERROR_SUCCESS,
1204 "returned %d with %u and 0x%x (expected ERROR_SUCCESS)\n",
1205 res, GetLastError(), needed);
1206
1207 needed = (DWORD) 0xdeadbeef;
1208 SetLastError(0xdeadbeef);
1209 res = pXcvDataPort(hXcv, cmd_PortIsValidW, (PBYTE) portname_lpt1W, 1, NULL, 0, &needed);
1210 ok( res == ERROR_SUCCESS,
1211 "returned %d with %u and 0x%x (expected ERROR_SUCCESS)\n",
1212 res, GetLastError(), needed);
1213
1214 needed = (DWORD) 0xdeadbeef;
1215 SetLastError(0xdeadbeef);
1216 res = pXcvDataPort(hXcv, cmd_PortIsValidW, (PBYTE) portname_lpt1W, sizeof(portname_lpt1W) -1, NULL, 0, &needed);
1217 ok( res == ERROR_SUCCESS,
1218 "returned %d with %u and 0x%x (expected ERROR_SUCCESS)\n",
1219 res, GetLastError(), needed);
1220
1221 needed = (DWORD) 0xdeadbeef;
1222 SetLastError(0xdeadbeef);
1223 res = pXcvDataPort(hXcv, cmd_PortIsValidW, (PBYTE) portname_lpt1W, sizeof(portname_lpt1W) -2, NULL, 0, &needed);
1224 ok( res == ERROR_SUCCESS,
1225 "returned %d with %u and 0x%x (expected ERROR_SUCCESS)\n",
1226 res, GetLastError(), needed);
1227
1228
1229 /* an empty name is not allowed */
1230 needed = (DWORD) 0xdeadbeef;
1231 SetLastError(0xdeadbeef);
1232 res = pXcvDataPort(hXcv, cmd_PortIsValidW, (PBYTE) emptyW, sizeof(emptyW), NULL, 0, &needed);
1233 ok( res == ERROR_PATH_NOT_FOUND,
1234 "returned %d with %u and 0x%x (expected ERROR_PATH_NOT_FOUND)\n",
1235 res, GetLastError(), needed);
1236
1237
1238 /* a directory is not allowed */
1239 needed = (DWORD) 0xdeadbeef;
1240 SetLastError(0xdeadbeef);
1241 res = pXcvDataPort(hXcv, cmd_PortIsValidW, (PBYTE) tempdirW, (lstrlenW(tempdirW) + 1) * sizeof(WCHAR), NULL, 0, &needed);
1242 /* XP(admin): ERROR_INVALID_NAME, XP(user): ERROR_PATH_NOT_FOUND, w2k ERROR_ACCESS_DENIED */
1243 ok( (res == ERROR_INVALID_NAME) || (res == ERROR_PATH_NOT_FOUND) ||
1244 (res == ERROR_ACCESS_DENIED), "returned %d with %u and 0x%x "
1245 "(expected ERROR_INVALID_NAME, ERROR_PATH_NOT_FOUND or ERROR_ACCESS_DENIED)\n",
1246 res, GetLastError(), needed);
1247
1248
1249 /* test more valid well known Ports: */
1250 needed = (DWORD) 0xdeadbeef;
1251 SetLastError(0xdeadbeef);
1252 res = pXcvDataPort(hXcv, cmd_PortIsValidW, (PBYTE) portname_lpt2W, sizeof(portname_lpt2W), NULL, 0, &needed);
1253 ok( res == ERROR_SUCCESS,
1254 "returned %d with %u and 0x%x (expected ERROR_SUCCESS)\n",
1255 res, GetLastError(), needed);
1256
1257
1258 needed = (DWORD) 0xdeadbeef;
1259 SetLastError(0xdeadbeef);
1260 res = pXcvDataPort(hXcv, cmd_PortIsValidW, (PBYTE) portname_com1W, sizeof(portname_com1W), NULL, 0, &needed);
1261 ok( res == ERROR_SUCCESS,
1262 "returned %d with %u and 0x%x (expected ERROR_SUCCESS)\n",
1263 res, GetLastError(), needed);
1264
1265
1266 needed = (DWORD) 0xdeadbeef;
1267 SetLastError(0xdeadbeef);
1268 res = pXcvDataPort(hXcv, cmd_PortIsValidW, (PBYTE) portname_com2W, sizeof(portname_com2W), NULL, 0, &needed);
1269 ok( res == ERROR_SUCCESS,
1270 "returned %d with %u and 0x%x (expected ERROR_SUCCESS)\n",
1271 res, GetLastError(), needed);
1272
1273
1274 needed = (DWORD) 0xdeadbeef;
1275 SetLastError(0xdeadbeef);
1276 res = pXcvDataPort(hXcv, cmd_PortIsValidW, (PBYTE) portname_fileW, sizeof(portname_fileW), NULL, 0, &needed);
1277 ok( res == ERROR_SUCCESS,
1278 "returned %d with %u and 0x%x (expected ERROR_SUCCESS)\n",
1279 res, GetLastError(), needed);
1280
1281
1282 /* a normal, writable file is allowed */
1283 needed = (DWORD) 0xdeadbeef;
1284 SetLastError(0xdeadbeef);
1285 res = pXcvDataPort(hXcv, cmd_PortIsValidW, (PBYTE) tempfileW, (lstrlenW(tempfileW) + 1) * sizeof(WCHAR), NULL, 0, &needed);
1286 ok( res == ERROR_SUCCESS,
1287 "returned %d with %u and 0x%x (expected ERROR_SUCCESS)\n",
1288 res, GetLastError(), needed);
1289
1290
1291 /* small check without access-rights: */
1292 if (!hXcv_noaccess) return;
1293
1294 /* The ACCESS_MASK from XcvOpenPort is ignored in "PortIsValid" */
1295 needed = (DWORD) 0xdeadbeef;
1296 SetLastError(0xdeadbeef);
1297 res = pXcvDataPort(hXcv_noaccess, cmd_PortIsValidW, (PBYTE) portname_lpt1W, sizeof(portname_lpt1W), NULL, 0, &needed);
1298 ok( res == ERROR_SUCCESS, "returned %d with %u (expected ERROR_SUCCESS)\n", res, GetLastError());
1299
1300 }
1301
1302 /* ########################### */
1303
1304 static void test_XcvOpenPort(void)
1305 {
1306 DWORD res;
1307 HANDLE hXcv2;
1308
1309
1310 if (0)
1311 {
1312 /* crash with native localspl.dll (w2k+xp) */
1313 pXcvOpenPort(NULL, SERVER_ACCESS_ADMINISTER, &hXcv2);
1314 pXcvOpenPort(emptyW, SERVER_ACCESS_ADMINISTER, NULL);
1315 }
1316
1317
1318 /* The returned handle is the result from a previous "spoolss.dll,DllAllocSplMem" */
1319 SetLastError(0xdeadbeef);
1320 hXcv2 = (HANDLE) 0xdeadbeef;
1321 res = pXcvOpenPort(emptyW, SERVER_ACCESS_ADMINISTER, &hXcv2);
1322 ok(res, "returned %d with %u and %p (expected '!= 0')\n", res, GetLastError(), hXcv2);
1323 if (res) pXcvClosePort(hXcv2);
1324
1325
1326 /* The ACCESS_MASK is not checked in XcvOpenPort */
1327 SetLastError(0xdeadbeef);
1328 hXcv2 = (HANDLE) 0xdeadbeef;
1329 res = pXcvOpenPort(emptyW, 0, &hXcv2);
1330 ok(res, "returned %d with %u and %p (expected '!= 0')\n", res, GetLastError(), hXcv2);
1331 if (res) pXcvClosePort(hXcv2);
1332
1333
1334 /* A copy of pszObject is saved in the Memory-Block */
1335 SetLastError(0xdeadbeef);
1336 hXcv2 = (HANDLE) 0xdeadbeef;
1337 res = pXcvOpenPort(portname_lpt1W, SERVER_ALL_ACCESS, &hXcv2);
1338 ok(res, "returned %d with %u and %p (expected '!= 0')\n", res, GetLastError(), hXcv2);
1339 if (res) pXcvClosePort(hXcv2);
1340
1341 SetLastError(0xdeadbeef);
1342 hXcv2 = (HANDLE) 0xdeadbeef;
1343 res = pXcvOpenPort(portname_fileW, SERVER_ALL_ACCESS, &hXcv2);
1344 ok(res, "returned %d with %u and %p (expected '!= 0')\n", res, GetLastError(), hXcv2);
1345 if (res) pXcvClosePort(hXcv2);
1346
1347 }
1348
1349 /* ########################### */
1350
1351 #define GET_MONITOR_FUNC(name) \
1352 if(numentries > 0) { \
1353 numentries--; \
1354 p##name = pm->Monitor.pfn##name ; \
1355 }
1356
1357
1358 START_TEST(localmon)
1359 {
1360 DWORD numentries;
1361 DWORD res;
1362
1363 LoadLibraryA("winspool.drv");
1364 /* This DLL does not exist on Win9x */
1365 hdll = LoadLibraryA("localspl.dll");
1366 if (!hdll) {
1367 skip("localspl.dll cannot be loaded, most likely running on Win9x\n");
1368 return;
1369 }
1370
1371 tempdirW[0] = '\0';
1372 tempfileW[0] = '\0';
1373 res = GetTempPathW(MAX_PATH, tempdirW);
1374 ok(res != 0, "with %u\n", GetLastError());
1375 res = GetTempFileNameW(tempdirW, wineW, 0, tempfileW);
1376 ok(res != 0, "with %u\n", GetLastError());
1377
1378 pInitializePrintMonitor = (void *) GetProcAddress(hdll, "InitializePrintMonitor");
1379
1380 if (!pInitializePrintMonitor) {
1381 /* The Monitor for "Local Ports" was in a separate dll before w2k */
1382 hlocalmon = LoadLibraryA("localmon.dll");
1383 if (hlocalmon) {
1384 pInitializePrintMonitor = (void *) GetProcAddress(hlocalmon, "InitializePrintMonitor");
1385 }
1386 }
1387 if (!pInitializePrintMonitor) return;
1388
1389 /* Native localmon.dll / localspl.dll need a valid Port-Entry in:
1390 a) since xp: HKLM\Software\Microsoft\Windows NT\CurrentVersion\Ports
1391 b) up to w2k: Section "Ports" in win.ini
1392 or InitializePrintMonitor fails. */
1393 pm = pInitializePrintMonitor(Monitors_LocalPortW);
1394 if (pm) {
1395 numentries = (pm->dwMonitorSize ) / sizeof(VOID *);
1396 /* NT4: 14, since w2k: 17 */
1397 ok( numentries == 14 || numentries == 17,
1398 "dwMonitorSize (%d) => %d Functions\n", pm->dwMonitorSize, numentries);
1399
1400 GET_MONITOR_FUNC(EnumPorts);
1401 GET_MONITOR_FUNC(OpenPort);
1402 GET_MONITOR_FUNC(OpenPortEx);
1403 GET_MONITOR_FUNC(StartDocPort);
1404 GET_MONITOR_FUNC(WritePort);
1405 GET_MONITOR_FUNC(ReadPort);
1406 GET_MONITOR_FUNC(EndDocPort);
1407 GET_MONITOR_FUNC(ClosePort);
1408 GET_MONITOR_FUNC(AddPort);
1409 GET_MONITOR_FUNC(AddPortEx);
1410 GET_MONITOR_FUNC(ConfigurePort);
1411 GET_MONITOR_FUNC(DeletePort);
1412 GET_MONITOR_FUNC(GetPrinterDataFromPort);
1413 GET_MONITOR_FUNC(SetPortTimeOuts);
1414 GET_MONITOR_FUNC(XcvOpenPort);
1415 GET_MONITOR_FUNC(XcvDataPort);
1416 GET_MONITOR_FUNC(XcvClosePort);
1417
1418 if ((pXcvOpenPort) && (pXcvDataPort) && (pXcvClosePort)) {
1419 SetLastError(0xdeadbeef);
1420 res = pXcvOpenPort(emptyW, SERVER_ACCESS_ADMINISTER, &hXcv);
1421 ok(res, "hXcv: %d with %u and %p (expected '!= 0')\n", res, GetLastError(), hXcv);
1422
1423 SetLastError(0xdeadbeef);
1424 res = pXcvOpenPort(emptyW, 0, &hXcv_noaccess);
1425 ok(res, "hXcv_noaccess: %d with %u and %p (expected '!= 0')\n", res, GetLastError(), hXcv_noaccess);
1426 }
1427 }
1428
1429 test_InitializePrintMonitor();
1430
1431 find_installed_ports();
1432
1433 test_AddPort();
1434 test_AddPortEx();
1435 test_ClosePort();
1436 test_ConfigurePort();
1437 test_DeletePort();
1438 test_EnumPorts();
1439 test_OpenPort();
1440
1441 if ( !hXcv ) {
1442 skip("Xcv not supported\n");
1443 }
1444 else
1445 {
1446 test_XcvClosePort();
1447 test_XcvDataPort_AddPort();
1448 test_XcvDataPort_ConfigureLPTPortCommandOK();
1449 test_XcvDataPort_DeletePort();
1450 test_XcvDataPort_GetTransmissionRetryTimeout();
1451 test_XcvDataPort_MonitorUI();
1452 test_XcvDataPort_PortIsValid();
1453 test_XcvOpenPort();
1454
1455 pXcvClosePort(hXcv);
1456 }
1457 if (hXcv_noaccess) pXcvClosePort(hXcv_noaccess);
1458
1459 /* Cleanup our temporary file */
1460 DeleteFileW(tempfileW);
1461 }