无法将套接字响应 C 服务器读取到 Java 客户端

Question

I've searched everywhere including here for possible solutions and tried some of the answers I found with no success.

I implemented a simple Java tcp socket client. The client works really well with one Java server but I keep having problems receiving the response from a server coded in C. The server appears to be handling the transaction correctly and it sends a reply accordingly. The problem lies in the client being able to receive the incoming stream of the reply. This was my initial implementation:

        String msg_out = message;
        String reply;

        //the stream object to transmit message to server
        DataOutputStream outStream = new DataOutputStream(clientSocket.getOutputStream());

        outStream.writeBytes(msg_out + '\n');
        outStream.flush();

        //try to break away from locked read 
        //clientSocket.setSoTimeout(10000);

        //initial implementation
        //the object to receive reply server
        BufferedReader replyStream = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
        reply = replyStream.readLine();

        System.out.println("Reply from "+ host + ":" + port + " -> " + reply);

I downloaded Wireshark and used it to monitor the tcp packet traffic between the client and server in the corresponding port the server socket is listening on. I saw multiple suggestions in other threads with similar topics, I unfortunately was not able to get any of those solutions to work for me. I found that the packet containing the reply has the flag value set to PSH (for do not buffer steam upon receiving, process immediately). I thought that the Java client by attempting to buffer the reply was causing the connection to reset (RST that appears in the failure packet, which is the next one that occurs) because of this flag. I tried testing with this implementation I found in a thread here trying to read the reply byte by byte but to no avail:

  try {
            DataInputStream in = new  DataInputStream(clientSocket.getInputStream());
            int bytesRead = 0;
            byte[] messageByte = new byte[1000];
            boolean end = false;
            String messageString = "";
            messageByte[0] = in.readByte();
            messageByte[1] = in.readByte();
            ByteBuffer byteBuffer = ByteBuffer.wrap(messageByte, 0, 2);

            int bytesToRead = byteBuffer.getShort();
            System.out.println("About to read " + bytesToRead + " octets");

            //The following code shows in detail how to read from a TCP socket

            while(!end)
            {
                bytesRead = in.read(messageByte);
                messageString += new String(messageByte, 0, bytesRead);
                if (messageString.length() == bytesToRead )
                {
                    end = true;
                }
            }


            System.out.println("Server Reply: " + messageString);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

I do not have access to the source code for the C server but its developer swears to me that the problem is not on his end and I believe him. I also know he can't make changes to it as it works with every other client architecture in use, the one I'm coding happens to be the only Java client one that interacts with this C based server. Is there an error in my implementation or is there another implementation I could use to read the reply stream in a more fool-proof way?

Here's the results of trying to run the client/server comm process:

[2/10/17 14:23:49:658 EST] 00000031 SystemOut     O Outgoing transaction message:C00052!GDT43000KU!01!D-10!G-11!NORMAL!|                   
[2/10/17 14:23:49:658 EST] 0000011e SystemOut     O Buffersize in stream:8192
[2/10/17 14:23:49:737 EST] 0000011e SystemOut     O About to read 12336 octets
[2/10/17 14:23:49:737 EST] 0000011e SystemErr     R java.net.SocketException: Connection reset
[2/10/17 14:23:49:737 EST] 0000011e SystemErr     R     at java.lang.Throwable.<init>(Throwable.java:67)
[2/10/17 14:23:49:737 EST] 0000011e SystemErr     R     at java.net.SocketInputStream.read(SocketInputStream.java:118)
[2/10/17 14:23:49:737 EST] 0000011e SystemErr     R     at java.io.DataInputStream.read(DataInputStream.java:94)
[2/10/17 14:23:49:737 EST] 0000011e SystemErr     R     at com.gf.btv.RTDLTSS.domain.LTSSClient.TCPClientRequest(LTSSClient.java:141)
[2/10/17 14:23:49:737 EST] 0000011e SystemErr     R     at com.gf.btv.RTDLTSS.helper.LTSSClientThread.run(LTSSClientThread.java:147)
[2/10/17 14:23:49:737 EST] 0000011e SystemErr     R     at java.lang.Thread.run(Thread.java:736)

Answer 1

The RST doesn't have anything to do with the PSH or the buffered reader, but if you need to read binary the reader isn't appropriate. The RST indicates that the peer closed the connection before you read from it, which is a strong indication that you're using the wrong protocol. It isn't credible that the request protocol is line-based but the response protocol is length-word-prefix-based. One or the other, or something else.

If you determine that it really is a length-word-prefix protocol, try this:

int messageLength = in.readShort();
byte messageBytes = new byte[messageLength];
in.readFully(messageBytes);
// etc.

But you need confirmation of the actual protocol. Guesswork won't get you there.