Question

我正在使用C

中的服务器/客户端应用程序

实际上我正在尝试允许服务器接受新客户端并在（几乎）同时接收数据。我发送数据两次，第一次发送登录信息并且有效。

我第二次发送一些字符串数据，就像客户端一次又一次地发送它们但我已经检查过它们只发送一次。

有人可以帮帮我吗？

我使用gcc -Wall -pedantic来编译它们。

这是客户端代码：需要一个参数，它可以是任何文本

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

#define PATH "soquette"
#define BACKLOG 2
#define TAILLE_BUFFER 256
#define TIME_SLEEP 10

int main(int argc,char ** argv){
    if(argc == 2){
        struct sockaddr_un addr;
        int serveur_socket;
        ssize_t taille_lue;
        char buffer[TAILLE_BUFFER];
        char * buffer2;
        if((serveur_socket = socket(PF_UNIX,SOCK_STREAM,0))<0){
            perror("socket \n");
            exit(EXIT_FAILURE);
        }
        memset(&addr,0,sizeof(struct sockaddr_un));
        addr.sun_family = AF_UNIX;
        strncpy(addr.sun_path,PATH,sizeof(addr.sun_path)-1);
        if(connect(serveur_socket,(struct sockaddr *)&addr,sizeof(struct sockaddr_un))<0){
            perror("connect \n");
            exit(EXIT_FAILURE);
        }
        printf("pseudo %s \n",argv[1]);
        if(write(serveur_socket,argv[1],strlen(argv[1])*sizeof(char))<0){
            perror("1 st write \n");
            exit(EXIT_FAILURE);
    }
        sleep(5);
        taille_lue = read(STDIN_FILENO,buffer,TAILLE_BUFFER);
        buffer2 = malloc(sizeof(int) + taille_lue * sizeof(char));
        sprintf(buffer2,"%ld",taille_lue);
        strcat(buffer2,buffer);
        if(write(serveur_socket,buffer2,sizeof(buffer2))<0){
            perror("write \n");
            exit(EXIT_FAILURE);
        }
        printf("message envoyé %s \n",buffer2);
        free(buffer2);
        exit(EXIT_SUCCESS);
    }
    else{
        printf("bad arguments number \n");
        exit(EXIT_SUCCESS);
    }
    exit(EXIT_SUCCESS);
}

这是服务器端。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/un.h>
#include <sys/socket.h>
#include <signal.h>
#include <fcntl.h>

#define PATH "soquette"
#define NB_MAX_CONNECTION 10
#define TAILLE_BUFFER 256
#define NB_BOUCLE 10
#define TIME_WAIT 10


int socket_server;

void signal_handler(){
    printf("signal handler \n");
    if(close(socket_server)==-1){
        perror("close \n");
    }
    if(unlink(PATH)==-1){
        perror("unlink \n");
    }
    exit(EXIT_SUCCESS);
}


int main(){
    int i,retval,j,fd_max,new_fd;
    ssize_t taille_recue;
    struct sockaddr_un addr;
    char buffer[TAILLE_BUFFER];
    struct timeval tv;
    fd_set rfds,active_fd_set;
    if(signal(SIGINT,signal_handler)==SIG_ERR){
        perror("signal \n");
    }
    tv.tv_sec=TIME_WAIT;
    tv.tv_usec=0;
    FD_ZERO(&rfds);
    FD_ZERO(&active_fd_set);

    printf("server launch \n");
    if((socket_server = socket(PF_UNIX,SOCK_STREAM,0))<0){
        perror("socket \n");
        exit(EXIT_FAILURE);
    }
    memset(&addr,0,sizeof(struct sockaddr_un));
    addr.sun_family = PF_UNIX;
    strncpy(addr.sun_path,PATH,sizeof(addr.sun_path)-1);
    if((bind(socket_server,(struct sockaddr *)&addr,sizeof(struct sockaddr_un))==-1)){
        perror("bind \n");
        exit(EXIT_FAILURE);
    }
    if(listen(socket_server,NB_MAX_CONNECTION)==-1){
        perror("listen \n");
        exit(EXIT_FAILURE);
    }
    FD_SET(socket_server,&active_fd_set);
    fd_max = socket_server;
    for(i=0;i<NB_BOUCLE;i++){
        FD_ZERO(&rfds);
        rfds = active_fd_set;
        printf("tour number  %d \n",i);
        if((retval = select(fd_max+1,&rfds,NULL,NULL,&tv))<0){
            perror("select \n");
        }
        for(j=0;j<=fd_max;j++){
            if(FD_ISSET(j,&rfds)){
                if(j == socket_server){
                    if((new_fd = accept(socket_server,NULL,NULL))<0){
                        perror("accept \n");
                        signal_handler();
                        exit(EXIT_FAILURE);
                    }
                    printf("new client \n");
                    FD_SET(new_fd,&active_fd_set);
                    if(read(new_fd,buffer,TAILLE_BUFFER)<0){
                        perror("read 1\n");
                    }
                    else{
                        printf("read from buffer %s \n",buffer);
                        fd_max = new_fd;
                    }
                }
                else{
                    printf("client already in the list \n");
                    if((taille_recue = read(j,buffer,sizeof(int)))<0){
                        if(taille_recue == 0){
                            close(j);
                            FD_CLR(j,&rfds);
                        }
                        else{
                            signal_handler();
                            perror("read server 2 \n");
                            exit(EXIT_FAILURE);
                        }
                    }
                    else{
                        printf("read from buffer %s \n",buffer);
                        FD_CLR(j,&rfds);
                    }
                }
            }
        }
    }
    printf("fermeture du serveur \n");
    close(socket_server);
    unlink(PATH);
    exit(EXIT_SUCCESS);
}

