命名管道服务器，如何中断或超时等待客户端连接和传入数据

我正在为 Windows 编写一个简单的命名管道服务器，调用 Windows API（在 Java 中使用 JNA，但这不相关）。

我试图找出如何避免服务器永远卡住等待客户端连接或来自客户端的数据。

服务器代码执行以下操作：

1）它通过调用创建管道CreateNamedPipe https://msdn.microsoft.com/en-us/library/windows/desktop/aa365150%28v=vs.85%29.aspx, with PIPE_WAIT in the dwPipeMode争论。

2）它调用ConnectNamedPipe https://msdn.microsoft.com/en-us/library/windows/desktop/aa365146%28v=vs.85%29.aspx在客户端连接之前不会返回。

3) 它进入一个循环，通过调用重复从客户端读取消息ReadFile https://msdn.microsoft.com/en-us/library/windows/desktop/aa365467%28v=vs.85%29.aspx在读取数据之前不会返回，并且对于每条收到的消息，它都会通过调用将消息发送回客户端作为响应WriteFile.

4) 经过多次这样的对话，客户端和服务器将断开与管道的连接。

我只是希望能够在等待中设置超时ConnectNamedPipe在步骤 2 和ReadFile在第 3 步，我看不到在哪里设置超时。有的是nDefaultTimeOut论证中CreateNamedPipe功能，但听起来并不是真正的目的； API 文档说：

默认超时值，以毫秒为单位，如果WaitNamedPipe函数指定NMPWAIT_USE_DEFAULT_WAIT.

So the nDefaultTimeOut arg in CreateNamedPipe听起来像默认超时客户它将连接到管道将用于他们的操作，并且只有当他们调用WaitNamedPipe功能。事实上，在我的测试中，0 或 1000 的值没有什么区别，调用ConnectNamedPipe永远不会返回（除非客户端连接）。我正在寻找的是服务器中的超时，而不是调用ConnectNamedPipe and ReadFile.

作为文档CreateNamedPipe https://msdn.microsoft.com/en-us/library/windows/desktop/aa365150%28v=vs.85%29.aspx， 为了dwPipeMode与争论PIPE_WAIT says, Blocking mode is enabled. When the pipe handle is specified in the ReadFile, WriteFile, or ConnectNamedPipe function, the operations are not completed until there is data to read, all data is written, or a client is connected. Use of this mode can mean waiting indefinitely in some situations for a client process to perform an action.

因此，也许实现此类超时的方法是以非阻塞模式创建管道（使用PIPE_NOWAIT代替PIPE_WAIT）这样就可以调用ReadFile, WriteFile and ConnectNamedPipe立即返回，然后以某种方式监视自己循环中的事件（客户端连接或接收数据），并在循环中检查自己是否超时或发生另一个中断事件（例如用户单击“取消”按钮）？

ADDED: 看起来像ReadFile打电话我也许可以使用PeekNamedPipe它立即返回，检查是否有数据要读取，然后调用ReadFile。我会尝试一下。但我仍然遇到同样的问题ConnectNamedPipe.

ADDED：正如我怀疑的那样，答案也证实了这一点，作为管道的新手，我从某种倾斜的角度看待它们，从这个角度来看，对超时的需求似乎比实际情况更大。

F. 前。想要超时调用背后的原因ReadFile是，如果我（服务器）在其中从客户端读取数据并且客户端突然关闭，有时我可能最终会陷入困境ReadFile。但现在我知道如果ReadFile正在从管道读取并且客户端关闭，ReadFile will always错误输出，因此执行不会卡在其中。

一些实际代码演示了 GUI 应用程序中管道服务器端的异步使用：

void wait_for_object(HANDLE object)
{
  DWORD dw;
  MSG msg;

  for (;;) 
  {
    dw = MsgWaitForMultipleObjectsEx(1, &object, INFINITE, QS_ALLINPUT, 0);

    if (dw == WAIT_OBJECT_0) break;
    if (dw == WAIT_OBJECT_0 + 1) 
    {
      while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessage(&msg);
      continue;
    }
    srvfail(L"sleep() messageloop", GetLastError());
  }
}

HANDLE server_pipe;
HANDLE io_event;

