d2/dc6/NpfsReadWrite_8c_source.html

 /*
  * PROJECT:         ReactOS kernel-mode tests
  * LICENSE:         LGPLv2+ - See COPYING.LIB in the top level directory
  * PURPOSE:         Kernel-Mode Test Suite NPFS Read/Write test
  * PROGRAMMER:      Thomas Faber <thomas.faber@reactos.org>
  */

 #include <kmt_test.h>
 #include "npfs.h"

 typedef struct _READ_WRITE_TEST_CONTEXT
 {
     PCWSTR PipePath;
     BOOLEAN ServerSynchronous;
     BOOLEAN ClientSynchronous;
 } READ_WRITE_TEST_CONTEXT, *PREAD_WRITE_TEST_CONTEXT;

 #define MAX_INSTANCES   5
 #define IN_QUOTA        4096
 #define OUT_QUOTA       4096

 #define MakeServer(ServerHandle, PipePath, ServerSynchronous)           \
     NpCreatePipeEx(ServerHandle,                                        \
                    PipePath,                                            \
                    BYTE_STREAM,                                         \
                    QUEUE,                                               \
                    BYTE_STREAM,                                         \
                    FILE_SHARE_READ | FILE_SHARE_WRITE,                  \
                    MAX_INSTANCES,                                       \
                    IN_QUOTA,                                            \
                    OUT_QUOTA,                                           \
                    SYNCHRONIZE | GENERIC_READ | GENERIC_WRITE,          \
                    FILE_OPEN_IF,                                        \
                    (ServerSynchronous) ? FILE_SYNCHRONOUS_IO_NONALERT   \
                                        : 0,                             \
                    &DefaultTimeout)

 #define CheckServer(ServerHandle, State)                                \
     NpCheckServerPipe(ServerHandle,                                     \
                       BYTE_STREAM, QUEUE, BYTE_STREAM, DUPLEX,          \
                       MAX_INSTANCES, 1,                                 \
                       IN_QUOTA, 0,                                      \
                       OUT_QUOTA, OUT_QUOTA,                             \
                       State)

 #define CheckClient(ClientHandle, State)                                \
     NpCheckClientPipe(ClientHandle,                                     \
                       BYTE_STREAM, QUEUE, BYTE_STREAM, DUPLEX,          \
                       MAX_INSTANCES, 1,                                 \
                       IN_QUOTA, 0,                                      \
                       OUT_QUOTA, OUT_QUOTA,                             \
                       State)

 #define CheckServerQuota(ServerHandle, InQ, OutQ)                       \
     NpCheckServerPipe(ServerHandle,                                     \
                       BYTE_STREAM, QUEUE, BYTE_STREAM, DUPLEX,          \
                       MAX_INSTANCES, 1,                                 \
                       IN_QUOTA, InQ,                                    \
                       OUT_QUOTA, OUT_QUOTA - (OutQ),                    \
                       FILE_PIPE_CONNECTED_STATE)

 #define CheckClientQuota(ClientHandle, InQ, OutQ)                       \
     NpCheckClientPipe(ClientHandle,                                     \
                       BYTE_STREAM, QUEUE, BYTE_STREAM, DUPLEX,          \
                       MAX_INSTANCES, 1,                                 \
                       IN_QUOTA, InQ,                                    \
                       OUT_QUOTA, OUT_QUOTA - (OutQ),                    \
                       FILE_PIPE_CONNECTED_STATE)

 #define CheckPipeContext(Context, ExpectedStatus, ExpectedBytes) do             \
 {                                                                           \
     ok_bool_true(Okay, "CheckPipeContext");                                     \
     ok_eq_hex((Context)->ReadWrite.Status, ExpectedStatus);                 \
     ok_eq_ulongptr((Context)->ReadWrite.BytesTransferred, ExpectedBytes);   \
 } while (0)

 static
 VOID
 ConnectPipe(
     IN OUT PTHREAD_CONTEXT Context)
 {
     HANDLE ClientHandle;

     ClientHandle = NULL;
     Context->Connect.Status = NpOpenPipeEx(&ClientHandle,
                                            Context->Connect.PipePath,
                                            SYNCHRONIZE | GENERIC_READ | GENERIC_WRITE,
                                            FILE_SHARE_READ | FILE_SHARE_WRITE,
                                            FILE_OPEN,
                                            Context->Connect.ClientSynchronous ? FILE_SYNCHRONOUS_IO_NONALERT
                                                                               : 0);
     Context->Connect.ClientHandle = ClientHandle;
 }

 static
 VOID
 ListenPipe(
     IN OUT PTHREAD_CONTEXT Context)
 {
     Context->Listen.Status = NpListenPipe(Context->Listen.ServerHandle);
 }

 static
 VOID
 ReadPipe(
     IN OUT PTHREAD_CONTEXT Context)
 {
     Context->ReadWrite.Status = NpReadPipe(Context->ReadWrite.PipeHandle,
                                            Context->ReadWrite.Buffer,
                                            Context->ReadWrite.BufferSize,
                                            (PULONG_PTR)&Context->ReadWrite.BytesTransferred);
 }

 static
 VOID
 WritePipe(
     IN OUT PTHREAD_CONTEXT Context)
 {
     Context->ReadWrite.Status = NpWritePipe(Context->ReadWrite.PipeHandle,
                                             Context->ReadWrite.Buffer,
                                             Context->ReadWrite.BufferSize,
                                             (PULONG_PTR)&Context->ReadWrite.BytesTransferred);
 }

 static
 BOOLEAN
 CheckConnectPipe(
     IN PTHREAD_CONTEXT Context,
     IN PCWSTR PipePath,
     IN BOOLEAN ClientSynchronous,
     IN ULONG MilliSeconds)
 {
     Context->Work = ConnectPipe;
     Context->Connect.PipePath = PipePath;
     Context->Connect.ClientSynchronous = ClientSynchronous;
     return TriggerWork(Context, MilliSeconds);
 }

 static
 BOOLEAN
 CheckListenPipe(
     IN PTHREAD_CONTEXT Context,
     IN HANDLE ServerHandle,
     IN ULONG MilliSeconds)
 {
     Context->Work = ListenPipe;
     Context->Listen.ServerHandle = ServerHandle;
     return TriggerWork(Context, MilliSeconds);
 }

 static
 BOOLEAN
 CheckReadPipe(
     IN PTHREAD_CONTEXT Context,
     IN HANDLE PipeHandle,
     OUT PVOID Buffer,
     IN ULONG BufferSize,
     IN ULONG MilliSeconds)
 {
     Context->Work = ReadPipe;
     Context->ReadWrite.PipeHandle = PipeHandle;
     Context->ReadWrite.Buffer = Buffer;
     Context->ReadWrite.BufferSize = BufferSize;
     return TriggerWork(Context, MilliSeconds);
 }

 static
 BOOLEAN
 CheckWritePipe(
     IN PTHREAD_CONTEXT Context,
     IN HANDLE PipeHandle,
     IN const VOID *Buffer,
     IN ULONG BufferSize,
     IN ULONG MilliSeconds)
 {
     Context->Work = WritePipe;
     Context->ReadWrite.PipeHandle = PipeHandle;
     Context->ReadWrite.Buffer = (PVOID)Buffer;
     Context->ReadWrite.BufferSize = BufferSize;
     return TriggerWork(Context, MilliSeconds);
 }

 static KSTART_ROUTINE TestReadWrite;
 static
 VOID
 NTAPI
 TestReadWrite(
     IN PVOID Context)
 {
     PREAD_WRITE_TEST_CONTEXT TestContext = Context;
     PCWSTR PipePath = TestContext->PipePath;
     BOOLEAN ServerSynchronous = TestContext->ServerSynchronous;
     BOOLEAN ClientSynchronous = TestContext->ClientSynchronous;
     NTSTATUS Status;
     HANDLE ServerHandle;
     LARGE_INTEGER DefaultTimeout;
     THREAD_CONTEXT ConnectContext;
     THREAD_CONTEXT ListenContext;
     THREAD_CONTEXT ClientReadContext;
     THREAD_CONTEXT ClientWriteContext;
     THREAD_CONTEXT ServerReadContext;
     THREAD_CONTEXT ServerWriteContext;
     BOOLEAN Okay;
     HANDLE ClientHandle;
     UCHAR ReadBuffer[128];
     UCHAR WriteBuffer[128];

     StartWorkerThread(&ConnectContext);
     StartWorkerThread(&ListenContext);
     StartWorkerThread(&ClientReadContext);
     StartWorkerThread(&ClientWriteContext);
     StartWorkerThread(&ServerReadContext);
     StartWorkerThread(&ServerWriteContext);

     DefaultTimeout.QuadPart = -50 * 1000 * 10;

     /* Server should start out listening */
     Status = MakeServer(&ServerHandle, PipePath, ServerSynchronous);
     ok_eq_hex(Status, STATUS_SUCCESS);
     CheckServer(ServerHandle, FILE_PIPE_LISTENING_STATE);

     Okay = CheckWritePipe(&ServerWriteContext, ServerHandle, NULL, 0, 100);
     ok_bool_true(Okay, "CheckWritePipe returned");
     ok_eq_ulongptr(ServerWriteContext.ReadWrite.BytesTransferred, 0);
     ok_eq_hex(ServerWriteContext.ReadWrite.Status, STATUS_PIPE_LISTENING);

     Okay = CheckReadPipe(&ServerReadContext, ServerHandle, NULL, 0, 100);
     ok_bool_true(Okay, "CheckReadPipe returned");
     ok_eq_ulongptr(ServerReadContext.ReadWrite.BytesTransferred, 0);
     ok_eq_hex(ServerReadContext.ReadWrite.Status, STATUS_PIPE_LISTENING);

     /* Connect a client */
     Okay = CheckConnectPipe(&ConnectContext, PipePath, ClientSynchronous, 100);
     ok_bool_true(Okay, "CheckConnectPipe returned");
     ok_eq_hex(ConnectContext.Connect.Status, STATUS_SUCCESS);
     ClientHandle = ConnectContext.Connect.ClientHandle;
     CheckClient(ClientHandle, FILE_PIPE_CONNECTED_STATE);
     CheckServer(ServerHandle, FILE_PIPE_CONNECTED_STATE);

     WriteBuffer[0] = 'A';
     ReadBuffer[0] = 'X';
     Okay = CheckWritePipe(&ServerWriteContext, ServerHandle, WriteBuffer, 1, 100);
     CheckPipeContext(&ServerWriteContext, STATUS_SUCCESS, 1);
     CheckServerQuota(ServerHandle, 0, 1); CheckClientQuota(ClientHandle, 1, 0);
     Okay = CheckReadPipe(&ClientReadContext, ClientHandle, ReadBuffer, 1, 100);
     CheckPipeContext(&ClientReadContext, STATUS_SUCCESS, 1);
     ok_eq_uint(ReadBuffer[0], 'A');
     CheckServerQuota(ServerHandle, 0, 0); CheckClientQuota(ClientHandle, 0, 0);

     WriteBuffer[0] = 'B';
     ReadBuffer[0] = 'X';
     Okay = CheckReadPipe(&ClientReadContext, ClientHandle, ReadBuffer, 1, 100);
     ok_bool_false(Okay, "CheckReadPipe returned");
     CheckServerQuota(ServerHandle, 0, 1);
     Okay = CheckWritePipe(&ServerWriteContext, ServerHandle, WriteBuffer, 1, 100);
     CheckPipeContext(&ServerWriteContext, STATUS_SUCCESS, 1);
     Okay = WaitForWork(&ClientReadContext, 100);
     CheckPipeContext(&ClientReadContext, STATUS_SUCCESS, 1);
     ok_eq_uint(ReadBuffer[0], 'B');
     CheckServerQuota(ServerHandle, 0, 0); CheckClientQuota(ClientHandle, 0, 0);

     WriteBuffer[0] = 'C';
     ReadBuffer[0] = 'X';
     Okay = CheckWritePipe(&ClientWriteContext, ClientHandle, WriteBuffer, 1, 100);
     CheckPipeContext(&ClientWriteContext, STATUS_SUCCESS, 1);
     CheckClientQuota(ClientHandle, 0, 1); CheckServerQuota(ServerHandle, 1, 0);
     Okay = CheckReadPipe(&ServerReadContext, ServerHandle, ReadBuffer, 1, 100);
     CheckPipeContext(&ServerReadContext, STATUS_SUCCESS, 1);
     ok_eq_uint(ReadBuffer[0], 'C');
     CheckClientQuota(ClientHandle, 0, 0); CheckServerQuota(ServerHandle, 0, 0);

     WriteBuffer[0] = 'D';
     ReadBuffer[0] = 'X';
     Okay = CheckReadPipe(&ServerReadContext, ServerHandle, ReadBuffer, 1, 100);
     ok_bool_false(Okay, "CheckReadPipe returned");
     CheckClientQuota(ClientHandle, 0, 1);
     Okay = CheckWritePipe(&ClientWriteContext, ClientHandle, WriteBuffer, 1, 100);
     CheckPipeContext(&ClientWriteContext, STATUS_SUCCESS, 1);
     Okay = WaitForWork(&ServerReadContext, 100);
     CheckPipeContext(&ServerReadContext, STATUS_SUCCESS, 1);
     ok_eq_uint(ReadBuffer[0], 'D');
     CheckClientQuota(ClientHandle, 0, 0); CheckServerQuota(ServerHandle, 0, 0);

     Okay = CheckWritePipe(&ServerWriteContext, ServerHandle, (PVOID)1, 0, 100);
     CheckPipeContext(&ServerWriteContext, STATUS_SUCCESS, 0);
     CheckServerQuota(ServerHandle, 0, 0); CheckClientQuota(ClientHandle, 0, 0);

     Okay = CheckWritePipe(&ClientWriteContext, ClientHandle, (PVOID)1, 0, 100);
     CheckPipeContext(&ClientWriteContext, STATUS_SUCCESS, 0);
     CheckClientQuota(ClientHandle, 0, 0); CheckServerQuota(ServerHandle, 0, 0);

     WriteBuffer[0] = 'E';
     ReadBuffer[0] = 'X';
     Okay = CheckReadPipe(&ClientReadContext, ClientHandle, (PVOID)1, 0, 100);
     ok_bool_false(Okay, "CheckReadPipe returned");
     CheckServerQuota(ServerHandle, 0, 0);
     Okay = CheckWritePipe(&ServerWriteContext, ServerHandle, (PVOID)1, 0, 100);
     CheckPipeContext(&ServerWriteContext, STATUS_SUCCESS, 0);
     Okay = WaitForWork(&ClientReadContext, 100);
     ok_bool_false(Okay, "WaitForWork returned");
     CheckServerQuota(ServerHandle, 0, 0);
     Okay = CheckWritePipe(&ServerWriteContext, ServerHandle, WriteBuffer, 1, 100);
     CheckPipeContext(&ServerWriteContext, STATUS_SUCCESS, 1);
     Okay = WaitForWork(&ClientReadContext, 100);
     CheckPipeContext(&ClientReadContext, STATUS_SUCCESS, 0);
     ok_eq_uint(ReadBuffer[0], 'X');
     CheckServerQuota(ServerHandle, 0, 1); CheckClientQuota(ClientHandle, 1, 0);
     Okay = CheckReadPipe(&ClientReadContext, ClientHandle, ReadBuffer, 1, 100);
     CheckPipeContext(&ClientReadContext, STATUS_SUCCESS, 1);
     ok_eq_uint(ReadBuffer[0], 'E');
     CheckServerQuota(ServerHandle, 0, 0); CheckClientQuota(ClientHandle, 0, 0);

     WriteBuffer[0] = 'F';
     ReadBuffer[0] = 'X';
     Okay = CheckReadPipe(&ServerReadContext, ServerHandle, (PVOID)1, 0, 100);
     ok_bool_false(Okay, "CheckReadPipe returned");
     CheckClientQuota(ClientHandle, 0, 0);
     Okay = CheckWritePipe(&ClientWriteContext, ClientHandle, (PVOID)1, 0, 100);
     CheckPipeContext(&ClientWriteContext, STATUS_SUCCESS, 0);
     Okay = WaitForWork(&ServerReadContext, 100);
     ok_bool_false(Okay, "WaitForWork returned");
     CheckClientQuota(ClientHandle, 0, 0);
     Okay = CheckWritePipe(&ClientWriteContext, ClientHandle, WriteBuffer, 1, 100);
     CheckPipeContext(&ClientWriteContext, STATUS_SUCCESS, 1);
     Okay = WaitForWork(&ServerReadContext, 100);
     CheckPipeContext(&ServerReadContext, STATUS_SUCCESS, 0);
     ok_eq_uint(ReadBuffer[0], 'X');
     CheckClientQuota(ClientHandle, 0, 1); CheckServerQuota(ServerHandle, 1, 0);
     Okay = CheckReadPipe(&ServerReadContext, ServerHandle, ReadBuffer, 1, 100);
     CheckPipeContext(&ServerReadContext, STATUS_SUCCESS, 1);
     ok_eq_uint(ReadBuffer[0], 'F');
     CheckClientQuota(ClientHandle, 0, 0); CheckServerQuota(ServerHandle, 0, 0);

     WriteBuffer[0] = 'G';
     ReadBuffer[0] = 'X';
     Okay = CheckReadPipe(&ClientReadContext, ClientHandle, ReadBuffer, 1, 100);
     ok_bool_false(Okay, "CheckReadPipe returned");
     CheckServerQuota(ServerHandle, 0, 1);
     Status = NpDisconnectPipe(ServerHandle);
     ok_eq_hex(Status, STATUS_SUCCESS);
     Okay = WaitForWork(&ClientReadContext, 100);
     CheckPipeContext(&ClientReadContext, STATUS_PIPE_DISCONNECTED, 0);
     ok_eq_uint(ReadBuffer[0], 'X');

     /* Read from server when disconnected */
     Okay = CheckReadPipe(&ServerReadContext, ServerHandle, ReadBuffer, 1, 100);
     CheckPipeContext(&ServerReadContext, STATUS_PIPE_DISCONNECTED, 0);

     /* Write to server when disconnected */
     Okay = CheckWritePipe(&ServerWriteContext, ServerHandle, WriteBuffer, 1, 100);
     CheckPipeContext(&ServerWriteContext, STATUS_PIPE_DISCONNECTED, 0);

     /* Read from client when disconnected */
     Okay = CheckReadPipe(&ClientReadContext, ClientHandle, ReadBuffer, 1, 100);
     CheckPipeContext(&ClientReadContext, STATUS_PIPE_DISCONNECTED, 0);

     /* Write to client when disconnected */
     Okay = CheckWritePipe(&ClientWriteContext, ClientHandle, WriteBuffer, 1, 100);
     CheckPipeContext(&ClientWriteContext, STATUS_PIPE_DISCONNECTED, 0);
     Status = ObCloseHandle(ClientHandle, KernelMode);
     ok_eq_hex(Status, STATUS_SUCCESS);

     /* Restore the connection */
     Okay = CheckListenPipe(&ListenContext, ServerHandle, 100);
     ok_bool_false(Okay, "CheckListenPipe returned");
     Okay = CheckConnectPipe(&ConnectContext, PipePath, ClientSynchronous, 100);
     ok_bool_true(Okay, "CheckConnectPipe returned");
     ok_eq_hex(ConnectContext.Connect.Status, STATUS_SUCCESS);
     Okay = WaitForWork(&ListenContext, 100);
     ok_bool_true(Okay, "WaitForWork returned");
     ok_eq_hex(ListenContext.Listen.Status, STATUS_SUCCESS);
     ClientHandle = ConnectContext.Connect.ClientHandle;
     CheckClient(ClientHandle, FILE_PIPE_CONNECTED_STATE);
     CheckServer(ServerHandle, FILE_PIPE_CONNECTED_STATE);

     WriteBuffer[0] = 'H';
     ReadBuffer[0] = 'X';
     Okay = CheckReadPipe(&ClientReadContext, ClientHandle, ReadBuffer, 1, 100);
     ok_bool_false(Okay, "CheckReadPipe returned");
     Status = ObCloseHandle(ServerHandle, KernelMode);
     ok_eq_hex(Status, STATUS_SUCCESS);
     Okay = WaitForWork(&ClientReadContext, 100);
     CheckPipeContext(&ClientReadContext, STATUS_PIPE_BROKEN, 0);
     ok_eq_uint(ReadBuffer[0], 'X');

     /* Read from client when closed */
     Okay = CheckReadPipe(&ClientReadContext, ClientHandle, ReadBuffer, 1, 100);
     CheckPipeContext(&ClientReadContext, STATUS_PIPE_BROKEN, 0);

     /* Write to client when closed */
     Okay = CheckWritePipe(&ClientWriteContext, ClientHandle, WriteBuffer, 1, 100);
     CheckPipeContext(&ClientWriteContext, STATUS_PIPE_CLOSING, 0);
     Status = ObCloseHandle(ClientHandle, KernelMode);
     ok_eq_hex(Status, STATUS_SUCCESS);

     /* Restore the connection */
     Status = MakeServer(&ServerHandle, PipePath, ServerSynchronous);
     ok_eq_hex(Status, STATUS_SUCCESS);
     Okay = CheckConnectPipe(&ConnectContext, PipePath, ClientSynchronous, 100);
     ok_bool_true(Okay, "CheckConnectPipe returned");
     ok_eq_hex(ConnectContext.Connect.Status, STATUS_SUCCESS);
     ClientHandle = ConnectContext.Connect.ClientHandle;
     CheckClient(ClientHandle, FILE_PIPE_CONNECTED_STATE);
     CheckServer(ServerHandle, FILE_PIPE_CONNECTED_STATE);

     WriteBuffer[0] = 'I';
     ReadBuffer[0] = 'X';
     Okay = CheckReadPipe(&ServerReadContext, ServerHandle, ReadBuffer, 1, 100);
     ok_bool_false(Okay, "CheckReadPipe returned");
     Status = ObCloseHandle(ClientHandle, KernelMode);
     ok_eq_hex(Status, STATUS_SUCCESS);
     Okay = WaitForWork(&ServerReadContext, 100);
     CheckPipeContext(&ServerReadContext, STATUS_PIPE_BROKEN, 0);
     ok_eq_uint(ReadBuffer[0], 'X');

     /* Read from server when closed */
     Okay = CheckReadPipe(&ServerReadContext, ServerHandle, ReadBuffer, 1, 100);
     CheckPipeContext(&ServerReadContext, STATUS_PIPE_BROKEN, 0);

     /* Write to server when closed */
     Okay = CheckWritePipe(&ServerWriteContext, ServerHandle, WriteBuffer, 1, 100);
     CheckPipeContext(&ServerWriteContext, STATUS_PIPE_CLOSING, 0);
     Status = ObCloseHandle(ServerHandle, KernelMode);
     ok_eq_hex(Status, STATUS_SUCCESS);

     /* Restore the connection */
     Status = MakeServer(&ServerHandle, PipePath, ServerSynchronous);
     ok_eq_hex(Status, STATUS_SUCCESS);
     Okay = CheckConnectPipe(&ConnectContext, PipePath, ClientSynchronous, 100);
     ok_bool_true(Okay, "CheckConnectPipe returned");
     ok_eq_hex(ConnectContext.Connect.Status, STATUS_SUCCESS);
     ClientHandle = ConnectContext.Connect.ClientHandle;
     CheckClient(ClientHandle, FILE_PIPE_CONNECTED_STATE);
     CheckServer(ServerHandle, FILE_PIPE_CONNECTED_STATE);

     WriteBuffer[0] = 'J';
     ReadBuffer[0] = 'X';
     Okay = CheckWritePipe(&ServerWriteContext, ServerHandle, WriteBuffer, 1, 100);
     CheckPipeContext(&ServerWriteContext, STATUS_SUCCESS, 1);
     CheckServerQuota(ServerHandle, 0, 1); CheckClientQuota(ClientHandle, 1, 0);
     Status = NpDisconnectPipe(ServerHandle);
     ok_eq_hex(Status, STATUS_SUCCESS);
     NpQueryPipe(ClientHandle, STATUS_PIPE_DISCONNECTED);
     CheckServer(ServerHandle, FILE_PIPE_DISCONNECTED_STATE);
     Okay = CheckReadPipe(&ClientReadContext, ClientHandle, ReadBuffer, 1, 100);
     CheckPipeContext(&ClientReadContext, STATUS_PIPE_DISCONNECTED, 0);
     ok_eq_uint(ReadBuffer[0], 'X');
     Okay = CheckReadPipe(&ClientReadContext, ClientHandle, ReadBuffer, 1, 100);
     CheckPipeContext(&ClientReadContext, STATUS_PIPE_DISCONNECTED, 0);
     Status = ObCloseHandle(ClientHandle, KernelMode);
     ok_eq_hex(Status, STATUS_SUCCESS);

     /* Restore the connection */
     Okay = CheckListenPipe(&ListenContext, ServerHandle, 100);
     ok_bool_false(Okay, "CheckListenPipe returned");
     Okay = CheckConnectPipe(&ConnectContext, PipePath, ClientSynchronous, 100);
     ok_bool_true(Okay, "CheckConnectPipe returned");
     ok_eq_hex(ConnectContext.Connect.Status, STATUS_SUCCESS);
     Okay = WaitForWork(&ListenContext, 100);
     ok_bool_true(Okay, "WaitForWork returned");
     ok_eq_hex(ListenContext.Listen.Status, STATUS_SUCCESS);
     ClientHandle = ConnectContext.Connect.ClientHandle;
     CheckClient(ClientHandle, FILE_PIPE_CONNECTED_STATE);
     CheckServer(ServerHandle, FILE_PIPE_CONNECTED_STATE);

     WriteBuffer[0] = 'K';
     ReadBuffer[0] = 'X';
     Okay = CheckWritePipe(&ServerWriteContext, ServerHandle, WriteBuffer, 1, 100);
     CheckPipeContext(&ServerWriteContext, STATUS_SUCCESS, 1);
     CheckServerQuota(ServerHandle, 0, 1); CheckClientQuota(ClientHandle, 1, 0);
     Status = ObCloseHandle(ServerHandle, KernelMode);
     ok_eq_hex(Status, STATUS_SUCCESS);
     NpCheckClientPipe(ClientHandle,
                       BYTE_STREAM, QUEUE, BYTE_STREAM, DUPLEX,
                       MAX_INSTANCES, 1,
                       IN_QUOTA, 1,
                       OUT_QUOTA, OUT_QUOTA,
                       FILE_PIPE_CLOSING_STATE);
     Okay = CheckReadPipe(&ClientReadContext, ClientHandle, ReadBuffer, 1, 100);
     CheckPipeContext(&ClientReadContext, STATUS_SUCCESS, 1);
     ok_eq_uint(ReadBuffer[0], 'K');
     Okay = CheckReadPipe(&ClientReadContext, ClientHandle, ReadBuffer, 1, 100);
     CheckPipeContext(&ClientReadContext, STATUS_PIPE_BROKEN, 0);
     Status = ObCloseHandle(ClientHandle, KernelMode);
     ok_eq_hex(Status, STATUS_SUCCESS);

     /* Restore the connection */
     Status = MakeServer(&ServerHandle, PipePath, ServerSynchronous);
     ok_eq_hex(Status, STATUS_SUCCESS);
     Okay = CheckConnectPipe(&ConnectContext, PipePath, ClientSynchronous, 100);
     ok_bool_true(Okay, "CheckConnectPipe returned");
     ok_eq_hex(ConnectContext.Connect.Status, STATUS_SUCCESS);
     ClientHandle = ConnectContext.Connect.ClientHandle;
     CheckClient(ClientHandle, FILE_PIPE_CONNECTED_STATE);
     CheckServer(ServerHandle, FILE_PIPE_CONNECTED_STATE);


     WriteBuffer[0] = 'L';
     ReadBuffer[0] = 'X';
     Okay = CheckWritePipe(&ClientWriteContext, ClientHandle, WriteBuffer, 1, 100);
     CheckPipeContext(&ClientWriteContext, STATUS_SUCCESS, 1);
     CheckClientQuota(ClientHandle, 0, 1); CheckServerQuota(ServerHandle, 1, 0);
     Status = ObCloseHandle(ClientHandle, KernelMode);
     ok_eq_hex(Status, STATUS_SUCCESS);
     NpCheckServerPipe(ServerHandle,
                       BYTE_STREAM, QUEUE, BYTE_STREAM, DUPLEX,
                       MAX_INSTANCES, 1,
                       IN_QUOTA, 1,
                       OUT_QUOTA, OUT_QUOTA,
                       FILE_PIPE_CLOSING_STATE);
     Okay = CheckReadPipe(&ServerReadContext, ServerHandle, ReadBuffer, 1, 100);
     CheckPipeContext(&ServerReadContext, STATUS_SUCCESS, 1);
     ok_eq_uint(ReadBuffer[0], 'L');
     Okay = CheckReadPipe(&ServerReadContext, ServerHandle, ReadBuffer, 1, 100);
     CheckPipeContext(&ServerReadContext, STATUS_PIPE_BROKEN, 0);
     Status = ObCloseHandle(ServerHandle, KernelMode);
     ok_eq_hex(Status, STATUS_SUCCESS);

     /* Restore the connection */
     Status = MakeServer(&ServerHandle, PipePath, ServerSynchronous);
     ok_eq_hex(Status, STATUS_SUCCESS);
     Okay = CheckConnectPipe(&ConnectContext, PipePath, ClientSynchronous, 100);
     ok_bool_true(Okay, "CheckConnectPipe returned");
     ok_eq_hex(ConnectContext.Connect.Status, STATUS_SUCCESS);
     ClientHandle = ConnectContext.Connect.ClientHandle;
     CheckClient(ClientHandle, FILE_PIPE_CONNECTED_STATE);
     CheckServer(ServerHandle, FILE_PIPE_CONNECTED_STATE);

     WriteBuffer[0] = 'M';
     ReadBuffer[0] = 'X';
     Okay = CheckWritePipe(&ClientWriteContext, ClientHandle, WriteBuffer, 1, 100);
     CheckPipeContext(&ClientWriteContext, STATUS_SUCCESS, 1);
     CheckClientQuota(ClientHandle, 0, 1); CheckServerQuota(ServerHandle, 1, 0);
     Status = NpDisconnectPipe(ServerHandle);
     ok_eq_hex(Status, STATUS_SUCCESS);
     NpQueryPipe(ClientHandle, STATUS_PIPE_DISCONNECTED);
     CheckServer(ServerHandle, FILE_PIPE_DISCONNECTED_STATE);
     Okay = CheckReadPipe(&ServerReadContext, ServerHandle, ReadBuffer, 1, 100);
     CheckPipeContext(&ServerReadContext, STATUS_PIPE_DISCONNECTED, 0);
     ok_eq_uint(ReadBuffer[0], 'X');
     Okay = CheckReadPipe(&ServerReadContext, ServerHandle, ReadBuffer, 1, 100);
     CheckPipeContext(&ServerReadContext, STATUS_PIPE_DISCONNECTED, 0);
     Status = ObCloseHandle(ClientHandle, KernelMode);
     ok_eq_hex(Status, STATUS_SUCCESS);

     Status = ObCloseHandle(ServerHandle, KernelMode);
     ok_eq_hex(Status, STATUS_SUCCESS);

     FinishWorkerThread(&ServerWriteContext);
     FinishWorkerThread(&ServerReadContext);
     FinishWorkerThread(&ClientWriteContext);
     FinishWorkerThread(&ClientReadContext);
     FinishWorkerThread(&ListenContext);
     FinishWorkerThread(&ConnectContext);
 }

 START_TEST(NpfsReadWrite)
 {
     PKTHREAD Thread;
     READ_WRITE_TEST_CONTEXT TestContext;

     TestContext.PipePath = DEVICE_NAMED_PIPE L"\\KmtestNpfsReadWriteTestPipe";

     TestContext.ServerSynchronous = TRUE;
     TestContext.ClientSynchronous = TRUE;
     Thread = KmtStartThread(TestReadWrite, &TestContext);
     KmtFinishThread(Thread, NULL);

     TestContext.ServerSynchronous = FALSE;
     TestContext.ClientSynchronous = TRUE;
     Thread = KmtStartThread(TestReadWrite, &TestContext);
     KmtFinishThread(Thread, NULL);

     TestContext.ServerSynchronous = TRUE;
     TestContext.ClientSynchronous = FALSE;
     Thread = KmtStartThread(TestReadWrite, &TestContext);
     KmtFinishThread(Thread, NULL);

     TestContext.ServerSynchronous = FALSE;
     TestContext.ClientSynchronous = FALSE;
     Thread = KmtStartThread(TestReadWrite, &TestContext);
     KmtFinishThread(Thread, NULL);
 }
