Socket Socket listening

[huckleberry]

Hallo,

ich habe versucht einen Client zu basteln. Erst mal ganz primitiv:
Ich schicke eine String "CHALLENGE;12234342243" übers Netwerk raus und warte dann bis eine Antwort vom Empfänger kommt.

Als Gegenseite habe ich netcat benutzt:

$netcat.exe -l -p 8181 > recv.txt
$type recv.txt
"CHALLENGE;12234342243"

Der String wird also korrekt weggeschickt. Als Antwortende Gegenseite habe ich wieder netcat benutzt:

$type msg.txt
"RESPONSE;BLA1;BLA2;BLA3"
$type msg.txt | netcat.exe 127.0.0.1 8181

Jedoch empfänt mein Java-Programm nichts?!?

        public String challenge_EdgeID(String id){
            String resultMsg = "";
            try{
                //1. creating a socket to connect to the server
                localhost = InetAddress.getLocalHost();
		challengeSocket = new Socket(localhost, CHALLENGE_COMPORT);
		System.out.println("Connected to "+localhost.getHostAddress()+" on port "+CHALLENGE_COMPORT);
		
                //2. get Input and Output streams
                outData = new BufferedWriter(new OutputStreamWriter(challengeSocket.getOutputStream()));
                outData.flush();
              
                inData = new BufferedReader(new InputStreamReader(challengeSocket.getInputStream()));
		
		//3: Communicating with the server
		do{
                    try{
                        resultMsg = inData.readLine();
                        if (mode) System.out.println("server>" + resultMsg);
                        transmit("CHALLENGE;"+id);
                    } catch(IOException ioException){
                        System.err.println("Error IO: "+ioException.toString());
                    }
                }while(!resultMsg.startsWith("RESPONSE"));
                
                return resultMsg;
            
            // CATCH BLOCK    
            } catch(UnknownHostException unknownHost){
                System.err.println("You are trying to connect to an unknown host! "+unknownHost.toString());
                return null;
            } catch(IOException ioException){
                System.err.println("Error IO: "+ioException.toString());
                return null;
            } finally {
                //4: Closing connection
		try{
                    inData.close();
                    outData.close();
                    challengeSocket.close();
                } catch(IOException ioException){
                    System.err.println("FINALLY Error IO: "+ioException.toString());
                }
            }
        }

Zeile 18: "resultMsg = inData.readLine();" Führt er aus, wartet dann aber vergeblich auf readLine(). Anscheinend schicke ich die msg.txt nicht korrekt über netcat raus?

Jemand Tipps?

Ich danke

Huck

 

[SlaterB]

vielleicht fehlt nur der Zeilenumbruch, aber ob das zu machen ist?
read(char[], ..) gibts noch, sonst wirds aufwendiger

 

[huckleberry]

vielleicht fehlt nur der Zeilenumbruch

Ja gute Idee. Ich habe im Hexeditor die msg.txt Textdatei mal erweitert, indem ich 0x0D0A (CR + LF) angehängt habe. War auch vergeblich.

Jedoch habe ich mal folgenden Code ergänzt:

System.out.println("Listen on "+challengeSocket.getLocalSocketAddress().toString());

und siehe da:

Listen on /10.251.145.71:2900

Mein Port sollte aber

challengeSocket = new Socket(localhost, 8181);

sein ???:L

Wieso steht da 2900 ???:L :autsch:

 

[SlaterB]

8181 ist der Ziel-Port, entweder auf einem anderen Rechner oder eben bei dir localhost, jedenfalls der Server, der schon da war,
der Client braucht selber auch einen Port, mehr oder weniger zufällig ist es in diesem Fall 2900 geworden


ein Server in Java wird mit
new ServerSocket(7575);
aufgemacht, das wäre dann auch exakt der lokale Port

 

[VfL_Freak]

Moin,

Ich habe im Hexeditor die msg.txt Textdatei mal erweitert, indem ich 0x0D0A (CR + LF) angehängt habe. War auch vergeblich.

ich hoffe, es war 0x0D 0x0A, 0x0D0A wäre dezimal 2573

Gruß
Klaus

 

[huckleberry]

8181 ist der Ziel-Port, entweder auf einem anderen Rechner oder eben bei dir localhost, jedenfalls der Server, der schon da war

Richtig, ich habe mit netcat -l -p 8181 > recv.txt auf port 8181 gelauscht und den ankommenden String korrekt in recv.txt schreiben können.

