互联网关闭时如何终止Windows套接字？ (C++ WinAPI)

Question

我已经建立了一个 Winsock2 连接，但我需要涵盖互联网中断的情况。这是我的代码；

#include <winsock2.h>
#include <windows.h>
#include <ctime>
int main()
{
    WSADATA w;
    if(WSAStartup(MAKEWORD(2,2),&w)) return 0;
    sockaddr_in sad;
    sad.sin_family=AF_INET;
    sad.sin_addr.s_addr=inet_addr("200.20.186.76");
    sad.sin_port=htons(123);
    sockaddr saddr;
    int saddr_l=sizeof(saddr);
    int s=socket(PF_INET,SOCK_DGRAM,IPPROTO_UDP);
    if(s==INVALID_SOCKET) return 0;
    char msg[48]={8};
    if(sendto(s,msg,sizeof(msg),0,(sockaddr*)&sad,sizeof(sad))==SOCKET_ERROR) return 0;
    if(recvfrom(s,msg,48,0,&saddr,&saddr_l)==SOCKET_ERROR) return 0;
    if(closesocket(s)==SOCKET_ERROR) return 0;
    if(WSACleanup()) return 0;
    return 0;
}

在这里它等待调用返回，因为它记录在案。我有两个问题。

1. 我可以像使用select 时那样设置超时吗
2. 我还能如何防止等待并使其立即返回？文档指出：

当发出诸如 sendto 之类的阻塞 Winsock 调用时，Winsock 可能需要等待网络事件才能完成调用。在这种情况下，Winsock 会执行警报等待，该等待可能会被安排在同一线程上的异步过程调用 (APC) 中断。

怎么做？

Answer 1

如果你想发出一个 recvfrom() 并让它立即返回，然后你自己决定等待多长时间（我假设是 Windows，因为你包含了 winsock2.h），你可以发出一个异步 OVERLAPPED 请求，然后通过等待 OVERLAPPED 结构的 hEvent 成员发出信号，随时等待完成。

这是基于您的原始代码的更新示例。

• 您可以使用 WaitForSingleObject 设置超时时间（下面我等待 10 秒 6 次）
• 通过传递一个 OVERLAPPED 指针，您表示您将自己等待完成。请注意，在发出 hEvent 信号之前，OVERLAPPED 结构不能超出范围。 （或释放，如果 OVERLAPPED 是动态分配的）。
• 在保证 IO 完成之前让 OVERLAPPED 超出范围是一个常见的 Winsock 错误（我已经在 Winsock 上工作了 10 多年 - 我已经看到了这个错误的许多变体）
• 如下所述，如果您不知道 hEvent 已发出信号，那么在调用 closesocket 之后，您必须等待 hEvent 发出信号后再继续 - closesocket 不保证所有异步 IO 请求都已完成在返回之前。

#define _WINSOCK_DEPRECATED_NO_WARNINGS
#include <winsock2.h>
#include <windows.h>
#include <ctime>
int main()
{
    WSADATA w;
    if (WSAStartup(MAKEWORD(2, 2), &w)) return 0;
    sockaddr_in sad;
    sad.sin_family = AF_INET;
    sad.sin_addr.s_addr = inet_addr("200.20.186.76");
    sad.sin_port = htons(123);
    sockaddr saddr;
    int saddr_l = sizeof(saddr);
    int s = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
    if (s == INVALID_SOCKET) return 0;
    char msg[48] = { 8 };
    if (sendto(s, msg, sizeof(msg), 0, (sockaddr*)&sad, sizeof(sad)) == SOCKET_ERROR) return 0;
    OVERLAPPED ov{};
    ov.hEvent = CreateEvent(nullptr, TRUE, FALSE, nullptr);
    if (ov.hEvent == nullptr) return 0;
    WSABUF wsabuffer{};
    wsabuffer.buf = msg;
    wsabuffer.len = 48;
    DWORD flags = 0;
    if (WSARecvFrom(s, &wsabuffer, 1, nullptr, &flags, &saddr, &saddr_l, &ov, nullptr) == SOCKET_ERROR)
    {
        DWORD gle = WSAGetLastError();
        if (gle != WSA_IO_PENDING) return 0;
    }
    for (DWORD recv_count = 0; recv_count < 6; ++recv_count)
    {
        DWORD wait = WaitForSingleObject(ov.hEvent, 10000);
        if (wait == WAIT_FAILED) return 0;
        if (wait == WAIT_OBJECT_0) break; // WSARecvFrom completed
        if (wait == WAIT_TIMEOUT) continue; // WSARecvFrom is still pended waiting for data
    }
    // assuming WSARecvFrom completed - i.e. ov.hEvent was signaled
    DWORD transferred;
    if (WSAGetOverlappedResult(s, &ov, &transferred, FALSE, &flags))
    {
        // WSARecvFrom completed successfully - 'transferred' shows the # of bytes that were received
    }
    else
    {
        DWORD gle = WSAGetLastError();
        gle;
        // WSARecvFrom failed with the error code in 'gle'
    }
    if (closesocket(s) == SOCKET_ERROR) return 0;
    // with real code, we must guarantee that hEvent is set after calling closesocket
    // e.g. if we get here in an error path
    // closesocket() won't guarantee all async IO has completed before returning
    WaitForSingleObject(ov.hEvent, INFINITE);
    if (WSACleanup()) return 0;
    return 0;
}