Don't terminate PeerConnection after moving to the failed state

Author: mickel8

examples/chat/lib/chat/peer_handler.ex

@@ -103,6 +103,16 @@ defmodule Chat.PeerHandler do
     {:push, {:text, msg}, state}
   end
 
+  defp handle_webrtc_msg({:connection_state_change, conn_state}, state) do
+    Logger.info("Connection state changed: #{conn_state}")
+
+    if conn_state == :failed do
+      {:stop, {:shutdown, :pc_failed}, state}
+    else
+      {:ok, state}
+    end
+  end
+
   defp handle_webrtc_msg({:data_channel, %DataChannel{ref: ref}}, state) do
     state = %{state | channel_ref: ref}
     {:ok, state}

examples/echo/lib/echo/peer_handler.ex

@@ -112,6 +112,16 @@ defmodule Echo.PeerHandler do
     {:ok, state}
   end
 
+  defp handle_webrtc_msg({:connection_state_change, conn_state}, state) do
+    Logger.info("Connection state changed: #{conn_state}")
+
+    if conn_state == :failed do
+      {:stop, {:shutdown, :pc_failed}, state}
+    else
+      {:ok, state}
+    end
+  end
+
   defp handle_webrtc_msg({:ice_candidate, candidate}, state) do
     candidate_json = ICECandidate.to_json(candidate)
 

examples/save_to_file/lib/save_to_file/peer_handler.ex

@@ -133,6 +133,16 @@ defmodule SaveToFile.PeerHandler do
     {:ok, state}
   end
 
+  defp handle_webrtc_msg({:connection_state_change, conn_state}, state) do
+    Logger.info("Connection state changed: #{conn_state}")
+
+    if conn_state == :failed do
+      {:stop, {:shutdown, :pc_failed}, state}
+    else
+      {:ok, state}
+    end
+  end
+
   defp handle_webrtc_msg({:ice_candidate, candidate}, state) do
     candidate_json = ICECandidate.to_json(candidate)
 

examples/send_from_file/lib/send_from_file/peer_handler.ex

@@ -225,6 +225,16 @@ defmodule SendFromFile.PeerHandler do
     :ok = PeerConnection.add_ice_candidate(state.peer_connection, candidate)
   end
 
+  defp handle_webrtc_msg({:connection_state_change, conn_state}, state) do
+    Logger.info("Connection state changed: #{conn_state}")
+
+    if conn_state == :failed do
+      {:stop, {:shutdown, :pc_failed}, state}
+    else
+      {:ok, state}
+    end
+  end
+
   defp handle_webrtc_msg({:ice_candidate, candidate}, state) do
     candidate_json = ICECandidate.to_json(candidate)
 

examples/whip_whep/lib/whip_whep/forwarder.ex

@@ -91,6 +91,16 @@ defmodule WhipWhep.Forwarder do
     {:noreply, state}
   end
 
+  @impl true
+  def handle_info({:ex_webrtc, pc, {:connection_state_change, :failed}}, state) do
+    Logger.info("Output peer connection #{inspect(pc)} failed")
+    :ok = PeerConnection.close(pc)
+    pending_outputs = List.delete(state.pending_outputs, pc)
+    outputs = Map.delete(state.outputs, pc)
+    state = %{state | pending_outputs: pending_outputs, outputs: outputs}
+    {:ok, state}
+  end
+
   @impl true
   def handle_info(
         {:ex_webrtc, input_pc, {:rtp, id, nil, packet}},

lib/ex_webrtc/dtls_transport.ex

@@ -163,7 +163,7 @@ defmodule ExWebRTC.DTLSTransport do
 
     if state.buffered_local_packets do
       Logger.debug("Sending buffered DTLS packets")
-      :ok = do_send(state, state.buffered_local_packets)
+      # :ok = do_send(state, state.buffered_local_packets)
       state = %{state | buffered_local_packets: nil}
       {:reply, :ok, state}
     else
@@ -251,12 +251,12 @@ defmodule ExWebRTC.DTLSTransport do
 
   @impl true
   def handle_cast({:send_rtp, _data}, state) do
-    Logger.warning("Attempted to send RTP before DTLS handshake has been finished. Ignoring.")
+    Logger.debug("Attempted to send RTP in wrong DTLS state: #{state.dtls_state}. Ignoring.")
     {:noreply, state}
   end
 
   @impl true
-  def handle_cast({:send_rtcp, data}, state) do
+  def handle_cast({:send_rtcp, data}, %{dtls_state: :connected, ice_connected: true} = state) do
     case ExLibSRTP.protect_rtcp(state.out_srtp, data) do
       {:ok, protected} -> do_send(state, protected)
       {:error, reason} -> Logger.warning("Unable to protect RTCP: #{inspect(reason)}")
@@ -266,7 +266,13 @@ defmodule ExWebRTC.DTLSTransport do
   end
 
   @impl true
-  def handle_cast({:send_data, data}, state) do
+  def handle_cast({:send_rtcp, _data}, state) do
+    Logger.debug("Attempted to send RTCP in wrong DTLS state: #{state.dtls_state}. Ignoring.")
+    {:noreply, state}
+  end
+
+  @impl true
+  def handle_cast({:send_data, data}, %{dtls_state: :connected, ice_connected: true} = state) do
     case ExDTLS.write_data(state.dtls, data) do
       {:ok, protected} -> do_send(state, protected)
       {:error, reason} -> Logger.warning("Unable to protect data: #{inspect(reason)}")
@@ -275,6 +281,12 @@ defmodule ExWebRTC.DTLSTransport do
     {:noreply, state}
   end
 
+  @impl true
+  def handle_cast({:send_data, _data}, state) do
+    Logger.debug("Attempted to send data in wrong DTLS state: #{state.dtls_state}. Ignoring.")
+    {:noreply, state}
+  end
+
   @impl true
   def handle_cast({:set_packet_loss, value}, state) do
     state = %{state | packet_loss: value}
@@ -285,7 +297,7 @@ defmodule ExWebRTC.DTLSTransport do
   def handle_info(:dtls_timeout, %{buffered_local_packets: buffered_local_packets} = state) do
     case ExDTLS.handle_timeout(state.dtls) do
       {:retransmit, packets, timeout} when state.ice_connected ->
-        do_send(state, packets)
+        # do_send(state, packets)
         Logger.debug("Retransmitted DTLS packets")
         Process.send_after(self(), :dtls_timeout, timeout)
 
@@ -312,9 +324,13 @@ defmodule ExWebRTC.DTLSTransport do
   @impl true
   def handle_info({:ex_ice, _from, {:data, _data} = msg}, state) do
     case handle_ice_data(msg, state) do
-      {:ok, state} -> {:noreply, state}
-      # we use shutdown to avoid logging an error
-      {:error, reason} -> {:stop, {:shutdown, reason}, state}
+      {:ok, state} ->
+        {:noreply, state}
+
+      {:error, reason} ->
+        # See W3C WebRTC sec. 5.5.
+        state = update_dtls_state(state, :failed)
+        {:noreply, state}
     end
   end
 
@@ -339,7 +355,7 @@ defmodule ExWebRTC.DTLSTransport do
   defp handle_ice_data({:data, <<f, _rest::binary>> = data}, state) when f in 20..63 do
     case ExDTLS.handle_data(state.dtls, data) do
       {:handshake_packets, packets, timeout} when state.ice_connected ->
-        :ok = do_send(state, packets)
+        # :ok = do_send(state, packets)
         Process.send_after(self(), :dtls_timeout, timeout)
         state = update_dtls_state(state, :connecting)
         {:ok, state}
@@ -358,7 +374,7 @@ defmodule ExWebRTC.DTLSTransport do
       {:handshake_finished, lkm, rkm, profile, packets} ->
         Logger.debug("DTLS handshake finished")
         state = update_remote_cert_info(state)
-        do_send(state, packets)
+        # do_send(state, packets)
 
         peer_fingerprint =
           state.dtls

lib/ex_webrtc/peer_connection.ex

@@ -409,7 +409,7 @@ defmodule ExWebRTC.PeerConnection do
 
   For more information, refer to the [RTCPeerConnection: createOffer() method](https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/createOffer).
   """
-  @spec create_offer(peer_connection(), restart_ice?: boolean()) ::
+  @spec create_offer(peer_connection(), ice_restart: boolean()) ::
           {:ok, SessionDescription.t()} | {:error, term()}
   def create_offer(peer_connection, options \\ []) do
     GenServer.call(peer_connection, {:create_offer, options})
@@ -1186,7 +1186,8 @@ defmodule ExWebRTC.PeerConnection do
   end
 
   @impl true
-  def handle_cast({:send_rtp, track_id, packet, opts}, state) do
+  def handle_cast({:send_rtp, track_id, packet, opts}, %{conn_state: conn_state} = state)
+      when conn_state != :failed do
     rtx? = Keyword.get(opts, :rtx?, false)
 
     # TODO: iterating over transceivers is not optimal
@@ -1238,7 +1239,13 @@ defmodule ExWebRTC.PeerConnection do
   end
 
   @impl true
-  def handle_cast({:send_pli, track_id, rid}, state) do
+  def handle_cast({:send_rtp, _track_id, packet, opts}, state) do
+    {:noreply, state}
+  end
+
+  @impl true
+  def handle_cast({:send_pli, track_id, rid}, %{conn_state: conn_state} = state)
+      when conn_state != :failed do
     state.transceivers
     |> Enum.with_index()
     |> Enum.find(fn {tr, _idx} -> tr.receiver.track.id == track_id end)
@@ -1265,7 +1272,13 @@ defmodule ExWebRTC.PeerConnection do
   end
 
   @impl true
-  def handle_cast({:send_data, channel_ref, data_type, data}, state) do
+  def handle_cast({:send_pli, _track_id, _rid}, state) do
+    {:noreply, state}
+  end
+
+  @impl true
+  def handle_cast({:send_data, channel_ref, data_type, data}, %{conn_state: conn_state} = state)
+      when conn_state != :failed do
     {events, sctp_transport} =
       SCTPTransport.send(state.sctp_transport, channel_ref, data_type, data)
 
@@ -1274,6 +1287,11 @@ defmodule ExWebRTC.PeerConnection do
     {:noreply, %{state | sctp_transport: sctp_transport}}
   end
 
+  @impl true
+  def handle_cast({:send_data, _channel_ref, _data_type, _data}, state) do
+    {:noreply, state}
+  end
+
   @impl true
   def handle_cast({:set_packet_loss, packet_loss}, state) do
     DTLSTransport.set_packet_loss(state.dtls_transport, packet_loss)
@@ -1294,7 +1312,7 @@ defmodule ExWebRTC.PeerConnection do
 
     if next_conn_state == :failed do
       Logger.debug("Stopping PeerConnection")
-      {:stop, {:shutdown, :conn_state_failed}, state}
+      {:noreply, state}
     else
       {:noreply, state}
     end