git.oblomov.eu Git - wine/blob - dlls/localspl/tests/localmon.c

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