der Client braucht selber auch einen Port, mehr oder weniger zufällig ist es in diesem Fall 2900 geworden

Da zufällig, ändert er sich höchstwahrscheinlich bei jedem Programmstart.
Also gut, wenn ich nun zB per netcat an den client war zurück schicken würde, müsste ich also port 2900 nehmen.

netcat 127.0.0.1 2900 < msg.txt

oder auch

netcat 10.251.145.71 2900 < msg.txt

Klingt eig. logisch. Hab ich aber grad gemacht, geht net :bahnhof:

Trotzdem sollte doch nichts dagegen sprechen, auf gleichem Port zu senden und zu empfangen?

 

[huckleberry]

ich hoffe, es war 0x0D 0x0A

Moin, ja klar. Wie es in Hex-editoren üblich ist, habe ich die "0x" gänzlich weggelassen (zumal es auch kein x gibt ). 0x sollte nur die Hexnotation verdeutlichen.

 

[SlaterB]

> Klingt eig. logisch. Hab ich aber grad gemacht, geht net
dein Programm hat doch nur für 5 ms den Port offen, mal abgesehen davon dass es aktuell hängt

aber auch so kann man nicht unbedingt einfach in eine bestehende Verbindung etwas reinschicken,
das widerspricht gewissen Grundsätzen, Netzverbindungen sind durch-protokollierte Abläufe,
dein Java-Programm spricht als 2900 mit 8181, genau so läuft es und nichts anderes

ob du mit dem Zeilenumbruch weiter kommst, kann ich nicht testen/ beurteilen,
versuche wie gesagt auch andere read-Methoden im Client, selbst einzelne bytes würden zumindest schon belegen, dass irgendwas ankommt

 

[huckleberry]

Also den Server habe ich nun fertig. Mit netcat getestet funzt er soweit:

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package openlrtestserver;

import java.io.*;
import java.net.*;
import java.util.Random;

public class OpenLR_TestServer {
        private Socket              challengeSocket;
        
        private ServerSocket        responseServerSocket;
        private Socket              responseSocket;

        private InetAddress         localhost;
        
        private final static int    CHALLENGE_COMPORT = 8181;
        private int                 incommingPort;
        
        private BufferedWriter      outData;
        private BufferedReader      inData;
        
        private String              resultMsg = "";
        
        private boolean             to_expired = false;
        
        public boolean challenge_EdgeID(){
            try{
                System.out.println("+++ Wait for request +++");
                responseServerSocket = new ServerSocket(CHALLENGE_COMPORT);
                responseServerSocket.setSoTimeout(5000);
                
                responseSocket = responseServerSocket.accept();
                inData = new BufferedReader(new InputStreamReader(responseSocket.getInputStream()));
                            
		//3: Communicating with the server
                try{
                    System.out.println("<<< Connected to "+responseSocket.getRemoteSocketAddress().toString());
                    System.out.println(">>> Listening on "+responseSocket.getLocalSocketAddress().toString());
//                    responseSocket.setSoTimeout(5000);
                    resultMsg = inData.readLine();
                    inData.close();
                    if ( resultMsg.startsWith("CHAL") ){
                        System.out.println("Received>>>" + resultMsg);
                        incommingPort = responseSocket.getPort();
                        System.out.println("SLEEP for Port ________ "+incommingPort);
                        Thread.sleep(5000);
                        System.out.println("AWAKE");
                    } else {
                        System.out.println("!!! Wrong HEADER>>>" + resultMsg);
                    }
                    return true;
                    
                } catch(SocketTimeoutException unknownHost){
                    System.err.println("Socket TO expired! "+unknownHost.toString());
                    to_expired = true;
                    return true;
                } catch(IOException ioException){
                        System.err.println("Error IO: "+ioException.toString());
                        return false;
                } 
                catch(InterruptedException ioException){
                        System.err.println("Sleep Error: "+ioException.toString());
                        return false;
                }
                
            // CATCH BLOCK    
            } catch(SocketTimeoutException unknownHost){
                System.err.println("Serversocket TO expired! "+unknownHost.toString());
                try {
                    responseServerSocket.close();
                } catch (IOException ioe) {
                    System.err.println("Error IO Closing ResponseServerSocket: "+ioe.toString());
                }
                to_expired = true;
                return true;
            } catch(UnknownHostException unknownHost){
                System.err.println("You are trying to connect to an unknown host! "+unknownHost.toString());
                return false;
            } catch(IOException ioException){
                System.err.println("SS Error IO: "+ioException.toString());
                return false;
            }
        }
        
