git.oblomov.eu Git - wine/blob - 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) != 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     todo_wine
 959     ok(!ret &&
 960        (error == ERROR_CANNOT_IMPERSONATE ||
 961         error == 0xdeadbeef), /* win2k3 */
 962        "ImpersonateNamedPipeClient should have failed with ERROR_CANNOT_IMPERSONATE instead of %d\n", GetLastError());
 963
 964     ret = ConnectNamedPipe(hPipeServer, NULL);
 965     ok(ret || (GetLastError() == ERROR_PIPE_CONNECTED), "ConnectNamedPipe failed with error %d\n", GetLastError());
 966
 967     ret = ReadFile(hPipeServer, buffer, sizeof(buffer), &dwBytesRead, NULL);
 968     ok(ret, "ReadFile failed with error %d\n", GetLastError());
 969
 970     ret = ImpersonateNamedPipeClient(hPipeServer);
 971     ok(ret, "ImpersonateNamedPipeClient failed with error %d\n", GetLastError());
 972
 973     ret = OpenThreadToken(GetCurrentThread(), TOKEN_QUERY, FALSE, &hToken);
 974     ok(ret, "OpenThreadToken failed with error %d\n", GetLastError());
 975
 976     (*test_func)(0, hToken);
 977
 978     ImpersonationLevel = 0xdeadbeef; /* to avoid false positives */
 979     ret = GetTokenInformation(hToken, TokenImpersonationLevel, &ImpersonationLevel, sizeof(ImpersonationLevel), &size);
 980     ok(ret, "GetTokenInformation(TokenImpersonationLevel) failed with error %d\n", GetLastError());
 981     ok(ImpersonationLevel == SecurityImpersonation, "ImpersonationLevel should have been SecurityImpersonation(%d) instead of %d\n", SecurityImpersonation, ImpersonationLevel);
 982
 983     CloseHandle(hToken);
 984
 985     RevertToSelf();
 986
 987     ret = WriteFile(hPipeServer, &dummy, sizeof(dummy), &dwBytesWritten, NULL);
 988     ok(ret, "WriteFile failed with error %d\n", GetLastError());
 989
 990     ret = ReadFile(hPipeServer, buffer, sizeof(buffer), &dwBytesRead, NULL);
 991     ok(ret, "ReadFile failed with error %d\n", GetLastError());
 992
 993     ret = ImpersonateNamedPipeClient(hPipeServer);
 994     ok(ret, "ImpersonateNamedPipeClient failed with error %d\n", GetLastError());
 995
 996     ret = OpenThreadToken(GetCurrentThread(), TOKEN_QUERY, FALSE, &hToken);
 997     ok(ret, "OpenThreadToken failed with error %d\n", GetLastError());
 998
 999     (*test_func)(1, hToken);
