# Prüfen, ob remote UDT Server erreichbar ist



## JuKu (31. Dez 2015)

Hallo liebe Community,

Gibt es eine Möglichkeit mit Java zu prüfen, ob ein remote UDT Port mit Timeout erreichbar ist?
In UDP wäre dies nicht so einfach, aber mit UDT sollte dies doch möglich sein, oder?
Wir nutzen für unser Projekt zwar sowieso Netty, ich würde diese kleine Sache aber nur mit Java bewältigen.
Es kann davon ausgegangen werden, dass auf dem Port entweder UDT läuft oder der Server nicht erreichbar ist.

Für TCP hatte ich dies wie folgt implementiert:


```
/**
* check, if the remote port is open
*
* @param hostname hostname or ip address
* @param port number of port to check
* @param timeout timeout in seconds
*/
public static boolean checkIfRemotePortAvailable (String hostname, int port, int timeout) throws SocketException {
    Socket s = new Socket();
    s.setReuseAddress(true);
    SocketAddress sa = new InetSocketAddress(hostname, port);

    try {
        s.connect(sa, timeout * 1000);
    } catch (IOException e) {
        return false;
    } finally {
        if (s.isConnected()) {
            try {
                s.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

            return true;
        } else {
            return false;
        }
    }
}
```

Da UDT auf UDP basiert, aber reliable ist, hatte ich mal folgendes für UDP versucht:


```
/**
* check, if the remote udp port is open
*
* @param hostname hostname or ip address
* @param port number of port to check
* @param timeout timeout in seconds
*
* @return true, if port is open
*/
public static boolean checkIfUDPPortIsOpen (String hostname, int port, int timeout) {
    try{
        //create inet address
        InetAddress address = InetAddress.getByName(hostname);

        byte [] bytes = new byte[128];
        DatagramSocket ds = new DatagramSocket();
        DatagramPacket dp = new DatagramPacket(bytes, bytes.length);
        ds.setSoTimeout(timeout);
        ds.connect(address, port);
        ds.send(dp);
        ds.isConnected();
        dp = new DatagramPacket(bytes, bytes.length);
        ds.receive(dp);
        ds.close();

        return true;
    } catch(InterruptedIOException e){
        //System.out.println("closed");
        return false;
    } catch(IOException e){
        //System.out.println("closed");
        return false;
    }
}
```

Dies funktionierte aber irgendwie nicht so richtig.


----------