这是客户端输出

/client 1
pseudo 1 
salut
message envoyé 6salut
/0

这是服务器输出

MacBook-Pro-de-Kevin:tp10 kevin$ ./server 
server launch 
tour number  0 
new client 
read from buffer 1 
tour number  1 
client already in the list 
read from buffer 6sal 
tour number  2 
client already in the list 
read from buffer ut
/ 
tour number  3 
client already in the list 
read from buffer ut
/ 
tour number  4 
client already in the list 
read from buffer ut
/ 
tour number  5 
client already in the list 
read from buffer ut
/ 
tour number  6 
client already in the list 
read from buffer ut
/ 
tour number  7 
client already in the list 
read from buffer ut
/ 
tour number  8 
client already in the list 
read from buffer ut
/ 
tour number  9 
client already in the list 
read from buffer ut
/ 
fermeture du serveur

Answer 1

服务器无法正确处理连接的套接字

首先，当它接受新连接时，服务器会立即尝试从套接字读取数据。此时可能没有可用数据，因此读取可以阻止。虽然这并不能解释您提出的问题，但它与您的目标相冲突。
服务器假定任何新接受的连接的fd必须是集合中的最大fd。虽然它还没有影响你，但这种假设并不安全。文件描述符被释放，并在关闭时可供重用。
关闭连接时，服务器不会更新fd_max。但是，尽管这可能导致后续的select()调用严格地不符合该函数的规范，但它可能不会导致任何实际的错误行为。

服务器和客户端无法正确处理I / O

您似乎假设客户端的write()调用始终写入指定给它们的完整字节数，并且服务器的下一个read()将读取所有写入的字节。。这些假设一般都不安全，尽管你很有可能会遇到unix-domain套接字。通常，对于read()和write()，您必须考虑返回值，不仅要发现错误/文件结束，还要确保写入/读取所有预期的字节。您必须准备循环以传输所有需要的字节。
在基于select()的场景中，前一点中描述的循环需要通过select()循环，否则您可能会引入阻塞。因此，您可能需要对每个连接进行计算，以确定在任何给定时间您希望读/写的字节数。实际上，除非您的服务器不做任何事情，只是尽可能快地将字节从源到接收器洗牌，否则很可能需要维持一些每个连接状态。
奇怪的是，对于已建立的连接，您尝试在任何给定读取时只读取int中的字节数，实际上比可用的字节数更多，并且缓冲区可以容纳更多。就在这里：

if((taille_recue = read(j,buffer,sizeof(int)))<0){

现在仔细考虑上面引用的行：只有当read()返回负值时才执行if块。特别是，当read()返回0以指示文件结束时，该块不执行，但它位于该块中，而不是else块，您在那里测试文件结束条件。 这就是导致您询问的行为的原因。位于EOF的打开文件始终准备好阅读，但您错误处理来自read()的EOF信号，将其视为已读取数据，而不是将其识别出来。
此外，如果要通过printf()和%s字段描述符打印缓冲区内容，则必须确定要将空字符（'\0'）插入到有效数据后的缓冲区，或者使用最大字段宽度将输出限制为缓冲区中的有效字节数。

选择服务器多读取问题

1 个答案:

服务器无法正确处理连接的套接字

服务器和客户端无法正确处理I / O