ReactOS  0.4.14-dev-41-g31d7680
localmon.c
Go to the documentation of this file.
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 }
Monitors_LocalPortW
static WCHAR Monitors_LocalPortW[]
Definition: localmon.c:82
phXcv
static PHANDLE phXcv
Definition: localmon.c:57
ERROR_INVALID_PARAMETER
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
RegQueryValueExA
LONG WINAPI RegQueryValueExA(_In_ HKEY hkeyorg, _In_ LPCSTR name, _In_ LPDWORD reserved, _Out_opt_ LPDWORD type, _Out_opt_ LPBYTE data, _Inout_opt_ LPDWORD count)
Definition: reg.c:4023
level
GLint level
Definition: gl.h:1546
num_1A
static const CHAR num_1A[]
Definition: localmon.c:92
ERROR_SUCCESS
#define ERROR_SUCCESS
Definition: deptool.c:10
PORTNAME_MAXSIZE
#define PORTNAME_MAXSIZE
Definition: localmon.c:123
ACCESS_MASK
static ACCESS_MASK
Definition: localmon.c:57
GET_MONITOR_FUNC
#define GET_MONITOR_FUNC(name)
Definition: localmon.c:1351
HWND
static HWND
Definition: localmon.c:51
LPDWORD
static LPDWORD
Definition: localmon.c:43
PORT_TYPE_WRITE
#define PORT_TYPE_WRITE
Definition: winspool.h:683
CHAR
char CHAR
Definition: xmlstorage.h:175
TransmissionRetryTimeoutA
static const CHAR TransmissionRetryTimeoutA[]
Definition: localmon.c:108
test_XcvClosePort
static void test_XcvClosePort(void)
Definition: localmon.c:742
pm
static LPMONITOREX pm
Definition: localmon.c:42
test_XcvDataPort_DeletePort
static void test_XcvDataPort_DeletePort(void)
Definition: localmon.c:916
cmd_GetTransmissionRetryTimeoutW
static const WCHAR cmd_GetTransmissionRetryTimeoutW[]
Definition: localmon.c:71
ReadPort
BOOL WINAPI ReadPort(_In_ HANDLE hPort, _Out_writes_bytes_(cbBuffer) LPBYTE pBuffer, _In_ DWORD cbBuffer, _Out_ LPDWORD pcbRead)
num_999999W
static WCHAR num_999999W[]
Definition: localmon.c:95
test_OpenPort
static void test_OpenPort(void)
Definition: localmon.c:632
RegOpenKeyExA
LONG WINAPI RegOpenKeyExA(_In_ HKEY hKey, _In_ LPCSTR lpSubKey, _In_ DWORD ulOptions, _In_ REGSAM samDesired, _Out_ PHKEY phkResult)
Definition: reg.c:3331
INVALID_HANDLE_VALUE
#define INVALID_HANDLE_VALUE
Definition: compat.h:391
lstrcmpA
int WINAPI lstrcmpA(LPCSTR lpString1, LPCSTR lpString2)
Definition: lstring.c:18
num_1000000W
static WCHAR num_1000000W[]
Definition: localmon.c:97
GetLastError
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1059
LPCWSTR
static LPCWSTR
Definition: localmon.c:58
buffer
GLuint buffer
Definition: glext.h:5915
test_ConfigurePort
static void test_ConfigurePort(void)
Definition: localmon.c:439
START_TEST
START_TEST(localmon)
Definition: localmon.c:1358
tempdirW
static WCHAR tempdirW[MAX_PATH]
Definition: localmon.c:118
test_XcvDataPort_PortIsValid
static void test_XcvDataPort_PortIsValid(void)
Definition: localmon.c:1164
ClosePort
BOOL WINAPI ClosePort(_In_ HANDLE hPort)
winetest_interactive
int winetest_interactive
DeletePort
#define DeletePort
Definition: winspool.h:1151
cmd_AddPortW
static const WCHAR cmd_AddPortW[]
Definition: localmon.c:66
emptyA
static const CHAR emptyA[]
Definition: localmon.c:79
WinNT_CV_WindowsA
static const CHAR WinNT_CV_WindowsA[]
Definition: localmon.c:111
lstrlenW
#define lstrlenW
Definition: compat.h:407
cmd_DeletePortW
static const WCHAR cmd_DeletePortW[]
Definition: localmon.c:70
SERVER_ALL_ACCESS
#define SERVER_ALL_ACCESS
Definition: winspool.h:1282
lstrcmpiW
int WINAPI lstrcmpiW(LPCWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:194
LPBYTE
static LPBYTE
Definition: localmon.c:43
cmd_PortIsValidW
static const WCHAR cmd_PortIsValidW[]
Definition: localmon.c:77
num_0A
static const CHAR num_0A[]
Definition: localmon.c:90
_MONITOR::pcReturned
_In_ DWORD _In_ DWORD _Out_ LPDWORD _Out_ LPDWORD pcReturned
Definition: winsplp.h:761
test_XcvDataPort_ConfigureLPTPortCommandOK
static void test_XcvDataPort_ConfigureLPTPortCommandOK(void)
Definition: localmon.c:820
portname_comW
static const WCHAR portname_comW[]
Definition: localmon.c:99
RegCloseKey
LONG WINAPI RegCloseKey(HKEY hKey)
Definition: reg.c:423
LPBYTE
unsigned char * LPBYTE
Definition: typedefs.h:52
cmd_ConfigureLPTPortCommandOKW
static const WCHAR cmd_ConfigureLPTPortCommandOKW[]
Definition: localmon.c:67
GetTempPathW
DWORD WINAPI GetTempPathW(IN DWORD count, OUT LPWSTR path)
Definition: path.c:2079
wineW
static WCHAR wineW[]
Definition: localmon.c:116
have_com
static WCHAR have_com[PORTNAME_MAXSIZE]
Definition: localmon.c:124
_MONITOR::cbBuf
_In_ DWORD _In_ DWORD cbBuf
Definition: winsplp.h:761
ERROR_ACCESS_DENIED
#define ERROR_ACCESS_DENIED
Definition: compat.h:87
emptyW
static WCHAR emptyW[]
Definition: localmon.c:80
LPWSTR
static LPWSTR
Definition: localmon.c:45
LoadLibraryA
HINSTANCE WINAPI DECLSPEC_HOTPATCH LoadLibraryA(LPCSTR lpLibFileName)
Definition: loader.c:111
num_999999A
static const CHAR num_999999A[]
Definition: localmon.c:94
DeleteFileW
BOOL WINAPI DeleteFileW(IN LPCWSTR lpFileName)
Definition: delete.c:39
AddPort
#define AddPort
Definition: winspool.h:1149
hXcv_noaccess
static HANDLE hXcv_noaccess
Definition: localmon.c:62
find_installed_ports
static void find_installed_ports(void)
Definition: localmon.c:146
NULL
smooth NULL
Definition: ftsmooth.c:416
DWORD
static DWORD
Definition: localmon.c:43
_PORT_INFO_1W
Definition: winspool.h:655
portname_lptW
static const WCHAR portname_lptW[]
Definition: localmon.c:103
PORTNAME_PREFIX
#define PORTNAME_PREFIX
Definition: localmon.c:121
ERROR_FILE_NOT_FOUND
#define ERROR_FILE_NOT_FOUND
Definition: disk.h:79
have_lpt
static WCHAR have_lpt[PORTNAME_MAXSIZE]
Definition: localmon.c:125
portname_fileW
static WCHAR portname_fileW[]
Definition: localmon.c:102
nameW
static const WCHAR nameW[]
Definition: main.c:46
pName
static LPSTR pName
Definition: security.c:75
BOOL
static BOOL(WINAPI *pEnumPorts)(LPWSTR
GetProcessHeap
#define GetProcessHeap()
Definition: compat.h:395
trace
#define trace
Definition: atltest.h:70
HeapAlloc
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180
PDWORD
static PDWORD
Definition: localmon.c:58
PORTNAME_MINSIZE
#define PORTNAME_MINSIZE
Definition: localmon.c:122
MAX_PATH
#define MAX_PATH
Definition: compat.h:26
test_AddPortEx
static void test_AddPortEx(void)
Definition: localmon.c:232
WINAPI
#define WINAPI
Definition: msvc.h:8
GetTempFileNameW
UINT WINAPI GetTempFileNameW(IN LPCWSTR lpPathName, IN LPCWSTR lpPrefixString, IN UINT uUnique, OUT LPWSTR lpTempFileName)
Definition: filename.c:84
XcvDataPort
DWORD WINAPI XcvDataPort(_In_ HANDLE hXcv, _In_ LPCWSTR pszDataName, _In_reads_bytes_(cbInputData) PBYTE pInputData, _In_ DWORD cbInputData, _Out_writes_bytes_(cbOutputData) PBYTE pOutputData, _In_ DWORD cbOutputData, _Out_ PDWORD pcbOutputNeeded)
portname_lpt2W
static WCHAR portname_lpt2W[]
Definition: localmon.c:105
DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95
HANDLE
PVOID HANDLE
Definition: typedefs.h:71
SetLastError
#define SetLastError(x)
Definition: compat.h:409
pi
static DWORD pi
Definition: protocol.c:150
test_XcvOpenPort
static void test_XcvOpenPort(void)
Definition: localmon.c:1304
XcvOpenPort
BOOL WINAPI XcvOpenPort(_In_ LPCWSTR pszObject, _In_ ACCESS_MASK GrantedAccess, _Out_ PHANDLE phXcv)
_MONITOREX
Definition: winsplp.h:862
PHANDLE
PVOID *typedef PHANDLE
Definition: ntsecpkg.h:414
test_EnumPorts
static void test_EnumPorts(void)
Definition: localmon.c:513
num_1W
static WCHAR num_1W[]
Definition: localmon.c:93
memcpy
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
len
GLenum GLsizei len
Definition: glext.h:6722
num_1000000A
static const CHAR num_1000000A[]
Definition: localmon.c:96
BYTE
unsigned char BYTE
Definition: mem.h:68
PBYTE
static PBYTE
Definition: localmon.c:58
_MONITOR
Definition: winsplp.h:754
hlocalmon
static HMODULE hlocalmon
Definition: localmon.c:39
LPCOMMTIMEOUTS
static LPCOMMTIMEOUTS
Definition: localmon.c:56
cmd_MonitorUIW
static const WCHAR cmd_MonitorUIW[]
Definition: localmon.c:75
portname_lpt1W
static WCHAR portname_lpt1W[]
Definition: localmon.c:104
ConfigurePort
#define ConfigurePort
Definition: winspool.h:1150
test_InitializePrintMonitor
static void test_InitializePrintMonitor(void)
Definition: localmon.c:604
delete_port
static DWORD delete_port(LPWSTR portname)
Definition: localmon.c:130
does_not_existW
static WCHAR does_not_existW[]
Definition: localmon.c:78
lstrlenA
int WINAPI lstrlenA(LPCSTR lpString)
Definition: lstring.c:145
pcbNeeded
_In_ DWORD _Out_ PDWORD pcbNeeded
Definition: winddi.h:3827
test_AddPort
static void test_AddPort(void)
Definition: localmon.c:202
KEY_ALL_ACCESS
#define KEY_ALL_ACCESS
Definition: nt_native.h:1041
ok
#define ok(value,...)
Definition: atltest.h:57
RegDeleteValueA
LONG WINAPI RegDeleteValueA(HKEY hKey, LPCSTR lpValueName)
Definition: reg.c:2319
WritePort
BOOL WINAPI WritePort(_In_ HANDLE hPort, _In_reads_bytes_(cbBuf) LPBYTE pBuffer, _In_ DWORD cbBuf, _Out_ LPDWORD pcbWritten)
EnumPorts
#define EnumPorts
Definition: winspool.h:1148
SERVER_ACCESS_ADMINISTER
#define SERVER_ACCESS_ADMINISTER
Definition: winspool.h:1273
test_DeletePort
static void test_DeletePort(void)
Definition: localmon.c:480
have_file
static WCHAR have_file[PORTNAME_MAXSIZE]
Definition: localmon.c:126
LocalPortW
static WCHAR LocalPortW[]
Definition: localmon.c:81
skip
#define skip(...)
Definition: atltest.h:64
PHANDLE
static PHANDLE
Definition: localmon.c:44
num_0W
static WCHAR num_0W[]
Definition: localmon.c:91
_MONITOREX::dwMonitorSize
DWORD dwMonitorSize
Definition: winsplp.h:863
res
GLuint res
Definition: glext.h:9613
id
GLenum GLuint id
Definition: glext.h:5579
OpenPort
BOOL WINAPI OpenPort(_In_ LPWSTR pName, _Out_ PHANDLE pHandle)
server_does_not_existW
static WCHAR server_does_not_existW[]
Definition: localmon.c:106
ERROR_INVALID_NAME
#define ERROR_INVALID_NAME
Definition: compat.h:93
GetProcAddress
#define GetProcAddress(x, y)
Definition: compat.h:410
ERROR_PATH_NOT_FOUND
#define ERROR_PATH_NOT_FOUND
Definition: winerror.h:106
ERROR_ALREADY_EXISTS
#define ERROR_ALREADY_EXISTS
Definition: disk.h:80
hXcv
static HANDLE hXcv
Definition: localmon.c:61
RegSetValueExA
LONG WINAPI RegSetValueExA(HKEY hKey, LPCSTR lpValueName, DWORD Reserved, DWORD dwType, CONST BYTE *lpData, DWORD cbData)
Definition: reg.c:4812
test_ClosePort
static void test_ClosePort(void)
Definition: localmon.c:342
ERROR_INVALID_LEVEL
#define ERROR_INVALID_LEVEL
Definition: winerror.h:196
portname_com1W
static WCHAR portname_com1W[]
Definition: localmon.c:100
LPWSTR
WCHAR * LPWSTR
Definition: xmlstorage.h:184
hdll
static HMODULE hdll
Definition: localmon.c:38
memset
#define memset(x, y, z)
Definition: compat.h:39
XcvClosePort
BOOL WINAPI XcvClosePort(_In_ HANDLE hXcv)
test_XcvDataPort_AddPort
static void test_XcvDataPort_AddPort(void)
Definition: localmon.c:776
PBYTE
BYTE * PBYTE
Definition: pedump.c:66
portname_com2W
static WCHAR portname_com2W[]
Definition: localmon.c:101
HeapFree
#define HeapFree(x, y, z)
Definition: compat.h:394
cmd_MonitorUI_lcaseW
static const WCHAR cmd_MonitorUI_lcaseW[]
Definition: localmon.c:76
tempfileW
static WCHAR tempfileW[MAX_PATH]
Definition: localmon.c:119
_PORT_INFO_2W
Definition: winspool.h:671
LPMONITOREX
static LPMONITOREX(WINAPI *pInitializePrintMonitor)(LPWSTR)
test_XcvDataPort_GetTransmissionRetryTimeout
static void test_XcvDataPort_GetTransmissionRetryTimeout(void)
Definition: localmon.c:948
HKEY_LOCAL_MACHINE
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12
ERROR_INSUFFICIENT_BUFFER
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10
REG_SZ
#define REG_SZ
Definition: layer.c:22
test_XcvDataPort_MonitorUI
static void test_XcvDataPort_MonitorUI(void)
Definition: localmon.c:1068