dlls/ntdll/tests/pipe.c

   1 /* Unit test suite for Ntdll NamedPipe API functions
   2  *
   3  * Copyright 2011 Bernhard Loos
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include <stdio.h>
  21 #include <stdarg.h>
  22
  23 #include "ntstatus.h"
  24 #define WIN32_NO_STATUS
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "winuser.h"
  28 #include "winreg.h"
  29 #include "winnls.h"
  30 #include "wine/test.h"
  31 #include "winternl.h"
  32 #include "winioctl.h"
  33
  34 #ifndef __WINE_WINTERNL_H
  35
  36 typedef struct {
  37   ULONG NamedPipeType;
  38   ULONG NamedPipeConfiguration;
  39   ULONG MaximumInstances;
  40   ULONG CurrentInstances;
  41   ULONG InboundQuota;
  42   ULONG ReadDataAvailable;
  43   ULONG OutboundQuota;
  44   ULONG WriteQuotaAvailable;
  45   ULONG NamedPipeState;
  46   ULONG NamedPipeEnd;
  47 } FILE_PIPE_LOCAL_INFORMATION;
  48
  49 #ifndef FILE_SYNCHRONOUS_IO_ALERT
  50 #define FILE_SYNCHRONOUS_IO_ALERT 0x10
  51 #endif
  52
  53 #ifndef FILE_SYNCHRONOUS_IO_NONALERT
  54 #define FILE_SYNCHRONOUS_IO_NONALERT 0x20
  55 #endif
  56
  57 #ifndef FSCTL_PIPE_LISTEN
  58 #define FSCTL_PIPE_LISTEN CTL_CODE(FILE_DEVICE_NAMED_PIPE, 2, METHOD_BUFFERED, FILE_ANY_ACCESS)
  59 #endif
  60 #endif
  61
  62 static NTSTATUS (WINAPI *pNtFsControlFile) (HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc, PVOID apc_context, PIO_STATUS_BLOCK io, ULONG code, PVOID in_buffer, ULONG in_size, PVOID out_buffer, ULONG out_size);
  63 static NTSTATUS (WINAPI *pNtCreateNamedPipeFile) (PHANDLE handle, ULONG access,
  64                                         POBJECT_ATTRIBUTES attr, PIO_STATUS_BLOCK iosb,
  65                                         ULONG sharing, ULONG dispo, ULONG options,
  66                                         ULONG pipe_type, ULONG read_mode,
  67                                         ULONG completion_mode, ULONG max_inst,
  68                                         ULONG inbound_quota, ULONG outbound_quota,
  69                                         PLARGE_INTEGER timeout);
  70 static NTSTATUS (WINAPI *pNtQueryInformationFile) (IN HANDLE FileHandle, OUT PIO_STATUS_BLOCK IoStatusBlock, OUT PVOID FileInformation, IN ULONG Length, IN FILE_INFORMATION_CLASS FileInformationClass);
  71 static NTSTATUS (WINAPI *pNtCancelIoFile) (HANDLE hFile, PIO_STATUS_BLOCK io_status);
  72 static void (WINAPI *pRtlInitUnicodeString) (PUNICODE_STRING target, PCWSTR source);
  73
  74 static HANDLE (WINAPI *pOpenThread)(DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwThreadId);
  75 static DWORD (WINAPI *pQueueUserAPC)(PAPCFUNC pfnAPC, HANDLE hThread, ULONG_PTR dwData);
  76
  77
  78 static BOOL init_func_ptrs(void)
  79 {
  80     HMODULE module = GetModuleHandle("ntdll.dll");
  81
  82 #define loadfunc(name)  if (!(p##name = (void *)GetProcAddress(module, #name))) { \
  83                             trace("GetProcAddress(%s) failed\n", #name); \
  84                             return FALSE; \
  85                         }
  86
  87     loadfunc(NtFsControlFile)
  88     loadfunc(NtCreateNamedPipeFile)
  89     loadfunc(NtQueryInformationFile)
  90     loadfunc(NtCancelIoFile)
  91     loadfunc(RtlInitUnicodeString)
  92
  93     /* not fatal */
  94     module = GetModuleHandle("kernel32.dll");
  95     pOpenThread = (void *)GetProcAddress(module, "OpenThread");
  96     pQueueUserAPC = (void *)GetProcAddress(module, "QueueUserAPC");
  97     return TRUE;
  98 }
  99
 100 static const WCHAR testpipe[] = { '\\', '\\', '.', '\\', 'p', 'i', 'p', 'e', '\\',
 101                                   't', 'e', 's', 't', 'p', 'i', 'p', 'e', 0 };
 102 static const WCHAR testpipe_nt[] = { '\\', '?', '?', '\\', 'p', 'i', 'p', 'e', '\\',
 103                                      't', 'e', 's', 't', 'p', 'i', 'p', 'e', 0 };
 104
 105 static NTSTATUS create_pipe(PHANDLE handle, ULONG sharing, ULONG options)
 106 {
 107     IO_STATUS_BLOCK iosb;
 108     OBJECT_ATTRIBUTES attr;
 109     UNICODE_STRING name;
 110     LARGE_INTEGER timeout;
 111     NTSTATUS res;
 112
 113     pRtlInitUnicodeString(&name, testpipe_nt);
 114
 115     attr.Length                   = sizeof(attr);
 116     attr.RootDirectory            = 0;
 117     attr.ObjectName               = &name;
 118     attr.Attributes               = 0x40; /*case insensitive */
 119     attr.SecurityDescriptor       = NULL;
 120     attr.SecurityQualityOfService = NULL;
 121
 122     timeout.QuadPart = -100000000000ll;
 123
 124     res = pNtCreateNamedPipeFile(handle, FILE_READ_ATTRIBUTES | SYNCHRONIZE, &attr, &iosb, sharing,  2 /*FILE_CREATE*/,
 125                                  options, 1, 0, 0, 0xFFFFFFFF, 500, 500, &timeout);
 126     return res;
 127 }
 128
 129 static void test_create_invalid(void)
 130 {
 131     IO_STATUS_BLOCK iosb;
 132     OBJECT_ATTRIBUTES attr;
 133     UNICODE_STRING name;
 134     LARGE_INTEGER timeout;
 135     NTSTATUS res;
 136     HANDLE handle, handle2;
 137     FILE_PIPE_LOCAL_INFORMATION info;
 138
 139     pRtlInitUnicodeString(&name, testpipe_nt);
 140
 141     attr.Length                   = sizeof(attr);
 142     attr.RootDirectory            = 0;
 143     attr.ObjectName               = &name;
 144     attr.Attributes               = 0x40; /*case insensitive */
 145     attr.SecurityDescriptor       = NULL;
 146     attr.SecurityQualityOfService = NULL;
 147
 148     timeout.QuadPart = -100000000000ll;
 149
 150 /* create a pipe with sharing = 0 */
 151     res = pNtCreateNamedPipeFile(&handle, FILE_READ_ATTRIBUTES | SYNCHRONIZE, &attr, &iosb, 0, 2 /*FILE_CREATE*/,
 152                                  0, 1, 0, 0, 0xFFFFFFFF, 500, 500, &timeout);
 153     ok(res == STATUS_INVALID_PARAMETER, "NtCreateNamedPipeFile returned %x\n", res);
 154     if (!res)
 155         CloseHandle(handle);
 156
 157 /* create a pipe without r/w access */
 158     res = pNtCreateNamedPipeFile(&handle, SYNCHRONIZE, &attr, &iosb, FILE_SHARE_READ | FILE_SHARE_WRITE, 2 /*FILE_CREATE*/,
 159                                  0, 1, 0, 0, 0xFFFFFFFF, 500, 500, &timeout);
 160     ok(!res, "NtCreateNamedPipeFile returned %x\n", res);
 161
 162     res = pNtQueryInformationFile(handle, &iosb, &info, sizeof(info), (FILE_INFORMATION_CLASS)24);
 163     todo_wine ok(res == STATUS_ACCESS_DENIED, "NtQueryInformationFile returned %x\n", res);
 164
 165 /* test FILE_CREATE creation disposition */
 166     res = pNtCreateNamedPipeFile(&handle2, SYNCHRONIZE, &attr, &iosb, FILE_SHARE_READ | FILE_SHARE_WRITE, 2 /*FILE_CREATE*/,
 167                                  0, 1, 0, 0, 0xFFFFFFFF, 500, 500, &timeout);
 168     todo_wine ok(res == STATUS_ACCESS_DENIED, "NtCreateNamedPipeFile returned %x\n", res);
 169     if (!res)
 170         CloseHandle(handle2);
 171
 172     CloseHandle(handle);
 173 }
 174
 175 static BOOL ioapc_called;
 176 static void CALLBACK ioapc(void *arg, PIO_STATUS_BLOCK io, ULONG reserved)
 177 {
 178     ioapc_called = TRUE;
 179 }
 180
 181 static NTSTATUS listen_pipe(HANDLE hPipe, HANDLE hEvent, PIO_STATUS_BLOCK iosb, BOOL use_apc)
 182 {
 183     int dummy;
 184
 185     ioapc_called = FALSE;
 186
 187     return pNtFsControlFile(hPipe, hEvent, use_apc ? &ioapc: NULL, use_apc ? &dummy: NULL, iosb, FSCTL_PIPE_LISTEN, 0, 0, 0, 0);
 188 }
 189
 190 static void test_overlapped(void)
 191 {
 192     IO_STATUS_BLOCK iosb;
 193     HANDLE hEvent;
 194     HANDLE hPipe;
 195     HANDLE hClient;
 196     NTSTATUS res;
 197
 198     hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
 199     ok(hEvent != INVALID_HANDLE_VALUE, "can't create event, GetLastError: %x\n", GetLastError());
 200
 201     res = create_pipe(&hPipe, FILE_SHARE_READ | FILE_SHARE_WRITE, 0 /* OVERLAPPED */);
 202     ok(!res, "NtCreateNamedPipeFile returned %x\n", res);
 203
 204     memset(&iosb, 0x55, sizeof(iosb));
 205
 206 /* try with event and apc */
 207     res = listen_pipe(hPipe, hEvent, &iosb, TRUE);
 208     ok(res == STATUS_PENDING, "NtFsControlFile returned %x\n", res);
 209
 210     hClient = CreateFileW(testpipe, GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, 0);
 211     ok(hClient != INVALID_HANDLE_VALUE, "can't open pipe, GetLastError: %x\n", GetLastError());
 212
 213     ok(U(iosb).Status == 0, "Wrong iostatus %x\n", U(iosb).Status);
 214     ok(WaitForSingleObject(hEvent, 0) == 0, "hEvent not signaled\n");
 215
 216     ok(!ioapc_called, "IOAPC ran too early\n");
 217
 218     SleepEx(0, TRUE); /* alertable wait state */
 219
 220     ok(ioapc_called, "IOAPC didn't run\n");
 221
 222     CloseHandle(hEvent);
 223     CloseHandle(hPipe);
 224     CloseHandle(hClient);
 225 }
 226
 227 static BOOL userapc_called;
 228 static void CALLBACK userapc(ULONG_PTR dwParam)
 229 {
 230     userapc_called = TRUE;
 231 }
 232
 233 static BOOL open_succeeded;
 234 static DWORD WINAPI thread(PVOID main_thread)
 235 {
 236     HANDLE h;
 237
 238     Sleep(400);
 239
 240     if (main_thread) {
 241         DWORD ret;
 242         userapc_called = FALSE;
 243         ret = pQueueUserAPC(&userapc, main_thread, 0);
 244         ok(ret, "can't queue user apc, GetLastError: %x\n", GetLastError());
 245         CloseHandle(main_thread);
 246     }
 247
 248     Sleep(400);
 249
 250     h = CreateFileW(testpipe, GENERIC_WRITE | GENERIC_READ, 0, 0, OPEN_EXISTING, 0, 0);
 251
 252     if (h != INVALID_HANDLE_VALUE) {
 253         open_succeeded = TRUE;
 254         Sleep(100);
 255         CloseHandle(h);
 256     } else
 257         open_succeeded = FALSE;
 258
 259     return 0;
 260 }
 261
 262 static void test_alertable(void)
 263 {
 264     IO_STATUS_BLOCK iosb;
 265     HANDLE hEvent;
 266     HANDLE hPipe;
 267     NTSTATUS res;
 268     HANDLE hThread;
 269     DWORD ret;
 270
 271     memset(&iosb, 0x55, sizeof(iosb));
 272
 273     hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
 274     ok(hEvent != INVALID_HANDLE_VALUE, "can't create event, GetLastError: %x\n", GetLastError());
 275
 276     res = create_pipe(&hPipe, FILE_SHARE_READ | FILE_SHARE_WRITE, FILE_SYNCHRONOUS_IO_ALERT);
 277     ok(!res, "NtCreateNamedPipeFile returned %x\n", res);
 278
 279 /* queue an user apc before calling listen */
 280     userapc_called = FALSE;
 281     ret = pQueueUserAPC(&userapc, GetCurrentThread(), 0);
 282     ok(ret, "can't queue user apc, GetLastError: %x\n", GetLastError());
 283
 284     res = listen_pipe(hPipe, hEvent, &iosb, TRUE);
 285     todo_wine ok(res == STATUS_CANCELLED, "NtFsControlFile returned %x\n", res);
 286
 287     todo_wine ok(userapc_called, "user apc didn't run\n");
 288     ok(U(iosb).Status == 0x55555555, "iosb.Status got changed to %x\n", U(iosb).Status);
 289     todo_wine ok(WaitForSingleObjectEx(hEvent, 0, TRUE) == WAIT_TIMEOUT, "hEvent signaled\n");
 290     ok(!ioapc_called, "IOAPC ran\n");
 291
 292 /* queue an user apc from a different thread */
 293     hThread = CreateThread(NULL, 0, &thread, pOpenThread(MAXIMUM_ALLOWED, FALSE, GetCurrentThreadId()), 0, 0);
 294     ok(hThread != INVALID_HANDLE_VALUE, "can't create thread, GetLastError: %x\n", GetLastError());
 295
 296     /* wine_todo: the earlier NtFsControlFile call gets cancelled after the pipe gets set into listen state
 297                   instead of before, so this NtFsControlFile will fail STATUS_INVALID_HANDLE */
 298     res = listen_pipe(hPipe, hEvent, &iosb, TRUE);
 299     todo_wine ok(res == STATUS_CANCELLED, "NtFsControlFile returned %x\n", res);
 300
 301     ok(userapc_called, "user apc didn't run\n");
 302     todo_wine ok(U(iosb).Status == 0x55555555, "iosb.Status got changed to %x\n", U(iosb).Status);
 303     ok(WaitForSingleObjectEx(hEvent, 0, TRUE) == WAIT_TIMEOUT, "hEvent signaled\n");
 304     ok(!ioapc_called, "IOAPC ran\n");
 305
 306     WaitForSingleObject(hThread, INFINITE);
 307
 308     SleepEx(0, TRUE); /* get rid of the userapc, if NtFsControlFile failed */
 309
 310     ok(open_succeeded, "couldn't open client side pipe\n");
 311
 312     CloseHandle(hThread);
 313     DisconnectNamedPipe(hPipe);
 314
 315 /* finally try without an apc */
 316     hThread = CreateThread(NULL, 0, &thread, 0, 0, 0);
 317     ok(hThread != INVALID_HANDLE_VALUE, "can't create thread, GetLastError: %x\n", GetLastError());
 318
 319     res = listen_pipe(hPipe, hEvent, &iosb, TRUE);
 320     todo_wine ok(!res, "NtFsControlFile returned %x\n", res);
 321
 322     ok(open_succeeded, "couldn't open client side pipe\n");
 323     ok(!U(iosb).Status, "Wrong iostatus %x\n", U(iosb).Status);
 324     todo_wine ok(WaitForSingleObject(hEvent, 0) == 0, "hEvent not signaled\n");
 325
 326     WaitForSingleObject(hThread, INFINITE);
 327     CloseHandle(hThread);
 328     CloseHandle(hEvent);
 329     CloseHandle(hPipe);
 330 }
 331
 332 static void test_nonalertable(void)
 333 {
 334     IO_STATUS_BLOCK iosb;
 335     HANDLE hEvent;
 336     HANDLE hPipe;
 337     NTSTATUS res;
 338     HANDLE hThread;
 339     DWORD ret;
 340
 341     memset(&iosb, 0x55, sizeof(iosb));
 342
 343     hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
 344     ok(hEvent != INVALID_HANDLE_VALUE, "can't create event, GetLastError: %x\n", GetLastError());
 345
 346     res = create_pipe(&hPipe, FILE_SHARE_READ | FILE_SHARE_WRITE, FILE_SYNCHRONOUS_IO_NONALERT);
 347     ok(!res, "NtCreateNamedPipeFile returned %x\n", res);
 348
 349     hThread = CreateThread(NULL, 0, &thread, 0, 0, 0);
 350     ok(hThread != INVALID_HANDLE_VALUE, "can't create thread, GetLastError: %x\n", GetLastError());
 351
 352     userapc_called = FALSE;
 353     ret = pQueueUserAPC(&userapc, GetCurrentThread(), 0);
 354     ok(ret, "can't queue user apc, GetLastError: %x\n", GetLastError());
 355
 356     res = listen_pipe(hPipe, hEvent, &iosb, TRUE);
 357     todo_wine ok(!res, "NtFsControlFile returned %x\n", res);
 358
 359     ok(open_succeeded, "couldn't open client side pipe\n");
 360     todo_wine ok(!U(iosb).Status, "Wrong iostatus %x\n", U(iosb).Status);
 361     todo_wine ok(WaitForSingleObject(hEvent, 0) == 0, "hEvent not signaled\n");
 362
 363     ok(!ioapc_called, "IOAPC ran too early\n");
 364     ok(!userapc_called, "user apc ran too early\n");
 365
 366     SleepEx(0, TRUE); /* alertable wait state */
 367
 368     ok(ioapc_called, "IOAPC didn't run\n");
 369     ok(userapc_called, "user apc didn't run\n");
 370
 371     WaitForSingleObject(hThread, INFINITE);
 372     CloseHandle(hThread);
 373     CloseHandle(hEvent);
 374     CloseHandle(hPipe);
 375 }
 376
 377 static void test_cancelio(void)
 378 {
 379     IO_STATUS_BLOCK iosb;
 380     IO_STATUS_BLOCK cancel_sb;
 381     HANDLE hEvent;
 382     HANDLE hPipe;
 383     NTSTATUS res;
 384
 385     hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
 386     ok(hEvent != INVALID_HANDLE_VALUE, "can't create event, GetLastError: %x\n", GetLastError());
 387
 388     res = create_pipe(&hPipe, FILE_SHARE_READ | FILE_SHARE_WRITE, 0 /* OVERLAPPED */);
 389     ok(!res, "NtCreateNamedPipeFile returned %x\n", res);
 390
 391     memset(&iosb, 0x55, sizeof(iosb));
 392
 393     res = listen_pipe(hPipe, hEvent, &iosb, TRUE);
 394     ok(res == STATUS_PENDING, "NtFsControlFile returned %x\n", res);
 395
 396     res = pNtCancelIoFile(hPipe, &cancel_sb);
 397     todo_wine ok(!res, "NtCancelIoFile returned %x\n", res);
 398
 399     todo_wine {
 400         ok(U(iosb).Status == STATUS_CANCELLED, "Wrong iostatus %x\n", U(iosb).Status);
 401         ok(WaitForSingleObject(hEvent, 0) == 0, "hEvent not signaled\n");
 402     }
 403
 404     ok(!ioapc_called, "IOAPC ran too early\n");
 405
 406     SleepEx(0, TRUE); /* alertable wait state */
 407
 408     ok(ioapc_called, "IOAPC didn't run\n");
 409
 410     CloseHandle(hEvent);
 411     CloseHandle(hPipe);
 412 }
 413
 414 START_TEST(pipe)
 415 {
 416     if (!init_func_ptrs())
 417         return;
 418
 419     trace("starting invalid create tests\n");
 420     test_create_invalid();
 421
 422     trace("starting overlapped tests\n");
 423     test_overlapped();
 424
 425     if (!pOpenThread || !pQueueUserAPC)
 426         return;
 427
 428     trace("starting alertable tests\n");
 429     test_alertable();
 430
 431     trace("starting nonalertable tests\n");
 432     test_nonalertable();
 433
 434     trace("starting cancelio tests\n");
 435     test_cancelio();
 436 }