发送带有多个数字的字符串客户端/服务器TCP

我正在使用C语言进行TCP客户机/服务器通信。客户机必须获取数据的数量（而不是>6），获取数据并将它们以单字符串消息的形式发送到服务器，如下所示：4 11 21 9 11。 4是数据的数量，11、21、9、11是数据

然后，服务器必须读取消息，打印它并将接收到的数据数（4）发送给客户端

我为客户试过这个：

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




int main(int argc, char *argv[]) {

    int simpleSocket = 0;
    int simplePort = 0;
    int returnStatus= 0;
    char buffsend[256];
    char buffrecv[256];
    int n, i;
    struct sockaddr_in simpleServer;

    if (3 != argc) {

        fprintf(stderr, "Usage: %s <server> <port>\n", argv[0]);
        exit(1);

    }

    /* create a streaming socket      */
    simpleSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

    if (simpleSocket == -1) {

        fprintf(stderr, "Could not create a socket!\n");
        exit(1);

    }
    else {
        fprintf(stderr, "Socket created!\n");
    }

    /* retrieve the port number for connecting */
    simplePort = atoi(argv[2]);

    /* setup the address structure */
    /* use the IP address sent as an argument for the server address  */
    //bzero(&simpleServer, sizeof(simpleServer)); 
    memset(&simpleServer, '\0', sizeof(simpleServer));
    simpleServer.sin_family = AF_INET;
    //inet_addr(argv[2], &simpleServer.sin_addr.s_addr);
    simpleServer.sin_addr.s_addr=inet_addr(argv[1]);
    simpleServer.sin_port = htons(simplePort);

    /*  connect to the address and port with our socket  */
    returnStatus = connect(simpleSocket, (struct sockaddr *)&simpleServer, sizeof(simpleServer));

    if (returnStatus == 0) {
        fprintf(stderr, "Connect successful!\n");
    }
    else {
        fprintf(stderr, "Could not connect to address!\n");
    close(simpleSocket);
    exit(1);
    }





    /* get the message from the server   */



      do {

        printf("get numb of data or terminate(write '0'): ");
        fgets(buffsend,256,stdin);
        n=atoi(buffsend);
        if(n>6) {
          printf("Error\n");

         }
        else {
                for(i=0;i<n;i++) {
                   printf("insert number: ");
                   fgets(buffsend,256,stdin);
                   write(simpleSocket, buffsend, strlen(buffsend)+1);


         }



     } while((n!=0) && (n>0));





    close(simpleSocket);
    return 0;

}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
int main（int argc，char*argv[]）{
int simpleSocket=0；
int simplePort=0；
int returnStatus=0；
char-buffsend[256]；
char-buffrecv[256]；
int n，i；
simpleServer中的结构sockaddr_；
如果（3！=argc）{
fprintf（stderr，“用法：%s\n”，argv[0]）；
出口（1）；
}
/*创建流式套接字*/
simpleSocket=socket（AF_INET、SOCK_STREAM、IPPROTO_TCP）；
if（simpleScocket==-1）{
fprintf（stderr，“无法创建套接字！\n”）；
出口（1）；
}
否则{
fprintf（stderr，“已创建套接字！\n”）；
}
/*检索用于连接的端口号*/
simplePort=atoi（argv[2]）；
/*设置地址结构*/
/*使用发送的IP地址作为服务器地址的参数*/
//bzero（&simpleServer，sizeof（simpleServer））；
memset（&simpleServer，'\0'，sizeof（simpleServer））；
simpleServer.sin_family=AF_INET；
//inet_addr（argv[2]，&simpleServer.sin_addr.s_addr）；
simpleServer.sin_addr.s_addr=inet_addr（argv[1]）；
simpleServer.sin_port=htons（simplePort）；
/*使用套接字连接到地址和端口*/
returnStatus=connect（simpleSocket，（struct sockaddr*）&simpleServer，sizeof（simpleServer））；
如果（返回状态==0）{
fprintf（标准“连接成功！\n”）；
}
否则{
fprintf（stderr，“无法连接到地址！\n”）；
关闭（simpleSocket）；
出口（1）；
}
/*从服务器获取消息*/
做{
printf（“获取数据编号或终止（写入“0”）：”；
fgets（buffsend，256，标准输入）；
n=atoi（buffsend）；
如果（n>6）{
printf（“错误\n”）；
}
否则{
对于（i=0；i0））；
关闭（simpleSocket）；
返回0；
}

对于服务器：

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

int main(int argc, char *argv[]) {

    int simpleSocket = 0;
    int simplePort = 0;
    int returnStatus = 0;
    char buff[256];
    char message[256];
    int count;

    struct sockaddr_in simpleServer;

    if (2 != argc) {

        fprintf(stderr, "Usage: %s <port>\n", argv[0]);
        exit(1);

    }

    simpleSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

    if (simpleSocket == -1) {

        fprintf(stderr, "Could not create a socket!\n");
        exit(1);

    }
    else {
        fprintf(stderr, "Socket created!\n");
    }

    /* retrieve the port number for listening */
    simplePort = atoi(argv[1]);

    /* setup the address structure */
    /* use INADDR_ANY to bind to all local addresses  */
    memset(&simpleServer, '\0', sizeof(simpleServer)); 
    simpleServer.sin_family = AF_INET;
    simpleServer.sin_addr.s_addr = htonl(INADDR_ANY);
    simpleServer.sin_port = htons(simplePort);

    /*  bind to the address and port with our socket  */
    returnStatus = bind(simpleSocket,(struct sockaddr *)&simpleServer,sizeof(simpleServer));

    if (returnStatus == 0) {
        fprintf(stderr, "Bind completed!\n");
    }
    else {
        fprintf(stderr, "Could not bind to address!\n");
    close(simpleSocket);
    exit(1);
    }

    /* lets listen on the socket for connections      */
    returnStatus = listen(simpleSocket, 5);

    if (returnStatus == -1) {
        fprintf(stderr, "Cannot listen on socket!\n");
    close(simpleSocket);
        exit(1);
    }

    while (1)

    {

        struct sockaddr_in clientName = { 0 };
    int simpleChildSocket = 0;
    int clientNameLength = sizeof(clientName);

    /* wait here */

        simpleChildSocket = accept(simpleSocket,(struct sockaddr *)&clientName, &clientNameLength);

    if (simpleChildSocket == -1) {

            fprintf(stderr, "Cannot accept connections!\n");
        close(simpleSocket);
        exit(1);

    }

        /* handle the new connection request  */
    /* write out our message to the client */


        while(read(simpleChildSocket, buff, 256))
            cont++;
            printf("%s", buff);
        printf("Data received: %d %s\n", cont, buff);



       close(simpleChildSocket);
    }

    close(simpleSocket);
    return 0;

}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
int main（int argc，char*argv[]）{
int simpleSocket=0；
int simplePort=0；
int returnStatus=0；
字符buff[256]；
字符消息[256]；
整数计数；
simpleServer中的结构sockaddr_；
如果（2！=argc）{
fprintf（stderr，“用法：%s\n”，argv[0]）；
出口（1）；
}
simpleSocket=socket（AF_INET、SOCK_STREAM、IPPROTO_TCP）；
if（simpleScocket==-1）{
fprintf（stderr，“无法创建套接字！\n”）；
出口（1）；
}
否则{
fprintf（stderr，“已创建套接字！\n”）；
}
/*检索用于侦听的端口号*/
simplePort=atoi（argv[1]）；
/*设置地址结构*/
/*使用INADDR_ANY绑定到所有本地地址*/
memset（&simpleServer，'\0'，sizeof（simpleServer））；
simpleServer.sin_family=AF_INET；
simpleServer.sin_addr.s_addr=htonl（INADDR_ANY）；
simpleServer.sin_port=htons（simplePort）；
/*使用套接字绑定到地址和端口*/
returnStatus=bind（simpleSocket，（struct sockaddr*）&simpleServer，sizeof（simpleServer））；
如果（返回状态==0）{
fprintf（标准“绑定完成！\n”）；
}
否则{
fprintf（stderr，“无法绑定到地址！\n”）；
关闭（simpleSocket）；
出口（1）；
}
/*让我们在套接字上侦听连接*/
returnStatus=listen（simpleSocket，5）；
如果（返回状态==-1）{
fprintf（stderr，“无法在套接字上侦听！\n”）；
关闭（simpleSocket）；
出口（1）；
}
而(1)
{
clientName={0}中的结构sockaddr_；
int simpleChildSocket=0；
int clientNameLength=sizeof（clientName）；
/*在这儿等着*/
simpleChildSocket=accept（simpleSocket，（struct sockaddr*）&clientName和&clientNameLength）；
如果（simpleChildSocket==-1）{
fprintf（stderr，“无法接受连接！\n”）；
关闭（simpleSocket）；
出口（1）；
}
/*处理新的连接请求*/
/*把我们的信息写给客户*/
while（读（simpleChildSocket，buff，256））
cont++；
printf（“%s”，浅黄色）；
printf（“收到的数据：%d%s\n”，续，buff）；
关闭（simpleChildSocket）；
}
关闭（simpleSocket）；
返回0；
}

问题在于客户端在每个值之后发送字符串终止符（

\0

），因此当服务器打印整个消息时，它会在第一个值之后停止打印

通过在发送时不包含字符串终止符，可以克服此特定问题：

      write(simpleSocket, buffsend, strlen(buffsend)); /* Removed the +1 */

接收消息时，需要添加字符串终止符：

    int length;
    char buff[256];

    while((length = read(simpleChildSocket, buff, 256-1)) > 0) {
        buff[length] = `\0`;
        cont++;
        printf("Data received: %d %d %s\n", cont, length, buff);
    }

---

还请注意，您使用的是基于流的套接字。这意味着套接字本身没有消息协议的概念。有关详细信息，请参阅。

问题在于客户端正在发送字符串终止符（

\0

）在每个值之后，因此当服务器打印整个消息时，它会在第一个值之后停止打印

通过在发送时不包含字符串终止符，可以克服此特定问题：

      write(simpleSocket, buffsend, strlen(buffsend)); /* Removed the +1 */

接收消息时，需要添加字符串终止符：

    int length;
    char buff[256];

    while((length = read(simpleChildSocket, buff, 256-1)) > 0) {
        buff[length] = `\0`;
        cont++;
        printf("Data received: %d %d %s\n", cont, length, buff);
    }

---

还请注意，您使用的是基于流的套接字。这意味着套接字本身没有消息协议的概念。有关更多信息，请参阅。

我无法编译您的客户端进行测试。我使用netcat进行测试（netcat 0端口）

我不明白是什么问题，是因为你没有指纹吗？ 这是因为printf使用put，而put做一些缓冲，所以