Dynamically determine ICE agent's role

Author: mickel8

lib/ex_webrtc/ice_transport.ex

@@ -5,16 +5,18 @@ defmodule ExWebRTC.ICETransport do
   @type t() :: module()
   @type state() :: :checking | :connected | :completed | :failed
 
-  @callback start_link(ExICE.ICEAgent.role(), Keyword.t()) :: {:ok, pid()}
+  @callback start_link(Keyword.t()) :: {:ok, pid()}
   @callback on_data(pid(), pid()) :: :ok
   @callback add_remote_candidate(pid(), candidate :: String.t()) :: :ok
   @callback end_of_candidates(pid()) :: :ok
   @callback gather_candidates(pid()) :: :ok
   @callback get_local_credentials(pid()) :: {:ok, ufrag :: binary(), pwd :: binary()}
   @callback get_local_candidates(pid()) :: [binary()]
   @callback get_remote_candidates(pid()) :: [binary()]
+  @callback get_role(pid()) :: ExICE.ICEAgent.role() | nil
   @callback restart(pid()) :: :ok
   @callback send_data(pid(), binary()) :: :ok
+  @callback set_role(pid(), ExICE.ICEAgent.role()) :: :ok
   @callback set_remote_credentials(pid(), ufrag :: binary(), pwd :: binary()) :: :ok
   @callback get_stats(pid()) :: map()
   @callback stop(pid()) :: :ok
@@ -28,7 +30,7 @@ defmodule ExWebRTC.DefaultICETransport do
   alias ExICE.ICEAgent
 
   @impl true
-  defdelegate start_link(role, opts), to: ICEAgent
+  defdelegate start_link(opts), to: ICEAgent
   @impl true
   defdelegate on_data(pid, dst_pid), to: ICEAgent
   @impl true
@@ -38,6 +40,8 @@ defmodule ExWebRTC.DefaultICETransport do
   @impl true
   defdelegate gather_candidates(pid), to: ICEAgent
   @impl true
+  defdelegate get_role(pid), to: ICEAgent
+  @impl true
   defdelegate get_local_credentials(pid), to: ICEAgent
   @impl true
   defdelegate get_local_candidates(pid), to: ICEAgent
@@ -48,6 +52,8 @@ defmodule ExWebRTC.DefaultICETransport do
   @impl true
   defdelegate send_data(pid, data), to: ICEAgent
   @impl true
+  defdelegate set_role(pid, role), to: ICEAgent
+  @impl true
   defdelegate set_remote_credentials(pid, ufrag, pwd), to: ICEAgent
   @impl true
   defdelegate get_stats(pid), to: ICEAgent

lib/ex_webrtc/peer_connection.ex

@@ -577,7 +577,7 @@ defmodule ExWebRTC.PeerConnection do
       on_data: nil
     ]
 
-    {:ok, ice_pid} = DefaultICETransport.start_link(:controlled, ice_config)
+    {:ok, ice_pid} = DefaultICETransport.start_link(ice_config)
     {:ok, dtls_transport} = DTLSTransport.start_link(DefaultICETransport, ice_pid)
     # route data to the DTLSTransport
     :ok = DefaultICETransport.on_data(ice_pid, dtls_transport)
@@ -1188,7 +1188,7 @@ defmodule ExWebRTC.PeerConnection do
         timestamp: timestamp,
         ice_state: ice_stats.state,
         ice_gathering_state: state.ice_gathering_state,
-        ice_role: ice_stats.role,
+        ice_role: ice_stats.role || :unknown,
         ice_local_ufrag: ice_stats.local_ufrag,
         dtls_state: state.dtls_state,
         bytes_sent: ice_stats.bytes_sent,
@@ -1361,6 +1361,8 @@ defmodule ExWebRTC.PeerConnection do
   def handle_info({:dtls_transport, _pid, {:state_change, new_dtls_state}}, state) do
     next_conn_state = next_conn_state(state.ice_state, new_dtls_state)
 
+    notify(state.owner, {:dtls_state_change, new_dtls_state})
+
     state =
       %{state | dtls_state: new_dtls_state}
       |> update_conn_state(next_conn_state)
@@ -1717,6 +1719,13 @@ defmodule ExWebRTC.PeerConnection do
     with {:ok, next_sig_state} <- next_signaling_state(state.signaling_state, :local, type),
          :ok <- check_altered(type, raw_sdp, state),
          {:ok, sdp} <- parse_sdp(raw_sdp) do
+      # See: https://www.w3.org/TR/webrtc/#ref-for-dfn-icerole-1
+      # Also, this has to be before gathering candidates.
+      # Note: If we add support for ice-lite, this code needs to be adjusted.
+      if state.ice_transport.get_role(state.ice_pid) == nil and type == :offer do
+        :ok = state.ice_transport.set_role(state.ice_pid, :controlling)
+      end
+
       if state.ice_gathering_state == :new do
         state.ice_transport.gather_candidates(state.ice_pid)
       end
