?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
localspl/tests: Add tests for XcvDataPort_GetTransmissionRetryTimeout.
[wine/winequartzdrv.git] / dlls / localspl / tests / localmon.c
blob131e4e67170e08cdfe472462ceddb6a00c8c519c
1 /*
2 * Unit test suite for localspl API functions: local print monitor
3 *
4 * Copyright 2006 Detlef Riekenberg
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 *
20 */
21
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 HMODULE hlocalui;
62 static PMONITORUI (WINAPI *pInitializePrintMonitorUI)(VOID);
63 static PMONITORUI pui;
64 static BOOL (WINAPI *pAddPortUI)(PCWSTR, HWND, PCWSTR, PWSTR *);
65 static BOOL (WINAPI *pConfigurePortUI)(PCWSTR, HWND, PCWSTR);
66 static BOOL (WINAPI *pDeletePortUI)(PCWSTR, HWND, PCWSTR);
67
68
69 static WCHAR cmd_GetTransmissionRetryTimeoutW[] = {'G','e','t',
70 'T','r','a','n','s','m','i','s','s','i','o','n',
71 'R','e','t','r','y','T','i','m','e','o','u','t',0};
72
73 static WCHAR cmd_MonitorUIW[] = {'M','o','n','i','t','o','r','U','I',0};
74 static WCHAR cmd_MonitorUI_lcaseW[] = {'m','o','n','i','t','o','r','u','i',0};
75 static WCHAR cmd_PortIsValidW[] = {'P','o','r','t','I','s','V','a','l','i','d',0};
76 static WCHAR does_not_existW[] = {'d','o','e','s','_','n','o','t','_','e','x','i','s','t',0};
77 static CHAR emptyA[] = "";
78 static WCHAR emptyW[] = {0};
79 static WCHAR Monitors_LocalPortW[] = {
80 'S','y','s','t','e','m','\\',
81 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
82 'C','o','n','t','r','o','l','\\',
83 'P','r','i','n','t','\\',
84 'M','o','n','i','t','o','r','s','\\',
85 'L','o','c','a','l',' ','P','o','r','t',0};
86
87 static CHAR num_0A[] = "0";
88 static CHAR num_1A[] = "1";
89 static CHAR num_999999A[] = "999999";
90 static CHAR num_1000000A[] = "1000000";
91
92 static WCHAR portname_com1W[] = {'C','O','M','1',':',0};
93 static WCHAR portname_com2W[] = {'C','O','M','2',':',0};
94 static WCHAR portname_fileW[] = {'F','I','L','E',':',0};
95 static WCHAR portname_lpt1W[] = {'L','P','T','1',':',0};
96 static WCHAR portname_lpt2W[] = {'L','P','T','2',':',0};
97 static WCHAR server_does_not_existW[] = {'\\','\\','d','o','e','s','_','n','o','t','_','e','x','i','s','t',0};
98
99 static CHAR TransmissionRetryTimeoutA[] = {'T','r','a','n','s','m','i','s','s','i','o','n',
100 'R','e','t','r','y','T','i','m','e','o','u','t',0};
101
102 static CHAR WinNT_CV_WindowsA[] = {'S','o','f','t','w','a','r','e','\\',
103 'M','i','c','r','o','s','o','f','t','\\',
104 'W','i','n','d','o','w','s',' ','N','T','\\',
105 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
106 'W','i','n','d','o','w','s',0};
107 static WCHAR wineW[] = {'W','i','n','e',0};
108
109 static WCHAR tempdirW[MAX_PATH];
110 static WCHAR tempfileW[MAX_PATH];
111
112 /* ########################### */
113
114 static void test_AddPort(void)
115 {
116 DWORD res;
117
118 /* moved to localui.dll since w2k */
119 if (!pAddPort) return;
120
121 if (0)
122 {
123 /* NT4 crash on this test */
124 res = pAddPort(NULL, 0, NULL);
125 }
126
127 /* Testing-Results (localmon.dll from NT4.0):
128 - The Servername is ignored
129 - Case of MonitorName is ignored
130 */
131
132 SetLastError(0xdeadbeef);
133 res = pAddPort(NULL, 0, emptyW);
134 ok(!res, "returned %d with %u (expected '0')\n", res, GetLastError());
135
136 SetLastError(0xdeadbeef);
137 res = pAddPort(NULL, 0, does_not_existW);
138 ok(!res, "returned %d with %u (expected '0')\n", res, GetLastError());
139
140 }
141
142 /* ########################### */
143
144 static void test_ConfigurePort(void)
145 {
146 DWORD res;
147
148 /* moved to localui.dll since w2k */
149 if (!pConfigurePort) return;
150
151 if (0)
152 {
153 /* NT4 crash on this test */
154 res = pConfigurePort(NULL, 0, NULL);
155 }
156
157 /* Testing-Results (localmon.dll from NT4.0):
158 - Case of Portname is ignored
159 - "COM1:" and "COM01:" are the same (Compared by value)
160 - Portname without ":" => Dialog "Nothing to configure" comes up; Success
161 - "LPT1:", "LPT0:" and "LPT:" are the same (Numbers in "LPT:" are ignored)
162 - Empty Servername (LPT1:) => Dialog comes up (Servername is ignored)
163 - "FILE:" => Dialog "Nothing to configure" comes up; Success
164 - Empty Portname => => Dialog "Nothing to configure" comes up; Success
165 - Port "does_not_exist" => Dialog "Nothing to configure" comes up; Success
166 */
167 if (winetest_interactive > 0) {
168
169 SetLastError(0xdeadbeef);
170 res = pConfigurePort(NULL, 0, portname_com1W);
171 trace("returned %d with %u\n", res, GetLastError());
172
173 SetLastError(0xdeadbeef);
174 res = pConfigurePort(NULL, 0, portname_lpt1W);
175 trace("returned %d with %u\n", res, GetLastError());
176
177 SetLastError(0xdeadbeef);
178 res = pConfigurePort(NULL, 0, portname_fileW);
179 trace("returned %d with %u\n", res, GetLastError());
180 }
181 }
182
183 /* ########################### */
184
185 static void test_DeletePort(void)
186 {
187 DWORD res;
188
189 /* moved to localui.dll since w2k */
190 if (!pDeletePort) return;
191
192 if (0)
193 {
194 /* NT4 crash on this test */
195 res = pDeletePort(NULL, 0, NULL);
196 }
197
198 /* Testing-Results (localmon.dll from NT4.0):
199 - Case of Portname is ignored (returned '1' on Success)
200 - "COM1:" and "COM01:" are different (Compared as string)
201 - server_does_not_exist (LPT1:) => Port deleted, Success (Servername is ignored)
202 - Empty Portname => => FALSE (LastError not changed)
203 - Port "does_not_exist" => FALSE (LastError not changed)
204 */
205
206 SetLastError(0xdeadbeef);
207 res = pDeletePort(NULL, 0, emptyW);
208 ok(!res, "returned %d with %u (expected '0')\n", res, GetLastError());
209
210 SetLastError(0xdeadbeef);
211 res = pDeletePort(NULL, 0, does_not_existW);
212 ok(!res, "returned %d with %u (expected '0')\n", res, GetLastError());
213
214 }
215
216 /* ########################### */
217
218 static void test_EnumPorts(void)
219 {
220 DWORD res;
221 DWORD level;
222 LPBYTE buffer;
223 DWORD cbBuf;
224 DWORD pcbNeeded;
225 DWORD pcReturned;
226
227 if (!pEnumPorts) return;
228
229 /* valid levels are 1 and 2 */
230 for(level = 0; level < 4; level++) {
231
232 cbBuf = 0xdeadbeef;
233 pcReturned = 0xdeadbeef;
234 SetLastError(0xdeadbeef);
235 res = pEnumPorts(NULL, level, NULL, 0, &cbBuf, &pcReturned);
236
237 /* use only a short test, when we test with an invalid level */
238 if(!level || (level > 2)) {
239 /* NT4 fails with ERROR_INVALID_LEVEL (as expected)
240 XP succeeds with ERROR_SUCCESS () */
241 ok( (cbBuf == 0) && (pcReturned == 0),
242 "(%d) returned %d with %u and %d, %d (expected 0, 0)\n",
243 level, res, GetLastError(), cbBuf, pcReturned);
244 continue;
245 }
246
247 ok( !res && (GetLastError() == ERROR_INSUFFICIENT_BUFFER),
248 "(%d) returned %d with %u and %d, %d (expected '0' with "
249 "ERROR_INSUFFICIENT_BUFFER)\n",
250 level, res, GetLastError(), cbBuf, pcReturned);
251
252 buffer = HeapAlloc(GetProcessHeap(), 0, cbBuf * 2);
253 if (buffer == NULL) continue;
254
255 pcbNeeded = 0xdeadbeef;
256 pcReturned = 0xdeadbeef;
257 SetLastError(0xdeadbeef);
258 res = pEnumPorts(NULL, level, buffer, cbBuf, &pcbNeeded, &pcReturned);
259 ok( res, "(%d) returned %d with %u and %d, %d (expected '!= 0')\n",
260 level, res, GetLastError(), pcbNeeded, pcReturned);
261 /* We can compare the returned Data with the Registry / "win.ini",[Ports] here */
262
263 pcbNeeded = 0xdeadbeef;
264 pcReturned = 0xdeadbeef;
265 SetLastError(0xdeadbeef);
266 res = pEnumPorts(NULL, level, buffer, cbBuf+1, &pcbNeeded, &pcReturned);
267 ok( res, "(%d) returned %d with %u and %d, %d (expected '!= 0')\n",
268 level, res, GetLastError(), pcbNeeded, pcReturned);
269
270 pcbNeeded = 0xdeadbeef;
271 pcReturned = 0xdeadbeef;
272 SetLastError(0xdeadbeef);
273 res = pEnumPorts(NULL, level, buffer, cbBuf-1, &pcbNeeded, &pcReturned);
274 ok( !res && (GetLastError() == ERROR_INSUFFICIENT_BUFFER),
275 "(%d) returned %d with %u and %d, %d (expected '0' with "
276 "ERROR_INSUFFICIENT_BUFFER)\n",
277 level, res, GetLastError(), pcbNeeded, pcReturned);
278
279 if (0)
280 {
281 /* The following tests crash this app with native localmon/localspl */
282 res = pEnumPorts(NULL, level, NULL, cbBuf, &pcbNeeded, &pcReturned);
283 res = pEnumPorts(NULL, level, buffer, cbBuf, NULL, &pcReturned);
284 res = pEnumPorts(NULL, level, buffer, cbBuf, &pcbNeeded, NULL);
285 }
286
287 /* The Servername is ignored */
288 pcbNeeded = 0xdeadbeef;
289 pcReturned = 0xdeadbeef;
290 SetLastError(0xdeadbeef);
291 res = pEnumPorts(emptyW, level, buffer, cbBuf+1, &pcbNeeded, &pcReturned);
292 ok( res, "(%d) returned %d with %u and %d, %d (expected '!= 0')\n",
293 level, res, GetLastError(), pcbNeeded, pcReturned);
294
295 pcbNeeded = 0xdeadbeef;
296 pcReturned = 0xdeadbeef;
297 SetLastError(0xdeadbeef);
298 res = pEnumPorts(server_does_not_existW, level, buffer, cbBuf+1, &pcbNeeded, &pcReturned);
299 ok( res, "(%d) returned %d with %u and %d, %d (expected '!= 0')\n",
300 level, res, GetLastError(), pcbNeeded, pcReturned);
301
302 HeapFree(GetProcessHeap(), 0, buffer);
303 }
304 }
305
306 /* ########################### */
307
308
309 static void test_InitializePrintMonitor(void)
310 {
311 LPMONITOREX res;
312
313 SetLastError(0xdeadbeef);
314 res = pInitializePrintMonitor(NULL);
315 /* The Parameter was unchecked before w2k */
316 ok( res || (GetLastError() == ERROR_INVALID_PARAMETER),
317 "returned %p with %u\n (expected '!= NULL' or: NULL with "
318 "ERROR_INVALID_PARAMETER)\n", res, GetLastError());
319
320 SetLastError(0xdeadbeef);
321 res = pInitializePrintMonitor(emptyW);
322 ok( res || (GetLastError() == ERROR_INVALID_PARAMETER),
323 "returned %p with %u\n (expected '!= NULL' or: NULL with "
324 "ERROR_INVALID_PARAMETER)\n", res, GetLastError());
325
326
327 /* Every call with a non-empty string returns the same Pointer */
328 SetLastError(0xdeadbeef);
329 res = pInitializePrintMonitor(Monitors_LocalPortW);
330 ok( res == pm,
331 "returned %p with %u (expected %p)\n", res, GetLastError(), pm);
332 }
333
334 /* ########################### */
335
336 static void test_XcvClosePort(void)
337 {
338 DWORD res;
339 HANDLE hXcv;
340
341 if ((pXcvOpenPort == NULL) || (pXcvClosePort == NULL)) return;
342
343 if (0)
344 {
345 /* crash with native localspl.dll (w2k+xp) */
346 res = pXcvClosePort(NULL);
347 res = pXcvClosePort(INVALID_HANDLE_VALUE);
348 }
349
350
351 SetLastError(0xdeadbeef);
352 hXcv = (HANDLE) 0xdeadbeef;
353 res = pXcvOpenPort(emptyW, SERVER_ACCESS_ADMINISTER, &hXcv);
354 ok(res, "returned %d with %u and %p (expected '!= 0')\n", res, GetLastError(), hXcv);
355
356 if (res) {
357 SetLastError(0xdeadbeef);
358 res = pXcvClosePort(hXcv);
359 ok( res, "returned %d with %u (expected '!= 0')\n", res, GetLastError());
360
361 if (0)
362 {
363 /* test for "Double Free": crash with native localspl.dll (w2k+xp) */
364 res = pXcvClosePort(hXcv);
365 }
366 }
367 }
368
369 /* ########################### */
370
371 static void test_XcvDataPort_GetTransmissionRetryTimeout(void)
372 {
373 CHAR org_value[16];
374 HKEY hroot = NULL;
375 HANDLE hXcv;
376 DWORD buffer[2];
377 DWORD res;
378 DWORD needed;
379 DWORD len;
380
381
382 if ((pXcvOpenPort == NULL) || (pXcvDataPort == NULL) || (pXcvClosePort == NULL)) return;
383
384 hXcv = (HANDLE) 0xdeadbeef;
385 SetLastError(0xdeadbeef);
386 res = pXcvOpenPort(emptyW, SERVER_ACCESS_ADMINISTER, &hXcv);
387 ok(res, "hXcv: %d with %u and %p (expected '!= 0')\n", res, GetLastError(), hXcv);
388 if (!res) return;
389
390 /* ask for needed size */
391 needed = (DWORD) 0xdeadbeef;
392 SetLastError(0xdeadbeef);
393 res = pXcvDataPort(hXcv, cmd_GetTransmissionRetryTimeoutW, NULL, 0, NULL, 0, &needed);
394 if (res == ERROR_INVALID_PARAMETER) {
395 pXcvClosePort(hXcv);
396 skip("'GetTransmissionRetryTimeout' not supported\n");
397 return;
398 }
399 len = sizeof(DWORD);
400 ok( (res == ERROR_INSUFFICIENT_BUFFER) && (needed == len),
401 "returned %d with %u and %u (expected ERROR_INSUFFICIENT_BUFFER "
402 "and '%u')\n", res, GetLastError(), needed, len);
403 len = needed;
404
405 /* Read the original value from the registry */
406 res = RegOpenKeyExA(HKEY_LOCAL_MACHINE, WinNT_CV_WindowsA, 0, KEY_ALL_ACCESS, &hroot);
407 if (res == ERROR_ACCESS_DENIED) {
408 pXcvClosePort(hXcv);
409 skip("ACCESS_DENIED\n");
410 return;
411 }
412
413 if (res != ERROR_SUCCESS) {
414 /* unable to open the registry: skip the test */
415 pXcvClosePort(hXcv);
416 skip("got %d\n", res);
417 return;
418 }
419
420 org_value[0] = '\0';
421 needed = sizeof(org_value)-1 ;
422 res = RegQueryValueExA(hroot, TransmissionRetryTimeoutA, NULL, NULL, (PBYTE) org_value, &needed);
423 ok( (res == ERROR_SUCCESS) || (res == ERROR_FILE_NOT_FOUND),
424 "returned %u and %u for \"%s\" (expected ERROR_SUCCESS or "
425 "ERROR_FILE_NOT_FOUND)\n", res, needed, org_value);
426
427 /* Get default value (documented as 90 in the w2k reskit, but that is wrong) */
428 RegDeleteValueA(hroot, TransmissionRetryTimeoutA);
429 needed = (DWORD) 0xdeadbeef;
430 buffer[0] = 0xdeadbeef;
431 SetLastError(0xdeadbeef);
432 res = pXcvDataPort(hXcv, cmd_GetTransmissionRetryTimeoutW, NULL, 0, (PBYTE) buffer, len, &needed);
433 ok( (res == ERROR_SUCCESS) && (buffer[0] == 45),
434 "returned %d with %u and %u for %d\n (expected ERROR_SUCCESS "
435 "for '45')\n", res, GetLastError(), needed, buffer[0]);
436
437 /* the default timeout is returned, when the value is empty */
438 res = RegSetValueExA(hroot, TransmissionRetryTimeoutA, 0, REG_SZ, (PBYTE)emptyA, 1);
439 needed = (DWORD) 0xdeadbeef;
440 buffer[0] = 0xdeadbeef;
441 SetLastError(0xdeadbeef);
442 res = pXcvDataPort(hXcv, cmd_GetTransmissionRetryTimeoutW, NULL, 0, (PBYTE) buffer, len, &needed);
443 ok( (res == ERROR_SUCCESS) && (buffer[0] == 45),
444 "returned %d with %u and %u for %d\n (expected ERROR_SUCCESS "
445 "for '45')\n", res, GetLastError(), needed, buffer[0]);
446
447 /* the dialog is limited (1 - 999999), but that is done somewhere else */
448 res = RegSetValueExA(hroot, TransmissionRetryTimeoutA, 0, REG_SZ, (PBYTE)num_0A, lstrlenA(num_0A)+1);
449 needed = (DWORD) 0xdeadbeef;
450 buffer[0] = 0xdeadbeef;
451 SetLastError(0xdeadbeef);
452 res = pXcvDataPort(hXcv, cmd_GetTransmissionRetryTimeoutW, NULL, 0, (PBYTE) buffer, len, &needed);
453 ok( (res == ERROR_SUCCESS) && (buffer[0] == 0),
454 "returned %d with %u and %u for %d\n (expected ERROR_SUCCESS "
455 "for '0')\n", res, GetLastError(), needed, buffer[0]);
456
457
458 res = RegSetValueExA(hroot, TransmissionRetryTimeoutA, 0, REG_SZ, (PBYTE)num_1A, lstrlenA(num_1A)+1);
459 needed = (DWORD) 0xdeadbeef;
460 buffer[0] = 0xdeadbeef;
461 SetLastError(0xdeadbeef);
462 res = pXcvDataPort(hXcv, cmd_GetTransmissionRetryTimeoutW, NULL, 0, (PBYTE) buffer, len, &needed);
463 ok( (res == ERROR_SUCCESS) && (buffer[0] == 1),
464 "returned %d with %u and %u for %d\n (expected 'ERROR_SUCCESS' "
465 "for '1')\n", res, GetLastError(), needed, buffer[0]);
466
467 res = RegSetValueExA(hroot, TransmissionRetryTimeoutA, 0, REG_SZ, (PBYTE)num_999999A, lstrlenA(num_999999A)+1);
468 needed = (DWORD) 0xdeadbeef;
469 buffer[0] = 0xdeadbeef;
470 SetLastError(0xdeadbeef);
471 res = pXcvDataPort(hXcv, cmd_GetTransmissionRetryTimeoutW, NULL, 0, (PBYTE) buffer, len, &needed);
472 ok( (res == ERROR_SUCCESS) && (buffer[0] == 999999),
473 "returned %d with %u and %u for %d\n (expected ERROR_SUCCESS "
474 "for '999999')\n", res, GetLastError(), needed, buffer[0]);
475
476
477 res = RegSetValueExA(hroot, TransmissionRetryTimeoutA, 0, REG_SZ, (PBYTE)num_1000000A, lstrlenA(num_1000000A)+1);
478 needed = (DWORD) 0xdeadbeef;
479 buffer[0] = 0xdeadbeef;
480 SetLastError(0xdeadbeef);
481 res = pXcvDataPort(hXcv, cmd_GetTransmissionRetryTimeoutW, NULL, 0, (PBYTE) buffer, len, &needed);
482 ok( (res == ERROR_SUCCESS) && (buffer[0] == 1000000),
483 "returned %d with %u and %u for %d\n (expected ERROR_SUCCESS "
484 "for '1000000')\n", res, GetLastError(), needed, buffer[0]);
485
486 /* restore the original value */
487 RegDeleteValueA(hroot, TransmissionRetryTimeoutA);
488 if (org_value[0]) {
489 res = RegSetValueExA(hroot, TransmissionRetryTimeoutA, 0, REG_SZ, (PBYTE)org_value, lstrlenA(org_value)+1);
490 ok(res == ERROR_SUCCESS, "unable to restore original value (got %u): %s\n", res, org_value);
491 }
492
493 RegCloseKey(hroot);
494 pXcvClosePort(hXcv);
495 }
496
497 /* ########################### */
498
499 static void test_XcvDataPort_MonitorUI(void)
500 {
501 DWORD res;
502 HANDLE hXcv;
503 BYTE buffer[MAX_PATH + 2];
504 DWORD needed;
505 DWORD len;
506
507
508 if ((pXcvOpenPort == NULL) || (pXcvDataPort == NULL) || (pXcvClosePort == NULL)) return;
509
510 hXcv = (HANDLE) 0xdeadbeef;
511 SetLastError(0xdeadbeef);
512 res = pXcvOpenPort(emptyW, SERVER_ACCESS_ADMINISTER, &hXcv);
513 ok(res, "returned %d with %u and %p (expected '!= 0')\n", res, GetLastError(), hXcv);
514 if (!res) return;
515
516 /* ask for needed size */
517 needed = (DWORD) 0xdeadbeef;
518 SetLastError(0xdeadbeef);
519 res = pXcvDataPort(hXcv, cmd_MonitorUIW, NULL, 0, NULL, 0, &needed);
520 if (res == ERROR_INVALID_PARAMETER) {
521 pXcvClosePort(hXcv);
522 skip("'MonitorUI' nor supported\n");
523 return;
524 }
525 ok( (res == ERROR_INSUFFICIENT_BUFFER) && (needed <= MAX_PATH),
526 "returned %d with %u and 0x%x (expected 'ERROR_INSUFFICIENT_BUFFER' "
527 " and '<= MAX_PATH')\n", res, GetLastError(), needed);
528
529 if (needed > MAX_PATH) {
530 pXcvClosePort(hXcv);
531 skip("buffer overflow (%u)\n", needed);
532 return;
533 }
534 len = needed;
535
536 /* the command is required */
537 needed = (DWORD) 0xdeadbeef;
538 SetLastError(0xdeadbeef);
539 res = pXcvDataPort(hXcv, emptyW, NULL, 0, NULL, 0, &needed);
540 ok( res == ERROR_INVALID_PARAMETER, "returned %d with %u and 0x%x "
541 "(expected 'ERROR_INVALID_PARAMETER')\n", res, GetLastError(), needed);
542
543 if (0) {
544 /* crash with native localspl.dll (w2k+xp) */
545 res = pXcvDataPort(hXcv, NULL, NULL, 0, buffer, MAX_PATH, &needed);
546 res = pXcvDataPort(hXcv, cmd_MonitorUIW, NULL, 0, NULL, len, &needed);
547 res = pXcvDataPort(hXcv, cmd_MonitorUIW, NULL, 0, buffer, len, NULL);
548 }
549
550
551 /* hXcv is ignored for the command "MonitorUI" */
552 needed = (DWORD) 0xdeadbeef;
553 SetLastError(0xdeadbeef);
554 res = pXcvDataPort(NULL, cmd_MonitorUIW, NULL, 0, buffer, len, &needed);
555 ok( res == ERROR_SUCCESS, "returned %d with %u and 0x%x "
556 "(expected 'ERROR_SUCCESS')\n", res, GetLastError(), needed);
557
558
559 /* pszDataName is case-sensitive */
560 memset(buffer, 0, len);
561 needed = (DWORD) 0xdeadbeef;
562 SetLastError(0xdeadbeef);
563 res = pXcvDataPort(hXcv, cmd_MonitorUI_lcaseW, NULL, 0, buffer, len, &needed);
564 ok( res == ERROR_INVALID_PARAMETER, "returned %d with %u and 0x%x "
565 "(expected 'ERROR_INVALID_PARAMETER')\n", res, GetLastError(), needed);
566
567 /* off by one: larger */
568 needed = (DWORD) 0xdeadbeef;
569 SetLastError(0xdeadbeef);
570 res = pXcvDataPort(hXcv, cmd_MonitorUIW, NULL, 0, buffer, len+1, &needed);
571 ok( res == ERROR_SUCCESS, "returned %d with %u and 0x%x "
572 "(expected 'ERROR_SUCCESS')\n", res, GetLastError(), needed);
573
574
575 /* off by one: smaller */
576 /* the buffer is not modified for NT4, w2k, XP */
577 needed = (DWORD) 0xdeadbeef;
578 SetLastError(0xdeadbeef);
579 res = pXcvDataPort(hXcv, cmd_MonitorUIW, NULL, 0, buffer, len-1, &needed);
580 ok( res == ERROR_INSUFFICIENT_BUFFER, "returned %d with %u and 0x%x "
581 "(expected 'ERROR_INSUFFICIENT_BUFFER')\n", res, GetLastError(), needed);
582
583 /* Normal use. The DLL-Name without a Path is returned */
584 memset(buffer, 0, len);
585 needed = (DWORD) 0xdeadbeef;
586 SetLastError(0xdeadbeef);
587 res = pXcvDataPort(hXcv, cmd_MonitorUIW, NULL, 0, buffer, len, &needed);
588 ok( res == ERROR_SUCCESS, "returned %d with %u and 0x%x "
589 "(expected 'ERROR_SUCCESS')\n", res, GetLastError(), needed);
590
591
592 pXcvClosePort(hXcv);
593
594
595 /* small check without access-rights: */
596 hXcv = (HANDLE) 0xdeadbeef;
597 SetLastError(0xdeadbeef);
598 res = pXcvOpenPort(emptyW, 0, &hXcv);
599 ok(res, "returned %d with %u and %p (expected '!= 0')\n", res, GetLastError(), hXcv);
600 if (!res) return;
601
602 /* The ACCESS_MASK is ignored for "MonitorUI" */
603 memset(buffer, 0, len);
604 needed = (DWORD) 0xdeadbeef;
605 SetLastError(0xdeadbeef);
606 res = pXcvDataPort(hXcv, cmd_MonitorUIW, NULL, 0, buffer, sizeof(buffer), &needed);
607 ok( res == ERROR_SUCCESS, "returned %d with %u and 0x%x "
608 "(expected 'ERROR_SUCCESS')\n", res, GetLastError(), needed);
609
610 pXcvClosePort(hXcv);
611
612 }
613
614 /* ########################### */
615
616 static void test_XcvDataPort_PortIsValid(void)
617 {
618 DWORD res;
619 HANDLE hXcv;
620 DWORD needed;
621
622
623 if ((pXcvOpenPort == NULL) || (pXcvDataPort == NULL) || (pXcvClosePort == NULL)) return;
624
625 hXcv = (HANDLE) 0xdeadbeef;
626 SetLastError(0xdeadbeef);
627 res = pXcvOpenPort(emptyW, SERVER_ACCESS_ADMINISTER, &hXcv);
628 ok(res, "hXcv: %d with %u and %p (expected '!= 0')\n", res, GetLastError(), hXcv);
629 if (!res) return;
630
631 /* normal use: "LPT1:" */
632 needed = (DWORD) 0xdeadbeef;
633 SetLastError(0xdeadbeef);
634 res = pXcvDataPort(hXcv, cmd_PortIsValidW, (PBYTE) portname_lpt1W, sizeof(portname_lpt1W), NULL, 0, &needed);
635 if (res == ERROR_INVALID_PARAMETER) {
636 pXcvClosePort(hXcv);
637 skip("'PostIsValid' not supported\n");
638 return;
639 }
640 ok( res == ERROR_SUCCESS, "returned %d with %u (expected ERROR_SUCCESS)\n", res, GetLastError());
641
642
643 if (0) {
644 /* crash with native localspl.dll (w2k+xp) */
645 res = pXcvDataPort(hXcv, cmd_PortIsValidW, NULL, 0, NULL, 0, &needed);
646 }
647
648
649 /* hXcv is ignored for the command "PortIsValid" */
650 needed = (DWORD) 0xdeadbeef;
651 SetLastError(0xdeadbeef);
652 res = pXcvDataPort(NULL, cmd_PortIsValidW, (PBYTE) portname_lpt1W, sizeof(portname_lpt1W), NULL, 0, NULL);
653 ok( res == ERROR_SUCCESS, "returned %d with %u (expected ERROR_SUCCESS)\n", res, GetLastError());
654
655 /* needed is ignored */
656 needed = (DWORD) 0xdeadbeef;
657 SetLastError(0xdeadbeef);
658 res = pXcvDataPort(hXcv, cmd_PortIsValidW, (PBYTE) portname_lpt1W, sizeof(portname_lpt1W), NULL, 0, NULL);
659 ok( res == ERROR_SUCCESS, "returned %d with %u (expected ERROR_SUCCESS)\n", res, GetLastError());
660
661
662 /* cbInputData is ignored */
663 needed = (DWORD) 0xdeadbeef;
664 SetLastError(0xdeadbeef);
665 res = pXcvDataPort(hXcv, cmd_PortIsValidW, (PBYTE) portname_lpt1W, 0, NULL, 0, &needed);
666 ok( res == ERROR_SUCCESS,
667 "returned %d with %u and 0x%x (expected ERROR_SUCCESS)\n",
668 res, GetLastError(), needed);
669
670 needed = (DWORD) 0xdeadbeef;
671 SetLastError(0xdeadbeef);
672 res = pXcvDataPort(hXcv, cmd_PortIsValidW, (PBYTE) portname_lpt1W, 1, NULL, 0, &needed);
673 ok( res == ERROR_SUCCESS,
674 "returned %d with %u and 0x%x (expected ERROR_SUCCESS)\n",
675 res, GetLastError(), needed);
676
677 needed = (DWORD) 0xdeadbeef;
678 SetLastError(0xdeadbeef);
679 res = pXcvDataPort(hXcv, cmd_PortIsValidW, (PBYTE) portname_lpt1W, sizeof(portname_lpt1W) -1, NULL, 0, &needed);
680 ok( res == ERROR_SUCCESS,
681 "returned %d with %u and 0x%x (expected ERROR_SUCCESS)\n",
682 res, GetLastError(), needed);
683
684 needed = (DWORD) 0xdeadbeef;
685 SetLastError(0xdeadbeef);
686 res = pXcvDataPort(hXcv, cmd_PortIsValidW, (PBYTE) portname_lpt1W, sizeof(portname_lpt1W) -2, NULL, 0, &needed);
687 ok( res == ERROR_SUCCESS,
688 "returned %d with %u and 0x%x (expected ERROR_SUCCESS)\n",
689 res, GetLastError(), needed);
690
691
692 /* an empty name is not allowed */
693 needed = (DWORD) 0xdeadbeef;
694 SetLastError(0xdeadbeef);
695 res = pXcvDataPort(hXcv, cmd_PortIsValidW, (PBYTE) emptyW, sizeof(emptyW), NULL, 0, &needed);
696 ok( res == ERROR_PATH_NOT_FOUND,
697 "returned %d with %u and 0x%x (expected ERROR_PATH_NOT_FOUND)\n",
698 res, GetLastError(), needed);
699
700
701 /* a directory is not allowed */
702 needed = (DWORD) 0xdeadbeef;
703 SetLastError(0xdeadbeef);
704 res = pXcvDataPort(hXcv, cmd_PortIsValidW, (PBYTE) tempdirW, (lstrlenW(tempdirW) + 1) * sizeof(WCHAR), NULL, 0, &needed);
705 /* XP(admin): ERROR_INVALID_NAME, XP(user): ERROR_PATH_NOT_FOUND, w2k ERROR_ACCESS_DENIED */
706 ok( (res == ERROR_INVALID_NAME) || (res == ERROR_PATH_NOT_FOUND) ||
707 (res == ERROR_ACCESS_DENIED), "returned %d with %u and 0x%x "
708 "(expected ERROR_INVALID_NAME, ERROR_PATH_NOT_FOUND or ERROR_ACCESS_DENIED)\n",
709 res, GetLastError(), needed);
710
711
712 /* test more valid well known Ports: */
713 needed = (DWORD) 0xdeadbeef;
714 SetLastError(0xdeadbeef);
715 res = pXcvDataPort(hXcv, cmd_PortIsValidW, (PBYTE) portname_lpt2W, sizeof(portname_lpt2W), NULL, 0, &needed);
716 ok( res == ERROR_SUCCESS,
717 "returned %d with %u and 0x%x (expected ERROR_SUCCESS)\n",
718 res, GetLastError(), needed);
719
720
721 needed = (DWORD) 0xdeadbeef;
722 SetLastError(0xdeadbeef);
723 res = pXcvDataPort(hXcv, cmd_PortIsValidW, (PBYTE) portname_com1W, sizeof(portname_com1W), NULL, 0, &needed);
724 ok( res == ERROR_SUCCESS,
725 "returned %d with %u and 0x%x (expected ERROR_SUCCESS)\n",
726 res, GetLastError(), needed);
727
728
729 needed = (DWORD) 0xdeadbeef;
730 SetLastError(0xdeadbeef);
731 res = pXcvDataPort(hXcv, cmd_PortIsValidW, (PBYTE) portname_com2W, sizeof(portname_com2W), NULL, 0, &needed);
732 ok( res == ERROR_SUCCESS,
733 "returned %d with %u and 0x%x (expected ERROR_SUCCESS)\n",
734 res, GetLastError(), needed);
735
736
737 needed = (DWORD) 0xdeadbeef;
738 SetLastError(0xdeadbeef);
739 res = pXcvDataPort(hXcv, cmd_PortIsValidW, (PBYTE) portname_fileW, sizeof(portname_fileW), NULL, 0, &needed);
740 ok( res == ERROR_SUCCESS,
741 "returned %d with %u and 0x%x (expected ERROR_SUCCESS)\n",
742 res, GetLastError(), needed);
743
744
745 /* a normal, writable file is allowed */
746 needed = (DWORD) 0xdeadbeef;
747 SetLastError(0xdeadbeef);
748 res = pXcvDataPort(hXcv, cmd_PortIsValidW, (PBYTE) tempfileW, (lstrlenW(tempfileW) + 1) * sizeof(WCHAR), NULL, 0, &needed);
749 ok( res == ERROR_SUCCESS,
750 "returned %d with %u and 0x%x (expected ERROR_SUCCESS)\n",
751 res, GetLastError(), needed);
752
753 pXcvClosePort(hXcv);
754
755
756 /* small check without access-rights: */
757 hXcv = (HANDLE) 0xdeadbeef;
758 SetLastError(0xdeadbeef);
759 res = pXcvOpenPort(emptyW, 0, &hXcv);
760 ok(res, "returned %d with %u and %p (expected '!= 0')\n", res, GetLastError(), hXcv);
761 if (!res) return;
762
763 /* The ACCESS_MASK from XcvOpenPort is ignored in "PortIsValid" */
764 needed = (DWORD) 0xdeadbeef;
765 SetLastError(0xdeadbeef);
766 res = pXcvDataPort(hXcv, cmd_PortIsValidW, (PBYTE) portname_lpt1W, sizeof(portname_lpt1W), NULL, 0, &needed);
767 ok( res == ERROR_SUCCESS, "returned %d with %u (expected ERROR_SUCCESS)\n", res, GetLastError());
768
769 pXcvClosePort(hXcv);
770
771 }
772
773 /* ########################### */
774
775 static void test_XcvOpenPort(void)
776 {
777 DWORD res;
778 HANDLE hXcv;
779
780 if ((pXcvOpenPort == NULL) || (pXcvClosePort == NULL)) return;
781
782 if (0)
783 {
784 /* crash with native localspl.dll (w2k+xp) */
785 res = pXcvOpenPort(NULL, SERVER_ACCESS_ADMINISTER, &hXcv);
786 res = pXcvOpenPort(emptyW, SERVER_ACCESS_ADMINISTER, NULL);
787 }
788
789
790 /* The returned handle is the result from a previous "spoolss.dll,DllAllocSplMem" */
791 SetLastError(0xdeadbeef);
792 hXcv = (HANDLE) 0xdeadbeef;
793 res = pXcvOpenPort(emptyW, SERVER_ACCESS_ADMINISTER, &hXcv);
794 ok(res, "returned %d with %u and %p (expected '!= 0')\n", res, GetLastError(), hXcv);
795 if (res) pXcvClosePort(hXcv);
796
797
798 /* The ACCESS_MASK is not checked in XcvOpenPort */
799 SetLastError(0xdeadbeef);
800 hXcv = (HANDLE) 0xdeadbeef;
801 res = pXcvOpenPort(emptyW, 0, &hXcv);
802 ok(res, "returned %d with %u and %p (expected '!= 0')\n", res, GetLastError(), hXcv);
803 if (res) pXcvClosePort(hXcv);
804
805
806 /* A copy of pszObject is saved in the Memory-Block */
807 SetLastError(0xdeadbeef);
808 hXcv = (HANDLE) 0xdeadbeef;
809 res = pXcvOpenPort(portname_lpt1W, SERVER_ALL_ACCESS, &hXcv);
810 ok(res, "returned %d with %u and %p (expected '!= 0')\n", res, GetLastError(), hXcv);
811 if (res) pXcvClosePort(hXcv);
812
813 SetLastError(0xdeadbeef);
814 hXcv = (HANDLE) 0xdeadbeef;
815 res = pXcvOpenPort(portname_fileW, SERVER_ALL_ACCESS, &hXcv);
816 ok(res, "returned %d with %u and %p (expected '!= 0')\n", res, GetLastError(), hXcv);
817 if (res) pXcvClosePort(hXcv);
818
819 }
820
821 /* ########################### */
822
823 #define GET_MONITOR_FUNC(name) \
824 if(numentries > 0) { \
825 numentries--; \
826 p##name = (void *) pm->Monitor.pfn##name ; \
827 }
828
829
830 START_TEST(localmon)
831 {
832 DWORD numentries;
833 DWORD res;
834
835 /* This DLL does not exist on Win9x */
836 hdll = LoadLibraryA("localspl.dll");
837 if (!hdll) return;
838
839 tempdirW[0] = '\0';
840 tempfileW[0] = '\0';
841 res = GetTempPathW(MAX_PATH, tempdirW);
842 ok(res != 0, "with %u\n", GetLastError());
843 res = GetTempFileNameW(tempdirW, wineW, 0, tempfileW);
844 ok(res != 0, "with %u\n", GetLastError());
845
846 pInitializePrintMonitor = (void *) GetProcAddress(hdll, "InitializePrintMonitor");
847 pInitializePrintMonitorUI = (void *) GetProcAddress(hdll, "InitializePrintMonitorUI");
848
849 if (!pInitializePrintMonitor) {
850 /* The Monitor for "Local Ports" was in a seperate dll before w2k */
851 hlocalmon = LoadLibraryA("localmon.dll");
852 if (hlocalmon) {
853 pInitializePrintMonitor = (void *) GetProcAddress(hlocalmon, "InitializePrintMonitor");
854 }
855 }
856 if (!pInitializePrintMonitor) return;
857
858 /* Native localmon.dll / localspl.dll need a vaild Port-Entry in:
859 a) since xp: HKLM\Software\Microsoft\Windows NT\CurrentVersion\Ports
860 b) up to w2k: Section "Ports" in win.ini
861 or InitializePrintMonitor fails. */
862 pm = pInitializePrintMonitor(Monitors_LocalPortW);
863 if (pm) {
864 numentries = (pm->dwMonitorSize ) / sizeof(VOID *);
865 /* NT4: 14, since w2k: 17 */
866 ok( numentries == 14 || numentries == 17,
867 "dwMonitorSize (%d) => %d Functions\n", pm->dwMonitorSize, numentries);
868
869 GET_MONITOR_FUNC(EnumPorts);
870 GET_MONITOR_FUNC(OpenPort);
871 GET_MONITOR_FUNC(OpenPortEx);
872 GET_MONITOR_FUNC(StartDocPort);
873 GET_MONITOR_FUNC(WritePort);
874 GET_MONITOR_FUNC(ReadPort);
875 GET_MONITOR_FUNC(EndDocPort);
876 GET_MONITOR_FUNC(ClosePort);
877 GET_MONITOR_FUNC(AddPort);
878 GET_MONITOR_FUNC(AddPortEx);
879 GET_MONITOR_FUNC(ConfigurePort);
880 GET_MONITOR_FUNC(DeletePort);
881 GET_MONITOR_FUNC(GetPrinterDataFromPort);
882 GET_MONITOR_FUNC(SetPortTimeOuts);
883 GET_MONITOR_FUNC(XcvOpenPort);
884 GET_MONITOR_FUNC(XcvDataPort);
885 GET_MONITOR_FUNC(XcvClosePort);
886 }
887
888 if ((!pInitializePrintMonitorUI) && (pXcvOpenPort) && (pXcvDataPort) && (pXcvClosePort)) {
889 /* The user interface for "Local Ports" is in a separate dll since w2k */
890 BYTE buffer[MAX_PATH];
891 DWORD res;
892 DWORD len;
893 HANDLE hXcv;
894
895 res = pXcvOpenPort(emptyW, SERVER_ACCESS_ADMINISTER, &hXcv);
896 if (res) {
897 res = pXcvDataPort(hXcv, cmd_MonitorUIW, NULL, 0, buffer, MAX_PATH, &len);
898 if (res == ERROR_SUCCESS) hlocalui = LoadLibraryW( (LPWSTR) buffer);
899 if (hlocalui) pInitializePrintMonitorUI = (void *) GetProcAddress(hlocalui, "InitializePrintMonitorUI");
900 pXcvClosePort(hXcv);
901 }
902 }
903
904 if (pInitializePrintMonitorUI) {
905 pui = pInitializePrintMonitorUI();
906 if (pui) {
907 numentries = (pui->dwMonitorUISize - sizeof(DWORD)) / sizeof(VOID *);
908 ok( numentries == 3,
909 "dwMonitorUISize (%d) => %d Functions\n", pui->dwMonitorUISize, numentries);
910
911 if (numentries > 2) {
912 pAddPortUI = pui->pfnAddPortUI;
913 pConfigurePortUI = pui->pfnConfigurePortUI;
914 pDeletePortUI = pui->pfnDeletePortUI;
915 }
916 }
917 }
918
919 test_InitializePrintMonitor();
920
921 test_AddPort();
922 test_ConfigurePort();
923 test_DeletePort();
924 test_EnumPorts();
925 test_XcvClosePort();
926 test_XcvDataPort_GetTransmissionRetryTimeout();
927 test_XcvDataPort_MonitorUI();
928 test_XcvDataPort_PortIsValid();
929 test_XcvOpenPort();
930 }
quartzdrv for OS X