c++ - 为什么这个缓冲区大小没有被套接字正确处理？

Question

当我将 BUF_SIZE 设置为 10000 时可以正常工作，但 50000 则不行。我只是试图将数据从客户端发送到服务器并测试缓冲区大小，但我发现对于某些大小，应用程序无法正常工作。

为什么？我该如何解决？？

例如，我运行服务器和客户端，第一次尝试工作正常，但当我重新运行客户端时，开始出现交付问题。

这是服务器:

#include <sys/types.h>
#include <sys/wait.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <signal.h>

#define BUF_SIZE 50000

using namespace std;

void manejador(int signo);

int main()
{
    int     sservice, sclient,l,nbytes_read, err, nbytes_sent;
    bool    end;
    char    buf[BUF_SIZE];
    struct sockaddr_in sin, clientfsin;
    pid_t pid;
    int status;

    sservice=socket(PF_INET,SOCK_STREAM, 0); /*Open the socket*/
    if(sservice == -1)
    {
        perror("Server. Socket: ");
        exit(-1);
    }

    sin.sin_family      = AF_INET;  /*ARPANET address family*/
    sin.sin_addr.s_addr = INADDR_ANY;   /*Accept connections on any Interface*/ 
    sin.sin_port        = htons(4000);          /*Service TSAP > 1023. CHANGE IT!*/

    /*Register the server in the system*/
    err=bind(sservice, (struct sockaddr*)&sin, sizeof(sin));
    if(err == -1)
    {
        perror("Server. bind: ");
        exit(-1);
    }

    /*Up to 5 waiting connections*/
    err = listen(sservice,5);
    if(err == -1)
    {
        perror("Server. Listen: ");
        exit(-1);
    }

    /* Receiving requests loop */
    for(;;)
    {
        /*Accept a connection from a client*/
        l = sizeof(clientfsin);
        sclient = accept(sservice,(struct sockaddr *)&clientfsin, (socklen_t*) &l);
        if(sclient == -1)
        {
            perror("Server. Accept: ");
            continue;
        }

        signal(SIGCHLD,manejador);          //Quitar si ponemos waitpid
        pid = fork();

        if(pid == -1){
            printf("Error al crear el proceso hijo\n");
            exit(0);
        }

        if(pid){
            close(sclient);
            //waitpid(pid,&status,0); //Descomentar si usamos waitpid
        }else{

        close(sservice);    
        /*Give the service*/
        end = false;
        int i=1;
        while(!end && (i<=10)) 
        {   
            nbytes_read=recv(sclient,(char *)buf,sizeof(buf),0);


            if (nbytes_read > 0)
            {
                buf[nbytes_read]='\0'; 
                //cout << "SERVER>Server received: " << buf << endl;
                printf("Recepcion <%i>: Se han recibido <%i> bytes del cliente\n",i,nbytes_read);
                cout.flush();

                err = 0;
                //sprintf(buf,"%s_server",buf);
                nbytes_sent = send(sclient,(char *)buf,sizeof(buf),0);
                printf("Envio <%i>: Se han enviado <%i> bytes al cliente\n",i,nbytes_sent);
                i++;
            }
            else    
            {
                perror("Sever. Receive/read: ");
                end=true;
                err = -1;
            }
        }

        if(err >= 0)
            cout << "SERVER>Cliente Atendido" << endl;
        else
            cout << "SERVER>Finalizacion incorrecta del cliente" << endl;

        /*Never forget to close a socket!*/
        close(sclient);
        exit(0);
        }
    }

    close(sservice);
    printf("Fin server");

} /*main()*/

void manejador(int signo) //comentar si usamos waitpid
{
      int estado;
      wait(&estado);
}

这是客户端:

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <sys/time.h>

#define BUF_SIZE 50000

using namespace std;

int main()
{
    int     sock, err;
    bool    end;
    char    buf[BUF_SIZE];
    struct sockaddr_in sout;

    sock=socket(PF_INET,SOCK_STREAM, 0); /*Open the socket*/
    if(sock == -1)
    {
        perror("Client. Socket: ");
        exit(-1);
    }


    sout.sin_family      = AF_INET;                       /*ARPANET address family*/
    sout.sin_addr.s_addr = inet_addr("127.0.0.1");     /*Which server?*/
    sout.sin_port        = htons(4000);                       /*Output port*/

    /*Connect to the server*/
    err = connect(sock,(struct sockaddr *)&sout, sizeof(sout));
    if(err == -1)
    {
        perror("Client. Connect: ");
        exit(-1);
    }

    end = false;
    double t1,t2;
    while(!end) 
    {   
        /*Ask for the service*/
        //cout << endl << "CLIENT> Send a message...: " ;    cout.flush();
        //cin.getline(buf, 128);
        int i=0;
        for(i=0;i<10;i++){
            timeval tim;
                    gettimeofday(&tim, NULL);
                    t1=tim.tv_sec+(tim.tv_usec/1000000.0);

            err = send(sock,(char *)buf,sizeof(buf),0);

            if(err == -1)
            {
            perror("Client. Send/write: ");
            exit(-1);
            }
            printf("Envio <%i>: Se han enviado <%i> bytes\n",i+1,err);

            gettimeofday(&tim, NULL);
                    t2=tim.tv_sec+(tim.tv_usec/1000000.0);
                    printf("%.6lf para el envio de <%i>\n", t2-t1,i+1);

            err = recv(sock,(char *)buf,sizeof(buf),0);
            printf("Recepcion <%i>: Se han recibido <%i> bytes\n",i+1,err);
            //cout << "CLIENT> Server response: " << buf;   
            cout.flush();
        }
        end=true;
    }

    close(sock);

} /*main()*/

Offtopic:很抱歉用西类牙语发表评论 ;)

Answer 1

错误:

1) 您的服务器不会尝试确保它已收到完整的消息。

2) 无论实际需要发送多少字节，您的服务器都会发送 50,000 个字节。

3) 如果您的服务器实际读取 50,000 字节，它尝试添加终止零将溢出缓冲区。

3) 您的客户端发送了 50,000 个不确定的字节。

4) 您的客户端忽略它收到的字节数。

5) 客户端不确保它确实收到了服务器发送的终止零字节。

但你最大的错误是:你没有合理的协议(protocol)。如果消息以零字节终止，为什么要发送 50,000 字节？如果您的消息始终为 50,000 字节，为什么接收方不尝试接收 50,000 字节？

我会给你我给每个 TCP 程序员的标准建议:从开发协议(protocol)开始并记录它。协议(protocol)应指定谁发送以及何时发送。协议(protocol)应指定消息的构造方式。该协议(protocol)应指定有效和无效消息的规则。该协议(protocol)应指定如何检测和处理死连接。等等。

正确记录协议(protocol)需要一个小时左右的时间，但这是非常值得的。没有一个，很难说出我上面的哪些 bug 真的是 bug。 (例如，也许你真的应该总是发送 50,000 字节，即使消息只是“hi”。服务器是应该通过字节计数还是通过终止零来找到消息的结尾？等等。)