EAGAIN 在recv非阻塞socket中的含义

在recv函数中，EAGAIN通常表示非阻塞socket的接收缓冲区当前没有数据可读，需要等待一段时间后再次尝试读取。这种情况通常发生在非阻塞socket的接收缓冲区中没有接收到数据时，或者在使用select或poll等函数进行socket多路复用时，没有可读的socket。与EWOULDBLOCK不同的是，EAGAIN通常是在一些操作系统上的定义，而EWOULDBLOCK则是在其他一些操作系统上的定义，但它们通常具有相同的含义。在这种情况下，程序可以选择等待一段时间后再次尝试读取，或者使用其他技术手段来处理这种情况。

相关问题

recv非阻塞，用C语言写出程序

下面是一个简单的C语言程序，使用非阻塞模式进行recv操作：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <errno.h>

int main() {
    int sock;
    struct sockaddr_in server_addr;
    char buffer[1024];
    int bytes_received;
    int flags;

    // 创建socket
    sock = socket(AF_INET, SOCK_STREAM, 0);

    // 设置socket为非阻塞模式
    flags = fcntl(sock, F_GETFL, 0);
    fcntl(sock, F_SETFL, flags | O_NONBLOCK);

    // 连接服务器
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(8080);
    inet_pton(AF_INET, "127.0.0.1", &server_addr.sin_addr);
    connect(sock, (struct sockaddr *)&server_addr, sizeof(server_addr));

    // 循环读取数据
    while (1) {
        bytes_received = recv(sock, buffer, sizeof(buffer), 0);
        if (bytes_received == -1) {
            if (errno == EWOULDBLOCK || errno == EAGAIN) {
                // 没有数据可读，继续循环
                continue;
            } else {
                // 其他错误，退出循环
                perror("recv error");
                break;
            }
        } else if (bytes_received == 0) {
            // 连接关闭，退出循环
            printf("connection closed by peer\n");
            break;
        } else {
            // 成功读取数据，处理数据
            buffer[bytes_received] = '\0';
            printf("received: %s\n", buffer);
        }
    }

    // 关闭socket
    close(sock);

    return 0;
}

该程序使用了fcntl函数将socket设置为非阻塞模式，然后循环调用recv函数读取数据。如果recv返回EWOULDBLOCK或者EAGAIN错误码，说明当前没有数据可读，需要继续循环。如果recv返回其他错误码，或者返回0表示连接关闭，就退出循环。如果成功读取到数据，就处理数据并继续循环。

C语言socket客户端ipv6非阻塞模式收发

以下是一个简单的 C 语言 IPv6 Socket 客户端示例代码，使用非阻塞模式收发数据：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <netdb.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <errno.h>

#define PORT "8080" // 连接的端口号
#define MAXDATASIZE 100 // 接收缓冲区的大小

int main(int argc, char *argv[]) {
    int sockfd, numbytes, flags;
    struct addrinfo hints, *servinfo, *p;
    int rv;
    char s[INET6_ADDRSTRLEN];
    char message[100]; // 发送的消息
    char buf[MAXDATASIZE]; // 接收缓冲区
    fd_set readfds, writefds;
    struct timeval tv;
    int retval;

    // 如果没有指定服务器的 IP 地址
    if (argc != 2) {
        fprintf(stderr,"usage: client hostname\n");
        exit(1);
    }

    memset(&hints, 0, sizeof hints);
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;

    if ((rv = getaddrinfo(argv[1], PORT, &hints, &servinfo)) != 0) {
        fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
        return 1;
    }

    // 遍历所有结果，直到成功连接为止
    for (p = servinfo; p != NULL; p = p->ai_next) {
        if ((sockfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1) {
            perror("client: socket");
            continue;
        }

        if (connect(sockfd, p->ai_addr, p->ai_addrlen) == -1) {
            close(sockfd);
            perror("client: connect");
            continue;
        }

        break;
    }

    if (p == NULL) {
        fprintf(stderr, "client: failed to connect\n");
        return 2;
    }

    inet_ntop(p->ai_family, get_in_addr((struct sockaddr *)p->ai_addr), s, sizeof s);
    printf("client: connecting to %s\n", s);

    freeaddrinfo(servinfo); // 全部都用这个结构体

    // 设置套接字为非阻塞模式
    flags = fcntl(sockfd, F_GETFL, 0);
    fcntl(sockfd, F_SETFL, flags | O_NONBLOCK);

    // 发送消息
    printf("Enter a message to send: ");
    fgets(message, 100, stdin);

    // 开始循环等待读写事件
    while(1) {
        FD_ZERO(&readfds);
        FD_ZERO(&writefds);
        FD_SET(sockfd, &readfds);
        FD_SET(sockfd, &writefds);
        tv.tv_sec = 1; // 超时时间为 1 秒
        tv.tv_usec = 0;
        retval = select(sockfd+1, &readfds, &writefds, NULL, &tv);

        if (retval == -1) {
            perror("select");
            exit(1);
        } else if (retval == 0) {
            printf("Timeout occurred! No data after 1 seconds.\n");
            continue;
        } else {
            // 有读写事件发生
            if (FD_ISSET(sockfd, &writefds)) {
                int len = strlen(message);
                int bytes_sent = send(sockfd, message, len, 0);
                if (bytes_sent == -1) {
                    perror("send");
                    exit(1);
                }
                printf("Sent %d bytes.\n", bytes_sent);
            }

            if (FD_ISSET(sockfd, &readfds)) {
                numbytes = recv(sockfd, buf, MAXDATASIZE-1, 0);
                if (numbytes == -1) {
                    if (errno != EAGAIN && errno != EWOULDBLOCK) {
                        perror("recv");
                        exit(1);
                    }
                } else if (numbytes == 0) {
                    printf("Connection closed by server.\n");
                    break;
                } else {
                    buf[numbytes] = '\0';
                    printf("Received: %s\n", buf);
                }
            }
        }
    }

    close(sockfd);

    return 0;
}

需要注意的是，在使用非阻塞模式时，我们需要使用 `select` 函数来循环等待读写事件的发生。在上述代码中，我们设置超时时间为 1 秒，即如果在 1 秒内没有读写事件发生，就继续等待。

在 `select` 中，我们使用 `FD_SET` 函数将套接字加入到读写事件的集合中，并使用 `FD_ISSET` 函数来检查套接字是否就绪。如果套接字可写，我们就调用 `send` 函数发送消息；如果套接字可读，我们就调用 `recv` 函数接收数据。需要注意的是，`recv` 函数在非阻塞模式下可能会返回 -1，此时我们需要检查 `errno` 是否为 `EAGAIN` 或 `EWOULDBLOCK`，如果是，则说明当前没有数据可读，需要继续等待。如果 `recv` 函数返回 0，则说明服务器关闭了连接，此时需要退出循环。

希望这份代码能够对你有所帮助！