2 * Unit tests for named pipe functions in Wine
4 * Copyright (c) 2002 Dan Kegel
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.
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.
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
32 #include "wine/test.h"
34 #define PIPENAME "\\\\.\\PiPe\\tests_pipe.c"
36 #define NB_SERVER_LOOPS 8
38 static HANDLE alarm_event
;
39 static BOOL (WINAPI
*pDuplicateTokenEx
)(HANDLE
,DWORD
,LPSECURITY_ATTRIBUTES
,
40 SECURITY_IMPERSONATION_LEVEL
,TOKEN_TYPE
,PHANDLE
);
43 static void test_CreateNamedPipe(int pipemode
)
47 static const char obuf
[] = "Bit Bucket";
48 static const char obuf2
[] = "More bits";
55 if (pipemode
== PIPE_TYPE_BYTE
)
56 trace("test_CreateNamedPipe starting in byte mode\n");
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
);
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");
73 ok(hnp
== INVALID_HANDLE_VALUE
&& GetLastError() == ERROR_INVALID_NAME
,
74 "CreateNamedPipe should fail if name doesn't start with \\\\.\\pipe\n");
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");
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");
87 /* Functional checks */
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");
97 ok(WaitNamedPipeA(PIPENAME
, 2000), "WaitNamedPipe failed (%d)\n", GetLastError());
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());
102 ok(!WaitNamedPipeA(PIPENAME
, 1000), "WaitNamedPipe succeeded\n");
103 ok(GetLastError() == ERROR_SEM_TIMEOUT
, "wrong error %u\n", GetLastError());
105 /* don't try to do i/o if one side couldn't be opened, as it hangs */
106 if (hFile
!= INVALID_HANDLE_VALUE
) {
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");
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");
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
);
141 todo_wine
ok(readden
== sizeof(obuf
) + sizeof(obuf2
), "peek3 got %d bytes\n", readden
);
145 if (readden
!= sizeof(obuf
) + sizeof(obuf2
)) /* MacOS returns both messages */
146 ok(readden
== sizeof(obuf
), "peek3 got %d bytes\n", readden
);
148 todo_wine
ok(readden
== sizeof(obuf
), "peek3 got %d bytes\n", readden
);
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
);
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");
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
);
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");
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
);
177 todo_wine
ok(readden
== sizeof(obuf
) + sizeof(obuf2
), "peek4 got %d bytes\n", readden
);
181 if (readden
!= sizeof(obuf
) + sizeof(obuf2
)) /* MacOS returns both messages */
182 ok(readden
== sizeof(obuf
), "peek4 got %d bytes\n", readden
);
184 todo_wine
ok(readden
== sizeof(obuf
), "peek4 got %d bytes\n", readden
);
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
);
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");
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
);
200 ok(readden
== sizeof(obuf
), "read 4 got %d bytes\n", readden
);
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");
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");
219 ok(SetNamedPipeHandleState(hFile
, &lpmode
, NULL
, NULL
), "Change mode\n");
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
);
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
);
235 todo_wine
ok(avail
== sizeof(obuf
) + sizeof(obuf2
), "peek5 got %d bytes available\n", avail
);
237 ok(memcmp(obuf
, pbuf
, sizeof(obuf
)) == 0, "content 5a check\n");
238 ok(ReadFile(hFile
, ibuf
, sizeof(ibuf
), &readden
, NULL
), "ReadFile\n");
240 ok(readden
== sizeof(obuf
), "read 5 got %d bytes\n", readden
);
243 ok(memcmp(obuf
, pbuf
, sizeof(obuf
)) == 0, "content 5a check\n");
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");
249 ok(readden
== sizeof(obuf2
), "peek6a got %d bytes\n", readden
);
250 ok(avail
== sizeof(obuf2
), "peek6a got %d bytes available\n", avail
);
253 ok(ReadFile(hnp
, ibuf
, sizeof(ibuf
), &readden
, NULL
), "ReadFile\n");
254 ok(readden
== sizeof(obuf2
), "read 6a got %d bytes\n", readden
);
256 ok(memcmp(obuf2
, pbuf
, sizeof(obuf2
)) == 0, "content 6a check\n");
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
);
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
);
271 ok(memcmp(obuf
, pbuf
, sizeof(obuf
)) == 0, "content 6a check\n");
272 ok(ReadFile(hnp
, ibuf
, sizeof(ibuf
), &readden
, NULL
), "ReadFile\n");
274 ok(readden
== sizeof(obuf
), "read 6b got %d bytes\n", readden
);
277 ok(memcmp(obuf
, pbuf
, sizeof(obuf
)) == 0, "content 6a check\n");
280 /* Picky conformance tests */
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
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");
293 ok(CloseHandle(hFile
), "CloseHandle\n");
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");
302 ok(DisconnectNamedPipe(hnp
), "DisconnectNamedPipe\n");
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");
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.
318 ok(CloseHandle(hnp
), "CloseHandle\n");
320 trace("test_CreateNamedPipe returning\n");
323 static void test_CreateNamedPipe_instances_must_match(void)
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");
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");
344 ok(CloseHandle(hnp
), "CloseHandle\n");
345 ok(CloseHandle(hnp2
), "CloseHandle\n");
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");
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");
365 ok(CloseHandle(hnp
), "CloseHandle\n");
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");
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");
385 ok(CloseHandle(hnp
), "CloseHandle\n");
390 /** implementation of alarm() */
391 static DWORD CALLBACK
alarmThreadMain(LPVOID arg
)
393 DWORD timeout
= (DWORD
) arg
;
394 trace("alarmThreadMain\n");
395 if (WaitForSingleObject( alarm_event
, timeout
) == WAIT_TIMEOUT
)
397 ok(FALSE
, "alarm\n");
403 HANDLE hnp
= INVALID_HANDLE_VALUE
;
405 /** Trivial byte echo server - disconnects after each session */
406 static DWORD CALLBACK
serverThreadMain1(LPVOID arg
)
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
);
420 ok(hnp
!= INVALID_HANDLE_VALUE
, "CreateNamedPipe failed\n");
421 for (i
= 0; i
< NB_SERVER_LOOPS
; i
++) {
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");
433 /* Echo bytes once */
434 memset(buf
, 0, sizeof(buf
));
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");
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");
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");
456 /** Trivial byte echo server - closes after each connection */
457 static DWORD CALLBACK
serverThreadMain2(LPVOID arg
)
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");
473 for (i
= 0; i
< NB_SERVER_LOOPS
; i
++) {
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");
485 /* Echo bytes once */
486 memset(buf
, 0, sizeof(buf
));
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");
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");
498 /* finish this connection, wait for next one */
499 ok(FlushFileBuffers(hnp
), "FlushFileBuffers\n");
500 ok(DisconnectNamedPipe(hnp
), "DisconnectNamedPipe\n");
502 /* Set up next echo server */
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
);
512 ok(hnpNext
!= INVALID_HANDLE_VALUE
, "CreateNamedPipe failed\n");
514 ok(CloseHandle(hnp
), "CloseHandle\n");
520 /** Trivial byte echo server - uses overlapped named pipe calls */
521 static DWORD CALLBACK
serverThreadMain3(LPVOID arg
)
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");
537 hEvent
= CreateEvent(NULL
, /* security attribute */
538 TRUE
, /* manual reset event */
539 FALSE
, /* initial state */
541 ok(hEvent
!= NULL
, "CreateEvent\n");
543 for (i
= 0; i
< NB_SERVER_LOOPS
; i
++) {
550 int letWFSOEwait
= (i
& 2);
551 int letGORwait
= (i
& 1);
554 memset(&oOverlap
, 0, sizeof(oOverlap
));
555 oOverlap
.hEvent
= hEvent
;
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
);
571 ok(success
, "GetOverlappedResult ConnectNamedPipe\n");
572 trace("overlapped ConnectNamedPipe operation complete.\n");
574 /* Echo bytes once */
575 memset(buf
, 0, sizeof(buf
));
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
);
590 trace("Server done reading.\n");
591 ok(success
, "overlapped ReadFile\n");
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
);
606 trace("Server done writing.\n");
607 ok(success
, "overlapped WriteFile\n");
608 ok(written
== readden
, "write file len\n");
610 /* finish this connection, wait for next one */
611 ok(FlushFileBuffers(hnp
), "FlushFileBuffers\n");
612 ok(DisconnectNamedPipe(hnp
), "DisconnectNamedPipe\n");
617 static void exercizeServer(const char *pipename
, HANDLE serverThread
)
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";
630 for (loop
= 0; loop
< 3; loop
++) {
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
)
638 err
= GetLastError();
640 ok(err
== ERROR_PIPE_BUSY
|| err
== ERROR_FILE_NOT_FOUND
, "connecting to pipe\n");
642 ok(err
== ERROR_PIPE_BUSY
, "connecting to pipe\n");
643 trace("connect failed, retrying\n");
646 ok(hFile
!= INVALID_HANDLE_VALUE
, "client opening named pipe\n");
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");
658 trace("Client closing...\n");
659 ok(CloseHandle(hFile
), "CloseHandle\n");
662 ok(WaitForSingleObject(serverThread
,INFINITE
) == WAIT_OBJECT_0
, "WaitForSingleObject\n");
664 trace("exercizeServer returning\n");
667 static void test_NamedPipe_2(void)
670 DWORD serverThreadId
;
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
);
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.
685 serverThread
= CreateThread(NULL
, 0, serverThreadMain1
, (void *)8, 0, &serverThreadId
);
686 ok(serverThread
!= INVALID_HANDLE_VALUE
, "CreateThread\n");
687 exercizeServer(PIPENAME
"serverThreadMain1", serverThread
);
690 serverThread
= CreateThread(NULL
, 0, serverThreadMain2
, 0, 0, &serverThreadId
);
691 ok(serverThread
!= INVALID_HANDLE_VALUE
, "CreateThread\n");
692 exercizeServer(PIPENAME
"serverThreadMain2", serverThread
);
694 if( 0 ) /* overlapped pipe server doesn't work yet - it randomly fails */
697 serverThread
= CreateThread(NULL
, 0, serverThreadMain3
, 0, 0, &serverThreadId
);
698 ok(serverThread
!= INVALID_HANDLE_VALUE
, "CreateThread\n");
699 exercizeServer(PIPENAME
"serverThreadMain3", serverThread
);
702 ok(SetEvent( alarm_event
), "SetEvent\n");
703 CloseHandle( alarm_event
);
704 trace("test_NamedPipe_2 returning\n");
707 static int test_DisconnectNamedPipe(void)
711 static const char obuf
[] = "Bit Bucket";
716 hnp
= CreateNamedPipe(PIPENAME
, PIPE_ACCESS_DUPLEX
, PIPE_TYPE_BYTE
| PIPE_WAIT
,
717 /* nMaxInstances */ 1,
718 /* nOutBufSize */ 1024,
719 /* nInBufSize */ 1024,
720 /* nDefaultWait */ NMPWAIT_USE_DEFAULT_WAIT
,
721 /* lpSecurityAttrib */ NULL
);
722 if (INVALID_HANDLE_VALUE
== hnp
) {
723 trace ("Seems we have no named pipes.\n");
727 ok(WriteFile(hnp
, obuf
, sizeof(obuf
), &written
, NULL
) == 0
728 && GetLastError() == ERROR_PIPE_LISTENING
, "WriteFile to not-yet-connected pipe\n");
729 ok(ReadFile(hnp
, ibuf
, sizeof(ibuf
), &readden
, NULL
) == 0
730 && GetLastError() == ERROR_PIPE_LISTENING
, "ReadFile from not-yet-connected pipe\n");
732 hFile
= CreateFileA(PIPENAME
, GENERIC_READ
| GENERIC_WRITE
, 0, NULL
, OPEN_EXISTING
, 0, 0);
733 ok(hFile
!= INVALID_HANDLE_VALUE
, "CreateFile failed\n");
735 /* don't try to do i/o if one side couldn't be opened, as it hangs */
736 if (hFile
!= INVALID_HANDLE_VALUE
) {
738 /* see what happens if server calls DisconnectNamedPipe
739 * when there are bytes in the pipe
742 ok(WriteFile(hFile
, obuf
, sizeof(obuf
), &written
, NULL
), "WriteFile\n");
743 ok(written
== sizeof(obuf
), "write file len\n");
744 ok(DisconnectNamedPipe(hnp
), "DisconnectNamedPipe while messages waiting\n");
745 ok(WriteFile(hFile
, obuf
, sizeof(obuf
), &written
, NULL
) == 0
746 && GetLastError() == ERROR_PIPE_NOT_CONNECTED
, "WriteFile to disconnected pipe\n");
747 ok(ReadFile(hnp
, ibuf
, sizeof(ibuf
), &readden
, NULL
) == 0
748 && GetLastError() == ERROR_PIPE_NOT_CONNECTED
,
749 "ReadFile from disconnected pipe with bytes waiting\n");
750 ok(!DisconnectNamedPipe(hnp
) && GetLastError() == ERROR_PIPE_NOT_CONNECTED
,
751 "DisconnectNamedPipe worked twice\n");
752 ok(CloseHandle(hFile
), "CloseHandle\n");
755 ok(CloseHandle(hnp
), "CloseHandle\n");
759 static void test_CreatePipe(void)
761 SECURITY_ATTRIBUTES pipe_attr
;
762 HANDLE piperead
, pipewrite
;
769 pipe_attr
.nLength
= sizeof(SECURITY_ATTRIBUTES
);
770 pipe_attr
.bInheritHandle
= TRUE
;
771 pipe_attr
.lpSecurityDescriptor
= NULL
;
772 ok(CreatePipe(&piperead
, &pipewrite
, &pipe_attr
, 0) != 0, "CreatePipe failed\n");
773 ok(WriteFile(pipewrite
,PIPENAME
,sizeof(PIPENAME
), &written
, NULL
), "Write to anonymous pipe failed\n");
774 ok(written
== sizeof(PIPENAME
), "Write to anonymous pipe wrote %d bytes\n", written
);
775 ok(ReadFile(piperead
,readbuf
,sizeof(readbuf
),&read
, NULL
), "Read from non empty pipe failed\n");
776 ok(read
== sizeof(PIPENAME
), "Read from anonymous pipe got %d bytes\n", read
);
777 ok(CloseHandle(pipewrite
), "CloseHandle for the write pipe failed\n");
778 ok(CloseHandle(piperead
), "CloseHandle for the read pipe failed\n");
780 /* Now write another chunk*/
781 ok(CreatePipe(&piperead
, &pipewrite
, &pipe_attr
, 0) != 0, "CreatePipe failed\n");
782 ok(WriteFile(pipewrite
,PIPENAME
,sizeof(PIPENAME
), &written
, NULL
), "Write to anonymous pipe failed\n");
783 ok(written
== sizeof(PIPENAME
), "Write to anonymous pipe wrote %d bytes\n", written
);
784 /* and close the write end, read should still succeed*/
785 ok(CloseHandle(pipewrite
), "CloseHandle for the Write Pipe failed\n");
786 ok(ReadFile(piperead
,readbuf
,sizeof(readbuf
),&read
, NULL
), "Read from broken pipe withe with pending data failed\n");
787 ok(read
== sizeof(PIPENAME
), "Read from anonymous pipe got %d bytes\n", read
);
788 /* But now we need to get informed that the pipe is closed */
789 ok(ReadFile(piperead
,readbuf
,sizeof(readbuf
),&read
, NULL
) == 0, "Broken pipe not detected\n");
790 ok(CloseHandle(piperead
), "CloseHandle for the read pipe failed\n");
792 /* Try bigger chunks */
794 buffer
= HeapAlloc( GetProcessHeap(), 0, size
);
795 for (i
= 0; i
< size
; i
++) buffer
[i
] = i
;
796 ok(CreatePipe(&piperead
, &pipewrite
, &pipe_attr
, size
) != 0, "CreatePipe failed\n");
797 ok(WriteFile(pipewrite
, buffer
, size
, &written
, NULL
), "Write to anonymous pipe failed\n");
798 ok(written
== size
, "Write to anonymous pipe wrote %d bytes\n", written
);
799 /* and close the write end, read should still succeed*/
800 ok(CloseHandle(pipewrite
), "CloseHandle for the Write Pipe failed\n");
801 memset( buffer
, 0, size
);
802 ok(ReadFile(piperead
, buffer
, size
, &read
, NULL
), "Read from broken pipe withe with pending data failed\n");
803 ok(read
== size
, "Read from anonymous pipe got %d bytes\n", read
);
804 for (i
= 0; i
< size
; i
++) ok( buffer
[i
] == (BYTE
)i
, "invalid data %x at %x\n", buffer
[i
], i
);
805 /* But now we need to get informed that the pipe is closed */
806 ok(ReadFile(piperead
,readbuf
,sizeof(readbuf
),&read
, NULL
) == 0, "Broken pipe not detected\n");
807 ok(CloseHandle(piperead
), "CloseHandle for the read pipe failed\n");
808 HeapFree(GetProcessHeap(), 0, buffer
);
811 struct named_pipe_client_params
813 DWORD security_flags
;
818 #define PIPE_NAME "\\\\.\\pipe\\named_pipe_test"
820 static DWORD CALLBACK
named_pipe_client_func(LPVOID p
)
822 struct named_pipe_client_params
*params
= (struct named_pipe_client_params
*)p
;
825 const char message
[] = "Test";
826 DWORD bytes_read
, bytes_written
;
828 TOKEN_PRIVILEGES
*Privileges
= NULL
;
834 /* modify the token so we can tell if the pipe impersonation
835 * token reverts to the process token */
836 ret
= AdjustTokenPrivileges(params
->token
, TRUE
, NULL
, 0, NULL
, NULL
);
837 ok(ret
, "AdjustTokenPrivileges failed with error %d\n", GetLastError());
839 ret
= SetThreadToken(NULL
, params
->token
);
840 ok(ret
, "SetThreadToken failed with error %d\n", GetLastError());
845 HANDLE process_token
;
847 ret
= OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY
|TOKEN_ADJUST_PRIVILEGES
, &process_token
);
848 ok(ret
, "OpenProcessToken failed with error %d\n", GetLastError());
850 ret
= GetTokenInformation(process_token
, TokenPrivileges
, NULL
, 0, &Size
);
851 ok(!ret
&& GetLastError() == ERROR_INSUFFICIENT_BUFFER
, "GetTokenInformation(TokenPrivileges) failed with %d\n", GetLastError());
852 Privileges
= HeapAlloc(GetProcessHeap(), 0, Size
);
853 ret
= GetTokenInformation(process_token
, TokenPrivileges
, Privileges
, Size
, &Size
);
854 ok(ret
, "GetTokenInformation(TokenPrivileges) failed with %d\n", GetLastError());
856 ret
= AdjustTokenPrivileges(process_token
, TRUE
, NULL
, 0, NULL
, NULL
);
857 ok(ret
, "AdjustTokenPrivileges failed with error %d\n", GetLastError());
859 CloseHandle(process_token
);
862 pipe
= CreateFile(PIPE_NAME
, GENERIC_READ
| GENERIC_WRITE
, 0, NULL
, OPEN_EXISTING
, params
->security_flags
, NULL
);
863 ok(pipe
!= INVALID_HANDLE_VALUE
, "CreateFile for pipe failed with error %d\n", GetLastError());
865 ret
= WriteFile(pipe
, message
, sizeof(message
), &bytes_written
, NULL
);
866 ok(ret
, "WriteFile failed with error %d\n", GetLastError());
868 ret
= ReadFile(pipe
, &dummy
, sizeof(dummy
), &bytes_read
, NULL
);
869 ok(ret
, "ReadFile failed with error %d\n", GetLastError());
875 ret
= RevertToSelf();
876 ok(ret
, "RevertToSelf failed with error %d\n", GetLastError());
880 ret
= AdjustTokenPrivileges(params
->token
, TRUE
, NULL
, 0, NULL
, NULL
);
881 ok(ret
, "AdjustTokenPrivileges failed with error %d\n", GetLastError());
886 HANDLE process_token
;
888 ret
= OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES
, &process_token
);
889 ok(ret
, "OpenProcessToken failed with error %d\n", GetLastError());
891 ret
= AdjustTokenPrivileges(process_token
, FALSE
, Privileges
, 0, NULL
, NULL
);
892 ok(ret
, "AdjustTokenPrivileges failed with error %d\n", GetLastError());
894 HeapFree(GetProcessHeap(), 0, Privileges
);
896 CloseHandle(process_token
);
899 ret
= WriteFile(pipe
, message
, sizeof(message
), &bytes_written
, NULL
);
900 ok(ret
, "WriteFile failed with error %d\n", GetLastError());
902 ret
= ReadFile(pipe
, &dummy
, sizeof(dummy
), &bytes_read
, NULL
);
903 ok(ret
, "ReadFile failed with error %d\n", GetLastError());
910 static HANDLE
make_impersonation_token(DWORD Access
, SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
)
916 ret
= OpenProcessToken(GetCurrentProcess(), TOKEN_DUPLICATE
, &ProcessToken
);
917 ok(ret
, "OpenProcessToken failed with error %d\n", GetLastError());
919 ret
= pDuplicateTokenEx(ProcessToken
, Access
, NULL
, ImpersonationLevel
, TokenImpersonation
, &Token
);
920 ok(ret
, "DuplicateToken failed with error %d\n", GetLastError());
922 CloseHandle(ProcessToken
);
927 static void test_ImpersonateNamedPipeClient(HANDLE hClientToken
, DWORD security_flags
, BOOL revert
, void (*test_func
)(int, HANDLE
))
936 struct named_pipe_client_params params
;
938 DWORD dwBytesWritten
;
939 HANDLE hToken
= NULL
;
940 SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
;
943 hPipeServer
= CreateNamedPipe(PIPE_NAME
, PIPE_ACCESS_DUPLEX
, PIPE_TYPE_BYTE
| PIPE_READMODE_BYTE
| PIPE_WAIT
, 1, 100, 100, NMPWAIT_USE_DEFAULT_WAIT
, NULL
);
944 ok(hPipeServer
!= INVALID_HANDLE_VALUE
, "CreateNamedPipe failed with error %d\n", GetLastError());
946 params
.security_flags
= security_flags
;
947 params
.token
= hClientToken
;
948 params
.revert
= revert
;
949 hThread
= CreateThread(NULL
, 0, named_pipe_client_func
, ¶ms
, 0, &dwTid
);
950 ok(hThread
!= NULL
, "CreateThread failed with error %d\n", GetLastError());
952 SetLastError(0xdeadbeef);
953 ret
= ImpersonateNamedPipeClient(hPipeServer
);
954 error
= GetLastError();
956 ok(!ret
&& (error
== ERROR_CANNOT_IMPERSONATE
), "ImpersonateNamedPipeClient should have failed with ERROR_CANNOT_IMPERSONATE instead of %d\n", GetLastError());
958 ret
= ConnectNamedPipe(hPipeServer
, NULL
);
959 ok(ret
|| (GetLastError() == ERROR_PIPE_CONNECTED
), "ConnectNamedPipe failed with error %d\n", GetLastError());
961 ret
= ReadFile(hPipeServer
, buffer
, sizeof(buffer
), &dwBytesRead
, NULL
);
962 ok(ret
, "ReadFile failed with error %d\n", GetLastError());
964 ret
= ImpersonateNamedPipeClient(hPipeServer
);
965 ok(ret
, "ImpersonateNamedPipeClient failed with error %d\n", GetLastError());
967 ret
= OpenThreadToken(GetCurrentThread(), TOKEN_QUERY
, FALSE
, &hToken
);
968 ok(ret
, "OpenThreadToken failed with error %d\n", GetLastError());
970 (*test_func
)(0, hToken
);
972 ImpersonationLevel
= 0xdeadbeef; /* to avoid false positives */
973 ret
= GetTokenInformation(hToken
, TokenImpersonationLevel
, &ImpersonationLevel
, sizeof(ImpersonationLevel
), &size
);
974 ok(ret
, "GetTokenInformation(TokenImpersonationLevel) failed with error %d\n", GetLastError());
975 ok(ImpersonationLevel
== SecurityImpersonation
, "ImpersonationLevel should have been SecurityImpersonation(%d) instead of %d\n", SecurityImpersonation
, ImpersonationLevel
);
981 ret
= WriteFile(hPipeServer
, &dummy
, sizeof(dummy
), &dwBytesWritten
, NULL
);
982 ok(ret
, "WriteFile failed with error %d\n", GetLastError());
984 ret
= ReadFile(hPipeServer
, buffer
, sizeof(buffer
), &dwBytesRead
, NULL
);
985 ok(ret
, "ReadFile failed with error %d\n", GetLastError());
987 ret
= ImpersonateNamedPipeClient(hPipeServer
);
988 ok(ret
, "ImpersonateNamedPipeClient failed with error %d\n", GetLastError());
990 ret
= OpenThreadToken(GetCurrentThread(), TOKEN_QUERY
, FALSE
, &hToken
);
991 ok(ret
, "OpenThreadToken failed with error %d\n", GetLastError());
993 (*test_func
)(1, hToken
);
999 ret
= WriteFile(hPipeServer
, &dummy
, sizeof(dummy
), &dwBytesWritten
, NULL
);
1000 ok(ret
, "WriteFile failed with error %d\n", GetLastError());
1002 WaitForSingleObject(hThread
, INFINITE
);
1004 ret
= ImpersonateNamedPipeClient(hPipeServer
);
1005 ok(ret
, "ImpersonateNamedPipeClient failed with error %d\n", GetLastError());
1009 CloseHandle(hThread
);
1010 CloseHandle(hPipeServer
);
1013 static BOOL
are_all_privileges_disabled(HANDLE hToken
)
1016 TOKEN_PRIVILEGES
*Privileges
= NULL
;
1018 BOOL all_privs_disabled
= TRUE
;
1021 ret
= GetTokenInformation(hToken
, TokenPrivileges
, NULL
, 0, &Size
);
1022 if (!ret
&& GetLastError() == ERROR_INSUFFICIENT_BUFFER
)
1024 Privileges
= HeapAlloc(GetProcessHeap(), 0, Size
);
1025 ret
= GetTokenInformation(hToken
, TokenPrivileges
, Privileges
, Size
, &Size
);
1028 HeapFree(GetProcessHeap(), 0, Privileges
);
1035 for (i
= 0; i
< Privileges
->PrivilegeCount
; i
++)
1037 if (Privileges
->Privileges
[i
].Attributes
& SE_PRIVILEGE_ENABLED
)
1039 all_privs_disabled
= FALSE
;
1044 HeapFree(GetProcessHeap(), 0, Privileges
);
1046 return all_privs_disabled
;
1049 static DWORD
get_privilege_count(HANDLE hToken
)
1051 TOKEN_STATISTICS Statistics
;
1052 DWORD Size
= sizeof(Statistics
);
1055 ret
= GetTokenInformation(hToken
, TokenStatistics
, &Statistics
, Size
, &Size
);
1056 ok(ret
, "GetTokenInformation(TokenStatistics)\n");
1057 if (!ret
) return -1;
1059 return Statistics
.PrivilegeCount
;
1062 static void test_no_sqos_no_token(int call_index
, HANDLE hToken
)
1069 priv_count
= get_privilege_count(hToken
);
1071 ok(priv_count
== 0, "privilege count should have been 0 instead of %d\n", priv_count
);
1074 priv_count
= get_privilege_count(hToken
);
1075 ok(priv_count
> 0, "privilege count should now be > 0 instead of 0\n");
1076 ok(!are_all_privileges_disabled(hToken
), "impersonated token should not have been modified\n");
1079 ok(0, "shouldn't happen\n");
1083 static void test_no_sqos(int call_index
, HANDLE hToken
)
1088 ok(!are_all_privileges_disabled(hToken
), "token should be a copy of the process one\n");
1092 ok(are_all_privileges_disabled(hToken
), "impersonated token should have been modified\n");
1095 ok(0, "shouldn't happen\n");
1099 static void test_static_context(int call_index
, HANDLE hToken
)
1104 ok(!are_all_privileges_disabled(hToken
), "token should be a copy of the process one\n");
1107 ok(!are_all_privileges_disabled(hToken
), "impersonated token should not have been modified\n");
1110 ok(0, "shouldn't happen\n");
1114 static void test_dynamic_context(int call_index
, HANDLE hToken
)
1119 ok(!are_all_privileges_disabled(hToken
), "token should be a copy of the process one\n");
1123 ok(are_all_privileges_disabled(hToken
), "impersonated token should have been modified\n");
1126 ok(0, "shouldn't happen\n");
1130 static void test_dynamic_context_no_token(int call_index
, HANDLE hToken
)
1135 ok(are_all_privileges_disabled(hToken
), "token should be a copy of the process one\n");
1138 ok(!are_all_privileges_disabled(hToken
), "process token modification should have been detected and impersonation token updated\n");
1141 ok(0, "shouldn't happen\n");
1145 static void test_no_sqos_revert(int call_index
, HANDLE hToken
)
1151 priv_count
= get_privilege_count(hToken
);
1153 ok(priv_count
== 0, "privilege count should have been 0 instead of %d\n", priv_count
);
1156 priv_count
= get_privilege_count(hToken
);
1157 ok(priv_count
> 0, "privilege count should now be > 0 instead of 0\n");
1158 ok(!are_all_privileges_disabled(hToken
), "impersonated token should not have been modified\n");
1161 ok(0, "shouldn't happen\n");
1165 static void test_static_context_revert(int call_index
, HANDLE hToken
)
1171 ok(are_all_privileges_disabled(hToken
), "privileges should have been disabled\n");
1175 ok(are_all_privileges_disabled(hToken
), "impersonated token should not have been modified\n");
1178 ok(0, "shouldn't happen\n");
1182 static void test_dynamic_context_revert(int call_index
, HANDLE hToken
)
1188 ok(are_all_privileges_disabled(hToken
), "privileges should have been disabled\n");
1191 ok(!are_all_privileges_disabled(hToken
), "impersonated token should now be process token\n");
1194 ok(0, "shouldn't happen\n");
1198 static void test_impersonation(void)
1200 HANDLE hClientToken
;
1201 HANDLE hProcessToken
;
1204 if( !pDuplicateTokenEx
) {
1205 skip("DuplicateTokenEx not found\n");
1209 ret
= OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY
, &hProcessToken
);
1212 skip("couldn't open process token, skipping impersonation tests\n");
1216 if (!get_privilege_count(hProcessToken
) || are_all_privileges_disabled(hProcessToken
))
1218 skip("token didn't have any privileges or they were all disabled. token not suitable for impersonation tests\n");
1219 CloseHandle(hProcessToken
);
1222 CloseHandle(hProcessToken
);
1224 test_ImpersonateNamedPipeClient(NULL
, 0, FALSE
, test_no_sqos_no_token
);
1225 hClientToken
= make_impersonation_token(TOKEN_IMPERSONATE
| TOKEN_ADJUST_PRIVILEGES
| TOKEN_QUERY
, SecurityImpersonation
);
1226 test_ImpersonateNamedPipeClient(hClientToken
, 0, FALSE
, test_no_sqos
);
1227 CloseHandle(hClientToken
);
1228 hClientToken
= make_impersonation_token(TOKEN_IMPERSONATE
| TOKEN_ADJUST_PRIVILEGES
| TOKEN_QUERY
, SecurityImpersonation
);
1229 test_ImpersonateNamedPipeClient(hClientToken
,
1230 SECURITY_SQOS_PRESENT
| SECURITY_IMPERSONATION
, FALSE
,
1231 test_static_context
);
1232 CloseHandle(hClientToken
);
1233 hClientToken
= make_impersonation_token(TOKEN_IMPERSONATE
| TOKEN_ADJUST_PRIVILEGES
| TOKEN_QUERY
, SecurityImpersonation
);
1234 test_ImpersonateNamedPipeClient(hClientToken
,
1235 SECURITY_SQOS_PRESENT
| SECURITY_CONTEXT_TRACKING
| SECURITY_IMPERSONATION
,
1236 FALSE
, test_dynamic_context
);
1237 CloseHandle(hClientToken
);
1238 test_ImpersonateNamedPipeClient(NULL
,
1239 SECURITY_SQOS_PRESENT
| SECURITY_CONTEXT_TRACKING
| SECURITY_IMPERSONATION
,
1240 FALSE
, test_dynamic_context_no_token
);
1242 hClientToken
= make_impersonation_token(TOKEN_IMPERSONATE
| TOKEN_ADJUST_PRIVILEGES
| TOKEN_QUERY
, SecurityImpersonation
);
1243 test_ImpersonateNamedPipeClient(hClientToken
, 0, TRUE
, test_no_sqos_revert
);
1244 CloseHandle(hClientToken
);
1245 hClientToken
= make_impersonation_token(TOKEN_IMPERSONATE
| TOKEN_ADJUST_PRIVILEGES
| TOKEN_QUERY
, SecurityImpersonation
);
1246 test_ImpersonateNamedPipeClient(hClientToken
,
1247 SECURITY_SQOS_PRESENT
| SECURITY_IMPERSONATION
, TRUE
,
1248 test_static_context_revert
);
1249 CloseHandle(hClientToken
);
1250 hClientToken
= make_impersonation_token(TOKEN_IMPERSONATE
| TOKEN_ADJUST_PRIVILEGES
| TOKEN_QUERY
, SecurityImpersonation
);
1251 test_ImpersonateNamedPipeClient(hClientToken
,
1252 SECURITY_SQOS_PRESENT
| SECURITY_CONTEXT_TRACKING
| SECURITY_IMPERSONATION
,
1253 TRUE
, test_dynamic_context_revert
);
1254 CloseHandle(hClientToken
);
1257 struct overlapped_server_args
1259 HANDLE pipe_created
;
1262 static DWORD CALLBACK
overlapped_server(LPVOID arg
)
1267 struct overlapped_server_args
*a
= (struct overlapped_server_args
*)arg
;
1271 pipe
= CreateNamedPipeA("\\\\.\\pipe\\my pipe", FILE_FLAG_OVERLAPPED
| PIPE_ACCESS_DUPLEX
, PIPE_TYPE_MESSAGE
| PIPE_READMODE_MESSAGE
, 1, 0, 0, 100000, NULL
);
1272 ok(pipe
!= NULL
, "pipe NULL\n");
1274 ol
.hEvent
= CreateEventA(0, 1, 0, 0);
1275 ok(ol
.hEvent
!= NULL
, "event NULL\n");
1276 ret
= ConnectNamedPipe(pipe
, &ol
);
1277 err
= GetLastError();
1278 ok(ret
== 0, "ret %d\n", ret
);
1279 ok(err
== ERROR_IO_PENDING
, "gle %d\n", err
);
1280 SetEvent(a
->pipe_created
);
1282 ret
= WaitForSingleObjectEx(ol
.hEvent
, INFINITE
, 1);
1283 ok(ret
== WAIT_OBJECT_0
, "ret %x\n", ret
);
1285 ret
= GetOverlappedResult(pipe
, &ol
, &num
, 1);
1286 ok(ret
== 1, "ret %d\n", ret
);
1288 /* This should block */
1289 ret
= ReadFile(pipe
, buf
, sizeof(buf
), &num
, NULL
);
1290 ok(ret
== 1, "ret %d\n", ret
);
1292 DisconnectNamedPipe(pipe
);
1293 CloseHandle(ol
.hEvent
);
1298 static void test_overlapped(void)
1301 HANDLE thread
, pipe
;
1303 struct overlapped_server_args args
;
1305 args
.pipe_created
= CreateEventA(0, 1, 0, 0);
1306 thread
= CreateThread(NULL
, 0, overlapped_server
, &args
, 0, &tid
);
1308 WaitForSingleObject(args
.pipe_created
, INFINITE
);
1309 pipe
= CreateFileA("\\\\.\\pipe\\my pipe", GENERIC_READ
|GENERIC_WRITE
, 0, NULL
, OPEN_EXISTING
, 0, NULL
);
1310 ok(pipe
!= INVALID_HANDLE_VALUE
, "cf failed\n");
1312 /* Sleep to try to get the ReadFile in the server to occur before the following WriteFile */
1315 ret
= WriteFile(pipe
, "x", 1, &num
, NULL
);
1316 ok(ret
== 1, "ret %d\n", ret
);
1318 WaitForSingleObject(thread
, INFINITE
);
1320 CloseHandle(args
.pipe_created
);
1321 CloseHandle(thread
);
1328 hmod
= GetModuleHandle("advapi32.dll");
1329 pDuplicateTokenEx
= (void *) GetProcAddress(hmod
, "DuplicateTokenEx");
1331 if (test_DisconnectNamedPipe())
1333 test_CreateNamedPipe_instances_must_match();
1335 test_CreateNamedPipe(PIPE_TYPE_BYTE
);
1336 test_CreateNamedPipe(PIPE_TYPE_MESSAGE
| PIPE_READMODE_MESSAGE
);
1338 test_impersonation();