Question

我正在使用代理和HTTP CONNECT请求设计HTTP隧道。大约90％的时间，当我尝试发送连接请求CONNECT 192.168.1.68:3001 HTTP/1.1\r\n\r\n时，发送失败，返回errno = 11, "Try Again"。

我正在使用非阻塞套接字，并且套接字已关闭，然后在连接尝试之间重新打开。我不认为发送缓冲区已满，因为我没有发送太多数据。我很困惑为什么它有时连接，有时不连接（并且它似乎不是一个模式，有时连续两次连接，有时连接之间有10次失败）。

我可能会遇到此错误的原因是什么？

编辑：

（代码）

if (connect(sock, pSockAddr, iSockAddrSize)) {
    ...
    char message[80];
    sprintf(message, "CONNECT 192.168.1.68:3001 HTTP/1.1\r\n\r\n");
    printf("*J* Message loaded.\n"); //*J*
    printf("*J* %s\n", message); //*J*
    if (send(sock, message, strlen(message) + 1, 0) < 0) printf("*J* Send Failed: %d\n", errno); 
    else printf("*J* Data Sent.\n");
    }
...
printf("\n*J* Close Socket (RESET HOST COMMAND)");
closesocket(sock);

（输出）

[SUCCESS]
*J* Starting connect...
*J* Message loaded.
*J* CONNECT 192.168.1.68:3001 HTTP/1.1


*J* Data Sent.
*J* rv = 1
*J* Ending connect...

[FAIL]
*J* Starting connect...
*J* Message loaded.
*J* CONNECT 192.168.1.68:3001 HTTP/1.1


*J* Send Failed: 11
*J* Ending connect...

Answer 1

您的代码中有几个错误：

connect()成功时返回0，错误时返回-1。对于任何非零值，if语句的计算结果为true。这意味着当CONNECT失败并出现错误时，您的代码正在发送connect()消息。但是，并非所有错误都是致命的。特别是，由于您使用的是非阻塞套接字，因此EINPROGRESS / WSAEWOULDBLOCK错误表示连接仍处于待处理状态，您需要使用select()或(e)poll()等待使套接字实际完成连接（或失败）。因此，只有在connect()异步连接并且恰好在您有机会呼叫send()之前完全连接到代理时，您的代码才会起作用。但这是你不应该依赖的行为。您需要正确处理错误。
send()的返回值指定实际接受的字节数，或者出错时为-1。可以接受比请求的字节少的字节（特别是在非阻塞套接字上）。并且您需要处理非致命错误，特别是(WSA)EWOULDBLOCK（和EAGAIN，可能还有EINTR，在非Windows平台上），这意味着套接字无法接受新的调用send()时的数据，请再次致电send()。您应该在循环中调用send()，直到发送完所有字节或发生致命错误。
即使您正确send()数据，在+ 1之后使用strlen()也是错误的。您在要发送的数据中包含空终止符，但这不是CONNECT协议的一部分。空终结符将被代理视为应用程序数据，并将按原样通过隧道转发到下一个服务器（如果隧道成功打开），从而断开与该服务器的通信。

说到这里，尝试更像下面的东西。您对closeocket()的使用表明您正在为Windows编程，因此这是特定于Windows的：

int ret, err;
...
ret = connect(sock, pSockAddr, iSockAddrSize);
if (ret == -1)
{
    err = WSAGetLastError();

    if (err == WSAEWOULDBLOCK)
    {
        fd_set wfd;
        FD_ZERO(&wfd);
        FD_SET(sock, &wfd);

        fd_set efd;
        FD_ZERO(&efd);
        FD_SET(sock, &efd);

        timeval timeout;
        timeout.tv_sec = ...;
        timeout.tv_usec = ...;

        ret = select(0, NULL, &wfd, &wfd, &timeout);

        if (ret == 0)
        {
            printf("*J* Connect Timeout\n"); 
            // handle timeout as needed ...
            return;
        }

        if ((ret > 0) && FD_ISSET(sock, &efd))
        {
            err = 0;
            getsockopt(sock, SOL_SOCKET, SO_ERROR, (char*)&err, sizeof(err));
            ret = -1;
        }
    }

    if (ret == -1)
    {
        printf("*J* Connect Failed: %d\n", err); 
        // handle fatal error as needed ...
        return;
    }
}

...

char message[80];
sprintf(message, "CONNECT 192.168.1.68:3001 HTTP/1.1\r\n\r\n");
printf("*J* Message loaded.\n"); //*J*
printf("*J* %s\n", message); //*J*

char *pmsg = message;
int len = strlen(message);