void pipe_connection(void)
{
    OVERLAPPED overlapped;
    DWORD dw, err;

    SecureZeroMemory(&overlapped, sizeof(overlapped));
    overlapped.hEvent = io_event;

    if (!ReadFile(server_pipe, input_buffer, sizeof(input_buffer) - 1, NULL, &overlapped))
    {
        err = GetLastError();
        if (err == ERROR_IO_PENDING)
        {
            wait_for_object(io_event);
            if (!GetOverlappedResult(server_pipe, &overlapped, &dw, FALSE)) 
            {
                srvfail(L"Read from pipe failed asynchronously.", GetLastError());
            }
        }
        else
        {
            srvfail(L"Read from pipe failed synchronously.", GetLastError());
        }
    }
    else
    {
        if (!GetOverlappedResult(server_pipe, &overlapped, &dw, FALSE)) 
        {
            srvfail(L"GetOverlappedResult failed reading from pipe.", GetLastError());
        }
    }

    input_buffer[dw] = '\0';

    process_command();

    if (!WriteFile(server_pipe, &output_struct, 
        ((char *)&output_struct.output_string - (char *)&output_struct) + output_struct.string_length, 
        NULL, &overlapped))
    {
        err = GetLastError();
        if (err == ERROR_IO_PENDING)
        {
            wait_for_object(io_event);
            if (!GetOverlappedResult(server_pipe, &overlapped, &dw, FALSE)) 
            {
                srvfail(L"Write to pipe failed asynchronously.", GetLastError());
            }
        }
        else
        {
            srvfail(L"Write to pipe failed synchronously.", GetLastError());
        }
    }
    else
    {
        if (!GetOverlappedResult(server_pipe, &overlapped, &dw, FALSE)) 
        {
            srvfail(L"GetOverlappedResult failed writing to pipe.", GetLastError());
        }
    }

    if (!FlushFileBuffers(server_pipe)) srvfail(L"FlushFileBuffers failed.", GetLastError());
    if (!DisconnectNamedPipe(server_pipe)) srvfail(L"DisconnectNamedPipe failed.", GetLastError());
}

void server(void)
{
    OVERLAPPED overlapped;
    DWORD err, dw; 

    // Create the named pipe

    server_pipe = CreateNamedPipe(pipe_name, PIPE_ACCESS_DUPLEX | FILE_FLAG_FIRST_PIPE_INSTANCE | FILE_FLAG_OVERLAPPED, PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE, 1, buffer_size, buffer_size, 0, NULL);
    if (server_pipe == INVALID_HANDLE_VALUE) srvfail(L"CreateNamedPipe failed.", GetLastError());

    // Wait for connections

    io_event = CreateEvent(NULL, FALSE, FALSE, NULL);
    if (io_event == NULL) srvfail(L"CreateEvent(io_event) failed.", GetLastError());

    for (;;)
    {
        SecureZeroMemory(&overlapped, sizeof(overlapped));
        overlapped.hEvent = io_event;

        if (!ConnectNamedPipe(server_pipe, &overlapped))
        {
            err = GetLastError();
            if (err == ERROR_PIPE_CONNECTED)
            {
                pipe_connection();
            }
            else if (err == ERROR_IO_PENDING)
            {
                wait_for_object(io_event);
                if (!GetOverlappedResult(server_pipe, &overlapped, &dw, FALSE)) 
                {
                    srvfail(L"Pipe connection failed asynchronously.", GetLastError());
                }
                pipe_connection();
            }
            else
            {
                srvfail(L"Pipe connection failed synchronously.", GetLastError());
            }
        }
        else
        {
            if (!GetOverlappedResult(server_pipe, &overlapped, &dw, FALSE)) 
            {
                srvfail(L"GetOverlappedResult failed connecting pipe.", GetLastError());
            }
            pipe_connection();
        }
    }
}

（此代码已从原始代码中进行了编辑，以删除无关的逻辑。我还没有尝试编译编辑后的版本，因此可能存在一些小问题。另请注意全局变量的使用，这在我的情况下是可以的，因为应用程序很小，但是应该usually应避免。）

使用 MsgWaitForMultipleObjectsEx() 允许在等待 I/O 完成时处理窗口消息。如果您还在等待其他事情发生，则可以向其传递一个句柄数组，而不仅仅是一个句柄 - 例如，如果您想监视子进程并在其退出时执行某些操作，则可以传递一个包含以下内容的数组：两个都io_event和进程句柄。如果你只是had要定期执行其他工作，您可以设置等待超时，或使用窗口计时器。