kmt_test.h

Context
Definition: compobj.c:4794

CheckWritePipe
static BOOLEAN CheckWritePipe(IN PTHREAD_CONTEXT Context, IN HANDLE PipeHandle, IN const VOID *Buffer, IN ULONG BufferSize, IN ULONG MilliSeconds)
Definition: NpfsReadWrite.c:169

PCWSTR
const uint16_t * PCWSTR
Definition: typedefs.h:55

IN
#define IN
Definition: typedefs.h:38

_KTHREAD
Definition: ketypes.h:1549

TRUE
#define TRUE
Definition: types.h:120

KmtStartThread
PKTHREAD KmtStartThread(IN PKSTART_ROUTINE StartRoutine, IN PVOID StartContext OPTIONAL)
Definition: kmt_test_kernel.h:136

STATUS_PIPE_DISCONNECTED
#define STATUS_PIPE_DISCONNECTED
Definition: ntstatus.h:398

CheckPipeContext
#define CheckPipeContext(Context, ExpectedStatus, ExpectedBytes)
Definition: NpfsReadWrite.c:70

CheckClient
#define CheckClient(ClientHandle, State)
Definition: NpfsReadWrite.c:46

CheckServer
#define CheckServer(ServerHandle, State)
Definition: NpfsReadWrite.c:38

