c - 当客户端发送超过 10 条消息时，IRC 服务器出现段错误

Question

当客户端发送超过10条消息时，服务器出现段错误，但服务器没有此问题。他可以发送不受数量限制的消息。

这可能是由我的 char *buffer malloc() 和 badly free() 引起的？？？我尝试使用不带 free() 的静态数组缓冲区，但这是最糟糕的。

客户端

#include "header.h"

void    app(SOCKET socket)
{
    char pseudo[24];
    int statu;
    fd_set readfs;

    strcpy(pseudo, "[");
    strcat(pseudo, getname(sizeof(pseudo)));
    strcat(pseudo, "] ");

    while (1)
    {
        char *buffer = malloc(sizeof(char) * 1024);
        char *msg = malloc(sizeof(char) * 1000);

        FD_ZERO(&readfs);
        FD_SET(socket, &readfs);
        FD_SET(STDIN_FILENO, &readfs);

        if (select(socket + 1, &readfs, NULL, NULL, NULL) == -1)
        {
            perror("select()");
            exit(errno);
        }
        if (FD_ISSET(STDIN_FILENO, &readfs))
        {
            fgets(msg, sizeof(char) * 1000, stdin);
            strcpy(buffer, pseudo);
            strcat(buffer, msg);
            send_message(socket, buffer);
            cleanMsg(buffer, msg);
        }
        else if (FD_ISSET(socket, &readfs))
        {
            statu = receive_message(socket, buffer);
            if (statu == 0)
            {
                printf("Server disconnected !\n");
                break;
            }
            else
            {
                printf("%s\n", buffer);
                cleanMsg(buffer, msg);
            }
        }
    }
    close_connection(socket);
}

void    send_message(SOCKET socket, char *buffer)
{   
    int i;

    for (i = 0; buffer[i] != '\n'; i++) ;
    buffer[i] = '\0';

    if (send(socket, buffer, strlen(buffer), 0) < 0)
    {
        perror("send()");
        exit(errno);
    }
}

int receive_message(SOCKET socket, char *buffer)
{
    int statu = 0;
    if ((statu = recv(socket, buffer, 1024, 0)) < 0)
        perror("recv()");
    return statu;
}

void    cleanMsg(char *buffer, char *msg)
{
    memset(buffer, 0, strlen(buffer));
    memset(msg, 0, strlen(msg));
    free(buffer);
    free(msg);
}

char    *getname(size_t namesize)
{
    char *tmp = NULL;

    tmp = malloc(namesize);
    getlogin_r(tmp, namesize);

    return tmp;
}

服务器:

#include "header.h"

int app(SOCKET master_socket, serv_config *s_conf)
{
    SOCKADDR_IN client_address = {0};
    SOCKET new_socket;
    int address_size = sizeof(client_address);
    int *clients_socket = NULL;
    int statu = 0;
    int fdmax;
    int sd;
    int i;

    clients_socket = malloc(sizeof(int) * s_conf->max_client);

    fd_set readfs;

    for (i = 0; i < s_conf->max_client; i++)
        clients_socket[i] = 0;

    while (1)
    {

        char *buffer = malloc(sizeof(char) * 1024);
        char *msg = malloc(sizeof(char) * 1000);

        FD_ZERO(&readfs);
        FD_SET(STDIN_FILENO, &readfs);
        FD_SET(master_socket, &readfs);

        fdmax = master_socket;

        for (i = 0; i < s_conf->max_client; i++)
        {
            sd = clients_socket[i];
            if (sd > 0)
                FD_SET(sd, &readfs);
            if (sd > fdmax)
                fdmax = sd;
        }

        if (select(fdmax + 1, &readfs, NULL, NULL, NULL) == -1)
        {
            perror("select()");
            exit(errno);
        }

        if (FD_ISSET(STDIN_FILENO, &readfs))
        {
            fgets(msg, sizeof(char) * 1000, stdin);
            strcpy(buffer, "[Server] ");
            strcat(buffer, msg);
            send_toall(clients_socket, 0, s_conf->max_client, buffer);
            cleanMsg(buffer, msg);
        }
        else if (FD_ISSET(master_socket, &readfs))
        {
            new_socket = accept(master_socket, (SOCKADDR *)&client_address, &address_size);

            if (new_socket == INVALID_SOCKET)
            {
                perror("accept()");
                closesocket(new_socket);
                exit(errno);
            }

            for (i = 0; i < s_conf->max_client; i++)
            {
                if (clients_socket[s_conf->max_client - 1] != 0)
                {
                    strcpy(buffer, "Connection error: no more client can be connected.\n");
                    send_message(new_socket, buffer);
                    cleanMsg(buffer, msg);
                    shutdown(new_socket, 2);
                    closesocket(new_socket);
                    break;
                }
                else if (clients_socket[i] == 0)
                {
                    clients_socket[i] = new_socket;
                    printf("New client connected with socket %d from %s:%d, in slot %d\n", clients_socket[i], inet_ntoa(client_address.sin_addr), ntohs(client_address.sin_port), i);
                    strcpy(buffer, "Success connecting.\n");
                    send_message(clients_socket[i], buffer);
                    cleanMsg(buffer, msg);
                    break;
                }
            }
        }
        else
        {
            for (i = 0; i < s_conf->max_client; i++)
            {
                if (FD_ISSET(clients_socket[i], &readfs))
                {
                    statu = receive_message(clients_socket[i], buffer);
                    if (statu == 0)
                    {
                        printf("Socket %d Disconnect\n", clients_socket[i]);
                        shutdown(clients_socket[i], 2);
                        closesocket(clients_socket[i]);
                        clients_socket[i] = 0;
                        break;
                    }
                    else
                    {
                        send_toall(clients_socket, clients_socket[i], s_conf->max_client, buffer);
                        cleanMsg(buffer, msg);
                        break;
                    }
                }
            }
        }
    }
    return *clients_socket;
}

void    send_toall(int *clients_socket, int actual_socket, int max, char *buffer)
{
    int i;

    for (i = 0; clients_socket[i] < max; i++)
    {
        if (clients_socket[i] != actual_socket && clients_socket[i] != 0)
            send_message(clients_socket[i], buffer);
    }
}

void    send_message(SOCKET socket, char *buffer)
{
    int i;

    for (i = 0; buffer[i] != '\n'; i++) ;
    buffer[i] = '\0';

    if (send(socket, buffer, strlen(buffer), 0) < 0)
    {
        perror("send()");
        exit(errno);
    }
}

int receive_message(SOCKET socket, char *buffer)
{
    int statu = 0;
    if ((statu = recv(socket, buffer, 1024, 0)) < 0)
        perror("recv()");
    return statu;
}

void cleanMsg(char *buffer, char *msg)
{
    memset(buffer, 0, strlen(buffer));
    memset(msg, 0, strlen(msg));
    free(buffer);
    free(msg);
}

客户端发送超过 10 条消息后，服务器出现段错误并退出。

Answer 1

您发送和接收消息的方式存在严重问题。

首先，您完全忽略了 TCP 连接是没有消息边界概念的流这一事实。如果您对 send() 进行两次调用，每次发送 10 个字节，则对等方可能会以多个字节的任意组合来调用 recv() 1 到 20 个字节的任何内容recv() 调用，直到接收到整个 20 个字节。 您必须弄清楚如何将它们分成两个原始消息。

其次，您不知道实际接收了多少字节，但您将接收到的数据视为以 NUL 结尾的字符串。 recv() 不会以 NUL 结尾数据，因此您必须自己执行此操作 - 在确定消息边界所在位置之后。