@@ -1755,10 +1764,23 @@ defmodule ExWebRTC.PeerConnection do
          {:ok, sdp} <- parse_sdp(raw_sdp),
          :ok <- SDPUtils.ensure_valid(sdp),
          {:ok, ice_creds} <- SDPUtils.get_ice_credentials(sdp),
+         ice_lite <- SDPUtils.get_ice_lite(sdp),
          {:ok, {:fingerprint, {:sha256, peer_fingerprint}}} <- SDPUtils.get_cert_fingerprint(sdp),
          {:ok, dtls_role} <- SDPUtils.get_dtls_role(sdp) do
       config = Configuration.update(state.config, sdp)
 
+      # See: https://www.w3.org/TR/webrtc/#ref-for-dfn-icerole-1
+      # Note: If we add support for ice-lite, this code needs to be adjusted.
+      if state.ice_transport.get_role(state.ice_pid) == nil do
+        cond do
+          type == :offer and ice_lite == true ->
+            :ok = state.ice_transport.set_role(state.ice_pid, :controlling)
+
+          type == :offer and ice_lite == false ->
+            :ok = state.ice_transport.set_role(state.ice_pid, :controlled)
+        end
+      end
+
       twcc_id =
         (config.video_extensions ++ config.audio_extensions)
         |> Enum.find(&(&1.uri == @twcc_uri))

lib/ex_webrtc/peer_connection/configuration.ex

@@ -199,6 +199,7 @@ defmodule ExWebRTC.PeerConnection.Configuration do
                 ice_servers: [],
                 ice_transport_policy: :all,
                 ice_port_range: [0],
+                ice_role: :controlled,
                 audio_codecs: @default_audio_codecs,
                 video_codecs: @default_video_codecs,
                 features: @default_features

lib/ex_webrtc/sdp_utils.ex

@@ -139,6 +139,9 @@ defmodule ExWebRTC.SDPUtils do
     |> Enum.map(fn msid -> msid.id end)
   end
 