TestReadWrite
static KSTART_ROUTINE TestReadWrite
Definition: NpfsReadWrite.c:183

_THREAD_CONTEXT::ReadWrite
struct _THREAD_CONTEXT::@1577::@1581 ReadWrite

TriggerWork
BOOLEAN TriggerWork(IN PTHREAD_CONTEXT Context, IN ULONG MilliSeconds)
Definition: NpfsHelpers.c:710

StartWorkerThread
VOID StartWorkerThread(OUT PTHREAD_CONTEXT Context)
Definition: NpfsHelpers.c:674

NTSTATUS
LONG NTSTATUS
Definition: precomp.h:26

ReadBuffer
#define ReadBuffer(BaseIoAddress, Buffer, Count)
Definition: atapi.h:339

ok_eq_ulongptr
#define ok_eq_ulongptr(value, expected)
Definition: kmt_test.h:249

IN_QUOTA
#define IN_QUOTA
Definition: NpfsReadWrite.c:19

DEVICE_NAMED_PIPE
#define DEVICE_NAMED_PIPE
Definition: npfs.h:11

OUT_QUOTA
#define OUT_QUOTA
Definition: NpfsReadWrite.c:20

FILE_PIPE_CONNECTED_STATE
#define FILE_PIPE_CONNECTED_STATE
Definition: winternl.h:792

