?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wininet: Implement InternetQueryOption(INTERNET_OPTION_CACHE_TIMESTAMPS).
[wine.git] / dlls / localspl / tests / localmon.c
blob23a3608d649914a415058c7d3a007c862467edab
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 WCHAR cmd_DeletePortW[] = {'D','e','l','e','t','e','P','o','r','t',0};
71 static 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 WCHAR cmd_MonitorUIW[] = {'M','o','n','i','t','o','r','U','I',0};
76 static WCHAR cmd_MonitorUI_lcaseW[] = {'m','o','n','i','t','o','r','u','i',0};
77 static 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 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 CHAR num_0A[] = "0";
91 static WCHAR num_0W[] = {'0',0};
92 static CHAR num_1A[] = "1";
93 static WCHAR num_1W[] = {'1',0};
94 static CHAR num_999999A[] = "999999";
95 static WCHAR num_999999W[] = {'9','9','9','9','9','9',0};
96 static CHAR num_1000000A[] = "1000000";
97 static WCHAR num_1000000W[] = {'1','0','0','0','0','0','0',0};
98
99 static 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 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 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 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 res = 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 res = 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 res = 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 res = pEnumPorts(NULL, level, NULL, cbBuf, &pcbNeeded, &pcReturned);
578 res = pEnumPorts(NULL, level, buffer, cbBuf, NULL, &pcReturned);
579 res = 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 res = pXcvClosePort(NULL);
752 res = 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 res = pXcvClosePort(hXcv2);
770 }
771 }
772 }
773
774 /* ########################### */
775
776 static void test_XcvDataPort_AddPort(void)
777 {
778 DWORD res;
779
780
781 /*
782 * The following tests crash with native localspl.dll on w2k and xp,
783 * but it works, when the native dll (w2k and xp) is used in wine.
784 * also tested (same crash): replacing emptyW with portname_lpt1W
785 * and replacing "NULL, 0, NULL" with "buffer, MAX_PATH, &needed"
786 *
787 * We need to use a different API (AddPortEx) instead
788 */
789 if (0)
790 {
791 /* create a Port for a normal, writable file */
792 SetLastError(0xdeadbeef);
793 res = pXcvDataPort(hXcv, cmd_AddPortW, (PBYTE) tempfileW, (lstrlenW(tempfileW) + 1) * sizeof(WCHAR), NULL, 0, NULL);
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
799 /* create a well-known Port */
800 SetLastError(0xdeadbeef);
801 res = pXcvDataPort(hXcv, cmd_AddPortW, (PBYTE) portname_lpt1W, (lstrlenW(portname_lpt1W) + 1) * sizeof(WCHAR), NULL, 0, NULL);
802
803 SetLastError(0xdeadbeef);
804 res = pXcvDataPort(hXcv, cmd_AddPortW, (PBYTE) portname_lpt1W, (lstrlenW(portname_lpt1W) + 1) * sizeof(WCHAR), NULL, 0, NULL);
805 /* native localspl.dll on wine: ERROR_ALREADY_EXISTS */
806
807 /* ERROR_ALREADY_EXISTS is also returned from native localspl.dll on wine,
808 when "RPT1:" was already installed for redmonnt.dll:
809 res = pXcvDataPort(hXcv, cmd_AddPortW, (PBYTE) portname_rpt1W, ...
810 */
811
812 /* cleanup */
813 SetLastError(0xdeadbeef);
814 res = pXcvDataPort(hXcv, cmd_DeletePortW, (PBYTE) tempfileW, (lstrlenW(tempfileW) + 1) * sizeof(WCHAR), NULL, 0, NULL);
815 }
816
817 }
818
819 /* ########################### */
820
821 static void test_XcvDataPort_ConfigureLPTPortCommandOK(void)
822 {
823 CHAR org_value[16];
824 CHAR buffer[16];
825 HKEY hroot = NULL;
826 DWORD res;
827 DWORD needed;
828
829
830 /* Read the original value from the registry */
831 res = RegOpenKeyExA(HKEY_LOCAL_MACHINE, WinNT_CV_WindowsA, 0, KEY_ALL_ACCESS, &hroot);
832 if (res == ERROR_ACCESS_DENIED) {
833 skip("ACCESS_DENIED\n");
834 return;
835 }
836
837 if (res != ERROR_SUCCESS) {
838 /* unable to open the registry: skip the test */
839 skip("got %d\n", res);
840 return;
841 }
842 org_value[0] = '\0';
843 needed = sizeof(org_value)-1 ;
844 res = RegQueryValueExA(hroot, TransmissionRetryTimeoutA, NULL, NULL, (PBYTE) org_value, &needed);
845 ok( (res == ERROR_SUCCESS) || (res == ERROR_FILE_NOT_FOUND),
846 "returned %u and %u for \"%s\" (expected ERROR_SUCCESS or "
847 "ERROR_FILE_NOT_FOUND)\n", res, needed, org_value);
848
849 RegDeleteValueA(hroot, TransmissionRetryTimeoutA);
850
851 /* set to "0" */
852 needed = (DWORD) 0xdeadbeef;
853 SetLastError(0xdeadbeef);
854 res = pXcvDataPort(hXcv, cmd_ConfigureLPTPortCommandOKW, (PBYTE) num_0W, sizeof(num_0W), NULL, 0, &needed);
855 if (res == ERROR_INVALID_PARAMETER) {
856 skip("'ConfigureLPTPortCommandOK' not supported\n");
857 return;
858 }
859 ok( res == ERROR_SUCCESS, "returned %d with %u (expected ERROR_SUCCESS)\n", res, GetLastError());
860 needed = sizeof(buffer)-1 ;
861 res = RegQueryValueExA(hroot, TransmissionRetryTimeoutA, NULL, NULL, (PBYTE) buffer, &needed);
862 ok( (res == ERROR_SUCCESS) && (lstrcmpA(buffer, num_0A) == 0),
863 "returned %d and '%s' (expected ERROR_SUCCESS and '%s')\n",
864 res, buffer, num_0A);
865
866
867 /* set to "1" */
868 needed = (DWORD) 0xdeadbeef;
869 SetLastError(0xdeadbeef);
870 res = pXcvDataPort(hXcv, cmd_ConfigureLPTPortCommandOKW, (PBYTE) num_1W, sizeof(num_1W), NULL, 0, &needed);
871 ok( res == ERROR_SUCCESS, "returned %d with %u (expected ERROR_SUCCESS)\n", res, GetLastError());
872 needed = sizeof(buffer)-1 ;
873 res = RegQueryValueExA(hroot, TransmissionRetryTimeoutA, NULL, NULL, (PBYTE) buffer, &needed);
874 ok( (res == ERROR_SUCCESS) && (lstrcmpA(buffer, num_1A) == 0),
875 "returned %d and '%s' (expected ERROR_SUCCESS and '%s')\n",
876 res, buffer, num_1A);
877
878 /* set to "999999" */
879 needed = (DWORD) 0xdeadbeef;
880 SetLastError(0xdeadbeef);
881 res = pXcvDataPort(hXcv, cmd_ConfigureLPTPortCommandOKW, (PBYTE) num_999999W, sizeof(num_999999W), NULL, 0, &needed);
882 ok( res == ERROR_SUCCESS, "returned %d with %u (expected ERROR_SUCCESS)\n", res, GetLastError());
883 needed = sizeof(buffer)-1 ;
884 res = RegQueryValueExA(hroot, TransmissionRetryTimeoutA, NULL, NULL, (PBYTE) buffer, &needed);
885 ok( (res == ERROR_SUCCESS) && (lstrcmpA(buffer, num_999999A) == 0),
886 "returned %d and '%s' (expected ERROR_SUCCESS and '%s')\n",
887 res, buffer, num_999999A);
888
889 /* set to "1000000" */
890 needed = (DWORD) 0xdeadbeef;
891 SetLastError(0xdeadbeef);
892 res = pXcvDataPort(hXcv, cmd_ConfigureLPTPortCommandOKW, (PBYTE) num_1000000W, sizeof(num_1000000W), NULL, 0, &needed);
893 ok( res == ERROR_SUCCESS, "returned %d with %u (expected ERROR_SUCCESS)\n", res, GetLastError());
894 needed = sizeof(buffer)-1 ;
895 res = RegQueryValueExA(hroot, TransmissionRetryTimeoutA, NULL, NULL, (PBYTE) buffer, &needed);
896 ok( (res == ERROR_SUCCESS) && (lstrcmpA(buffer, num_1000000A) == 0),
897 "returned %d and '%s' (expected ERROR_SUCCESS and '%s')\n",
898 res, buffer, num_1000000A);
899
900 /* using cmd_ConfigureLPTPortCommandOKW with does_not_existW:
901 the string "does_not_exist" is written to the registry */
902
903
904 /* restore the original value */
905 RegDeleteValueA(hroot, TransmissionRetryTimeoutA);
906 if (org_value[0]) {
907 res = RegSetValueExA(hroot, TransmissionRetryTimeoutA, 0, REG_SZ, (PBYTE)org_value, lstrlenA(org_value)+1);
908 ok(res == ERROR_SUCCESS, "unable to restore original value (got %u): %s\n", res, org_value);
909 }
910
911 RegCloseKey(hroot);
912
913 }
914
915 /* ########################### */
916
917 static void test_XcvDataPort_DeletePort(void)
918 {
919 DWORD res;
920 DWORD needed;
921
922
923 /* cleanup: just to make sure */
924 needed = (DWORD) 0xdeadbeef;
925 SetLastError(0xdeadbeef);
926 res = pXcvDataPort(hXcv, cmd_DeletePortW, (PBYTE) tempfileW, (lstrlenW(tempfileW) + 1) * sizeof(WCHAR), NULL, 0, &needed);
927 ok( !res || (res == ERROR_FILE_NOT_FOUND),
928 "returned %d with %u (expected ERROR_SUCCESS or ERROR_FILE_NOT_FOUND)\n",
929 res, GetLastError());
930
931
932 /* ToDo: cmd_AddPortW for tempfileW, then cmd_DeletePortW for the existing Port */
933
934
935 /* try to delete a nonexistent Port */
936 needed = (DWORD) 0xdeadbeef;
937 SetLastError(0xdeadbeef);
938 res = pXcvDataPort(hXcv, cmd_DeletePortW, (PBYTE) tempfileW, (lstrlenW(tempfileW) + 1) * sizeof(WCHAR), NULL, 0, &needed);
939 ok( res == ERROR_FILE_NOT_FOUND,
940 "returned %d with %u (expected ERROR_FILE_NOT_FOUND)\n", res, GetLastError());
941
942 /* emptyW as Portname: ERROR_FILE_NOT_FOUND is returned */
943 /* NULL as Portname: Native localspl.dll crashed */
944
945 }
946
947 /* ########################### */
948
949 static void test_XcvDataPort_GetTransmissionRetryTimeout(void)
950 {
951 CHAR org_value[16];
952 HKEY hroot = NULL;
953 DWORD buffer[2];
954 DWORD res;
955 DWORD needed;
956 DWORD len;
957
958
959 /* ask for needed size */
960 needed = (DWORD) 0xdeadbeef;
961 SetLastError(0xdeadbeef);
962 res = pXcvDataPort(hXcv, cmd_GetTransmissionRetryTimeoutW, NULL, 0, NULL, 0, &needed);
963 if (res == ERROR_INVALID_PARAMETER) {
964 skip("'GetTransmissionRetryTimeout' not supported\n");
965 return;
966 }
967 len = sizeof(DWORD);
968 ok( (res == ERROR_INSUFFICIENT_BUFFER) && (needed == len),
969 "returned %d with %u and %u (expected ERROR_INSUFFICIENT_BUFFER "
970 "and '%u')\n", res, GetLastError(), needed, len);
971 len = needed;
972
973 /* Read the original value from the registry */
974 res = RegOpenKeyExA(HKEY_LOCAL_MACHINE, WinNT_CV_WindowsA, 0, KEY_ALL_ACCESS, &hroot);
975 if (res == ERROR_ACCESS_DENIED) {
976 skip("ACCESS_DENIED\n");
977 return;
978 }
979
980 if (res != ERROR_SUCCESS) {
981 /* unable to open the registry: skip the test */
982 skip("got %d\n", res);
983 return;
984 }
985
986 org_value[0] = '\0';
987 needed = sizeof(org_value)-1 ;
988 res = RegQueryValueExA(hroot, TransmissionRetryTimeoutA, NULL, NULL, (PBYTE) org_value, &needed);
989 ok( (res == ERROR_SUCCESS) || (res == ERROR_FILE_NOT_FOUND),
990 "returned %u and %u for \"%s\" (expected ERROR_SUCCESS or "
991 "ERROR_FILE_NOT_FOUND)\n", res, needed, org_value);
992
993 /* Get default value (documented as 90 in the w2k reskit, but that is wrong) */
994 RegDeleteValueA(hroot, TransmissionRetryTimeoutA);
995 needed = (DWORD) 0xdeadbeef;
996 buffer[0] = 0xdeadbeef;
997 SetLastError(0xdeadbeef);
998 res = pXcvDataPort(hXcv, cmd_GetTransmissionRetryTimeoutW, NULL, 0, (PBYTE) buffer, len, &needed);
999 ok( (res == ERROR_SUCCESS) && (buffer[0] == 45),
1000 "returned %d with %u and %u for %d\n (expected ERROR_SUCCESS "
1001 "for '45')\n", res, GetLastError(), needed, buffer[0]);
1002
1003 /* the default timeout is returned, when the value is empty */
1004 res = RegSetValueExA(hroot, TransmissionRetryTimeoutA, 0, REG_SZ, (PBYTE)emptyA, 1);
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 needed = (DWORD) 0xdeadbeef;
1016 buffer[0] = 0xdeadbeef;
1017 SetLastError(0xdeadbeef);
1018 res = pXcvDataPort(hXcv, cmd_GetTransmissionRetryTimeoutW, NULL, 0, (PBYTE) buffer, len, &needed);
1019 ok( (res == ERROR_SUCCESS) && (buffer[0] == 0),
1020 "returned %d with %u and %u for %d\n (expected ERROR_SUCCESS "
1021 "for '0')\n", res, GetLastError(), needed, buffer[0]);
1022
1023
1024 res = RegSetValueExA(hroot, TransmissionRetryTimeoutA, 0, REG_SZ, (PBYTE)num_1A, lstrlenA(num_1A)+1);
1025 needed = (DWORD) 0xdeadbeef;
1026 buffer[0] = 0xdeadbeef;
1027 SetLastError(0xdeadbeef);
1028 res = pXcvDataPort(hXcv, cmd_GetTransmissionRetryTimeoutW, NULL, 0, (PBYTE) buffer, len, &needed);
1029 ok( (res == ERROR_SUCCESS) && (buffer[0] == 1),
1030 "returned %d with %u and %u for %d\n (expected 'ERROR_SUCCESS' "
1031 "for '1')\n", res, GetLastError(), needed, buffer[0]);
1032
1033 res = RegSetValueExA(hroot, TransmissionRetryTimeoutA, 0, REG_SZ, (PBYTE)num_999999A, lstrlenA(num_999999A)+1);
1034 needed = (DWORD) 0xdeadbeef;
1035 buffer[0] = 0xdeadbeef;
1036 SetLastError(0xdeadbeef);
1037 res = pXcvDataPort(hXcv, cmd_GetTransmissionRetryTimeoutW, NULL, 0, (PBYTE) buffer, len, &needed);
1038 ok( (res == ERROR_SUCCESS) && (buffer[0] == 999999),
1039 "returned %d with %u and %u for %d\n (expected ERROR_SUCCESS "
1040 "for '999999')\n", res, GetLastError(), needed, buffer[0]);
1041
1042
1043 res = RegSetValueExA(hroot, TransmissionRetryTimeoutA, 0, REG_SZ, (PBYTE)num_1000000A, lstrlenA(num_1000000A)+1);
1044 needed = (DWORD) 0xdeadbeef;
1045 buffer[0] = 0xdeadbeef;
1046 SetLastError(0xdeadbeef);
1047 res = pXcvDataPort(hXcv, cmd_GetTransmissionRetryTimeoutW, NULL, 0, (PBYTE) buffer, len, &needed);
1048 ok( (res == ERROR_SUCCESS) && (buffer[0] == 1000000),
1049 "returned %d with %u and %u for %d\n (expected ERROR_SUCCESS "
1050 "for '1000000')\n", res, GetLastError(), needed, buffer[0]);
1051
1052 /* restore the original value */
1053 RegDeleteValueA(hroot, TransmissionRetryTimeoutA);
1054 if (org_value[0]) {
1055 res = RegSetValueExA(hroot, TransmissionRetryTimeoutA, 0, REG_SZ, (PBYTE)org_value, lstrlenA(org_value)+1);
1056 ok(res == ERROR_SUCCESS, "unable to restore original value (got %u): %s\n", res, org_value);
1057 }
1058
1059 RegCloseKey(hroot);
1060 }
1061
1062 /* ########################### */
1063
1064 static void test_XcvDataPort_MonitorUI(void)
1065 {
1066 DWORD res;
1067 BYTE buffer[MAX_PATH + 2];
1068 DWORD needed;
1069 DWORD len;
1070
1071
1072 /* ask for needed size */
1073 needed = (DWORD) 0xdeadbeef;
1074 SetLastError(0xdeadbeef);
1075 res = pXcvDataPort(hXcv, cmd_MonitorUIW, NULL, 0, NULL, 0, &needed);
1076 if (res == ERROR_INVALID_PARAMETER) {
1077 skip("'MonitorUI' nor supported\n");
1078 return;
1079 }
1080 ok( (res == ERROR_INSUFFICIENT_BUFFER) && (needed <= MAX_PATH),
1081 "returned %d with %u and 0x%x (expected 'ERROR_INSUFFICIENT_BUFFER' "
1082 " and '<= MAX_PATH')\n", res, GetLastError(), needed);
1083
1084 if (needed > MAX_PATH) {
1085 skip("buffer overflow (%u)\n", needed);
1086 return;
1087 }
1088 len = needed;
1089
1090 /* the command is required */
1091 needed = (DWORD) 0xdeadbeef;
1092 SetLastError(0xdeadbeef);
1093 res = pXcvDataPort(hXcv, emptyW, NULL, 0, NULL, 0, &needed);
1094 ok( res == ERROR_INVALID_PARAMETER, "returned %d with %u and 0x%x "
1095 "(expected 'ERROR_INVALID_PARAMETER')\n", res, GetLastError(), needed);
1096
1097 if (0) {
1098 /* crash with native localspl.dll (w2k+xp) */
1099 res = pXcvDataPort(hXcv, NULL, NULL, 0, buffer, MAX_PATH, &needed);
1100 res = pXcvDataPort(hXcv, cmd_MonitorUIW, NULL, 0, NULL, len, &needed);
1101 res = pXcvDataPort(hXcv, cmd_MonitorUIW, NULL, 0, buffer, len, NULL);
1102 }
1103
1104
1105 /* hXcv is ignored for the command "MonitorUI" */
1106 needed = (DWORD) 0xdeadbeef;
1107 SetLastError(0xdeadbeef);
1108 res = pXcvDataPort(NULL, cmd_MonitorUIW, NULL, 0, buffer, len, &needed);
1109 ok( res == ERROR_SUCCESS, "returned %d with %u and 0x%x "
1110 "(expected 'ERROR_SUCCESS')\n", res, GetLastError(), needed);
1111
1112
1113 /* pszDataName is case-sensitive */
1114 memset(buffer, 0, len);
1115 needed = (DWORD) 0xdeadbeef;
1116 SetLastError(0xdeadbeef);
1117 res = pXcvDataPort(hXcv, cmd_MonitorUI_lcaseW, NULL, 0, buffer, len, &needed);
1118 ok( res == ERROR_INVALID_PARAMETER, "returned %d with %u and 0x%x "
1119 "(expected 'ERROR_INVALID_PARAMETER')\n", res, GetLastError(), needed);
1120
1121 /* off by one: larger */
1122 needed = (DWORD) 0xdeadbeef;
1123 SetLastError(0xdeadbeef);
1124 res = pXcvDataPort(hXcv, cmd_MonitorUIW, NULL, 0, buffer, len+1, &needed);
1125 ok( res == ERROR_SUCCESS, "returned %d with %u and 0x%x "
1126 "(expected 'ERROR_SUCCESS')\n", res, GetLastError(), needed);
1127
1128
1129 /* off by one: smaller */
1130 /* the buffer is not modified for NT4, w2k, XP */
1131 needed = (DWORD) 0xdeadbeef;
1132 SetLastError(0xdeadbeef);
1133 res = pXcvDataPort(hXcv, cmd_MonitorUIW, NULL, 0, buffer, len-1, &needed);
1134 ok( res == ERROR_INSUFFICIENT_BUFFER, "returned %d with %u and 0x%x "
1135 "(expected 'ERROR_INSUFFICIENT_BUFFER')\n", res, GetLastError(), needed);
1136
1137 /* Normal use. The DLL-Name without a Path is returned */
1138 memset(buffer, 0, len);
1139 needed = (DWORD) 0xdeadbeef;
1140 SetLastError(0xdeadbeef);
1141 res = pXcvDataPort(hXcv, cmd_MonitorUIW, NULL, 0, buffer, len, &needed);
1142 ok( res == ERROR_SUCCESS, "returned %d with %u and 0x%x "
1143 "(expected 'ERROR_SUCCESS')\n", res, GetLastError(), needed);
1144
1145
1146 /* small check without access-rights: */
1147 if (!hXcv_noaccess) return;
1148
1149 /* The ACCESS_MASK is ignored for "MonitorUI" */
1150 memset(buffer, 0, len);
1151 needed = (DWORD) 0xdeadbeef;
1152 SetLastError(0xdeadbeef);
1153 res = pXcvDataPort(hXcv_noaccess, cmd_MonitorUIW, NULL, 0, buffer, sizeof(buffer), &needed);
1154 ok( res == ERROR_SUCCESS, "returned %d with %u and 0x%x "
1155 "(expected 'ERROR_SUCCESS')\n", res, GetLastError(), needed);
1156 }
1157
1158 /* ########################### */
1159
1160 static void test_XcvDataPort_PortIsValid(void)
1161 {
1162 DWORD res;
1163 DWORD needed;
1164
1165 /* normal use: "LPT1:" */
1166 needed = (DWORD) 0xdeadbeef;
1167 SetLastError(0xdeadbeef);
1168 res = pXcvDataPort(hXcv, cmd_PortIsValidW, (PBYTE) portname_lpt1W, sizeof(portname_lpt1W), NULL, 0, &needed);
1169 if (res == ERROR_INVALID_PARAMETER) {
1170 skip("'PostIsValid' not supported\n");
1171 return;
1172 }
1173 ok( res == ERROR_SUCCESS, "returned %d with %u (expected ERROR_SUCCESS)\n", res, GetLastError());
1174
1175
1176 if (0) {
1177 /* crash with native localspl.dll (w2k+xp) */
1178 res = pXcvDataPort(hXcv, cmd_PortIsValidW, NULL, 0, NULL, 0, &needed);
1179 }
1180
1181
1182 /* hXcv is ignored for the command "PortIsValid" */
1183 needed = (DWORD) 0xdeadbeef;
1184 SetLastError(0xdeadbeef);
1185 res = pXcvDataPort(NULL, cmd_PortIsValidW, (PBYTE) portname_lpt1W, sizeof(portname_lpt1W), NULL, 0, NULL);
1186 ok( res == ERROR_SUCCESS, "returned %d with %u (expected ERROR_SUCCESS)\n", res, GetLastError());
1187
1188 /* needed is ignored */
1189 needed = (DWORD) 0xdeadbeef;
1190 SetLastError(0xdeadbeef);
1191 res = pXcvDataPort(hXcv, cmd_PortIsValidW, (PBYTE) portname_lpt1W, sizeof(portname_lpt1W), NULL, 0, NULL);
1192 ok( res == ERROR_SUCCESS, "returned %d with %u (expected ERROR_SUCCESS)\n", res, GetLastError());
1193
1194
1195 /* cbInputData is ignored */
1196 needed = (DWORD) 0xdeadbeef;
1197 SetLastError(0xdeadbeef);
1198 res = pXcvDataPort(hXcv, cmd_PortIsValidW, (PBYTE) portname_lpt1W, 0, NULL, 0, &needed);
1199 ok( res == ERROR_SUCCESS,
1200 "returned %d with %u and 0x%x (expected ERROR_SUCCESS)\n",
1201 res, GetLastError(), needed);
1202
1203 needed = (DWORD) 0xdeadbeef;
1204 SetLastError(0xdeadbeef);
1205 res = pXcvDataPort(hXcv, cmd_PortIsValidW, (PBYTE) portname_lpt1W, 1, NULL, 0, &needed);
1206 ok( res == ERROR_SUCCESS,
1207 "returned %d with %u and 0x%x (expected ERROR_SUCCESS)\n",
1208 res, GetLastError(), needed);
1209
1210 needed = (DWORD) 0xdeadbeef;
1211 SetLastError(0xdeadbeef);
1212 res = pXcvDataPort(hXcv, cmd_PortIsValidW, (PBYTE) portname_lpt1W, sizeof(portname_lpt1W) -1, NULL, 0, &needed);
1213 ok( res == ERROR_SUCCESS,
1214 "returned %d with %u and 0x%x (expected ERROR_SUCCESS)\n",
1215 res, GetLastError(), needed);
1216
1217 needed = (DWORD) 0xdeadbeef;
1218 SetLastError(0xdeadbeef);
1219 res = pXcvDataPort(hXcv, cmd_PortIsValidW, (PBYTE) portname_lpt1W, sizeof(portname_lpt1W) -2, NULL, 0, &needed);
1220 ok( res == ERROR_SUCCESS,
1221 "returned %d with %u and 0x%x (expected ERROR_SUCCESS)\n",
1222 res, GetLastError(), needed);
1223
1224
1225 /* an empty name is not allowed */
1226 needed = (DWORD) 0xdeadbeef;
1227 SetLastError(0xdeadbeef);
1228 res = pXcvDataPort(hXcv, cmd_PortIsValidW, (PBYTE) emptyW, sizeof(emptyW), NULL, 0, &needed);
1229 ok( res == ERROR_PATH_NOT_FOUND,
1230 "returned %d with %u and 0x%x (expected ERROR_PATH_NOT_FOUND)\n",
1231 res, GetLastError(), needed);
1232
1233
1234 /* a directory is not allowed */
1235 needed = (DWORD) 0xdeadbeef;
1236 SetLastError(0xdeadbeef);
1237 res = pXcvDataPort(hXcv, cmd_PortIsValidW, (PBYTE) tempdirW, (lstrlenW(tempdirW) + 1) * sizeof(WCHAR), NULL, 0, &needed);
1238 /* XP(admin): ERROR_INVALID_NAME, XP(user): ERROR_PATH_NOT_FOUND, w2k ERROR_ACCESS_DENIED */
1239 ok( (res == ERROR_INVALID_NAME) || (res == ERROR_PATH_NOT_FOUND) ||
1240 (res == ERROR_ACCESS_DENIED), "returned %d with %u and 0x%x "
1241 "(expected ERROR_INVALID_NAME, ERROR_PATH_NOT_FOUND or ERROR_ACCESS_DENIED)\n",
1242 res, GetLastError(), needed);
1243
1244
1245 /* test more valid well known Ports: */
1246 needed = (DWORD) 0xdeadbeef;
1247 SetLastError(0xdeadbeef);
1248 res = pXcvDataPort(hXcv, cmd_PortIsValidW, (PBYTE) portname_lpt2W, sizeof(portname_lpt2W), NULL, 0, &needed);
1249 ok( res == ERROR_SUCCESS,
1250 "returned %d with %u and 0x%x (expected ERROR_SUCCESS)\n",
1251 res, GetLastError(), needed);
1252
1253
1254 needed = (DWORD) 0xdeadbeef;
1255 SetLastError(0xdeadbeef);
1256 res = pXcvDataPort(hXcv, cmd_PortIsValidW, (PBYTE) portname_com1W, sizeof(portname_com1W), NULL, 0, &needed);
1257 ok( res == ERROR_SUCCESS,
1258 "returned %d with %u and 0x%x (expected ERROR_SUCCESS)\n",
1259 res, GetLastError(), needed);
1260
1261
1262 needed = (DWORD) 0xdeadbeef;
1263 SetLastError(0xdeadbeef);
1264 res = pXcvDataPort(hXcv, cmd_PortIsValidW, (PBYTE) portname_com2W, sizeof(portname_com2W), NULL, 0, &needed);
1265 ok( res == ERROR_SUCCESS,
1266 "returned %d with %u and 0x%x (expected ERROR_SUCCESS)\n",
1267 res, GetLastError(), needed);
1268
1269
1270 needed = (DWORD) 0xdeadbeef;
1271 SetLastError(0xdeadbeef);
1272 res = pXcvDataPort(hXcv, cmd_PortIsValidW, (PBYTE) portname_fileW, sizeof(portname_fileW), NULL, 0, &needed);
1273 ok( res == ERROR_SUCCESS,
1274 "returned %d with %u and 0x%x (expected ERROR_SUCCESS)\n",
1275 res, GetLastError(), needed);
1276
1277
1278 /* a normal, writable file is allowed */
1279 needed = (DWORD) 0xdeadbeef;
1280 SetLastError(0xdeadbeef);
1281 res = pXcvDataPort(hXcv, cmd_PortIsValidW, (PBYTE) tempfileW, (lstrlenW(tempfileW) + 1) * sizeof(WCHAR), NULL, 0, &needed);
1282 ok( res == ERROR_SUCCESS,
1283 "returned %d with %u and 0x%x (expected ERROR_SUCCESS)\n",
1284 res, GetLastError(), needed);
1285
1286
1287 /* small check without access-rights: */
1288 if (!hXcv_noaccess) return;
1289
1290 /* The ACCESS_MASK from XcvOpenPort is ignored in "PortIsValid" */
1291 needed = (DWORD) 0xdeadbeef;
1292 SetLastError(0xdeadbeef);
1293 res = pXcvDataPort(hXcv_noaccess, cmd_PortIsValidW, (PBYTE) portname_lpt1W, sizeof(portname_lpt1W), NULL, 0, &needed);
1294 ok( res == ERROR_SUCCESS, "returned %d with %u (expected ERROR_SUCCESS)\n", res, GetLastError());
1295
1296 }
1297
1298 /* ########################### */
1299
1300 static void test_XcvOpenPort(void)
1301 {
1302 DWORD res;
1303 HANDLE hXcv2;
1304
1305
1306 if (0)
1307 {
1308 /* crash with native localspl.dll (w2k+xp) */
1309 res = pXcvOpenPort(NULL, SERVER_ACCESS_ADMINISTER, &hXcv2);
1310 res = pXcvOpenPort(emptyW, SERVER_ACCESS_ADMINISTER, NULL);
1311 }
1312
1313
1314 /* The returned handle is the result from a previous "spoolss.dll,DllAllocSplMem" */
1315 SetLastError(0xdeadbeef);
1316 hXcv2 = (HANDLE) 0xdeadbeef;
1317 res = pXcvOpenPort(emptyW, SERVER_ACCESS_ADMINISTER, &hXcv2);
1318 ok(res, "returned %d with %u and %p (expected '!= 0')\n", res, GetLastError(), hXcv2);
1319 if (res) pXcvClosePort(hXcv2);
1320
1321
1322 /* The ACCESS_MASK is not checked in XcvOpenPort */
1323 SetLastError(0xdeadbeef);
1324 hXcv2 = (HANDLE) 0xdeadbeef;
1325 res = pXcvOpenPort(emptyW, 0, &hXcv2);
1326 ok(res, "returned %d with %u and %p (expected '!= 0')\n", res, GetLastError(), hXcv2);
1327 if (res) pXcvClosePort(hXcv2);
1328
1329
1330 /* A copy of pszObject is saved in the Memory-Block */
1331 SetLastError(0xdeadbeef);
1332 hXcv2 = (HANDLE) 0xdeadbeef;
1333 res = pXcvOpenPort(portname_lpt1W, SERVER_ALL_ACCESS, &hXcv2);
1334 ok(res, "returned %d with %u and %p (expected '!= 0')\n", res, GetLastError(), hXcv2);
1335 if (res) pXcvClosePort(hXcv2);
1336
1337 SetLastError(0xdeadbeef);
1338 hXcv2 = (HANDLE) 0xdeadbeef;
1339 res = pXcvOpenPort(portname_fileW, SERVER_ALL_ACCESS, &hXcv2);
1340 ok(res, "returned %d with %u and %p (expected '!= 0')\n", res, GetLastError(), hXcv2);
1341 if (res) pXcvClosePort(hXcv2);
1342
1343 }
1344
1345 /* ########################### */
1346
1347 #define GET_MONITOR_FUNC(name) \
1348 if(numentries > 0) { \
1349 numentries--; \
1350 p##name = pm->Monitor.pfn##name ; \
1351 }
1352
1353
1354 START_TEST(localmon)
1355 {
1356 DWORD numentries;
1357 DWORD res;
1358
1359 LoadLibraryA("winspool.drv");
1360 /* This DLL does not exist on Win9x */
1361 hdll = LoadLibraryA("localspl.dll");
1362 if (!hdll) {
1363 skip("localspl.dll cannot be loaded, most likely running on Win9x\n");
1364 return;
1365 }
1366
1367 tempdirW[0] = '\0';
1368 tempfileW[0] = '\0';
1369 res = GetTempPathW(MAX_PATH, tempdirW);
1370 ok(res != 0, "with %u\n", GetLastError());
1371 res = GetTempFileNameW(tempdirW, wineW, 0, tempfileW);
1372 ok(res != 0, "with %u\n", GetLastError());
1373
1374 pInitializePrintMonitor = (void *) GetProcAddress(hdll, "InitializePrintMonitor");
1375
1376 if (!pInitializePrintMonitor) {
1377 /* The Monitor for "Local Ports" was in a separate dll before w2k */
1378 hlocalmon = LoadLibraryA("localmon.dll");
1379 if (hlocalmon) {
1380 pInitializePrintMonitor = (void *) GetProcAddress(hlocalmon, "InitializePrintMonitor");
1381 }
1382 }
1383 if (!pInitializePrintMonitor) return;
1384
1385 /* Native localmon.dll / localspl.dll need a valid Port-Entry in:
1386 a) since xp: HKLM\Software\Microsoft\Windows NT\CurrentVersion\Ports
1387 b) up to w2k: Section "Ports" in win.ini
1388 or InitializePrintMonitor fails. */
1389 pm = pInitializePrintMonitor(Monitors_LocalPortW);
1390 if (pm) {
1391 numentries = (pm->dwMonitorSize ) / sizeof(VOID *);
1392 /* NT4: 14, since w2k: 17 */
1393 ok( numentries == 14 || numentries == 17,
1394 "dwMonitorSize (%d) => %d Functions\n", pm->dwMonitorSize, numentries);
1395
1396 GET_MONITOR_FUNC(EnumPorts);
1397 GET_MONITOR_FUNC(OpenPort);
1398 GET_MONITOR_FUNC(OpenPortEx);
1399 GET_MONITOR_FUNC(StartDocPort);
1400 GET_MONITOR_FUNC(WritePort);
1401 GET_MONITOR_FUNC(ReadPort);
1402 GET_MONITOR_FUNC(EndDocPort);
1403 GET_MONITOR_FUNC(ClosePort);
1404 GET_MONITOR_FUNC(AddPort);
1405 GET_MONITOR_FUNC(AddPortEx);
1406 GET_MONITOR_FUNC(ConfigurePort);
1407 GET_MONITOR_FUNC(DeletePort);
1408 GET_MONITOR_FUNC(GetPrinterDataFromPort);
1409 GET_MONITOR_FUNC(SetPortTimeOuts);
1410 GET_MONITOR_FUNC(XcvOpenPort);
1411 GET_MONITOR_FUNC(XcvDataPort);
1412 GET_MONITOR_FUNC(XcvClosePort);
1413
1414 if ((pXcvOpenPort) && (pXcvDataPort) && (pXcvClosePort)) {
1415 SetLastError(0xdeadbeef);
1416 res = pXcvOpenPort(emptyW, SERVER_ACCESS_ADMINISTER, &hXcv);
1417 ok(res, "hXcv: %d with %u and %p (expected '!= 0')\n", res, GetLastError(), hXcv);
1418
1419 SetLastError(0xdeadbeef);
1420 res = pXcvOpenPort(emptyW, 0, &hXcv_noaccess);
1421 ok(res, "hXcv_noaccess: %d with %u and %p (expected '!= 0')\n", res, GetLastError(), hXcv_noaccess);
1422 }
1423 }
1424
1425 test_InitializePrintMonitor();
1426
1427 find_installed_ports();
1428
1429 test_AddPort();
1430 test_AddPortEx();
1431 test_ClosePort();
1432 test_ConfigurePort();
1433 test_DeletePort();
1434 test_EnumPorts();
1435 test_OpenPort();
1436
1437 if ( !hXcv ) {
1438 skip("Xcv not supported\n");
1439 }
1440 else
1441 {
1442 test_XcvClosePort();
1443 test_XcvDataPort_AddPort();
1444 test_XcvDataPort_ConfigureLPTPortCommandOK();
1445 test_XcvDataPort_DeletePort();
1446 test_XcvDataPort_GetTransmissionRetryTimeout();
1447 test_XcvDataPort_MonitorUI();
1448 test_XcvDataPort_PortIsValid();
1449 test_XcvOpenPort();
1450
1451 pXcvClosePort(hXcv);
1452 }
1453 if (hXcv_noaccess) pXcvClosePort(hXcv_noaccess);
1454
1455 /* Cleanup our temporary file */
1456 DeleteFileW(tempfileW);
1457 }
Windows API implementation