kernel32/tests: Add a couple of tests for write watches.
[wine] / dlls / kernel32 / tests / pipe.c
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 read;
768     DWORD i, size;
769     BYTE *buffer;
770     char readbuf[32];
771
772     pipe_attr.nLength = sizeof(SECURITY_ATTRIBUTES); 
773     pipe_attr.bInheritHandle = TRUE; 
774     pipe_attr.lpSecurityDescriptor = NULL; 
775     ok(CreatePipe(&piperead, &pipewrite, &pipe_attr, 0) != 0, "CreatePipe failed\n");
776     ok(WriteFile(pipewrite,PIPENAME,sizeof(PIPENAME), &written, NULL), "Write to anonymous pipe failed\n");
777     ok(written == sizeof(PIPENAME), "Write to anonymous pipe wrote %d bytes\n", written);
778     ok(ReadFile(piperead,readbuf,sizeof(readbuf),&read, NULL), "Read from non empty pipe failed\n");
779     ok(read == sizeof(PIPENAME), "Read from  anonymous pipe got %d bytes\n", read);
780     ok(CloseHandle(pipewrite), "CloseHandle for the write pipe failed\n");
781     ok(CloseHandle(piperead), "CloseHandle for the read pipe failed\n");
782
783     /* Now write another chunk*/
784     ok(CreatePipe(&piperead, &pipewrite, &pipe_attr, 0) != 0, "CreatePipe failed\n");
785     ok(WriteFile(pipewrite,PIPENAME,sizeof(PIPENAME), &written, NULL), "Write to anonymous pipe failed\n");
786     ok(written == sizeof(PIPENAME), "Write to anonymous pipe wrote %d bytes\n", written);
787     /* and close the write end, read should still succeed*/
788     ok(CloseHandle(pipewrite), "CloseHandle for the Write Pipe failed\n");
789     ok(ReadFile(piperead,readbuf,sizeof(readbuf),&read, NULL), "Read from broken pipe withe with pending data failed\n");
790     ok(read == sizeof(PIPENAME), "Read from  anonymous pipe got %d bytes\n", read);
791     /* But now we need to get informed that the pipe is closed */
792     ok(ReadFile(piperead,readbuf,sizeof(readbuf),&read, NULL) == 0, "Broken pipe not detected\n");
793     ok(CloseHandle(piperead), "CloseHandle for the read pipe failed\n");
794
795     /* Try bigger chunks */
796     size = 32768;
797     buffer = HeapAlloc( GetProcessHeap(), 0, size );
798     for (i = 0; i < size; i++) buffer[i] = i;
799     ok(CreatePipe(&piperead, &pipewrite, &pipe_attr, (size + 24)) != 0, "CreatePipe failed\n");
800     ok(WriteFile(pipewrite, buffer, size, &written, NULL), "Write to anonymous pipe failed\n");
801     ok(written == size, "Write to anonymous pipe wrote %d bytes\n", written);
802     /* and close the write end, read should still succeed*/
803     ok(CloseHandle(pipewrite), "CloseHandle for the Write Pipe failed\n");
804     memset( buffer, 0, size );
805     ok(ReadFile(piperead, buffer, size, &read, NULL), "Read from broken pipe withe with pending data failed\n");
806     ok(read == size, "Read from  anonymous pipe got %d bytes\n", read);
807     for (i = 0; i < size; i++) ok( buffer[i] == (BYTE)i, "invalid data %x at %x\n", buffer[i], i );
808     /* But now we need to get informed that the pipe is closed */
809     ok(ReadFile(piperead,readbuf,sizeof(readbuf),&read, NULL) == 0, "Broken pipe not detected\n");
810     ok(CloseHandle(piperead), "CloseHandle for the read pipe failed\n");
811     HeapFree(GetProcessHeap(), 0, buffer);
812 }
813
814 struct named_pipe_client_params
815 {
816     DWORD security_flags;
817     HANDLE token;
818     BOOL revert;
819 };
820
821 #define PIPE_NAME "\\\\.\\pipe\\named_pipe_test"
822
823 static DWORD CALLBACK named_pipe_client_func(LPVOID p)
824 {
825     struct named_pipe_client_params *params = (struct named_pipe_client_params *)p;
826     HANDLE pipe;
827     BOOL ret;
828     const char message[] = "Test";
829     DWORD bytes_read, bytes_written;
830     char dummy;
831     TOKEN_PRIVILEGES *Privileges = NULL;
832
833     if (params->token)
834     {
835         if (params->revert)
836         {
837             /* modify the token so we can tell if the pipe impersonation
838              * token reverts to the process token */
839             ret = AdjustTokenPrivileges(params->token, TRUE, NULL, 0, NULL, NULL);
840             ok(ret, "AdjustTokenPrivileges failed with error %d\n", GetLastError());
841         }
842         ret = SetThreadToken(NULL, params->token);
843         ok(ret, "SetThreadToken failed with error %d\n", GetLastError());
844     }
845     else
846     {
847         DWORD Size = 0;
848         HANDLE process_token;
849
850         ret = OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY|TOKEN_ADJUST_PRIVILEGES, &process_token);
851         ok(ret, "OpenProcessToken failed with error %d\n", GetLastError());
852
853         ret = GetTokenInformation(process_token, TokenPrivileges, NULL, 0, &Size);
854         ok(!ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER, "GetTokenInformation(TokenPrivileges) failed with %d\n", GetLastError());
855         Privileges = HeapAlloc(GetProcessHeap(), 0, Size);
856         ret = GetTokenInformation(process_token, TokenPrivileges, Privileges, Size, &Size);
857         ok(ret, "GetTokenInformation(TokenPrivileges) failed with %d\n", GetLastError());
858
859         ret = AdjustTokenPrivileges(process_token, TRUE, NULL, 0, NULL, NULL);
860         ok(ret, "AdjustTokenPrivileges failed with error %d\n", GetLastError());
861
862         CloseHandle(process_token);
863     }
864
865     pipe = CreateFile(PIPE_NAME, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, params->security_flags, NULL);
866     ok(pipe != INVALID_HANDLE_VALUE, "CreateFile for pipe failed with error %d\n", GetLastError());
867
868     ret = WriteFile(pipe, message, sizeof(message), &bytes_written, NULL);
869     ok(ret, "WriteFile failed with error %d\n", GetLastError());
870
871     ret = ReadFile(pipe, &dummy, sizeof(dummy), &bytes_read, NULL);
872     ok(ret, "ReadFile failed with error %d\n", GetLastError());
873
874     if (params->token)
875     {
876         if (params->revert)
877         {
878             ret = RevertToSelf();
879             ok(ret, "RevertToSelf failed with error %d\n", GetLastError());
880         }
881         else
882         {
883             ret = AdjustTokenPrivileges(params->token, TRUE, NULL, 0, NULL, NULL);
884             ok(ret, "AdjustTokenPrivileges failed with error %d\n", GetLastError());
885         }
886     }
887     else
888     {
889         HANDLE process_token;
890
891         ret = OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &process_token);
892         ok(ret, "OpenProcessToken failed with error %d\n", GetLastError());
893
894         ret = AdjustTokenPrivileges(process_token, FALSE, Privileges, 0, NULL, NULL);
895         ok(ret, "AdjustTokenPrivileges failed with error %d\n", GetLastError());
896
897         HeapFree(GetProcessHeap(), 0, Privileges);
898
899         CloseHandle(process_token);
900     }
901
902     ret = WriteFile(pipe, message, sizeof(message), &bytes_written, NULL);
903     ok(ret, "WriteFile failed with error %d\n", GetLastError());
904
905     ret = ReadFile(pipe, &dummy, sizeof(dummy), &bytes_read, NULL);
906     ok(ret, "ReadFile failed with error %d\n", GetLastError());
907
908     CloseHandle(pipe);
909
910     return 0;
911 }
912
913 static HANDLE make_impersonation_token(DWORD Access, SECURITY_IMPERSONATION_LEVEL ImpersonationLevel)
914 {
915     HANDLE ProcessToken;
916     HANDLE Token = NULL;
917     BOOL ret;
918
919     ret = OpenProcessToken(GetCurrentProcess(), TOKEN_DUPLICATE, &ProcessToken);
920     ok(ret, "OpenProcessToken failed with error %d\n", GetLastError());
921
922     ret = pDuplicateTokenEx(ProcessToken, Access, NULL, ImpersonationLevel, TokenImpersonation, &Token);
923     ok(ret, "DuplicateToken failed with error %d\n", GetLastError());
924
925     CloseHandle(ProcessToken);
926
927     return Token;
928 }
929
930 static void test_ImpersonateNamedPipeClient(HANDLE hClientToken, DWORD security_flags, BOOL revert, void (*test_func)(int, HANDLE))
931 {
932     HANDLE hPipeServer;
933     BOOL ret;
934     DWORD dwTid;
935     HANDLE hThread;
936     char buffer[256];
937     DWORD dwBytesRead;
938     DWORD error;
939     struct named_pipe_client_params params;
940     char dummy = 0;
941     DWORD dwBytesWritten;
942     HANDLE hToken = NULL;
943     SECURITY_IMPERSONATION_LEVEL ImpersonationLevel;
944     DWORD size;
945
946     hPipeServer = CreateNamedPipe(PIPE_NAME, PIPE_ACCESS_DUPLEX, PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT, 1, 100, 100, NMPWAIT_USE_DEFAULT_WAIT, NULL);
947     ok(hPipeServer != INVALID_HANDLE_VALUE, "CreateNamedPipe failed with error %d\n", GetLastError());
948
949     params.security_flags = security_flags;
950     params.token = hClientToken;
951     params.revert = revert;
952     hThread = CreateThread(NULL, 0, named_pipe_client_func, &params, 0, &dwTid);
953     ok(hThread != NULL, "CreateThread failed with error %d\n", GetLastError());
954
955     SetLastError(0xdeadbeef);
956     ret = ImpersonateNamedPipeClient(hPipeServer);
957     error = GetLastError();
958     ok(ret /* win2k3 */ || (error == ERROR_CANNOT_IMPERSONATE),
959        "ImpersonateNamedPipeClient should have failed with ERROR_CANNOT_IMPERSONATE instead of %d\n", GetLastError());
960
961     ret = ConnectNamedPipe(hPipeServer, NULL);
962     ok(ret || (GetLastError() == ERROR_PIPE_CONNECTED), "ConnectNamedPipe failed with error %d\n", GetLastError());
963
964     ret = ReadFile(hPipeServer, buffer, sizeof(buffer), &dwBytesRead, NULL);
965     ok(ret, "ReadFile failed with error %d\n", GetLastError());
966
967     ret = ImpersonateNamedPipeClient(hPipeServer);
968     ok(ret, "ImpersonateNamedPipeClient failed with error %d\n", GetLastError());
969
970     ret = OpenThreadToken(GetCurrentThread(), TOKEN_QUERY, FALSE, &hToken);
971     ok(ret, "OpenThreadToken failed with error %d\n", GetLastError());
972
973     (*test_func)(0, hToken);
974
975     ImpersonationLevel = 0xdeadbeef; /* to avoid false positives */
976     ret = GetTokenInformation(hToken, TokenImpersonationLevel, &ImpersonationLevel, sizeof(ImpersonationLevel), &size);
977     ok(ret, "GetTokenInformation(TokenImpersonationLevel) failed with error %d\n", GetLastError());
978     ok(ImpersonationLevel == SecurityImpersonation, "ImpersonationLevel should have been SecurityImpersonation(%d) instead of %d\n", SecurityImpersonation, ImpersonationLevel);
979
980     CloseHandle(hToken);
981
982     RevertToSelf();
983
984     ret = WriteFile(hPipeServer, &dummy, sizeof(dummy), &dwBytesWritten, NULL);
985     ok(ret, "WriteFile failed with error %d\n", GetLastError());
986
987     ret = ReadFile(hPipeServer, buffer, sizeof(buffer), &dwBytesRead, NULL);
988     ok(ret, "ReadFile failed with error %d\n", GetLastError());
989
990     ret = ImpersonateNamedPipeClient(hPipeServer);
991     ok(ret, "ImpersonateNamedPipeClient failed with error %d\n", GetLastError());
992
993     ret = OpenThreadToken(GetCurrentThread(), TOKEN_QUERY, FALSE, &hToken);
994     ok(ret, "OpenThreadToken failed with error %d\n", GetLastError());
995
996     (*test_func)(1, hToken);
997
998     CloseHandle(hToken);
999
1000     RevertToSelf();
1001
1002     ret = WriteFile(hPipeServer, &dummy, sizeof(dummy), &dwBytesWritten, NULL);
1003     ok(ret, "WriteFile failed with error %d\n", GetLastError());
1004
1005     WaitForSingleObject(hThread, INFINITE);
1006
1007     ret = ImpersonateNamedPipeClient(hPipeServer);
1008     ok(ret, "ImpersonateNamedPipeClient failed with error %d\n", GetLastError());
1009
1010     RevertToSelf();
1011
1012     CloseHandle(hThread);
1013     CloseHandle(hPipeServer);
1014 }
1015
1016 static BOOL are_all_privileges_disabled(HANDLE hToken)
1017 {
1018     BOOL ret;
1019     TOKEN_PRIVILEGES *Privileges = NULL;
1020     DWORD Size = 0;
1021     BOOL all_privs_disabled = TRUE;
1022     DWORD i;
1023
1024     ret = GetTokenInformation(hToken, TokenPrivileges, NULL, 0, &Size);
1025     if (!ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER)
1026     {
1027         Privileges = HeapAlloc(GetProcessHeap(), 0, Size);
1028         ret = GetTokenInformation(hToken, TokenPrivileges, Privileges, Size, &Size);
1029         if (!ret)
1030         {
1031             HeapFree(GetProcessHeap(), 0, Privileges);
1032             return FALSE;
1033         }
1034     }
1035     else
1036         return FALSE;
1037
1038     for (i = 0; i < Privileges->PrivilegeCount; i++)
1039     {
1040         if (Privileges->Privileges[i].Attributes & SE_PRIVILEGE_ENABLED)
1041         {
1042             all_privs_disabled = FALSE;
1043             break;
1044         }
1045     }
1046
1047     HeapFree(GetProcessHeap(), 0, Privileges);
1048
1049     return all_privs_disabled;
1050 }
1051
1052 static DWORD get_privilege_count(HANDLE hToken)
1053 {
1054     TOKEN_STATISTICS Statistics;
1055     DWORD Size = sizeof(Statistics);
1056     BOOL ret;
1057
1058     ret = GetTokenInformation(hToken, TokenStatistics, &Statistics, Size, &Size);
1059     ok(ret, "GetTokenInformation(TokenStatistics)\n");
1060     if (!ret) return -1;
1061
1062     return Statistics.PrivilegeCount;
1063 }
1064
1065 static void test_no_sqos_no_token(int call_index, HANDLE hToken)
1066 {
1067     DWORD priv_count;
1068
1069     switch (call_index)
1070     {
1071     case 0:
1072         priv_count = get_privilege_count(hToken);
1073         todo_wine
1074         ok(priv_count == 0, "privilege count should have been 0 instead of %d\n", priv_count);
1075         break;
1076     case 1:
1077         priv_count = get_privilege_count(hToken);
1078         ok(priv_count > 0, "privilege count should now be > 0 instead of 0\n");
1079         ok(!are_all_privileges_disabled(hToken), "impersonated token should not have been modified\n");
1080         break;
1081     default:
1082         ok(0, "shouldn't happen\n");
1083     }
1084 }
1085
1086 static void test_no_sqos(int call_index, HANDLE hToken)
1087 {
1088     switch (call_index)
1089     {
1090     case 0:
1091         ok(!are_all_privileges_disabled(hToken), "token should be a copy of the process one\n");
1092         break;
1093     case 1:
1094         todo_wine
1095         ok(are_all_privileges_disabled(hToken), "impersonated token should have been modified\n");
1096         break;
1097     default:
1098         ok(0, "shouldn't happen\n");
1099     }
1100 }
1101
1102 static void test_static_context(int call_index, HANDLE hToken)
1103 {
1104     switch (call_index)
1105     {
1106     case 0:
1107         ok(!are_all_privileges_disabled(hToken), "token should be a copy of the process one\n");
1108         break;
1109     case 1:
1110         ok(!are_all_privileges_disabled(hToken), "impersonated token should not have been modified\n");
1111         break;
1112     default:
1113         ok(0, "shouldn't happen\n");
1114     }
1115 }
1116
1117 static void test_dynamic_context(int call_index, HANDLE hToken)
1118 {
1119     switch (call_index)
1120     {
1121     case 0:
1122         ok(!are_all_privileges_disabled(hToken), "token should be a copy of the process one\n");
1123         break;
1124     case 1:
1125         todo_wine
1126         ok(are_all_privileges_disabled(hToken), "impersonated token should have been modified\n");
1127         break;
1128     default:
1129         ok(0, "shouldn't happen\n");
1130     }
1131 }
1132
1133 static void test_dynamic_context_no_token(int call_index, HANDLE hToken)
1134 {
1135     switch (call_index)
1136     {
1137     case 0:
1138         ok(are_all_privileges_disabled(hToken), "token should be a copy of the process one\n");
1139         break;
1140     case 1:
1141         ok(!are_all_privileges_disabled(hToken), "process token modification should have been detected and impersonation token updated\n");
1142         break;
1143     default:
1144         ok(0, "shouldn't happen\n");
1145     }
1146 }
1147
1148 static void test_no_sqos_revert(int call_index, HANDLE hToken)
1149 {
1150     DWORD priv_count;
1151     switch (call_index)
1152     {
1153     case 0:
1154         priv_count = get_privilege_count(hToken);
1155         todo_wine
1156         ok(priv_count == 0, "privilege count should have been 0 instead of %d\n", priv_count);
1157         break;
1158     case 1:
1159         priv_count = get_privilege_count(hToken);
1160         ok(priv_count > 0, "privilege count should now be > 0 instead of 0\n");
1161         ok(!are_all_privileges_disabled(hToken), "impersonated token should not have been modified\n");
1162         break;
1163     default:
1164         ok(0, "shouldn't happen\n");
1165     }
1166 }
1167
1168 static void test_static_context_revert(int call_index, HANDLE hToken)
1169 {
1170     switch (call_index)
1171     {
1172     case 0:
1173         todo_wine
1174         ok(are_all_privileges_disabled(hToken), "privileges should have been disabled\n");
1175         break;
1176     case 1:
1177         todo_wine
1178         ok(are_all_privileges_disabled(hToken), "impersonated token should not have been modified\n");
1179         break;
1180     default:
1181         ok(0, "shouldn't happen\n");
1182     }
1183 }
1184
1185 static void test_dynamic_context_revert(int call_index, HANDLE hToken)
1186 {
1187     switch (call_index)
1188     {
1189     case 0:
1190         todo_wine
1191         ok(are_all_privileges_disabled(hToken), "privileges should have been disabled\n");
1192         break;
1193     case 1:
1194         ok(!are_all_privileges_disabled(hToken), "impersonated token should now be process token\n");
1195         break;
1196     default:
1197         ok(0, "shouldn't happen\n");
1198     }
1199 }
1200
1201 static void test_impersonation(void)
1202 {
1203     HANDLE hClientToken;
1204     HANDLE hProcessToken;
1205     BOOL ret;
1206
1207     if( !pDuplicateTokenEx ) {
1208         skip("DuplicateTokenEx not found\n");
1209         return;
1210     }
1211
1212     ret = OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hProcessToken);
1213     if (!ret)
1214     {
1215         skip("couldn't open process token, skipping impersonation tests\n");
1216         return;
1217     }
1218
1219     if (!get_privilege_count(hProcessToken) || are_all_privileges_disabled(hProcessToken))
1220     {
1221         skip("token didn't have any privileges or they were all disabled. token not suitable for impersonation tests\n");
1222         CloseHandle(hProcessToken);
1223         return;
1224     }
1225     CloseHandle(hProcessToken);
1226
1227     test_ImpersonateNamedPipeClient(NULL, 0, FALSE, test_no_sqos_no_token);
1228     hClientToken = make_impersonation_token(TOKEN_IMPERSONATE | TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, SecurityImpersonation);
1229     test_ImpersonateNamedPipeClient(hClientToken, 0, FALSE, test_no_sqos);
1230     CloseHandle(hClientToken);
1231     hClientToken = make_impersonation_token(TOKEN_IMPERSONATE | TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, SecurityImpersonation);
1232     test_ImpersonateNamedPipeClient(hClientToken,
1233         SECURITY_SQOS_PRESENT | SECURITY_IMPERSONATION, FALSE,
1234         test_static_context);
1235     CloseHandle(hClientToken);
1236     hClientToken = make_impersonation_token(TOKEN_IMPERSONATE | TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, SecurityImpersonation);
1237     test_ImpersonateNamedPipeClient(hClientToken,
1238         SECURITY_SQOS_PRESENT | SECURITY_CONTEXT_TRACKING | SECURITY_IMPERSONATION,
1239         FALSE, test_dynamic_context);
1240     CloseHandle(hClientToken);
1241     test_ImpersonateNamedPipeClient(NULL,
1242         SECURITY_SQOS_PRESENT | SECURITY_CONTEXT_TRACKING | SECURITY_IMPERSONATION,
1243         FALSE, test_dynamic_context_no_token);
1244
1245     hClientToken = make_impersonation_token(TOKEN_IMPERSONATE | TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, SecurityImpersonation);
1246     test_ImpersonateNamedPipeClient(hClientToken, 0, TRUE, test_no_sqos_revert);
1247     CloseHandle(hClientToken);
1248     hClientToken = make_impersonation_token(TOKEN_IMPERSONATE | TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, SecurityImpersonation);
1249     test_ImpersonateNamedPipeClient(hClientToken,
1250         SECURITY_SQOS_PRESENT | SECURITY_IMPERSONATION, TRUE,
1251         test_static_context_revert);
1252     CloseHandle(hClientToken);
1253     hClientToken = make_impersonation_token(TOKEN_IMPERSONATE | TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, SecurityImpersonation);
1254     test_ImpersonateNamedPipeClient(hClientToken,
1255         SECURITY_SQOS_PRESENT | SECURITY_CONTEXT_TRACKING | SECURITY_IMPERSONATION,
1256         TRUE, test_dynamic_context_revert);
1257     CloseHandle(hClientToken);
1258 }
1259
1260 struct overlapped_server_args
1261 {
1262     HANDLE pipe_created;
1263 };
1264
1265 static DWORD CALLBACK overlapped_server(LPVOID arg)
1266 {
1267     OVERLAPPED ol;
1268     HANDLE pipe;
1269     int ret, err;
1270     struct overlapped_server_args *a = (struct overlapped_server_args*)arg;
1271     DWORD num;
1272     char buf[100];
1273
1274     pipe = CreateNamedPipeA("\\\\.\\pipe\\my pipe", FILE_FLAG_OVERLAPPED | PIPE_ACCESS_DUPLEX, PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE, 1, 0, 0, 100000, NULL);
1275     ok(pipe != NULL, "pipe NULL\n");
1276
1277     ol.hEvent = CreateEventA(0, 1, 0, 0);
1278     ok(ol.hEvent != NULL, "event NULL\n");
1279     ret = ConnectNamedPipe(pipe, &ol);
1280     err = GetLastError();
1281     ok(ret == 0, "ret %d\n", ret);
1282     ok(err == ERROR_IO_PENDING, "gle %d\n", err);
1283     SetEvent(a->pipe_created);
1284
1285     ret = WaitForSingleObjectEx(ol.hEvent, INFINITE, 1);
1286     ok(ret == WAIT_OBJECT_0, "ret %x\n", ret);
1287
1288     ret = GetOverlappedResult(pipe, &ol, &num, 1);
1289     ok(ret == 1, "ret %d\n", ret);
1290
1291     /* This should block */
1292     ret = ReadFile(pipe, buf, sizeof(buf), &num, NULL);
1293     ok(ret == 1, "ret %d\n", ret);
1294
1295     DisconnectNamedPipe(pipe);
1296     CloseHandle(ol.hEvent);
1297     CloseHandle(pipe);
1298     return 1;
1299 }
1300
1301 static void test_overlapped(void)
1302 {
1303     DWORD tid, num;
1304     HANDLE thread, pipe;
1305     int ret;
1306     struct overlapped_server_args args;
1307
1308     args.pipe_created = CreateEventA(0, 1, 0, 0);
1309     thread = CreateThread(NULL, 0, overlapped_server, &args, 0, &tid);
1310
1311     WaitForSingleObject(args.pipe_created, INFINITE);
1312     pipe = CreateFileA("\\\\.\\pipe\\my pipe", GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
1313     ok(pipe != INVALID_HANDLE_VALUE, "cf failed\n");
1314
1315     /* Sleep to try to get the ReadFile in the server to occur before the following WriteFile */
1316     Sleep(1);
1317
1318     ret = WriteFile(pipe, "x", 1, &num, NULL);
1319     ok(ret == 1, "ret %d\n", ret);
1320
1321     WaitForSingleObject(thread, INFINITE);
1322     CloseHandle(pipe);
1323     CloseHandle(args.pipe_created);
1324     CloseHandle(thread);
1325 }
1326
1327 START_TEST(pipe)
1328 {
1329     HMODULE hmod;
1330
1331     hmod = GetModuleHandle("advapi32.dll");
1332     pDuplicateTokenEx = (void *) GetProcAddress(hmod, "DuplicateTokenEx");
1333
1334     if (test_DisconnectNamedPipe())
1335         return;
1336     test_CreateNamedPipe_instances_must_match();
1337     test_NamedPipe_2();
1338     test_CreateNamedPipe(PIPE_TYPE_BYTE);
1339     test_CreateNamedPipe(PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE);
1340     test_CreatePipe();
1341     test_impersonation();
1342     test_overlapped();
1343 }