C中的套接字：客户端无法接收和打印从服务器发送的字符串数组

我编写了一个套接字程序，客户端向服务器发送一个字符串数组，服务器接收该数组并发送回客户端。我的服务器可以在服务器端成功打印出字符串数组reply[]。但是，在客户端，它无法打印结果。这是我的密码

客户c

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

#define PORT 4444

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

    if (argc < 2 || argc > 3)      // Test for correct number of arguments
        printf("Parameter(): <Server Address>");    

    char *servIP = argv[1];        // arg: server IP address (dotted quad)
    int clientSocket, ret;
    struct sockaddr_in serverAddr; // Server address
    char buffer[1024];
    char **reply = malloc(20*sizeof(char *));

    // Create a reliable, stream socket using TCP
    clientSocket = socket(AF_INET, SOCK_STREAM, 0);
    if(clientSocket < 0){
        printf("Error in connection.\n");
        exit(1);
    }
    printf("Client Socket is created.\n");

    // Construct the server address structure
    memset(&serverAddr, '\0', sizeof(serverAddr)); // Zero out structure
    serverAddr.sin_family = AF_INET;               // IPv4 address family
    serverAddr.sin_port = htons(PORT);             // Server port
    // Convert address
    int rtnVal = inet_pton(AF_INET, servIP, &serverAddr.sin_addr.s_addr);
    if (rtnVal == 0)
        printf("inet_pton() failed: invalid address string");
    else if (rtnVal < 0)
        printf("inet_pton() failed");

    // Establish the connection to the sorted server
    ret = connect(clientSocket, (struct sockaddr*)&serverAddr, sizeof(serverAddr));
    if(ret < 0){
        printf("Error in connection.\n");
        exit(1);
    }
    printf("Connected to Server.\n");

    //Read arrays from input file
    FILE *fptr;
    fptr = fopen("client1.inputdat", "r"); //open input file to read
    if (fptr != NULL)
    { 
        int line =0;
        while(fgets(buffer, sizeof(buffer), fptr)) {  //read line by line of the input file
            line++;
            if (line==1) {
                printf("\n");               
                printf("Unsorted array: %s\n", buffer);
                // Send arrays to the server
                send(clientSocket, buffer, strlen(buffer), 0);
                // Receive the sorted arrays back from the server
                if(recv(clientSocket, &reply, 20*sizeof(char *), 0) < 0){
                    printf("Error in receiving data.\n");
                }
                else {
                    int i;
                    printf("Sorted array:");
                    for (i=0; i<20; i++) {
                        reply[i] = malloc(10*sizeof(char));
                        printf("%s ", reply[i]); 
                    }
                }
            }
        }
        fclose(fptr);
    } 
    else {
        printf("File does not exits");
        exit(1);
    }
    return 0;
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#定义端口4444
int main（int argc，char*argv[]）{
if（argc<2 | | argc>3）//测试参数的正确数量
printf（“参数（）：”）；
char*servIP=argv[1]；//arg:服务器IP地址（虚线四元）
int clientSocket，ret；
serverAddr中的struct sockaddr\u；//服务器地址
字符缓冲区[1024]；
char**reply=malloc（20*sizeof（char*）；
//使用TCP创建可靠的流套接字
clientSocket=socket（AF\u INET，SOCK\u STREAM，0）；
if（clientSocket<0）{
printf（“连接错误。\n”）；
出口（1）；
}
printf（“已创建客户端套接字。\n”）；
//构造服务器地址结构
memset（&serverAddr，'\0'，sizeof（serverAddr））；//零出结构
serverAddr.sin\u family=AF\u INET；//IPv4地址族
serverAddr.sin_port=htons（port）；//服务器端口
//转换地址
int rtnVal=inet\u pton（AF\u inet、servIP和serverAddr.sin\u addr.s\u addr）；
如果（rtnVal==0）
printf（“inet_pton（）失败：无效的地址字符串”）；
否则如果（rtnVal<0）
printf（“inet_pton（）失败”）；
//建立到已排序服务器的连接
ret=connect（clientSocket，（struct sockaddr*）&serverAddr，sizeof（serverAddr））；
如果（ret<0）{
printf（“连接错误。\n”）；
出口（1）；
}
printf（“已连接到服务器。\n”）；
//从输入文件读取数组
文件*fptr；
fptr=fopen（“client1.inputdat”，“r”）；//打开要读取的输入文件
如果（fptr！=NULL）
{ 
内线=0；
而（fgets（buffer，sizeof（buffer），fptr））{//逐行读取输入文件
line++；
如果（行==1）{
printf（“\n”）；
printf（“未排序的数组：%s\n”，缓冲区）；
//将阵列发送到服务器
发送（clientSocket，buffer，strlen（buffer），0）；
//从服务器接收已排序的数组
if（recv（clientSocket，&reply，20*sizeof（char*），0）<0）{
printf（“接收数据时出错。\n”）；
}
否则{
int i；
printf（“排序数组：”）；
对于（i=0；i好。你的代码清楚地表明你对C不太了解，更不用说Socket了，但我认为这是一个新的改进版本，可以满足你的需要。我的大部分改进都包含在原始帖子的评论中。我没有检查任何适当的错误，这在许多其他方面都远远不够完美这会做一些看起来像你想要的事情而不会爆炸

您发送数据时没有任何方式知道您是否获得了所有传输的数据。套接字是流。它以最方便的方式发送数据，而不是您可能喜欢的方式。为了解决此问题，我要求我们在每次传输时发送一个
\n
。我们检查
\n
并在每次发送时继续读取数据e从另一端获取数据。在我发送了大量回复数据之后，我发送了一个
\n
字符，这样客户端就知道已收到完整的行。我们不需要从客户端添加
\n
，因为
fgets
将
\n
保留在缓冲区的末尾

您提到排序是为了增加额外的好处，我添加了一个
qsort
来对数据进行排序。在
compReply
函数中，我不仅仅直接从
strcmp
返回值，而是将其放入
int
中，以便在必要时在调试器中看到它。我相信一些编译器会抱怨我正在执行
操作>strcmp
在两个
void*
变量上。为了保持整洁，在将它们传递给
strcmp
之前，您可能需要使用
（char*）a
强制转换它们

我删除了您的
fork
，以便于调试。很抱歉，一次只允许一个连接。当我编写类似的内容时，我通常不会fork一个新进程，而是使用一个newSocket值数组，并使用
选择
来决定从哪个进程读取。（选择<代码>功能也可以与接受<代码>一起使用。）同样，这种方式更容易调试

strtok
函数将找到的字符替换为null，并返回指向字符串开头的指针。我只是想删除不需要的字符，所以我使用它时不必费心接受返回值。这也可以通过以下方法完成：

char *p=strchr(buffer,'\n');
if( NULL != p ) *p=0;

但是strtok更简洁

我允许将端口号传递给服务器，但没有将其添加到客户端。哦，好吧

在让客户端运行之前，我测试了服务器

telnet 127.0.0.1 4444

并键入：
a、s、d、f、g、h、j、k、l
要返回排序列表
a、d、f、g、h、j、k、l、s，
我也不喜欢后面的逗号，但我现在不想让它消失

服务器：

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

#define PORT 4444
#define BUF_SIZE 1024
static int compReply(const void *a, const void *b)
{
    int ret=strcmp(a,b);
    return(ret);
}
int main(int argc, char *argv[])
{
    int port=4444;
    int sockfd, ret;
    struct sockaddr_in serverAddr; // Local address

    int newSocket;
    struct sockaddr_in newAddr;

    socklen_t addr_size;

    if( argc > 1 ) {
        port=atoi(argv[1]);
        if( port < 1024 ) {
            port=4444;
        }
    }

    // Create socket for incoming connections
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if(sockfd < 0){
        printf("Error in connection.\n");
        exit(1);
    }
    printf("Server Socket is created.\n");

    // Construct local address structure
    memset(&serverAddr, '\0', sizeof(serverAddr));        // Zero out structure
    serverAddr.sin_family = AF_INET;                      // IPv4 address family
    serverAddr.sin_port = htons(PORT);                    // Local port
    serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);       // Any incoming interface

    // Bind to the local address
    ret = bind(sockfd, (struct sockaddr*)&serverAddr, sizeof(serverAddr));
    if(ret < 0){
        printf("Error in binding.\n");
        perror("bind");
        exit(1);
    }
    printf("Bind to port %d\n", port);

    // Mark the socket so it will listen for incoming connections
    if(listen(sockfd, 10) == 0){                 //Maximum outstanding connection requests is 10
        printf("Listening....\n");
    }else{
        printf("Error in listening.\n");
        perror("listen");
    }

    while(1){
        // Wait for clients to connect
        newSocket = accept(sockfd, (struct sockaddr*)&newAddr, &addr_size);
        if(newSocket < 0){
            exit(1);
        }
        // newSocket is connected to client!
        char newName[INET_ADDRSTRLEN]; // String to contain client address
        if (inet_ntop(AF_INET, &newAddr.sin_addr.s_addr, newName, sizeof(newName)) != NULL)
            printf("Handling client %s/ %d\n", newName, ntohs(newAddr.sin_port));
        else
            printf("Unable to get client address");

        while(1){
            char buffer[BUF_SIZE]={0};
            int ret=1;
            int count=0;
            while(NULL == strchr(buffer,'\n') && ret > 0 && count < sizeof(buffer))
            {
                ret=recv(newSocket, &buffer[count], sizeof(buffer)-count, 0);
                count+=ret;
            }
            if( ret <= 0 ) {
                if( ret < 0 ) {
                    printf("Problem with recv: %d\n", ret);
                }
                break;
            }
            printf("recv: %s\n", buffer);
            strtok(buffer,"\n\r"); /* throw away any \r\n */
            if( ret> 0 ) {
                int i=0;
                char reply[20][BUF_SIZE]={0};
                char *p = strtok(buffer, ",");
                while (p!=NULL) {
                    strncpy(reply[i],p,BUF_SIZE);
                    strcat(reply[i],",");
                    p = strtok(NULL, ","); //stroke received string into tokens
                    i++;
                }
                qsort(reply,i,BUF_SIZE,compReply);
                for(int jj=0; jj<i; jj++) {
                    printf("%s ", reply[jj]);
                    ret=send(newSocket, reply[jj], strlen(reply[jj]), 0);
                }
                ret=send(newSocket, "\n", 1, 0);
                printf("\n");
            }
        }

        close(newSocket);
    }
    return 0;
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#定义端口4444
#定义BUF_大小1024
静态整数压缩（常量无效*a，常量无效*b）
{
int-ret=strcmp（a，b）；
返回（ret）；
}
int main（int argc，char*argv[]）
{
int端口=4444；
int sockfd，ret；
serverAddr中的struct sockaddr\u；//本地地址
int newSocket；
newAddr中的结构sockaddr_；
袜子尺寸；
如果（argc>1）{
端口=atoi（argv[1]）；
如果（端口<1024
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define PORT 4444
#define BUF_SIZE 1024
static int compReply(const void *a, const void *b)
{
    int ret=strcmp(a,b);
    return(ret);
}
int main(int argc, char *argv[])
{
    int port=4444;
    int sockfd, ret;
    struct sockaddr_in serverAddr; // Local address

    int newSocket;
    struct sockaddr_in newAddr;

    socklen_t addr_size;

    if( argc > 1 ) {
        port=atoi(argv[1]);
        if( port < 1024 ) {
            port=4444;
        }
    }

    // Create socket for incoming connections
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if(sockfd < 0){
        printf("Error in connection.\n");
        exit(1);
    }
    printf("Server Socket is created.\n");

    // Construct local address structure
    memset(&serverAddr, '\0', sizeof(serverAddr));        // Zero out structure
    serverAddr.sin_family = AF_INET;                      // IPv4 address family
    serverAddr.sin_port = htons(PORT);                    // Local port
    serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);       // Any incoming interface

    // Bind to the local address
    ret = bind(sockfd, (struct sockaddr*)&serverAddr, sizeof(serverAddr));
    if(ret < 0){
        printf("Error in binding.\n");
        perror("bind");
        exit(1);
    }
    printf("Bind to port %d\n", port);

    // Mark the socket so it will listen for incoming connections
    if(listen(sockfd, 10) == 0){                 //Maximum outstanding connection requests is 10
        printf("Listening....\n");
    }else{
        printf("Error in listening.\n");
        perror("listen");
    }

    while(1){
        // Wait for clients to connect
        newSocket = accept(sockfd, (struct sockaddr*)&newAddr, &addr_size);
        if(newSocket < 0){
            exit(1);
        }
        // newSocket is connected to client!
        char newName[INET_ADDRSTRLEN]; // String to contain client address
        if (inet_ntop(AF_INET, &newAddr.sin_addr.s_addr, newName, sizeof(newName)) != NULL)
            printf("Handling client %s/ %d\n", newName, ntohs(newAddr.sin_port));
        else
            printf("Unable to get client address");

        while(1){
            char buffer[BUF_SIZE]={0};
            int ret=1;
            int count=0;
            while(NULL == strchr(buffer,'\n') && ret > 0 && count < sizeof(buffer))
            {
                ret=recv(newSocket, &buffer[count], sizeof(buffer)-count, 0);
                count+=ret;
            }
            if( ret <= 0 ) {
                if( ret < 0 ) {
                    printf("Problem with recv: %d\n", ret);
                }
                break;
            }
            printf("recv: %s\n", buffer);
            strtok(buffer,"\n\r"); /* throw away any \r\n */
            if( ret> 0 ) {
                int i=0;
                char reply[20][BUF_SIZE]={0};
                char *p = strtok(buffer, ",");
                while (p!=NULL) {
                    strncpy(reply[i],p,BUF_SIZE);
                    strcat(reply[i],",");
                    p = strtok(NULL, ","); //stroke received string into tokens
                    i++;
                }
                qsort(reply,i,BUF_SIZE,compReply);
                for(int jj=0; jj<i; jj++) {
                    printf("%s ", reply[jj]);
                    ret=send(newSocket, reply[jj], strlen(reply[jj]), 0);
                }
                ret=send(newSocket, "\n", 1, 0);
                printf("\n");
            }
        }

        close(newSocket);
    }
    return 0;
}

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

#define PORT 4444
#define BUF_SIZE 1024

int main(int argc, char *argv[])
{
    char servIP[120]="127.0.0.1";

    if( argc > 1 ) {
        strncpy(servIP,argv[1],sizeof(servIP));
    }

    int clientSocket, ret;
    struct sockaddr_in serverAddr; // Server address
    char buffer[BUF_SIZE];

    // Create a reliable, stream socket using TCP
    clientSocket = socket(AF_INET, SOCK_STREAM, 0);
    if(clientSocket < 0){
        printf("Error in connection.\n");
        exit(1);
    }
    printf("Client Socket is created.\n");

    // Construct the server address structure
    memset(&serverAddr, '\0', sizeof(serverAddr)); // Zero out structure
    serverAddr.sin_family = AF_INET;               // IPv4 address family
    serverAddr.sin_port = htons(PORT);             // Server port
    // Convert address
    int rtnVal = inet_pton(AF_INET, servIP, &serverAddr.sin_addr.s_addr);
    if (rtnVal == 0)
        printf("inet_pton() failed: invalid address string");
    else if (rtnVal < 0)
        printf("inet_pton() failed");

    // Establish the connection to the sorted server
    ret = connect(clientSocket, (struct sockaddr*)&serverAddr, sizeof(serverAddr));
    if(ret < 0){
        printf("Error in connection.\n");
        exit(1);
    }
    printf("Connected to Server.\n");

    //Read arrays from input file
    FILE *fptr;
    fptr = fopen("this.csv", "r"); //open input file to read
    if (fptr != NULL) {
        while(fgets(buffer, sizeof(buffer), fptr))    //read line by line of the input file
        {
            char reply[BUF_SIZE]={0};
            char repList[20][BUF_SIZE]={0};
            int count=0;
            int ret=1;
            printf("Unsorted array: %s", buffer);
            // Send array to the server
            send(clientSocket, buffer, strlen(buffer), 0);
            // Receive the sorted arrays back from the server
            while(NULL == strchr(reply,'\n') && ret > 0 && count < sizeof(reply))
            {
                ret=recv(clientSocket, &reply[count],sizeof(reply)-count,0);
                count+=ret;
            }
            if( ret < 0 ) {
                printf("Error in receiving data.\n");
            }
            else {
                int i=0;
                strtok(reply,"\n\r");
                for(char *p=strtok(reply,",");p!=NULL; p=strtok(NULL,","))
                {
                    strncpy(repList[i],p,BUF_SIZE);
                    i++;
                }
                printf("Sorted array:");
                for (int jj=0; jj<i; jj++) {
                    printf("%s ", repList[jj]);
                }
            }
            printf("\n");
        }
        fclose(fptr);
    }
    else {
        printf("File does not exist");
        perror("fopen");
        exit(1);
    }
    return 0;
}