FinishWorkerThread
VOID FinishWorkerThread(IN PTHREAD_CONTEXT Context)
Definition: NpfsHelpers.c:685

KernelMode
Definition: ketypes.h:11

FILE_SHARE_WRITE
#define FILE_SHARE_WRITE
Definition: nt_native.h:681

STATUS_PIPE_CLOSING
#define STATUS_PIPE_CLOSING
Definition: ntstatus.h:399

CheckServerQuota
#define CheckServerQuota(ServerHandle, InQ, OutQ)
Definition: NpfsReadWrite.c:54

FILE_SHARE_READ
#define FILE_SHARE_READ
Definition: compat.h:125

ok_bool_false
#define ok_bool_false(value, desc)
Definition: kmt_test.h:257

CheckReadPipe
static BOOLEAN CheckReadPipe(IN PTHREAD_CONTEXT Context, IN HANDLE PipeHandle, OUT PVOID Buffer, IN ULONG BufferSize, IN ULONG MilliSeconds)
Definition: NpfsReadWrite.c:153

ok_bool_true
#define ok_bool_true(value, desc)
Definition: kmt_test.h:256

NTAPI
NTSTATUS(* NTAPI)(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
Definition: IoEaTest.cpp:117

NpCheckServerPipe
#define NpCheckServerPipe(h, rm, cm, npt, npc, mi, ci, iq, rsa, oq, wqa, nps)
Definition: npfs.h:95

_READ_WRITE_TEST_CONTEXT::ClientSynchronous
BOOLEAN ClientSynchronous
Definition: NpfsReadWrite.c:15

FALSE
Definition: jmorecfg.h:365

_THREAD_CONTEXT
Definition: cdstruc.h:1369

GENERIC_WRITE
#define GENERIC_WRITE
Definition: nt_native.h:90

ReadPipe
static VOID ReadPipe(IN OUT PTHREAD_CONTEXT Context)
Definition: NpfsReadWrite.c:105

CheckListenPipe
static BOOLEAN CheckListenPipe(IN PTHREAD_CONTEXT Context, IN HANDLE ServerHandle, IN ULONG MilliSeconds)
Definition: NpfsReadWrite.c:141

BOOLEAN
unsigned char BOOLEAN
Definition: ProcessorBind.h:185

NpReadPipe
NTSTATUS NpReadPipe(IN HANDLE PipeHandle, OUT PVOID Buffer, IN ULONG BufferSize, OUT PULONG_PTR BytesRead)
Definition: NpfsHelpers.c:322

NULL
smooth NULL
Definition: ftsmooth.c:416

Buffer
Definition: bufpool.h:45

PVOID
void * PVOID
Definition: retypes.h:9

CheckConnectPipe
static BOOLEAN CheckConnectPipe(IN PTHREAD_CONTEXT Context, IN PCWSTR PipePath, IN BOOLEAN ClientSynchronous, IN ULONG MilliSeconds)
Definition: NpfsReadWrite.c:127

FILE_PIPE_LISTENING_STATE
#define FILE_PIPE_LISTENING_STATE
Definition: winternl.h:791

NpWritePipe
NTSTATUS NpWritePipe(IN HANDLE PipeHandle, IN const VOID *Buffer, IN ULONG BufferSize, OUT PULONG_PTR BytesWritten)
Definition: NpfsHelpers.c:374

STATUS_PIPE_LISTENING
#define STATUS_PIPE_LISTENING
Definition: ntstatus.h:401

BufferSize
#define BufferSize
Definition: classpnp.h:419

Thread
_In_opt_ PFILE_OBJECT _In_opt_ PETHREAD Thread
Definition: fltkernel.h:2653

DUPLEX
#define DUPLEX
Definition: npfs.h:21

NpDisconnectPipe
#define NpDisconnectPipe(ServerHandle)
Definition: npfs.h:74

STATUS_PIPE_BROKEN
#define STATUS_PIPE_BROKEN
Definition: ntstatus.h:553

CheckClientQuota
#define CheckClientQuota(ClientHandle, InQ, OutQ)
Definition: NpfsReadWrite.c:62

npfs.h

UCHAR
unsigned char UCHAR
Definition: xmlstorage.h:181

ObCloseHandle
NTSTATUS NTAPI ObCloseHandle(IN HANDLE Handle, IN KPROCESSOR_MODE AccessMode)
Definition: obhandle.c:3376

L
static const WCHAR L[]
Definition: oid.c:1250

_READ_WRITE_TEST_CONTEXT::PipePath
PCWSTR PipePath
Definition: NpfsReadWrite.c:13

START_TEST
START_TEST(NpfsReadWrite)
Definition: NpfsReadWrite.c:572

GENERIC_READ
#define GENERIC_READ
Definition: compat.h:124

BYTE_STREAM
#define BYTE_STREAM
Definition: npfs.h:13

SYNCHRONIZE
#define SYNCHRONIZE
Definition: nt_native.h:61

ListenPipe
static VOID ListenPipe(IN OUT PTHREAD_CONTEXT Context)
Definition: NpfsReadWrite.c:97

KmtFinishThread
VOID KmtFinishThread(IN PKTHREAD Thread OPTIONAL, IN PKEVENT Event OPTIONAL)
Definition: kmt_test_kernel.h:171

MakeServer
#define MakeServer(ServerHandle, PipePath, ServerSynchronous)
Definition: NpfsReadWrite.c:22

Status
Status
Definition: gdiplustypes.h:24

FILE_OPEN
#define FILE_OPEN
Definition: from_kernel.h:54

NpCheckClientPipe
#define NpCheckClientPipe(h, rm, cm, npt, npc, mi, ci, iq, rsa, oq, wqa, nps)
Definition: npfs.h:121

WaitForWork
BOOLEAN WaitForWork(IN PTHREAD_CONTEXT Context, IN ULONG MilliSeconds)
Definition: NpfsHelpers.c:692

FILE_PIPE_DISCONNECTED_STATE
#define FILE_PIPE_DISCONNECTED_STATE
Definition: winternl.h:790

NpQueryPipe
#define NpQueryPipe(h, es)
Definition: npfs.h:147

_READ_WRITE_TEST_CONTEXT
Definition: NpfsReadWrite.c:11

PipeHandle
static HANDLE PipeHandle
Definition: dhcpcsvc.c:21

PREAD_WRITE_TEST_CONTEXT
struct _READ_WRITE_TEST_CONTEXT * PREAD_WRITE_TEST_CONTEXT

_READ_WRITE_TEST_CONTEXT::ServerSynchronous
BOOLEAN ServerSynchronous
Definition: NpfsReadWrite.c:14

QUEUE
#define QUEUE
Definition: npfs.h:17

_LARGE_INTEGER
Definition: typedefs.h:100

WritePipe
static VOID WritePipe(IN OUT PTHREAD_CONTEXT Context)
Definition: NpfsReadWrite.c:116

FILE_SYNCHRONOUS_IO_NONALERT
#define FILE_SYNCHRONOUS_IO_NONALERT
Definition: from_kernel.h:31

FILE_PIPE_CLOSING_STATE
#define FILE_PIPE_CLOSING_STATE
Definition: winternl.h:793

OUT
#define OUT
Definition: typedefs.h:39

Context
struct tagContext Context
Definition: acpixf.h:1030

ULONG
unsigned int ULONG
Definition: retypes.h:1

_THREAD_CONTEXT::Listen
struct _THREAD_CONTEXT::@1577::@1580 Listen

PULONG_PTR
uint32_t * PULONG_PTR
Definition: typedefs.h:63

ok_eq_hex
#define ok_eq_hex(value, expected)
Definition: RtlDosApplyFileIsolationRedirection_Ustr.c:10

ok_eq_uint
#define ok_eq_uint(value, expected)
Definition: kmt_test.h:239

void
Definition: nsiface.idl:2306

ConnectPipe
static VOID ConnectPipe(IN OUT PTHREAD_CONTEXT Context)
Definition: NpfsReadWrite.c:79

Buffer
IN BOOLEAN OUT PSTR Buffer
Definition: progress.h:34

STATUS_SUCCESS
return STATUS_SUCCESS
Definition: btrfs.c:2938

_THREAD_CONTEXT::Connect
struct _THREAD_CONTEXT::@1577::@1579 Connect

WriteBuffer
#define WriteBuffer(BaseIoAddress, Buffer, Count)
Definition: atapi.h:344

_LARGE_INTEGER::QuadPart
LONGLONG QuadPart
Definition: typedefs.h:112

READ_WRITE_TEST_CONTEXT
struct _READ_WRITE_TEST_CONTEXT READ_WRITE_TEST_CONTEXT

NpOpenPipeEx
NTSTATUS NpOpenPipeEx(OUT PHANDLE ClientHandle, IN PCWSTR PipePath, IN ACCESS_MASK DesiredAccess, IN ULONG ShareAccess, IN ULONG Disposition, IN ULONG CreateOptions)
Definition: NpfsHelpers.c:130

NpListenPipe
#define NpListenPipe(ServerHandle)
Definition: npfs.h:73

MAX_INSTANCES
#define MAX_INSTANCES
Definition: NpfsReadWrite.c:18