+  @spec get_ice_lite(ExSDP.t()) :: boolean()
+  def get_ice_lite(sdp), do: ExSDP.get_attribute(sdp, "ice-lite") != nil
+
   @spec get_ice_credentials(ExSDP.t()) ::
           {:ok, {binary(), binary()} | nil}
           | {:error,

mix.exs

@@ -57,7 +57,7 @@ defmodule ExWebRTC.MixProject do
   defp deps do
     [
       {:ex_sdp, "~> 1.0"},
-      {:ex_ice, "~> 0.10.0"},
+      {:ex_ice, github: "elixir-webrtc/ex_ice"},
       {:ex_dtls, "~> 0.16.0"},
       {:ex_libsrtp, "~> 0.7.1"},
       {:ex_rtp, "~> 0.4.0"},

mix.lock

@@ -12,7 +12,7 @@
   "erlex": {:hex, :erlex, "0.2.7", "810e8725f96ab74d17aac676e748627a07bc87eb950d2b83acd29dc047a30595", [:mix], [], "hexpm", "3ed95f79d1a844c3f6bf0cea61e0d5612a42ce56da9c03f01df538685365efb0"},
   "ex_doc": {:hex, :ex_doc, "0.37.0", "970f92b39e62c460aa8a367508e938f5e4da6e2ff3eaed3f8530b25870f45471", [:mix], [{:earmark_parser, "~> 1.4.42", [hex: :earmark_parser, repo: "hexpm", optional: false]}, {:makeup_c, ">= 0.1.0", [hex: :makeup_c, repo: "hexpm", optional: true]}, {:makeup_elixir, "~> 0.14 or ~> 1.0", [hex: :makeup_elixir, repo: "hexpm", optional: false]}, {:makeup_erlang, "~> 0.1 or ~> 1.0", [hex: :makeup_erlang, repo: "hexpm", optional: false]}, {:makeup_html, ">= 0.1.0", [hex: :makeup_html, repo: "hexpm", optional: true]}], "hexpm", "b0ee7f17373948e0cf471e59c3a0ee42f3bd1171c67d91eb3626456ef9c6202c"},
   "ex_dtls": {:hex, :ex_dtls, "0.16.0", "3ae38025ccc77f6db573e2e391602fa9bbc02253c137d8d2d59469a66cbe806b", [:mix], [{:bundlex, "~> 1.5.3", [hex: :bundlex, repo: "hexpm", optional: false]}, {:unifex, "~> 1.0", [hex: :unifex, repo: "hexpm", optional: false]}], "hexpm", "2a4e30d74c6ddf95cc5b796423293c06a0da295454c3823819808ff031b4b361"},
-  "ex_ice": {:hex, :ex_ice, "0.10.0", "cbfe28b01fea0dcb70b4c289db21e712bf22d26f63f32d6a67326d178dbdcaf5", [:mix], [{:elixir_uuid, "~> 1.0", [hex: :elixir_uuid, repo: "hexpm", optional: false]}, {:ex_stun, "~> 0.2.0", [hex: :ex_stun, repo: "hexpm", optional: false]}, {:ex_turn, "~> 0.2.0", [hex: :ex_turn, repo: "hexpm", optional: false]}], "hexpm", "1490f979d7eb47115a50ebb0bae7c06d13d22932aaf43e42088474582f2af705"},
+  "ex_ice": {:git, "https://github.com/elixir-webrtc/ex_ice.git", "b58aceee2641a35c3edfadaaef6fa9d7c48258d8", []},
   "ex_libsrtp": {:hex, :ex_libsrtp, "0.7.2", "211bd89c08026943ce71f3e2c0231795b99cee748808ed3ae7b97cd8d2450b6b", [:mix], [{:bunch, "~> 1.6", [hex: :bunch, repo: "hexpm", optional: false]}, {:bundlex, "~> 1.3", [hex: :bundlex, repo: "hexpm", optional: false]}, {:membrane_precompiled_dependency_provider, "~> 0.1.0", [hex: :membrane_precompiled_dependency_provider, repo: "hexpm", optional: false]}, {:unifex, "~> 1.1", [hex: :unifex, repo: "hexpm", optional: false]}], "hexpm", "2e20645d0d739a4ecdcf8d4810a0c198120c8a2f617f2b75b2e2e704d59f492a"},
   "ex_rtcp": {:hex, :ex_rtcp, "0.4.0", "f9e515462a9581798ff6413583a25174cfd2101c94a2ebee871cca7639886f0a", [:mix], [], "hexpm", "28956602cf210d692fcdaf3f60ca49681634e1deb28ace41246aee61ee22dc3b"},
   "ex_rtp": {:hex, :ex_rtp, "0.4.0", "1f1b5c1440a904706011e3afbb41741f5da309ce251cb986690ce9fd82636658", [:mix], [], "hexpm", "0f72d80d5953a62057270040f0f1ee6f955c08eeae82ac659c038001d7d5a790"},

test/ex_webrtc/dtls_transport_test.exs

@@ -23,7 +23,7 @@ defmodule ExWebRTC.DTLSTransportTest do
     use GenServer
 
     @impl true
-    def start_link(_mode, config), do: GenServer.start_link(__MODULE__, config)
+    def start_link(config), do: GenServer.start_link(__MODULE__, config)
 
     @impl true
     def on_data(ice_pid, dst_pid), do: GenServer.call(ice_pid, {:on_data, dst_pid})
@@ -40,6 +40,11 @@ defmodule ExWebRTC.DTLSTransportTest do
     @impl true
     def gather_candidates(ice_pid), do: ice_pid
 
+    @impl true
+    def get_role(ice_pid) do
+      GenServer.call(ice_pid, :get_role)
+    end
+
     @impl true
     def get_local_credentials(_state), do: {:ok, "testufrag", "testpwd"}
 
@@ -55,6 +60,11 @@ defmodule ExWebRTC.DTLSTransportTest do
     @impl true
     def set_remote_credentials(ice_pid, _ufrag, _pwd), do: ice_pid
 
+    @impl true
+    def set_role(ice_pid, role) do
+      GenServer.cast(ice_pid, {:set_role, role})
+    end
+
     @impl true
     def get_stats(_ice_pid), do: %{}
 
@@ -65,13 +75,23 @@ defmodule ExWebRTC.DTLSTransportTest do
 
     @impl true
     def init(tester: tester),
-      do: {:ok, %{on_data_dst: nil, tester: tester}}
+      do: {:ok, %{role: nil, on_data_dst: nil, tester: tester}}
 
     @impl true
     def handle_call({:on_data, dst_pid}, _from, state) do
       {:reply, :ok, %{state | on_data_dst: dst_pid}}
     end
 
+    @impl true
+    def handle_call(:get_role, _from, state) do
+      {:reply, state.role, state}
+    end
+
+    @impl true
+    def handle_cast({:set_role, role}, state) do
+      {:noreply, %{state | role: role}}
+    end
+
     @impl true
     def handle_cast({:send_data, data}, state) do
       send(state.tester, {:mock_ice, data})
@@ -86,7 +106,7 @@ defmodule ExWebRTC.DTLSTransportTest do
   end
 
   setup do
-    {:ok, ice_pid} = MockICETransport.start_link(:controlled, tester: self())
+    {:ok, ice_pid} = MockICETransport.start_link(tester: self())
     assert {:ok, dtls} = DTLSTransport.start_link(MockICETransport, ice_pid)
     MockICETransport.on_data(ice_pid, dtls)
     assert_receive {:dtls_transport, ^dtls, {:state_change, :new}}

test/ex_webrtc/peer_connection_test.exs

@@ -970,7 +970,7 @@ defmodule ExWebRTC.PeerConnectionTest do
     assert is_binary(stats.local_certificate.fingerprint)
     assert is_binary(stats.local_certificate.base64_certificate)
 
-    assert stats.transport.ice_role in [:controlling, :controlled]
+    assert stats.transport.ice_role == :unknown
     assert is_binary(stats.transport.ice_local_ufrag)
 
     groups = Enum.group_by(Map.values(stats), & &1.type)