C 服务器只返回第一条消息

Question

我有一个简单的 C 服务器和一个简单的 Java 客户端。客户端从键盘获取输入并将其发送到服务器。服务器将其打印并发送回。但它只是第一次工作，可能是什么问题？

主要：

package test;

import java.util.Scanner;

public class Main {


    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Client cli = new Client();
        cli.connect();

        while(sc.hasNextLine()) {
            cli.send(sc.nextLine());
            System.out.println(cli.rec());
        }

    }
}

客户：

package test;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.net.UnknownHostException;

public class Client {

    Socket socket;
    OutputStreamWriter out;
    BufferedReader in;

    public void connect() {

        try {
            socket = new Socket("localhost", 50001);
            socket.setSoTimeout(5000);
        } catch (UnknownHostException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        try {
            out = new OutputStreamWriter(socket.getOutputStream());
        } catch (IOException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
        try {
            in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public void send(String message) {
        try {
            this.out.write(message + "\n");
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        try {
            this.out.flush();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public String rec() {
        try {
            return in.readLine();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return "";
    }
}

服务器：

#include <stdio.h>
#include <errno.h>
#include <sys/socket.h>
#include <resolv.h>
#include <arpa/inet.h>
#include <errno.h>

#define MY_PORT     50001
#define MAXBUF      1024

int main(int Count, char *Strings[])
{   int sockfd;
    struct sockaddr_in self;
    char buffer[MAXBUF];
    int clientfd;
    struct sockaddr_in client_addr;
    int addrlen=sizeof(client_addr);
    int yes = 1;

    /*---Create streaming socket---*/
    if ( (sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0 )
    {
        perror("Socket");
        exit(errno);
    }

    /*---Initialize address/port structure---*/
    bzero(&self, sizeof(self));
    self.sin_family = AF_INET;
    self.sin_port = htons(MY_PORT);
    self.sin_addr.s_addr = INADDR_ANY;

    if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == 0)
        {
            printf("Socket options was set.\n"); //TODO
        }
        else
        {
            printf("Set socket options failure.\n"); //TODO
        }

    /*---Assign a port number to the socket---*/
    if ( bind(sockfd, (struct sockaddr*)&self, sizeof(self)) != 0 )
    {
        perror("socket--bind");
        exit(errno);
    }

    /*---Make it a "listening socket"---*/
    if ( listen(sockfd, 20) != 0 )
    {
        perror("socket--listen");
        exit(errno);
    }

    clientfd = accept(sockfd, (struct sockaddr*)&client_addr, &addrlen);

    /*---Forever... ---*/
    while (1)
    {
        memset(buffer, 0, MAXBUF);
        /*---accept a connection (creating a data pipe)---*/
        printf("%s:%d connected\n", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));

        recv(clientfd, buffer, MAXBUF, 0);
        printf("Server got: %s", buffer);
        //sprintf(buffer, "%s\r\n", buffer);
        /*---Echo back anything sent---*/
        printf("sending...\n");
        int n = send(clientfd, buffer, MAXBUF, 0);
        printf("sent: %d\n", n);
    }

    /*---Close data connection---*/
            close(clientfd);

    /*---Clean up (should never get here!)---*/
    close(sockfd);
    return 0;
}

Answer 1

好了，根本原因就到这里了。 （不想要细节的可以跳过）

1. 当您将数据发送回 Java 客户端时，您发送的数据长度为 MAXBUF (1024)。

2. 现在，显然发生的事情是 java 收到了 1024 个字符作为输入。您可以在（C 语言）服务器输出中看到这一点。 sent: 1024
   为了填充剩余的字符，它发送 ASCII 值 0（即 NUL）
   您可以通过删除 java 代码中的 readLine() API 并添加它来验证这一点。

       StringBuilder strb = new StringBuilder();
       while ((value = inputStream.read()) != -1) {
           if(value != 0)
               strb.append((char) value);
           System.out.print(value + ":" + (char) value+",");
       }
       return strb.toString();
   

3. 第一次请求从服务器返回到客户端，用户输入的数据后跟剩余的空值，会发生以下情况

   • 由于使用了 readLine() API。它读取到\n 或\r 字符。这样你就可以看到输出了。
   • 此时，bufferedReader 的缓冲区中仍存储有那些 NUL 字符。

   • 现在，当我们第二次尝试从该读取器读取时，它首先尝试清空旧缓冲区，直到（没有找到 \n 或 \r，除了所有 NUL）。它将所有这些附加到 StringBuilder（它在内部使用），然后将新读取的字符串附加到构建器。
     如果出现此 NUL 字符，则附加到 StringBuilder 的所有字符都将在其缓冲区中消失。 (Explanation given here) 你可以用这个代码试试这个：

     StringBuilder str = new StringBuilder().append((char)0).append("kishore");
     System.out.println(str.toString()); // Output : Blank
     

   • 这就是您看不到输出的原因。所以你的客户端和服务器通信没有问题。

4. 修复：更改您的“C”服务器代码以发送正确的长度。

       int bytes = recv(clientfd, buffer, MAXBUF, 0);
       ...
       int n = send(clientfd, buffer, bytes, 0);
   

这样它应该可以工作。

Answer 2

我不确定这是否能解决您的问题，但我认为您的 accept 函数调用应该进入 while 循环，正如我看到 Jacajack 刚刚评论的那样。

这样，每次您收到连接时，循环都会累积。它应该是这样的：

示例：

/* Do what's in the loop every time that you accept a connection */

while (clientfd = accept(sockfd, (struct sockaddr*)&client_addr, &addrlen))
{
    memset(buffer, 0, MAXBUF);
    /*---accept a connection (creating a data pipe)---*/
    printf("%s:%d connected\n", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));

    int iResult = recv(clientfd, buffer, MAXBUF, 0); 
    // iResult is the amount of data from recv

    // Handle information and echo it back 


}

此外，我认为您应该实现某种协议来验证服务器收到的消息（看看它确实以行尾或您想要的任何其他验证结束指定）。

Answer 3

accept 必须在你的无限循环中。 它接受那里的任何新连接。所以你只接受第一个而不接受其他。

listen 是您最后一次通话。然后你按连接进行。如果您有一些可扩展性（例如接受分叉），这也是这种方式。