1 /*
2 * Unit tests for named pipe functions in Wine
3 *
4 * Copyright (c) 2002 Dan Kegel
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 #include <assert.h>
22 #include <stdarg.h>
23 #include <stdio.h>
24 #include <time.h>
25
26 #include <windef.h>
27 #include <winbase.h>
28 #include <winsock.h>
29 #include <wtypes.h>
30 #include <winerror.h>
31
32 #include "wine/test.h"
33
34 #define PIPENAME "\\\\.\\PiPe\\tests_pipe.c"
35
36 #define NB_SERVER_LOOPS 8
37
38 static HANDLE alarm_event;
39 static BOOL (WINAPI *pDuplicateTokenEx)(HANDLE,DWORD,LPSECURITY_ATTRIBUTES,
40 SECURITY_IMPERSONATION_LEVEL,TOKEN_TYPE,PHANDLE);
41
42
43 static void test_CreateNamedPipe(int pipemode)
44 {
45 HANDLE hnp;
46 HANDLE hFile;
47 static const char obuf[] = "Bit Bucket";
48 static const char obuf2[] = "More bits";
49 char ibuf[32], *pbuf;
50 DWORD written;
51 DWORD readden;
52 DWORD avail;
53 DWORD lpmode;
54
55 if (pipemode == PIPE_TYPE_BYTE)
56 trace("test_CreateNamedPipe starting in byte mode\n");
57 else
58 trace("test_CreateNamedPipe starting in message mode\n");
59 /* Bad parameter checks */
60 hnp = CreateNamedPipe("not a named pipe", PIPE_ACCESS_DUPLEX, pipemode | PIPE_WAIT,
61 /* nMaxInstances */ 1,
62 /* nOutBufSize */ 1024,
63 /* nInBufSize */ 1024,
64 /* nDefaultWait */ NMPWAIT_USE_DEFAULT_WAIT,
65 /* lpSecurityAttrib */ NULL);
66
67 if (hnp == INVALID_HANDLE_VALUE && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED) {
68 /* Is this the right way to notify user of skipped tests? */
69 ok(hnp == INVALID_HANDLE_VALUE && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED,
70 "CreateNamedPipe not supported on this platform, skipping tests.\n");
71 return;
72 }
73 ok(hnp == INVALID_HANDLE_VALUE && GetLastError() == ERROR_INVALID_NAME,
74 "CreateNamedPipe should fail if name doesn't start with \\\\.\\pipe\n");
75
76 hnp = CreateNamedPipe(NULL,
77 PIPE_ACCESS_DUPLEX, pipemode | PIPE_WAIT,
78 1, 1024, 1024, NMPWAIT_USE_DEFAULT_WAIT, NULL);
79 ok(hnp == INVALID_HANDLE_VALUE && GetLastError() == ERROR_PATH_NOT_FOUND,
80 "CreateNamedPipe should fail if name is NULL\n");
81
82 hFile = CreateFileA(PIPENAME, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0);
83 ok(hFile == INVALID_HANDLE_VALUE
84 && GetLastError() == ERROR_FILE_NOT_FOUND,
85 "connecting to nonexistent named pipe should fail with ERROR_FILE_NOT_FOUND\n");
86
87 /* Functional checks */
88
89 hnp = CreateNamedPipe(PIPENAME, PIPE_ACCESS_DUPLEX, pipemode | PIPE_WAIT,
90 /* nMaxInstances */ 1,
91 /* nOutBufSize */ 1024,
92 /* nInBufSize */ 1024,
93 /* nDefaultWait */ NMPWAIT_USE_DEFAULT_WAIT,
94 /* lpSecurityAttrib */ NULL);
95 ok(hnp != INVALID_HANDLE_VALUE, "CreateNamedPipe failed\n");
96
97 ok(WaitNamedPipeA(PIPENAME, 2000), "WaitNamedPipe failed (%d)\n", GetLastError());
98
99 hFile = CreateFileA(PIPENAME, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0);
100 ok(hFile != INVALID_HANDLE_VALUE, "CreateFile failed (%d)\n", GetLastError());
101
102 ok(!WaitNamedPipeA(PIPENAME, 1000), "WaitNamedPipe succeeded\n");
103 ok(GetLastError() == ERROR_SEM_TIMEOUT, "wrong error %u\n", GetLastError());
104
105 /* don't try to do i/o if one side couldn't be opened, as it hangs */
106 if (hFile != INVALID_HANDLE_VALUE) {
107 HANDLE hFile2;
108
109 /* Make sure we can read and write a few bytes in both directions */
110 memset(ibuf, 0, sizeof(ibuf));
111 ok(WriteFile(hnp, obuf, sizeof(obuf), &written, NULL), "WriteFile\n");
112 ok(written == sizeof(obuf), "write file len 1\n");
113 ok(PeekNamedPipe(hFile, NULL, 0, NULL, &readden, NULL), "Peek\n");
114 ok(readden == sizeof(obuf), "peek 1 got %d bytes\n", readden);
115 ok(ReadFile(hFile, ibuf, sizeof(ibuf), &readden, NULL), "ReadFile\n");
116 ok(readden == sizeof(obuf), "read 1 got %d bytes\n", readden);
117 ok(memcmp(obuf, ibuf, written) == 0, "content 1 check\n");
118
119 memset(ibuf, 0, sizeof(ibuf));
120 ok(WriteFile(hFile, obuf2, sizeof(obuf2), &written, NULL), "WriteFile\n");
121 ok(written == sizeof(obuf2), "write file len 2\n");
122 ok(PeekNamedPipe(hnp, NULL, 0, NULL, &readden, NULL), "Peek\n");
123 ok(readden == sizeof(obuf2), "peek 2 got %d bytes\n", readden);
124 ok(PeekNamedPipe(hnp, (LPVOID)1, 0, NULL, &readden, NULL), "Peek\n");
125 ok(readden == sizeof(obuf2), "peek 2 got %d bytes\n", readden);
126 ok(ReadFile(hnp, ibuf, sizeof(ibuf), &readden, NULL), "ReadFile\n");
127 ok(readden == sizeof(obuf2), "read 2 got %d bytes\n", readden);
128 ok(memcmp(obuf2, ibuf, written) == 0, "content 2 check\n");
129
130 /* Test reading of multiple writes */
131 memset(ibuf, 0, sizeof(ibuf));
132 ok(WriteFile(hnp, obuf, sizeof(obuf), &written, NULL), "WriteFile3a\n");
133 ok(written == sizeof(obuf), "write file len 3a\n");
134 ok(WriteFile(hnp, obuf2, sizeof(obuf2), &written, NULL), " WriteFile3b\n");
135 ok(written == sizeof(obuf2), "write file len 3b\n");
136 ok(PeekNamedPipe(hFile, ibuf, sizeof(ibuf), &readden, &avail, NULL), "Peek3\n");
137 if (pipemode == PIPE_TYPE_BYTE) {
138 if (readden != sizeof(obuf)) /* Linux only returns the first message */
139 ok(readden == sizeof(obuf) + sizeof(obuf2), "peek3 got %d bytes\n", readden);
140 else
141 todo_wine ok(readden == sizeof(obuf) + sizeof(obuf2), "peek3 got %d bytes\n", readden);
142 }
143 else
144 {
145 if (readden != sizeof(obuf) + sizeof(obuf2)) /* MacOS returns both messages */
146 ok(readden == sizeof(obuf), "peek3 got %d bytes\n", readden);
147 else
148 todo_wine ok(readden == sizeof(obuf), "peek3 got %d bytes\n", readden);
149 }
150 if (avail != sizeof(obuf)) /* older Linux kernels only return the first write here */
151 ok(avail == sizeof(obuf) + sizeof(obuf2), "peek3 got %d bytes available\n", avail);
152 pbuf = ibuf;
153 ok(memcmp(obuf, pbuf, sizeof(obuf)) == 0, "pipe content 3a check\n");
154 if (pipemode == PIPE_TYPE_BYTE && readden >= sizeof(obuf)+sizeof(obuf2)) {
155 pbuf += sizeof(obuf);
156 ok(memcmp(obuf2, pbuf, sizeof(obuf2)) == 0, "pipe content 3b check\n");
157 }
158 ok(ReadFile(hFile, ibuf, sizeof(ibuf), &readden, NULL), "ReadFile\n");
159 ok(readden == sizeof(obuf) + sizeof(obuf2), "read 3 got %d bytes\n", readden);
160 pbuf = ibuf;
161 ok(memcmp(obuf, pbuf, sizeof(obuf)) == 0, "content 3a check\n");
162 pbuf += sizeof(obuf);
163 ok(memcmp(obuf2, pbuf, sizeof(obuf2)) == 0, "content 3b check\n");
164
165 /* Multiple writes in the reverse direction */
166 memset(ibuf, 0, sizeof(ibuf));
167 ok(WriteFile(hFile, obuf, sizeof(obuf), &written, NULL), "WriteFile4a\n");
168 ok(written == sizeof(obuf), "write file len 4a\n");
169 ok(WriteFile(hFile, obuf2, sizeof(obuf2), &written, NULL), " WriteFile4b\n");
170 ok(written == sizeof(obuf2), "write file len 4b\n");
171 ok(PeekNamedPipe(hnp, ibuf, sizeof(ibuf), &readden, &avail, NULL), "Peek4\n");
172 if (pipemode == PIPE_TYPE_BYTE) {
173 if (readden != sizeof(obuf)) /* Linux only returns the first message */
174 /* should return all 23 bytes */
175 ok(readden == sizeof(obuf) + sizeof(obuf2), "peek4 got %d bytes\n", readden);
176 else
177 todo_wine ok(readden == sizeof(obuf) + sizeof(obuf2), "peek4 got %d bytes\n", readden);
178 }
179 else
180 {
181 if (readden != sizeof(obuf) + sizeof(obuf2)) /* MacOS returns both messages */
182 ok(readden == sizeof(obuf), "peek4 got %d bytes\n", readden);
183 else
184 todo_wine ok(readden == sizeof(obuf), "peek4 got %d bytes\n", readden);
185 }
186 if (avail != sizeof(obuf)) /* older Linux kernels only return the first write here */
187 ok(avail == sizeof(obuf) + sizeof(obuf2), "peek4 got %d bytes available\n", avail);
188 pbuf = ibuf;
189 ok(memcmp(obuf, pbuf, sizeof(obuf)) == 0, "pipe content 4a check\n");
190 if (pipemode == PIPE_TYPE_BYTE && readden >= sizeof(obuf)+sizeof(obuf2)) {
191 pbuf += sizeof(obuf);
192 ok(memcmp(obuf2, pbuf, sizeof(obuf2)) == 0, "pipe content 4b check\n");
193 }
194 ok(ReadFile(hnp, ibuf, sizeof(ibuf), &readden, NULL), "ReadFile\n");
195 if (pipemode == PIPE_TYPE_BYTE) {
196 ok(readden == sizeof(obuf) + sizeof(obuf2), "read 4 got %d bytes\n", readden);
197 }
198 else {
199 todo_wine {
200 ok(readden == sizeof(obuf), "read 4 got %d bytes\n", readden);
201 }
202 }
203 pbuf = ibuf;
204 ok(memcmp(obuf, pbuf, sizeof(obuf)) == 0, "content 4a check\n");
205 if (pipemode == PIPE_TYPE_BYTE) {
206 pbuf += sizeof(obuf);
207 ok(memcmp(obuf2, pbuf, sizeof(obuf2)) == 0, "content 4b check\n");
208 }
209
210 /* Test reading of multiple writes after a mode change
211 (CreateFile always creates a byte mode pipe) */
212 lpmode = PIPE_READMODE_MESSAGE;
213 if (pipemode == PIPE_TYPE_BYTE) {
214 /* trying to change the client end of a byte pipe to message mode should fail */
215 ok(!SetNamedPipeHandleState(hFile, &lpmode, NULL, NULL), "Change mode\n");
216 }
217 else {
218 todo_wine {
219 ok(SetNamedPipeHandleState(hFile, &lpmode, NULL, NULL), "Change mode\n");
220 }
221
222 memset(ibuf, 0, sizeof(ibuf));
223 ok(WriteFile(hnp, obuf, sizeof(obuf), &written, NULL), "WriteFile5a\n");
224 ok(written == sizeof(obuf), "write file len 3a\n");
225 ok(WriteFile(hnp, obuf2, sizeof(obuf2), &written, NULL), " WriteFile5b\n");
226 ok(written == sizeof(obuf2), "write file len 3b\n");
227 ok(PeekNamedPipe(hFile, ibuf, sizeof(ibuf), &readden, &avail, NULL), "Peek5\n");
228 if (readden != sizeof(obuf) + sizeof(obuf2)) /* MacOS returns both writes */
229 ok(readden == sizeof(obuf), "peek5 got %d bytes\n", readden);
230 else
231 todo_wine ok(readden == sizeof(obuf), "peek5 got %d bytes\n", readden);
232 if (avail != sizeof(obuf)) /* older Linux kernels only return the first write here */
233 ok(avail == sizeof(obuf) + sizeof(obuf2), "peek5 got %d bytes available\n", avail);
234 else
235 todo_wine ok(avail == sizeof(obuf) + sizeof(obuf2), "peek5 got %d bytes available\n", avail);
236 pbuf = ibuf;
237 ok(memcmp(obuf, pbuf, sizeof(obuf)) == 0, "content 5a check\n");
238 ok(ReadFile(hFile, ibuf, sizeof(ibuf), &readden, NULL), "ReadFile\n");
239 todo_wine {
240 ok(readden == sizeof(obuf), "read 5 got %d bytes\n", readden);
241 }
242 pbuf = ibuf;
243 ok(memcmp(obuf, pbuf, sizeof(obuf)) == 0, "content 5a check\n");
244
245 /* Multiple writes in the reverse direction */
246 /* the write of obuf2 from write4 should still be in the buffer */
247 ok(PeekNamedPipe(hnp, ibuf, sizeof(ibuf), &readden, &avail, NULL), "Peek6a\n");
248 todo_wine {
249 ok(readden == sizeof(obuf2), "peek6a got %d bytes\n", readden);
250 ok(avail == sizeof(obuf2), "peek6a got %d bytes available\n", avail);
251 }
252 if (avail > 0) {
253 ok(ReadFile(hnp, ibuf, sizeof(ibuf), &readden, NULL), "ReadFile\n");
254 ok(readden == sizeof(obuf2), "read 6a got %d bytes\n", readden);
255 pbuf = ibuf;
256 ok(memcmp(obuf2, pbuf, sizeof(obuf2)) == 0, "content 6a check\n");
257 }
258 memset(ibuf, 0, sizeof(ibuf));
259 ok(WriteFile(hFile, obuf, sizeof(obuf), &written, NULL), "WriteFile6a\n");
260 ok(written == sizeof(obuf), "write file len 6a\n");
261 ok(WriteFile(hFile, obuf2, sizeof(obuf2), &written, NULL), " WriteFile6b\n");
262 ok(written == sizeof(obuf2), "write file len 6b\n");
263 ok(PeekNamedPipe(hnp, ibuf, sizeof(ibuf), &readden, &avail, NULL), "Peek6\n");
264 if (readden != sizeof(obuf) + sizeof(obuf2)) /* MacOS returns both writes */
265 ok(readden == sizeof(obuf), "peek6 got %d bytes\n", readden);
266 else
267 todo_wine ok(readden == sizeof(obuf), "peek6 got %d bytes\n", readden);
268 if (avail != sizeof(obuf)) /* older Linux kernels only return the first write here */
269 ok(avail == sizeof(obuf) + sizeof(obuf2), "peek6b got %d bytes available\n", avail);
270 pbuf = ibuf;
271 ok(memcmp(obuf, pbuf, sizeof(obuf)) == 0, "content 6a check\n");
272 ok(ReadFile(hnp, ibuf, sizeof(ibuf), &readden, NULL), "ReadFile\n");
273 todo_wine {
274 ok(readden == sizeof(obuf), "read 6b got %d bytes\n", readden);
275 }
276 pbuf = ibuf;
277 ok(memcmp(obuf, pbuf, sizeof(obuf)) == 0, "content 6a check\n");
278 }
279
280 /* Picky conformance tests */
281
282 /* Verify that you can't connect to pipe again
283 * until server calls DisconnectNamedPipe+ConnectNamedPipe
284 * or creates a new pipe
285 * case 1: other client not yet closed
286 */
287 hFile2 = CreateFileA(PIPENAME, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0);
288 ok(hFile2 == INVALID_HANDLE_VALUE,
289 "connecting to named pipe after other client closes but before DisconnectNamedPipe should fail\n");
290 ok(GetLastError() == ERROR_PIPE_BUSY,
291 "connecting to named pipe before other client closes should fail with ERROR_PIPE_BUSY\n");
292
293 ok(CloseHandle(hFile), "CloseHandle\n");
294
295 /* case 2: other client already closed */
296 hFile = CreateFileA(PIPENAME, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0);
297 ok(hFile == INVALID_HANDLE_VALUE,
298 "connecting to named pipe after other client closes but before DisconnectNamedPipe should fail\n");
299 ok(GetLastError() == ERROR_PIPE_BUSY,
300 "connecting to named pipe after other client closes but before DisconnectNamedPipe should fail with ERROR_PIPE_BUSY\n");
301
302 ok(DisconnectNamedPipe(hnp), "DisconnectNamedPipe\n");
303
304 /* case 3: server has called DisconnectNamedPipe but not ConnectNamed Pipe */
305 hFile = CreateFileA(PIPENAME, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0);
306 ok(hFile == INVALID_HANDLE_VALUE,
307 "connecting to named pipe after other client closes but before DisconnectNamedPipe should fail\n");
308 ok(GetLastError() == ERROR_PIPE_BUSY,
309 "connecting to named pipe after other client closes but before ConnectNamedPipe should fail with ERROR_PIPE_BUSY\n");
310
311 /* to be complete, we'd call ConnectNamedPipe here and loop,
312 * but by default that's blocking, so we'd either have
313 * to turn on the uncommon nonblocking mode, or
314 * use another thread.
315 */
316 }
317
318 ok(CloseHandle(hnp), "CloseHandle\n");
319
320 trace("test_CreateNamedPipe returning\n");
321 }
322
323 static void test_CreateNamedPipe_instances_must_match(void)
324 {
325 HANDLE hnp, hnp2;
326
327 /* Check no mismatch */
328 hnp = CreateNamedPipe(PIPENAME, PIPE_ACCESS_DUPLEX, PIPE_TYPE_BYTE | PIPE_WAIT,
329 /* nMaxInstances */ 2,
330 /* nOutBufSize */ 1024,
331 /* nInBufSize */ 1024,
332 /* nDefaultWait */ NMPWAIT_USE_DEFAULT_WAIT,
333 /* lpSecurityAttrib */ NULL);
334 ok(hnp != INVALID_HANDLE_VALUE, "CreateNamedPipe failed\n");
335
336 hnp2 = CreateNamedPipe(PIPENAME, PIPE_ACCESS_DUPLEX, PIPE_TYPE_BYTE | PIPE_WAIT,
337 /* nMaxInstances */ 2,
338 /* nOutBufSize */ 1024,
339 /* nInBufSize */ 1024,
340 /* nDefaultWait */ NMPWAIT_USE_DEFAULT_WAIT,
341 /* lpSecurityAttrib */ NULL);
342 ok(hnp2 != INVALID_HANDLE_VALUE, "CreateNamedPipe failed\n");
343
344 ok(CloseHandle(hnp), "CloseHandle\n");
345 ok(CloseHandle(hnp2), "CloseHandle\n");
346
347 /* Check nMaxInstances */
348 hnp = CreateNamedPipe(PIPENAME, PIPE_ACCESS_DUPLEX, PIPE_TYPE_BYTE | PIPE_WAIT,
349 /* nMaxInstances */ 1,
350 /* nOutBufSize */ 1024,
351 /* nInBufSize */ 1024,
352 /* nDefaultWait */ NMPWAIT_USE_DEFAULT_WAIT,
353 /* lpSecurityAttrib */ NULL);
354 ok(hnp != INVALID_HANDLE_VALUE, "CreateNamedPipe failed\n");
355
356 hnp2 = CreateNamedPipe(PIPENAME, PIPE_ACCESS_DUPLEX, PIPE_TYPE_BYTE | PIPE_WAIT,
357 /* nMaxInstances */ 1,
358 /* nOutBufSize */ 1024,
359 /* nInBufSize */ 1024,
360 /* nDefaultWait */ NMPWAIT_USE_DEFAULT_WAIT,
361 /* lpSecurityAttrib */ NULL);
362 ok(hnp2 == INVALID_HANDLE_VALUE
363 && GetLastError() == ERROR_PIPE_BUSY, "nMaxInstances not obeyed\n");
364
365 ok(CloseHandle(hnp), "CloseHandle\n");
366
367 /* Check PIPE_ACCESS_* */
368 hnp = CreateNamedPipe(PIPENAME, PIPE_ACCESS_DUPLEX, PIPE_TYPE_BYTE | PIPE_WAIT,
369 /* nMaxInstances */ 2,
370 /* nOutBufSize */ 1024,
371 /* nInBufSize */ 1024,
372 /* nDefaultWait */ NMPWAIT_USE_DEFAULT_WAIT,
373 /* lpSecurityAttrib */ NULL);
374 ok(hnp != INVALID_HANDLE_VALUE, "CreateNamedPipe failed\n");
375
376 hnp2 = CreateNamedPipe(PIPENAME, PIPE_ACCESS_INBOUND, PIPE_TYPE_BYTE | PIPE_WAIT,
377 /* nMaxInstances */ 1,
378 /* nOutBufSize */ 1024,
379 /* nInBufSize */ 1024,
380 /* nDefaultWait */ NMPWAIT_USE_DEFAULT_WAIT,
381 /* lpSecurityAttrib */ NULL);
382 ok(hnp2 == INVALID_HANDLE_VALUE
383 && GetLastError() == ERROR_ACCESS_DENIED, "PIPE_ACCESS_* mismatch allowed\n");
384
385 ok(CloseHandle(hnp), "CloseHandle\n");
386
387 /* etc, etc */
388 }
389
390 /** implementation of alarm() */
391 static DWORD CALLBACK alarmThreadMain(LPVOID arg)
392 {
393 DWORD timeout = (DWORD) arg;
394 trace("alarmThreadMain\n");
395 if (WaitForSingleObject( alarm_event, timeout ) == WAIT_TIMEOUT)
396 {
397 ok(FALSE, "alarm\n");
398 ExitProcess(1);
399 }
400 return 1;
401 }
402
403 HANDLE hnp = INVALID_HANDLE_VALUE;
404
405 /** Trivial byte echo server - disconnects after each session */
406 static DWORD CALLBACK serverThreadMain1(LPVOID arg)
407 {
408 int i;
409
410 trace("serverThreadMain1 start\n");
411 /* Set up a simple echo server */
412 hnp = CreateNamedPipe(PIPENAME "serverThreadMain1", PIPE_ACCESS_DUPLEX,
413 PIPE_TYPE_BYTE | PIPE_WAIT,
414 /* nMaxInstances */ 1,
415 /* nOutBufSize */ 1024,
416 /* nInBufSize */ 1024,
417 /* nDefaultWait */ NMPWAIT_USE_DEFAULT_WAIT,
418 /* lpSecurityAttrib */ NULL);
419
420 ok(hnp != INVALID_HANDLE_VALUE, "CreateNamedPipe failed\n");
421 for (i = 0; i < NB_SERVER_LOOPS; i++) {
422 char buf[512];
423 DWORD written;
424 DWORD readden;
425 DWORD success;
426
427 /* Wait for client to connect */
428 trace("Server calling ConnectNamedPipe...\n");
429 ok(ConnectNamedPipe(hnp, NULL)
430 || GetLastError() == ERROR_PIPE_CONNECTED, "ConnectNamedPipe\n");
431 trace("ConnectNamedPipe returned.\n");
432
433 /* Echo bytes once */
434 memset(buf, 0, sizeof(buf));
435
436 trace("Server reading...\n");
437 success = ReadFile(hnp, buf, sizeof(buf), &readden, NULL);
438 trace("Server done reading.\n");
439 ok(success, "ReadFile\n");
440 ok(readden, "short read\n");
441
442 trace("Server writing...\n");
443 ok(WriteFile(hnp, buf, readden, &written, NULL), "WriteFile\n");
444 trace("Server done writing.\n");
445 ok(written == readden, "write file len\n");
446
447 /* finish this connection, wait for next one */
448 ok(FlushFileBuffers(hnp), "FlushFileBuffers\n");
449 trace("Server done flushing.\n");
450 ok(DisconnectNamedPipe(hnp), "DisconnectNamedPipe\n");
451 trace("Server done disconnecting.\n");
452 }
453 return 0;
454 }
455
456 /** Trivial byte echo server - closes after each connection */
457 static DWORD CALLBACK serverThreadMain2(LPVOID arg)
458 {
459 int i;
460 HANDLE hnpNext = 0;
461
462 trace("serverThreadMain2\n");
463 /* Set up a simple echo server */
464 hnp = CreateNamedPipe(PIPENAME "serverThreadMain2", PIPE_ACCESS_DUPLEX,
465 PIPE_TYPE_BYTE | PIPE_WAIT,
466 /* nMaxInstances */ 2,
467 /* nOutBufSize */ 1024,
468 /* nInBufSize */ 1024,
469 /* nDefaultWait */ NMPWAIT_USE_DEFAULT_WAIT,
470 /* lpSecurityAttrib */ NULL);
471 ok(hnp != INVALID_HANDLE_VALUE, "CreateNamedPipe failed\n");
472
473 for (i = 0; i < NB_SERVER_LOOPS; i++) {
474 char buf[512];
475 DWORD written;
476 DWORD readden;
477 DWORD success;
478
479 /* Wait for client to connect */
480 trace("Server calling ConnectNamedPipe...\n");
481 ok(ConnectNamedPipe(hnp, NULL)
482 || GetLastError() == ERROR_PIPE_CONNECTED, "ConnectNamedPipe\n");
483 trace("ConnectNamedPipe returned.\n");
484
485 /* Echo bytes once */
486 memset(buf, 0, sizeof(buf));
487
488 trace("Server reading...\n");
489 success = ReadFile(hnp, buf, sizeof(buf), &readden, NULL);
490 trace("Server done reading.\n");
491 ok(success, "ReadFile\n");
492
493 trace("Server writing...\n");
494 ok(WriteFile(hnp, buf, readden, &written, NULL), "WriteFile\n");
495 trace("Server done writing.\n");
496 ok(written == readden, "write file len\n");
497
498 /* finish this connection, wait for next one */
499 ok(FlushFileBuffers(hnp), "FlushFileBuffers\n");
500 ok(DisconnectNamedPipe(hnp), "DisconnectNamedPipe\n");
501
502 /* Set up next echo server */
503 hnpNext =
504 CreateNamedPipe(PIPENAME "serverThreadMain2", PIPE_ACCESS_DUPLEX,
505 PIPE_TYPE_BYTE | PIPE_WAIT,
506 /* nMaxInstances */ 2,
507 /* nOutBufSize */ 1024,
508 /* nInBufSize */ 1024,
509 /* nDefaultWait */ NMPWAIT_USE_DEFAULT_WAIT,
510 /* lpSecurityAttrib */ NULL);
511
512 ok(hnpNext != INVALID_HANDLE_VALUE, "CreateNamedPipe failed\n");
513
514 ok(CloseHandle(hnp), "CloseHandle\n");
515 hnp = hnpNext;
516 }
517 return 0;
518 }
519
520 /** Trivial byte echo server - uses overlapped named pipe calls */
521 static DWORD CALLBACK serverThreadMain3(LPVOID arg)
522 {
523 int i;
524 HANDLE hEvent;
525
526 trace("serverThreadMain3\n");
527 /* Set up a simple echo server */
528 hnp = CreateNamedPipe(PIPENAME "serverThreadMain3", PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
529 PIPE_TYPE_BYTE | PIPE_WAIT,
530 /* nMaxInstances */ 1,
531 /* nOutBufSize */ 1024,
532 /* nInBufSize */ 1024,
533 /* nDefaultWait */ NMPWAIT_USE_DEFAULT_WAIT,
534 /* lpSecurityAttrib */ NULL);
535 ok(hnp != INVALID_HANDLE_VALUE, "CreateNamedPipe failed\n");
536
537 hEvent = CreateEvent(NULL, /* security attribute */
538 TRUE, /* manual reset event */
539 FALSE, /* initial state */
540 NULL); /* name */
541 ok(hEvent != NULL, "CreateEvent\n");
542
543 for (i = 0; i < NB_SERVER_LOOPS; i++) {
544 char buf[512];
545 DWORD written;
546 DWORD readden;
547 DWORD dummy;
548 DWORD success;
549 OVERLAPPED oOverlap;
550 int letWFSOEwait = (i & 2);
551 int letGORwait = (i & 1);
552 DWORD err;
553
554 memset(&oOverlap, 0, sizeof(oOverlap));
555 oOverlap.hEvent = hEvent;
556
557 /* Wait for client to connect */
558 trace("Server calling overlapped ConnectNamedPipe...\n");
559 success = ConnectNamedPipe(hnp, &oOverlap);
560 err = GetLastError();
561 ok(success || err == ERROR_IO_PENDING
562 || err == ERROR_PIPE_CONNECTED, "overlapped ConnectNamedPipe\n");
563 trace("overlapped ConnectNamedPipe returned.\n");
564 if (!success && (err == ERROR_IO_PENDING) && letWFSOEwait)
565 ok(WaitForSingleObjectEx(hEvent, INFINITE, TRUE) == 0, "wait ConnectNamedPipe\n");
566 success = GetOverlappedResult(hnp, &oOverlap, &dummy, letGORwait);
567 if (!letGORwait && !letWFSOEwait && !success) {
568 ok(GetLastError() == ERROR_IO_INCOMPLETE, "GetOverlappedResult\n");
569 success = GetOverlappedResult(hnp, &oOverlap, &dummy, TRUE);
570 }
571 ok(success, "GetOverlappedResult ConnectNamedPipe\n");
572 trace("overlapped ConnectNamedPipe operation complete.\n");
573
574 /* Echo bytes once */
575 memset(buf, 0, sizeof(buf));
576
577 trace("Server reading...\n");
578 success = ReadFile(hnp, buf, sizeof(buf), NULL, &oOverlap);
579 trace("Server ReadFile returned...\n");
580 err = GetLastError();
581 ok(success || err == ERROR_IO_PENDING, "overlapped ReadFile\n");
582 trace("overlapped ReadFile returned.\n");
583 if (!success && (err == ERROR_IO_PENDING) && letWFSOEwait)
584 ok(WaitForSingleObjectEx(hEvent, INFINITE, TRUE) == 0, "wait ReadFile\n");
585 success = GetOverlappedResult(hnp, &oOverlap, &readden, letGORwait);
586 if (!letGORwait && !letWFSOEwait && !success) {
587 ok(GetLastError() == ERROR_IO_INCOMPLETE, "GetOverlappedResult\n");
588 success = GetOverlappedResult(hnp, &oOverlap, &readden, TRUE);
589 }
590 trace("Server done reading.\n");
591 ok(success, "overlapped ReadFile\n");
592
593 trace("Server writing...\n");
594 success = WriteFile(hnp, buf, readden, NULL, &oOverlap);
595 trace("Server WriteFile returned...\n");
596 err = GetLastError();
597 ok(success || err == ERROR_IO_PENDING, "overlapped WriteFile\n");
598 trace("overlapped WriteFile returned.\n");
599 if (!success && (err == ERROR_IO_PENDING) && letWFSOEwait)
600 ok(WaitForSingleObjectEx(hEvent, INFINITE, TRUE) == 0, "wait WriteFile\n");
601 success = GetOverlappedResult(hnp, &oOverlap, &written, letGORwait);
602 if (!letGORwait && !letWFSOEwait && !success) {
603 ok(GetLastError() == ERROR_IO_INCOMPLETE, "GetOverlappedResult\n");
604 success = GetOverlappedResult(hnp, &oOverlap, &written, TRUE);
605 }
606 trace("Server done writing.\n");
607 ok(success, "overlapped WriteFile\n");
608 ok(written == readden, "write file len\n");
609
610 /* finish this connection, wait for next one */
611 ok(FlushFileBuffers(hnp), "FlushFileBuffers\n");
612 ok(DisconnectNamedPipe(hnp), "DisconnectNamedPipe\n");
613 }
614 return 0;
615 }
616
617 static void exercizeServer(const char *pipename, HANDLE serverThread)
618 {
619 int i;
620
621 trace("exercizeServer starting\n");
622 for (i = 0; i < NB_SERVER_LOOPS; i++) {
623 HANDLE hFile=INVALID_HANDLE_VALUE;
624 static const char obuf[] = "Bit Bucket";
625 char ibuf[32];
626 DWORD written;
627 DWORD readden;
628 int loop;
629
630 for (loop = 0; loop < 3; loop++) {
631 DWORD err;
632 trace("Client connecting...\n");
633 /* Connect to the server */
634 hFile = CreateFileA(pipename, GENERIC_READ | GENERIC_WRITE, 0,
635 NULL, OPEN_EXISTING, 0, 0);
636 if (hFile != INVALID_HANDLE_VALUE)
637 break;
638 err = GetLastError();
639 if (loop == 0)
640 ok(err == ERROR_PIPE_BUSY || err == ERROR_FILE_NOT_FOUND, "connecting to pipe\n");
641 else
642 ok(err == ERROR_PIPE_BUSY, "connecting to pipe\n");
643 trace("connect failed, retrying\n");
644 Sleep(200);
645 }
646 ok(hFile != INVALID_HANDLE_VALUE, "client opening named pipe\n");
647
648 /* Make sure it can echo */
649 memset(ibuf, 0, sizeof(ibuf));
650 trace("Client writing...\n");
651 ok(WriteFile(hFile, obuf, sizeof(obuf), &written, NULL), "WriteFile to client end of pipe\n");
652 ok(written == sizeof(obuf), "write file len\n");
653 trace("Client reading...\n");
654 ok(ReadFile(hFile, ibuf, sizeof(obuf), &readden, NULL), "ReadFile from client end of pipe\n");
655 ok(readden == sizeof(obuf), "read file len\n");
656 ok(memcmp(obuf, ibuf, written) == 0, "content check\n");
657
658 trace("Client closing...\n");
659 ok(CloseHandle(hFile), "CloseHandle\n");
660 }
661
662 ok(WaitForSingleObject(serverThread,INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject\n");
663 CloseHandle(hnp);
664 trace("exercizeServer returning\n");
665 }
666
667 static void test_NamedPipe_2(void)
668 {
669 HANDLE serverThread;
670 DWORD serverThreadId;
671 HANDLE alarmThread;
672 DWORD alarmThreadId;
673
674 trace("test_NamedPipe_2 starting\n");
675 /* Set up a ten second timeout */
676 alarm_event = CreateEvent( NULL, TRUE, FALSE, NULL );
677 alarmThread = CreateThread(NULL, 0, alarmThreadMain, (void *) 10000, 0, &alarmThreadId);
678
679 /* The servers we're about to exercize do try to clean up carefully,
680 * but to reduce the change of a test failure due to a pipe handle
681 * leak in the test code, we'll use a different pipe name for each server.
682 */
683
684 /* Try server #1 */
685 serverThread = CreateThread(NULL, 0, serverThreadMain1, (void *)8, 0, &serverThreadId);
686 ok(serverThread != INVALID_HANDLE_VALUE, "CreateThread\n");
687 exercizeServer(PIPENAME "serverThreadMain1", serverThread);
688
689 /* Try server #2 */
690 serverThread = CreateThread(NULL, 0, serverThreadMain2, 0, 0, &serverThreadId);
691 ok(serverThread != INVALID_HANDLE_VALUE, "CreateThread\n");
692 exercizeServer(PIPENAME "serverThreadMain2", serverThread);
693
694 if( 0 ) /* overlapped pipe server doesn't work yet - it randomly fails */
695 {
696 /* Try server #3 */
697 serverThread = CreateThread(NULL, 0, serverThreadMain3, 0, 0, &serverThreadId);
698 ok(serverThread != INVALID_HANDLE_VALUE, "CreateThread\n");
699 exercizeServer(PIPENAME "serverThreadMain3", serverThread);
700 }
701
702 ok(SetEvent( alarm_event ), "SetEvent\n");
703 CloseHandle( alarm_event );
704 trace("test_NamedPipe_2 returning\n");
705 }
706
707 static int test_DisconnectNamedPipe(void)
708 {
709 HANDLE hnp;
710 HANDLE hFile;
711 static const char obuf[] = "Bit Bucket";
712 char ibuf[32];
713 DWORD written;
714 DWORD readden;
715
716 SetLastError(0xdeadbeef);
717 hnp = CreateNamedPipe(PIPENAME, PIPE_ACCESS_DUPLEX, PIPE_TYPE_BYTE | PIPE_WAIT,
718 /* nMaxInstances */ 1,
719 /* nOutBufSize */ 1024,
720 /* nInBufSize */ 1024,
721 /* nDefaultWait */ NMPWAIT_USE_DEFAULT_WAIT,
722 /* lpSecurityAttrib */ NULL);
723 if ((hnp == INVALID_HANDLE_VALUE /* Win98 */ || !hnp /* Win95 */)
724 && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED) {
725
726 win_skip("Named pipes are not implemented\n");
727 return 1;
728 }
729
730 ok(WriteFile(hnp, obuf, sizeof(obuf), &written, NULL) == 0
731 && GetLastError() == ERROR_PIPE_LISTENING, "WriteFile to not-yet-connected pipe\n");
732 ok(ReadFile(hnp, ibuf, sizeof(ibuf), &readden, NULL) == 0
733 && GetLastError() == ERROR_PIPE_LISTENING, "ReadFile from not-yet-connected pipe\n");
734
735 hFile = CreateFileA(PIPENAME, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0);
736 ok(hFile != INVALID_HANDLE_VALUE, "CreateFile failed\n");
737
738 /* don't try to do i/o if one side couldn't be opened, as it hangs */
739 if (hFile != INVALID_HANDLE_VALUE) {
740
741 /* see what happens if server calls DisconnectNamedPipe
742 * when there are bytes in the pipe
743 */
744
745 ok(WriteFile(hFile, obuf, sizeof(obuf), &written, NULL), "WriteFile\n");
746 ok(written == sizeof(obuf), "write file len\n");
747 ok(DisconnectNamedPipe(hnp), "DisconnectNamedPipe while messages waiting\n");
748 ok(WriteFile(hFile, obuf, sizeof(obuf), &written, NULL) == 0
749 && GetLastError() == ERROR_PIPE_NOT_CONNECTED, "WriteFile to disconnected pipe\n");
750 ok(ReadFile(hnp, ibuf, sizeof(ibuf), &readden, NULL) == 0
751 && GetLastError() == ERROR_PIPE_NOT_CONNECTED,
752 "ReadFile from disconnected pipe with bytes waiting\n");
753 ok(!DisconnectNamedPipe(hnp) && GetLastError() == ERROR_PIPE_NOT_CONNECTED,
754 "DisconnectNamedPipe worked twice\n");
755 ok(CloseHandle(hFile), "CloseHandle\n");
756 }
757
758 ok(CloseHandle(hnp), "CloseHandle\n");
759
760 return 0;
761 }
762 static void test_CreatePipe(void)
763 {
764 SECURITY_ATTRIBUTES pipe_attr;
765 HANDLE piperead, pipewrite;
766 DWORD written;
767 DWORD