c语言socket断开连接

以下是C语言中socket断连接的方法：
1. 使用close()函数关闭socket连接。

close(socket_fd);

2. 使用shutdown()关闭socket连接。

shutdown(socket_fd, SHUT_RDWR);

需要注意的是，这种方法都会立即关闭socket连接，如果还有数据需要发送或接收，可能会导致数据丢失因此，在关闭socket连接之前，需要确保所有数据都已经发送或接收完。

关于引用中提到的问题，程序被阻塞的原因可能是因为在调用recv()函数时，没有正确处理errno == EINTR的情况，导致程序一直等待数据而被阻塞。正确的处理方法是在errno == EINTR的情况下，重新调用recv()函数。

相关问题

socket多连接的C语言通信例子

好的，以下是一个基本的多连接的 C 语言 socket 通信例子：

服务端代码：

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

#define MAX_CLIENTS 10

int main(int argc, char *argv[]) {
    int server_socket, client_socket[MAX_CLIENTS];
    struct sockaddr_in server_addr, client_addr;
    char buffer[1024];
    int i;

    // 创建服务器 socket
    server_socket = socket(AF_INET, SOCK_STREAM, 0);
    if (server_socket < 0) {
        perror("socket");
        exit(EXIT_FAILURE);
    }

    // 设置服务器地址和端口号
    bzero(&server_addr, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_port = htons(8888);

    // 绑定服务器地址和端口号
    if (bind(server_socket, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
        perror("bind");
        exit(EXIT_FAILURE);
    }

    // 开始监听
    if (listen(server_socket, MAX_CLIENTS) < 0) {
        perror("listen");
        exit(EXIT_FAILURE);
    }

    printf("等待客户端连接...\n");

    // 处理客户端连接请求
    while (1) {
        // 接收客户端连接请求
        socklen_t client_len = sizeof(client_addr);
        client_socket[i] = accept(server_socket, (struct sockaddr *)&client_addr, &client_len);
        if (client_socket[i] < 0) {
            perror("accept");
            exit(EXIT_FAILURE);
        }

        printf("客户端 %s:%d 已连接！\n", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));

        // 接收客户端发送的消息并回复
        while (1) {
            // 清空缓冲区
            memset(buffer, 0, sizeof(buffer));

            // 接收客户端发送的消息
            ssize_t n = recv(client_socket[i], buffer, sizeof(buffer), 0);
            if (n < 0) {
                perror("recv");
                exit(EXIT_FAILURE);
            } else if (n == 0) {
                // 客户端已断开连接
                printf("客户端 %s:%d 已断开连接！\n", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
                close(client_socket[i]);
                break;
            } else {
                // 打印接收到的消息
                printf("接收到客户端 %s:%d 的消息：%s\n", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port), buffer);

                // 发送回复给客户端
                if (send(client_socket[i], "Hello, client!", strlen("Hello, client!"), 0) < 0) {
                    perror("send");
                    exit(EXIT_FAILURE);
                }
            }
        }

        i++;
    }

    return 0;
}

客户端代码：

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

int main(int argc, char *argv[]) {
    int client_socket;
    struct sockaddr_in server_addr;
    char buffer[1024];

    // 创建客户端 socket
    client_socket = socket(AF_INET, SOCK_STREAM, 0);
    if (client_socket < 0) {
        perror("socket");
        exit(EXIT_FAILURE);
    }

    // 设置服务器地址和端口号
    bzero(&server_addr, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
    server_addr.sin_port = htons(8888);

    // 连接服务器
    if (connect(client_socket, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
        perror("connect");
        exit(EXIT_FAILURE);
    }

    printf("连接服务器成功！\n");

    // 发送消息给服务器
    if (send(client_socket, "Hello, server!", strlen("Hello, server!"), 0) < 0) {
        perror("send");
        exit(EXIT_FAILURE);
    }

    // 接收服务器回复的消息
    ssize_t n = recv(client_socket, buffer, sizeof(buffer), 0);
    if (n < 0) {
        perror("recv");
        exit(EXIT_FAILURE);
    } else if (n == 0) {
        printf("服务器已断开连接！\n");
        close(client_socket);
        exit(EXIT_FAILURE);
    } else {
        printf("接收到服务器的回复：%s\n", buffer);
    }

    // 关闭连接
    close(client_socket);

    return 0;
}

这个例子中，服务端创建一个服务器 socket，然后绑定本地地址和端口号，开始监听客户端连接请求。当客户端连接服务器后，服务端接收客户端发送的消息并发送回复，直到客户端断开连接。同时，服务端可以处理多个客户端连接。客户端连接服务器后，发送一条消息给服务器，然后接收服务器回复的消息，最后关闭连接。

windowssocket聊天室c语言

Windows Socket 是 Windows 操作系统提供的一个 API，可以用来在网络上进行数据传输。下面是一个基于 Windows Socket 的聊天室程序的实现，使用 C 语言编写。

服务器端：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <winsock2.h>

#define PORT 8888
#define MAX_CLIENTS 30
#define BUFFER_SIZE 1024

int main()
{
    WSADATA wsaData;
    SOCKET master_socket , new_socket , client_socket[MAX_CLIENTS];
    struct sockaddr_in server , address;
    int i, activity, addrlen, valread, sd;
    char buffer[BUFFER_SIZE];
    fd_set readfds;

    // 初始化 Winsock
    if (WSAStartup(MAKEWORD(2,2), &wsaData) != 0)
    {
        printf("Failed. Error Code : %d",WSAGetLastError());
        return 1;
    }

    // 创建主套接字
    if((master_socket = socket(AF_INET , SOCK_STREAM , 0 )) == INVALID_SOCKET)
    {
        printf("Could not create socket : %d" , WSAGetLastError());
        return 1;
    }

    // 设定服务器地址和端口号
    server.sin_family = AF_INET;
    server.sin_addr.s_addr = INADDR_ANY;
    server.sin_port = htons( PORT );

    // 绑定主套接字
    if( bind(master_socket, (struct sockaddr *)&server , sizeof(server)) == SOCKET_ERROR)
    {
        printf("Bind failed with error code : %d" , WSAGetLastError());
        return 1;
    }

    // 监听主套接字
    if (listen(master_socket, 3) < 0)
    {
        printf("Listen failed with error code : %d" , WSAGetLastError());
        return 1;
    }

    printf("Server started on port %d\n", PORT);

    // 接受客户端连接
    addrlen = sizeof(address);
    while(TRUE)
    {
        FD_ZERO(&readfds);
        FD_SET(master_socket, &readfds);

        for (i = 0 ; i < MAX_CLIENTS ; i++)
        {
            sd = client_socket[i];
            if(sd > 0)
                FD_SET( sd , &readfds);
        }

        // 等待任意一个套接字上有数据到达
        activity = select( 0 , &readfds , NULL , NULL , NULL);

        if ((activity < 0) && (errno!=EINTR))
        {
            printf("select error");
        }

        // 如果主套接字有数据到达，说明有新客户端连接
        if (FD_ISSET(master_socket, &readfds))
        {
            if ((new_socket = accept(master_socket, (struct sockaddr *)&address, (int*)&addrlen))<0)
            {
                perror("accept");
                exit(EXIT_FAILURE);
            }

            printf("New connection from %s:%d\n", inet_ntoa(address.sin_addr), ntohs(address.sin_port));

            // 把新套接字加入客户端套接字数组
            for (i = 0; i < MAX_CLIENTS; i++)
            {
                if (client_socket[i] == 0)
                {
                    client_socket[i] = new_socket;
                    break;
                }
            }
        }

        // 遍历客户端套接字数组，看哪些套接字上有数据到达
        for (i = 0; i < MAX_CLIENTS; i++)
        {
            sd = client_socket[i];

            if (FD_ISSET( sd , &readfds))
            {
                // 读取客户端发来的消息
                if ((valread = recv( sd , buffer, BUFFER_SIZE, 0)) == 0)
                {
                    // 客户端断开连接
                    printf("Client disconnected\n");

                    // 关闭套接字并清除客户端套接字数组
                    closesocket( sd );
                    client_socket[i] = 0;
                }
                else
                {
                    // 把消息发给其他客户端
                    buffer[valread] = '\0';
                    for (i = 0; i < MAX_CLIENTS; i++)
                    {
                        if (client_socket[i] != 0 && client_socket[i] != sd)
                            send(client_socket[i], buffer, strlen(buffer), 0 );
                    }
                }
            }
        }
    }

    closesocket(master_socket);
    WSACleanup();

    return 0;
}

客户端：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <winsock2.h>
#pragma comment(lib,"ws2_32.lib")

#define SERVER_ADDRESS "127.0.0.1"
#define PORT 8888
#define BUFFER_SIZE 1024

int main()
{
    WSADATA wsaData;
    SOCKET s;
    struct sockaddr_in server;
    char message[BUFFER_SIZE] , server_reply[BUFFER_SIZE];
    int recv_size;

    // 初始化 Winsock
    if (WSAStartup(MAKEWORD(2,2),&wsaData) != 0)
    {
        printf("Failed. Error Code : %d",WSAGetLastError());
        return 1;
    }

    // 创建套接字
    if ((s = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
    {
        printf("Could not create socket : %d" , WSAGetLastError());
        return 1;
    }

    // 设定服务器地址和端口号
    server.sin_addr.s_addr = inet_addr(SERVER_ADDRESS);
    server.sin_family = AF_INET;
    server.sin_port = htons(PORT);

    // 连接服务器
    if (connect(s, (struct sockaddr *)&server, sizeof(server)) < 0)
    {
        puts("connect error");
        return 1;
    }

    puts("Connected to server");

    // 发送消息给服务器
    while (TRUE)
    {
        printf("Message: ");
        fgets(message, BUFFER_SIZE, stdin);

        if (send(s, message, strlen(message), 0) < 0)
        {
            puts("Send failed");
            return 1;
        }

        // 接收服务器发来的消息
        recv_size = recv(s, server_reply, BUFFER_SIZE, 0);
        if (recv_size > 0)
            printf("Server reply: %.*s", recv_size, server_reply);
        else
        {
            puts("recv failed");
            break;
        }
    }

    closesocket(s);
    WSACleanup();

    return 0;
}

运行方式：

1. 编译服务器端程序 `server.c` 和客户端程序 `client.c`，命令为 `gcc server.c -o server` 和 `gcc client.c -o client`。
2. 启动服务器端程序 `server`。
3. 在另一个命令行窗口中启动客户端程序 `client`，可以发送消息给服务器，并接收其他客户端发来的消息。