Why does gen_tcp not detect cable unplugs?

water

This code let’s me connect with a 2d camera.
I’m running Linux and I can read the messages from the TCP server on the camera.

But it never triggers :tcp_closed or :tcp_error which I’d expect to happen after unplugging the Ethernet cable (rj45).

When I do unplug the cable, the message stop coming in. After reconnecting the cable the messages come in again, without even mentioning the connection was temporarily severed.


defmodule TcpClient do
  use GenServer
  require Logger

  @con_opts [:binary, active: true, packet: :raw, send_timeout: 10000]
  @connect_timeout 2000
  @retry_interval 1000

  defmodule State do
    defstruct host: "localhost",
              port: 1234
  end

  def start_link(opts) do
    GenServer.start_link(__MODULE__, opts)
  end

  def init(opts) do
    state = opts_to_initial_state(opts)
    send(self(), :connect)
    {:ok, state}
  end

  def handle_info(:connect, state) do
    Logger.info("Connecting to #{state.host}:#{state.port}")

    case :gen_tcp.connect(state.host, state.port, @con_opts, @connect_timeout) do
      {:ok, _socket} ->
        Logger.info("Connected successfully to #{state.host}:#{state.port}")
        {:noreply, state}

      {:error, reason} ->
        Logger.warning(
          "Connection to #{state.host}:#{state.port} failed: #{inspect(reason)}. Will retry in #{@retry_interval}ms"
        )

        {:noreply, state, @retry_interval}
    end
  end

  def handle_info(:timeout, state) do
    send(self(), :connect)
    {:noreply, state}
  end

  def handle_info({:tcp_closed, _socket}, state) do
    Logger.info("Connection to #{state.host}:#{state.port} closed. Reconnecting...")
    send(self(), :connect)
    {:noreply, state}
  end

  def handle_info({:tcp_error, _socket, reason}, state) do
    Logger.info("Connection to #{state.host}:#{state.port} error: #{inspect(reason)}")
    send(self(), :connect)
    {:noreply, state}
  end

  def handle_info({:tcp, _socket, data}, state) do
    string =
      Regex.scan(~r/star;(\S+);stop/, data <> data, capture: :all_but_first)
      |> List.first()
      |> List.first()

    Logger.info("String: #{string}")
    {:noreply, state}
  end

  defp opts_to_initial_state(opts) do
    host = Keyword.get(opts, :host, "localhost") |> String.to_charlist()
    port = Keyword.fetch!(opts, :port)
    %State{host: host, port: port}
  end
end

5 comments

#gen-tcp #genserver #gen_tcp

0 367 5

2026-03-07 16:20:15 UTC

Showing Posts 1 to 5

Show Best Posts
Show All Posts (oldest first)
Show All Posts (newest first)

lud

I believe this is inherent to how tcp works. Connections are not something physical nor permanent, its just an agreement to send and receive messages.

I guess if you want to detect unplugs you would have to send ping messages every N seconds to detect failure to send/receive.

Post #1

al2o3cr

+1 @lud - the TCP connection only cares about if packets are moving through.

You’ll only get a :tcp_closed when either end explicitly says “close this connection”.

If the other end goes away without saying goodbye, you’ll get a :tcp_error when you try to send a packet (after waiting send_timeout)

Post #2

krasenyp

To elaborate a little further - TCP is at the transport layer of the network stack, while disconnecting the cable is a physical layer concern. There are two levels between them - the data link layer and the network layer.

Post #3

jhogberg

Erlang Core Team

To elaborate even further, it’s mathematically impossible to detect this in the general case, you cannot design a protocol that will do it reliably. The closest you can get is to send ping messages as @lud suggested, which has its own issues but is good enough for most real-world uses.

https://en.wikipedia.org/wiki/Two_Generals’_Problem

Post #4

water

Thanks for all feedback.

I tried a few thing and I think I found an approach, feedback appreciated.

I send a ping every 5 second:

        case :gen_tcp.send(socket, "PING") do
          :ok ->
            Logger.debug("Ping message sent successfully")
            # Schedule next ping
            Process.send_after(self(), :ping, @ping_interval)
            {:noreply, state}

          {:error, reason} ->
            Logger.warning("Failed to send ping message: #{inspect(reason)}")
            # Try to reconnect
            send(self(), :connect)
            {:noreply, state}
        end

It’s always :ok

[debug] Ping message sent successfully
[debug] Received ping
[debug] Ping message sent successfully
[debug] Received ping
[debug] Ping message sent successfully
[debug] Received ping

And capture a response:
def handle_info({:tcp, _socket, "0003L000000007\r\n0003?\r\n"}, state) do

Even after unplugging, I only see successful sends.
Of course it’s not giving a response.

[debug] Ping message sent successfully
[debug] Ping message sent successfully
[debug] Ping message sent successfully

I thought this would trigger an error somewhere, but it doesn’t.

I guess I’ll keep a state.counter and +1 after send, then -1 it after receive.
Check if this counter is to big to trigger a :detected_a_disconnect

Post #5

— All posts loaded —