1000
1001     CloseHandle(hToken);
1002
1003     RevertToSelf();
1004
1005     ret = WriteFile(hPipeServer, &dummy, sizeof(dummy), &dwBytesWritten, NULL);
1006     ok(ret, "WriteFile failed with error %d\n", GetLastError());
1007
1008     WaitForSingleObject(hThread, INFINITE);
1009
1010     ret = ImpersonateNamedPipeClient(hPipeServer);
1011     ok(ret, "ImpersonateNamedPipeClient failed with error %d\n", GetLastError());
1012
1013     RevertToSelf();
1014
1015     CloseHandle(hThread);
1016     CloseHandle(hPipeServer);
1017 }
1018
1019 static BOOL are_all_privileges_disabled(HANDLE hToken)
1020 {
1021     BOOL ret;
1022     TOKEN_PRIVILEGES *Privileges = NULL;
1023     DWORD Size = 0;
1024     BOOL all_privs_disabled = TRUE;
1025     DWORD i;
1026
1027     ret = GetTokenInformation(hToken, TokenPrivileges, NULL, 0, &Size);
1028     if (!ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER)
1029     {
1030         Privileges = HeapAlloc(GetProcessHeap(), 0, Size);
1031         ret = GetTokenInformation(hToken, TokenPrivileges, Privileges, Size, &Size);
1032         if (!ret)
1033         {
1034             HeapFree(GetProcessHeap(), 0, Privileges);
1035             return FALSE;
1036         }
1037     }
1038     else
1039         return FALSE;
1040
1041     for (i = 0; i < Privileges->PrivilegeCount; i++)
1042     {
1043         if (Privileges->Privileges[i].Attributes & SE_PRIVILEGE_ENABLED)
1044         {
1045             all_privs_disabled = FALSE;
1046             break;
1047         }
1048     }
1049
1050     HeapFree(GetProcessHeap(), 0, Privileges);
1051
1052     return all_privs_disabled;
1053 }
1054
1055 static DWORD get_privilege_count(HANDLE hToken)
1056 {
1057     TOKEN_STATISTICS Statistics;
1058     DWORD Size = sizeof(Statistics);
1059     BOOL ret;
1060
1061     ret = GetTokenInformation(hToken, TokenStatistics, &Statistics, Size, &Size);
1062     ok(ret, "GetTokenInformation(TokenStatistics)\n");
1063     if (!ret) return -1;
1064
1065     return Statistics.PrivilegeCount;
1066 }
1067
1068 static void test_no_sqos_no_token(int call_index, HANDLE hToken)
1069 {
1070     DWORD priv_count;
1071
1072     switch (call_index)
1073     {
1074     case 0:
1075         priv_count = get_privilege_count(hToken);
1076         todo_wine
1077         ok(priv_count == 0, "privilege count should have been 0 instead of %d\n", priv_count);
1078         break;
1079     case 1:
1080         priv_count = get_privilege_count(hToken);
1081         ok(priv_count > 0, "privilege count should now be > 0 instead of 0\n");
1082         ok(!are_all_privileges_disabled(hToken), "impersonated token should not have been modified\n");
1083         break;
1084     default:
1085         ok(0, "shouldn't happen\n");
1086     }
1087 }
1088
1089 static void test_no_sqos(int call_index, HANDLE hToken)
1090 {
1091     switch (call_index)
1092     {
1093     case 0:
1094         ok(!are_all_privileges_disabled(hToken), "token should be a copy of the process one\n");
1095         break;
1096     case 1:
1097         todo_wine
1098         ok(are_all_privileges_disabled(hToken), "impersonated token should have been modified\n");
1099         break;
1100     default:
1101         ok(0, "shouldn't happen\n");
1102     }
1103 }
1104
1105 static void test_static_context(int call_index, HANDLE hToken)
1106 {
1107     switch (call_index)
1108     {
1109     case 0:
1110         ok(!are_all_privileges_disabled(hToken), "token should be a copy of the process one\n");
1111         break;
1112     case 1:
1113         ok(!are_all_privileges_disabled(hToken), "impersonated token should not have been modified\n");
1114         break;
1115     default:
1116         ok(0, "shouldn't happen\n");
1117     }
1118 }
1119
1120 static void test_dynamic_context(int call_index, HANDLE hToken)
1121 {
1122     switch (call_index)
1123     {
1124     case 0:
1125         ok(!are_all_privileges_disabled(hToken), "token should be a copy of the process one\n");
1126         break;
1127     case 1:
1128         todo_wine
1129         ok(are_all_privileges_disabled(hToken), "impersonated token should have been modified\n");
1130         break;
1131     default:
1132         ok(0, "shouldn't happen\n");
1133     }
1134 }
1135
1136 static void test_dynamic_context_no_token(int call_index, HANDLE hToken)
1137 {
1138     switch (call_index)
1139     {
1140     case 0:
1141         ok(are_all_privileges_disabled(hToken), "token should be a copy of the process one\n");
1142         break;
1143     case 1:
1144         ok(!are_all_privileges_disabled(hToken), "process token modification should have been detected and impersonation token updated\n");
1145         break;
1146     default:
1147         ok(0, "shouldn't happen\n");
1148     }
1149 }
1150
1151 static void test_no_sqos_revert(int call_index, HANDLE hToken)
1152 {
1153     DWORD priv_count;
1154     switch (call_index)
1155     {
1156     case 0:
1157         priv_count = get_privilege_count(hToken);
1158         todo_wine
1159         ok(priv_count == 0, "privilege count should have been 0 instead of %d\n", priv_count);
1160         break;
1161     case 1:
1162         priv_count = get_privilege_count(hToken);
1163         ok(priv_count > 0, "privilege count should now be > 0 instead of 0\n");
1164         ok(!are_all_privileges_disabled(hToken), "impersonated token should not have been modified\n");
1165         break;
1166     default:
1167         ok(0, "shouldn't happen\n");
1168     }
1169 }
1170
1171 static void test_static_context_revert(int call_index, HANDLE hToken)
1172 {
1173     switch (call_index)
1174     {
1175     case 0:
1176         todo_wine
1177         ok(are_all_privileges_disabled(hToken), "privileges should have been disabled\n");
1178         break;
1179     case 1:
1180         todo_wine
1181         ok(are_all_privileges_disabled(hToken), "impersonated token should not have been modified\n");
1182         break;
1183     default:
1184         ok(0, "shouldn't happen\n");
1185     }
1186 }
1187
1188 static void test_dynamic_context_revert(int call_index, HANDLE hToken)
1189 {
1190     switch (call_index)
1191     {
1192     case 0:
1193         todo_wine
1194         ok(are_all_privileges_disabled(hToken), "privileges should have been disabled\n");
1195         break;
1196     case 1:
1197         ok(!are_all_privileges_disabled(hToken), "impersonated token should now be process token\n");
1198         break;
1199     default:
1200         ok(0, "shouldn't happen\n");
1201     }
1202 }
1203
1204 static void test_impersonation(void)
1205 {
1206     HANDLE hClientToken;
1207     HANDLE hProcessToken;
1208     BOOL ret;
1209
1210     if( !pDuplicateTokenEx ) {
1211         skip("DuplicateTokenEx not found\n");
1212         return;
1213     }
1214
1215     ret = OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hProcessToken);
1216     if (!ret)
1217     {
1218         skip("couldn't open process token, skipping impersonation tests\n");
1219         return;
1220     }
1221
1222     if (!get_privilege_count(hProcessToken) || are_all_privileges_disabled(hProcessToken))
1223     {
1224         skip("token didn't have any privileges or they were all disabled. token not suitable for impersonation tests\n");
1225         CloseHandle(hProcessToken);
1226         return;
1227     }
1228     CloseHandle(hProcessToken);
1229
1230     test_ImpersonateNamedPipeClient(NULL, 0, FALSE, test_no_sqos_no_token);
1231     hClientToken = make_impersonation_token(TOKEN_IMPERSONATE | TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, SecurityImpersonation);
1232     test_ImpersonateNamedPipeClient(hClientToken, 0, FALSE, test_no_sqos);
1233     CloseHandle(hClientToken);
1234     hClientToken = make_impersonation_token(TOKEN_IMPERSONATE | TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, SecurityImpersonation);
1235     test_ImpersonateNamedPipeClient(hClientToken,
1236         SECURITY_SQOS_PRESENT | SECURITY_IMPERSONATION, FALSE,
1237         test_static_context);
1238     CloseHandle(hClientToken);
1239     hClientToken = make_impersonation_token(TOKEN_IMPERSONATE | TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, SecurityImpersonation);
1240     test_ImpersonateNamedPipeClient(hClientToken,
1241         SECURITY_SQOS_PRESENT | SECURITY_CONTEXT_TRACKING | SECURITY_IMPERSONATION,
1242         FALSE, test_dynamic_context);
1243     CloseHandle(hClientToken);
1244     test_ImpersonateNamedPipeClient(NULL,
1245         SECURITY_SQOS_PRESENT | SECURITY_CONTEXT_TRACKING | SECURITY_IMPERSONATION,
1246         FALSE, test_dynamic_context_no_token);
1247
1248     hClientToken = make_impersonation_token(TOKEN_IMPERSONATE | TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, SecurityImpersonation);
1249     test_ImpersonateNamedPipeClient(hClientToken, 0, TRUE, test_no_sqos_revert);
1250     CloseHandle(hClientToken);
1251     hClientToken = make_impersonation_token(TOKEN_IMPERSONATE | TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, SecurityImpersonation);
1252     test_ImpersonateNamedPipeClient(hClientToken,
1253         SECURITY_SQOS_PRESENT | SECURITY_IMPERSONATION, TRUE,
1254         test_static_context_revert);
1255     CloseHandle(hClientToken);
1256     hClientToken = make_impersonation_token(TOKEN_IMPERSONATE | TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, SecurityImpersonation);
1257     test_ImpersonateNamedPipeClient(hClientToken,
1258         SECURITY_SQOS_PRESENT | SECURITY_CONTEXT_TRACKING | SECURITY_IMPERSONATION,
1259         TRUE, test_dynamic_context_revert);
1260     CloseHandle(hClientToken);
1261 }
1262
1263 struct overlapped_server_args
1264 {
1265     HANDLE pipe_created;
1266 };
1267
1268 static DWORD CALLBACK overlapped_server(LPVOID arg)
1269 {
1270     OVERLAPPED ol;
1271     HANDLE pipe;
1272     int ret, err;
1273     struct overlapped_server_args *a = (struct overlapped_server_args*)arg;
1274     DWORD num;
1275     char buf[100];
1276
1277     pipe = CreateNamedPipeA("\\\\.\\pipe\\my pipe", FILE_FLAG_OVERLAPPED | PIPE_ACCESS_DUPLEX, PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE, 1, 0, 0, 100000, NULL);
1278     ok(pipe != NULL, "pipe NULL\n");
1279
1280     ol.hEvent = CreateEventA(0, 1, 0, 0);
1281     ok(ol.hEvent != NULL, "event NULL\n");
1282     ret = ConnectNamedPipe(pipe, &ol);
1283     err = GetLastError();
1284     ok(ret == 0, "ret %d\n", ret);
1285     ok(err == ERROR_IO_PENDING, "gle %d\n", err);
1286     SetEvent(a->pipe_created);
1287
1288     ret = WaitForSingleObjectEx(ol.hEvent, INFINITE, 1);
1289     ok(ret == WAIT_OBJECT_0, "ret %x\n", ret);
1290
1291     ret = GetOverlappedResult(pipe, &ol, &num, 1);
1292     ok(ret == 1, "ret %d\n", ret);
1293
1294     /* This should block */
1295     ret = ReadFile(pipe, buf, sizeof(buf), &num, NULL);
1296     ok(ret == 1, "ret %d\n", ret);
1297
1298     DisconnectNamedPipe(pipe);
1299     CloseHandle(ol.hEvent);
1300     CloseHandle(pipe);
1301     return 1;
1302 }
1303
1304 static void test_overlapped(void)
1305 {
1306     DWORD tid, num;
1307     HANDLE thread, pipe;
1308     int ret;
1309     struct overlapped_server_args args;
1310
1311     args.pipe_created = CreateEventA(0, 1, 0, 0);
1312     thread = CreateThread(NULL, 0, overlapped_server, &args, 0, &tid);
1313
1314     WaitForSingleObject(args.pipe_created, INFINITE);
1315     pipe = CreateFileA("\\\\.\\pipe\\my pipe", GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
1316     ok(pipe != INVALID_HANDLE_VALUE, "cf failed\n");
1317
1318     /* Sleep to try to get the ReadFile in the server to occur before the following WriteFile */
1319     Sleep(1);
1320
1321     ret = WriteFile(pipe, "x", 1, &num, NULL);
1322     ok(ret == 1, "ret %d\n", ret);
1323
1324     WaitForSingleObject(thread, INFINITE);
1325     CloseHandle(pipe);
1326     CloseHandle(args.pipe_created);
1327     CloseHandle(thread);
1328 }
1329
1330 START_TEST(pipe)
1331 {
1332     HMODULE hmod;
1333
1334     hmod = GetModuleHandle("advapi32.dll");
1335     pDuplicateTokenEx = (void *) GetProcAddress(hmod, "DuplicateTokenEx");
1336
1337     if (test_DisconnectNamedPipe())
1338         return;
1339     test_CreateNamedPipe_instances_must_match();
1340     test_NamedPipe_2();
1341     test_CreateNamedPipe(PIPE_TYPE_BYTE);
1342     test_CreateNamedPipe(PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE);
1343     test_CreatePipe();
1344     test_impersonation();
1345     test_overlapped();
1346 }