        public boolean cleanUpSockets(){
            try {
                responseSocket.close();
                responseServerSocket.close();
                return true;
            } catch (IOException ioe) {
                System.err.println("IO@CleanUp: "+ioe.toString());
                return false;
            }
        }
        
        public void transmit(String toBeSent) {
            try{
                System.out.println("Transmit> " + toBeSent+" > "+responseSocket.getRemoteSocketAddress());
//                challengeSocket = new Socket(responseSocket.getInetAddress(), 8182);
                while (challengeSocket == null) {
                    System.out.println("<< Connect ChallengeSocket!");
                    challengeSocket = new Socket(responseSocket.getInetAddress(), incommingPort);
                }
                System.out.println("ESTABLISHED> "+toBeSent+" > "+challengeSocket.getRemoteSocketAddress());
                outData = new BufferedWriter(new OutputStreamWriter(challengeSocket.getOutputStream()));
                outData.write(toBeSent);
                outData.newLine();
                outData.flush();
                outData.close();
                challengeSocket.close();
                to_expired = false;
            } catch(IOException ioException){
                System.err.println("Transmit Error IO: "+ioException.toString());
                to_expired = false;
            }
        }

    
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        System.out.println("################# Start Testserver ###################");
        OpenLR_TestServer ots = new OpenLR_TestServer();
        System.out.println("---> Generated!");
        try {
            ots.localhost = InetAddress.getLocalHost();
            System.out.println("Localhost: "+ots.localhost);
        } catch (UnknownHostException uhe) {
            
        }
        System.out.println("Start Challenge");
        Random randomGenerator = new Random();
      
        while ( ots.challenge_EdgeID() ) {
            if (ots.to_expired) {
                ots.to_expired = false;
                System.out.println("Start Challenge");
                continue;
            }
            int randomInt = randomGenerator.nextInt(2934787);
            int randomInt2 = randomGenerator.nextInt(4545767);
            String msg = "RESPONSE;"+randomInt+";"+(randomInt-randomInt2)+";"+randomInt2+";"+(randomInt+randomInt2);
            System.out.println("+++ MainWhile");
            ots.transmit(msg);
            ots.cleanUpSockets();
            System.out.println("Start Challenge");
        }
    }
    
}

 

[huckleberry]

aber auch so kann man nicht unbedingt einfach in eine bestehende Verbindung etwas reinschicken

Mit dem obigen Server ging es mit netcat. Mein Java-Client sendet seine Challenge and den server, dieser empfängt diesen und sollte eig. mit einer Response antowrten.. *pustekuchen*

Transmit> RESPONSE;1389518;1152950;236568;1626086 > /10.251.145.71:2287
<< Connect ChallengeSocket!
Transmit Error IO: java.net.ConnectException: Connection refused: connect

Also der Server wartet auf accept() und benutzt diesen Socket auch als Antwortkanal. incommingPort passe ich bei ampfang an. Wie gesagt mit netcat ging es:

           responseServerSocket = new ServerSocket(CHALLENGE_COMPORT);
           responseServerSocket.setSoTimeout(5000);
           responseSocket = responseServerSocket.accept();
//...
}

public void transmit(String toBeSent) {
            try{
                 while (challengeSocket == null) {
                    challengeSocket = new Socket(responseSocket.getInetAddress(), incommingPort);
}

Auf dem Client liefert mir:

resultMsg = inData.readLine();    
System.out.println("server>" + resultMsg);

dann null, da Server ja die Antowrt-Connection refused.

 

[TheRealSpikee]

Du hast aber auch Grundlagen oder sowas ne ?

Wenn du einen Socket zu einem Ziel aufbaust verbindet sich dein Client mit einem zufälligem local-Port mit dem remote-Port des Zieles ... soweit so gut.

Und dann wird dieser Socket auch offen gehalten bis die Verbindung beendet wird.

Was du machst : Socket aufbauen ... Nachricht schicken ... Socket abbauen ... versuchen ne Antwort zu schicken ... DAS GEHT NICHT !

Du musst schon mit dem Socket arbeiten den deine App aufgebaut hat ... also brauchst du erstmal sowas wie n ECHO-Server der das macht ...


GRUNDLAGEN !!! -> JavaInsel ...

 

[huckleberry]

Yo Danke, des wars.