do
{
    ret = send(sock, pmsg, len, 0);
    if (ret == -1)
    {
        err = getLastSocketError();    

        if (err == WSAEWOULDBLOCK)
        {
            fd_set wfd;
            FD_ZERO(&wfd);
            FD_SET(sock, &wfd);

            timeval timeout;
            timeout.tv_sec = ...;
            timeout.tv_usec = ...;

            ret = select(0, NULL, &wfd, NULL, &timeout);

            if (ret > 0)
                continue;

            if (ret == 0)
            {
                printf("*J* Send Timeout\n"); 
                // handle timeout as needed ...
                return;
            }

            err = WSAGetLastError();
        }

        printf("*J* Send Failed: %d\n", err); 
        // handle fatal error as needed ...
        return;
    }
    else
    {
        pmsg += ret;
        len += ret;
    }
}
while (len > 0);

printf("*J* Data Sent\n");

...

printf("*J* Close Socket\n");
closesocket(sock);

如果您想要更多跨平台的东西，请尝试使用它（或使用跨平台套接字库）：

int getLastSocketError()
{
    #ifdef WINDOWS
    return WSAGetLastError();
    #else
    return errno;
    #endif
};

int ret, err;
...
ret = connect(sock, pSockAddr, iSockAddrSize);
if (ret == -1)
{
    err = getLastSocketError();    

    if (
        #ifdef WINDOWS
        err == WSAEWOULDBLOCK
        #else
        err == EINPROGRESS
        #endif
        )
    {
        #ifndef WINDOWS
        do {
        #endif

        fd_set wfd;
        FD_ZERO(&wfd);
        FD_SET(sock, &wfd);

        #ifdef WINDOWS
        fd_set efd;
        FD_ZERO(&efd);
        FD_SET(sock, &efd);
        #endif

        timeval timeout;
        timeout.tv_sec = ...;
        timeout.tv_usec = ...;

        #ifdef WINDOWS
        ret = select(0, NULL, &wfd, &wfd, &timeout);
        #else
        ret = select(sock+1, NULL, &wfd, NULL, &timeout);
        #endif

        if (ret == 0)
        {
            printf("*J* Connect Timeout\n"); 
            // handle timeout as needed ...
            return;
        }

        #ifdef WINDOWS
        if ((ret > 0) && FD_ISSET(sock, &efd))
        {
            err = 0;
            getsockopt(sock, SOL_SOCKET, SO_ERROR, (char*)&err, sizeof(err));
            ret = -1;
        }
        #endif

        #ifndef WINDOWS
        } while ((ret == -1) && (errno == EINTR));
        #endif
    }

    if (ret == -1)
    {
        printf("*J* Connect Failed: %d\n", err); 
        // handle fatal error as needed ...
        return;
    }
}

...

char message[80];
sprintf(message, "CONNECT 192.168.1.68:3001 HTTP/1.1\r\n\r\n");
printf("*J* Message loaded.\n"); //*J*
printf("*J* %s\n", message); //*J*

char *pmsg = message;
int len = strlen(message);

do
{
    ret = send(sock, pmsg, len, 0);
    if (ret == -1)
    {
        err = getLastSocketError();    

        if (
            #ifdef WINDOWS
            err == WSAEWOULDBLOCK
            #else
            (err == EWOULDBLOCK) || (err == EAGAIN)
            #endif
            )
        {
            fd_set wfd;
            FD_ZERO(&wfd);
            FD_SET(sock, &wfd);

            timeval timeout;
            timeout.tv_sec = ...;
            timeout.tv_usec = ...;

            ret = select(
                #ifdef WINDOWS
                0
                #else
                sock+1
                #endif
                , NULL, &wfd, NULL, &timeout);

            if (ret > 0)
                continue;

            if (ret == 0)
            {
                printf("*J* Send Timeout\n"); 
                // handle timeout as needed ...
                return;
            }

            err = getLastSocketError();
        }

        #ifndef WINDOWS
        if (err != EINTR)
        #endif
        {
            printf("*J* Send Failed: %d\n", err); 
            // handle fatal error as needed ...
            return;
        }
    }
    else
    {
        pmsg += ret;
        len += ret;
    }
}
while (len > 0);

printf("*J* Data Sent\n");

...

printf("*J* Close Socket\n");

#ifdef WINDOWS
closesocket(sock);
#else
close(sock);
#endif

Answer 2

if (connect(sock, pSockAddr, iSockAddrSize)) {
    ...
    if (send(sock, message, strlen(message) + 1, 0) < 0) printf("*J* Send Failed: %d\n", errno);

当if (connect(..返回非零值时，输入connect内的块。由于连接成功时返回0，错误时返回-1（永久或暂时），这意味着当connect尚未成功时输入该块。在这种情况下调用send在大多数情况下会失败，因为连接尚未完成，但在某些幸运的情况下，如果连接成功的话，可能会成功。

如果连接成功，打算可能进入该块。在这种情况下，正确的处理将是

if (0 == connect(sock, pSockAddr, iSockAddrSize)) {
     ...

当然，由于使用了非阻塞套接字，因此连接不太可能立即成功，因此需要正确处理非阻塞连接。

Linux socket send（）错误EAGAIN

2 个答案: