Don't terminate PeerConnection after moving to the failed state

Author: mickel8

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/save_to_file/priv/static/script.js

@@ -18,6 +18,10 @@ button.onclick = () => {
 
 const start_connection = async (ws) => {
   const pc = new RTCPeerConnection(pcConfig);
+  window.pc = pc;
+  pc.onconnectionstatechange = () => {
+    console.log(pc.connectionState);
+  }
   pc.onicecandidate = event => {
     if (event.candidate === null) return;
 

lib/ex_webrtc/dtls_transport.ex

@@ -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}
@@ -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
 

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