# Verbindungsstatus prüfen



## Gast2 (20. Feb 2010)

Hi,
ich stelle mit meinem Java Programm eine Verbindung zu einem XPort her (Umsetzer von LAN auf RS232). Bisher prüfe ich den Verbindungsstatus indem ich in regelmäßigen Abständen eine 0x00 sende. Das funktioniert auch zuverlässig.
Ich vermute dass diese nullen irgendwo gepuffert werden und den XPort erst erreichen wenn dieser Daten weiterleiten soll (also die RS232 Handshakeleitungen geschlossen sind). Dann erreichen diese nullen auch den Empfänger auf RS232 Seite.
Nun kann es aber vorkommen dass eine lange Zeit lang keine Daten übertragen werden müssen. Plötzlich blockiert mein Programm dann beim Senden der nullen. Erst nachdem dann wieder Daten abgeholt werden läuft wieder alles weiter.
Ich vermute daher dass irgendwo ein Datenpuffer vollläuft, vermutlich auf PC Seite.

Gibt es eine andere Möglichkeit festzustellen ob die Gegenseite noch verbunden ist, die effektiver funktioniert?


----------



## MQue (20. Feb 2010)

Wo auch immer der Buffer überlaufen soll, bei deinem Programm solltest du nach jedem Senden ein flush machen, wenn du es noch nicht gemacht hast. 
Ansonsten musst du meiner Meinung nach schon ein eigenes Protokoll implementieren, dass dedektiert, ob noch eine Verbindung besteht. Eine Möglichkeit wäre noch, dass du einen Ping an die gegenüberliegende Seite sendest. 
Ansonsten würde ich das Senden noch in einen eigenen Thread geben, damit das Senden nicht die ganze Applikation blockiert. 
Wenn das alles nicht hilft, dann zeig mal code.


----------



## Gast2 (20. Feb 2010)

Hi,
danke für die Hinweise. Dieser Programmteil läuft bereits als Thread nen flush ist auch schon drin.

An nen Ping habe ich auch schon gedacht. Aber wie kann ich das implementieren?

Hier ist noch mein Thread welcher die Kommunikation regelt (wenn ich ihn auf das wichtigste kürzen soll bitte eben bescheid geben):


```
public abstract class BasicConnection extends Thread {
    /* log4j rootLogger laden */
    protected static Logger logger = Logger.getRootLogger();

    protected String ip;
    protected boolean running;
    protected int machineType;
    
    protected Socket socket;
    protected BufferedInputStream in;
    protected PrintStream out;
    protected String input;
    protected String realInput;
    protected boolean dataProcessed = false;
    
    /* Programmbuffer */
    protected ArrayList<String> programsToSend;
    
    public BasicConnection(Socket socket, String name, ThreadGroup threadgroup, int priority, int machineType) {
		/* Thread in die ThreadGroup eintragen */
        super(threadgroup, name);
	this.setPriority(priority);
       
        /* Daten übernehmen */
        this.socket = socket;
        this.machineType = machineType;

        /* IP Addresse extrahieren */
        ip = socket.getInetAddress().getHostAddress();

        /* Datenströme erstellen */
        try {
            in = new BufferedInputStream(socket.getInputStream());
            out = new PrintStream(socket.getOutputStream());
        } catch (IOException ioe) {
            logger.error("Datenströme konnten nicht erstellt werden", ioe);
        }

        /* Timeout setzen */
        try {
            socket.setSoTimeout(Settings.getInt("LAN", "timeout_millis")); // sind 500ms
        } catch (SocketException se) {
            logger.error("Es konnte kein Timeout festgelegt werden", se);
            return;
        }

        /* Programmbuffer initialisieren */
        programsToSend = new ArrayList<String>(5);
        
        running = true;
        start();
    }

    @Override
    public void run() {
        try {
            while (running) {
                try {
                    doInititalSendings();

                    /* eingelesene Daten zurücksetzen */
                    input = "";
                    if (Settings.getBoolean("DEBUG", "socketinput")) logger.debug("--- Lese von Socket ---");
                    while (true) {
                        /* Solange lesen bis Timeout auftritt */
                        int r = in.read();
                        if (Settings.getBoolean("DEBUG", "socketinput")) logger.debug(r);

                        input += (char)r;
                    }
                    
                } catch (SocketTimeoutException stoe) {
                    if (Settings.getBoolean("DEBUG", "socketinput")) logger.debug("--- Lesen der Daten beendet ---");
                    
                    dataProcessed = false;

                    long start = System.currentTimeMillis();
                    processData();
                    if (dataProcessed) logger.info("Daten wurden bearbeitet. Bearbeitungszeit: " + (System.currentTimeMillis() - start) + "ms");
                }
            }
        } catch (SocketException se) {
            logger.info("Verbindung zu " + ip + " wurde unterbrochen");
            logger.debug(null, se);
        } catch (IOException ioe) {
            logger.info("Es ist ein Verbindungsfehler aufgetreten bei: " + ip);
            logger.debug(null, ioe);
        } catch (Exception e) {
            logger.error("Nicht spezifizierter Verbindungsfehler aufgetreten bei: " + ip, e);
        } finally {
            /* Verbindung löschen */
            ConnectionManager.killConnection(ip);
            logger.debug("Connection ausgetragen: " + getName());
        }

        logger.info("Verbindungsthread '" + getName() + "' wurde beendet");
    }

    protected abstract void processData();
    protected abstract void doInititalSendings() throws IOException;

    protected boolean checkInput() {
        if (!RuleManager.checkInput(input)) {
            logger.info("Eingehendes Programm wurde abgewiesen");
            logger.debug("Eingehender Input: " + input);

            /* Eintrag im SocketMonitor hinterlassen */
            SocketMonitorManager.addSocketEvent(ip, "Server", input, "Abgewiesen (Regelverstoß)");

            return false;
        }
        return true;
    }
    protected String getZeros(int count) throws IOException {
        String zeros = "";
        for (int i = 0; i < count; i++) {
            zeros += (char)0;
        }
        return zeros;
    }
    protected void sendZeros(int count) throws IOException {
        for (int i = 0; i <= count; i++) {
            out.write(0);
        }
    }
    public void addProgramToSend(String programCode) {
        programsToSend.add(programCode);
    }

    protected String trimZeros(String input) {
        String result = input.replaceAll((char)0 + "", "");

        return result;
    }

    public void shutdown() {
        running = false;
        try {
            if (socket != null) socket.close();
            if (in != null) in.close();
            if (out != null) out.close();
        } catch (IOException ioe) {
            logger.error("", ioe);
        }
    }
    public String getIP() {
        return ip;
    }

    @Override
    public String toString() {
        return getName() + " [" + ip+ "]";
    }
}
```


----------



## MQue (21. Feb 2010)

Das ist z.B.: eine Möglichkeit:


```
String ip = "127.0.0.1";
Process p = Runtime.getRuntime().exec("ping -n 1 " + ip);
int status = p.waitFor();
System.out.println(ip + " is " + (status==0 ? "alive" : "dead"));
```


----------



## Gast2 (21. Feb 2010)

Danke, ich habs jetzt allerdings noch etwas anders gelöst, wobei mich deine antwort auf den richtigen Weg gebracht hat.
Die Box besitzt noch einen Port um Statusabfragen zu machen. An diesen Port schicke ich dann in regelmäßigen abständen nen paket welches dann auch von der box verarbeitet wird.


----------

