Sockets: How can server detect that client is no longer connected?

Question

Hi,
I really need help and advice with the following problem:
I have a Client - Server socket program.
The server listens on port 30000 using a server socket on one machine
The client connects to localhost on port 20000, previously creating an ssh port forward connection using the Jsch package from www.jcraft.com with
"session.setPortForwardingL(20000, addr, 30000);"
Then the client sends Strings to the server using a PrintWriter.
Both are connected to each other through the internet and the server uses a dynamic dns service.
This all works well until the IP address of the Server changes, The client successfully reconnects to the server using the dynamic dns domain name, but the server keeps listening on the old socket from the previous connection, while opening a new one for the new client connection. The server doesn't seem to notice that Client has disconnected because of this IP address change.
looks like the server is stuck inside the while loop. If i cut the connection manually on the client side, the server seems to notice that the client has disconnected, and jumps out of the while look (see code below)
this is the code I'm using for the server:
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;
import java.util.logging.Logger ;
public class SocketHandler extends Thread {
    static Logger logger = Logger.getLogger("Server.SocketHandler");
    private Socket clientSocket = null;
    private BufferedReader in = null;
    private InputStreamReader inReader = null;
    public SocketHandler(Socket clientSocket) throws IOException {
        this.clientSocket = clientSocket;
        inReader = new InputStreamReader(clientSocket.getInputStream ());
        in = new BufferedReader(inReader);
    public void run() {
        try {
            String clientMessage = null;
            while ((clientMessage = in.readLine()) != null) {
                logger.info("client says: " + clientMessage);
        } catch (IOException e) {
            logger.severe(e.getMessage());
            e.printStackTrace();
        } finally {
            try {
                logger.info("closing client Socket: " + clientSocket);
                clientSocket.close();
                in.close();
                ServerRunner.list.remove(clientSocket);
                logger.info("currently "+ServerRunner.list.size()+" clients connected");
            } catch (IOException e) {
                logger.severe (e.getMessage());
                e.printStackTrace();
}I've tried making the server create some artificial traffing by writing some byte every few seconds into the clients OutputStream. However I get no exceptions when the IP address changes. The server doesn't detect a disconnected socket connection.
I'd really appreciate help and advice

Answer 1

If a TCP/IP peer is shut down "uncleanly", the other end of the connection doesn't get the final end of connection packet, and read() will wait forever. close() sends the final packet, as will killing the peer process (the OS does the close()). But if the OS crashes or for some other reason can't send the final packet, the server never gets notification that the peer has gone away.
Like you say, one way is timeout, if the protocol is such that there always is something coming in at regular intervals.
The other way is a heartbeat. Write something to the other end periodically, just some kind of "hello, I'm here, ignore this message". The other end doesn't even have to answer. If the peer has gone away, TCP will retransmit your heartbeat message a few times. After about a minute it will give up, and mark the socket as broken. read() will then throw an IOException. You could send heartbeats from the client too, so that the client detects if the server computer dies.
TCP/IP also has a TCP-level heartbeat; see Socket.setKeepAlive(). The heartbeat interval is about two hours, so it takes it a while to detect broken connections.