Add MDNS resolver

Author: mickel8

lib/ex_ice/app.ex

@@ -0,0 +1,10 @@
+defmodule ExICE.App do
+  @moduledoc false
+  use Application
+
+  @impl true
+  def start(_type, _args) do
+    children = [{ExICE.MDNS.Resolver, :gen_udp}]
+    Supervisor.start_link(children, strategy: :one_for_one)
+  end
+end

lib/ex_ice/candidate.ex

@@ -9,7 +9,7 @@ defmodule ExICE.Candidate do
 
   @type t() :: %__MODULE__{
           id: integer(),
-          address: :inet.ip_address(),
+          address: :inet.ip_address() | String.t(),
           base_address: :inet.ip_address() | nil,
           base_port: :inet.port_number() | nil,
           foundation: integer(),
@@ -36,7 +36,7 @@ defmodule ExICE.Candidate do
 
   @spec new(
           type(),
-          :inet.ip_address(),
+          :inet.ip_address() | String.t(),
           :inet.port_number(),
           :inet.ip_address() | nil,
           :inet.port_number() | nil,
@@ -90,7 +90,7 @@ defmodule ExICE.Candidate do
          {_component_id, ""} <- Integer.parse(c_str),
          {:ok, transport} <- parse_transport(String.downcase(tr_str)),
          {priority, ""} <- Integer.parse(pr_str),
-         {:ok, address} <- :inet.parse_address(String.to_charlist(a_str)),
+         {:ok, address} <- parse_address(a_str),
          {port, ""} <- Integer.parse(po_str),
          {:ok, type} <- parse_type(ty_str) do
       {:ok,
@@ -134,6 +134,14 @@ defmodule ExICE.Candidate do
   defp parse_transport("udp"), do: {:ok, :udp}
   defp parse_transport(_other), do: {:error, :invalid_transport}
 
+  defp parse_address(address) do
+    if String.ends_with?(address, ".local") do
+      {:ok, address}
+    else
+      :inet.parse_address(String.to_charlist(address))
+    end
+  end
+
   defp parse_type("host" <> _rest), do: {:ok, :host}
   defp parse_type("srflx" <> _rest), do: {:ok, :srflx}
   defp parse_type("prflx" <> _rest), do: {:ok, :prflx}

lib/ex_ice/dns/message.ex

@@ -42,7 +42,7 @@ defmodule ExICE.DNS.Message do
          {:ok, body, <<>>} <- decode_body(data, header) do
       header = Map.drop(header, [:qdcount, :ancount, :nscount, :arcount])
       msg = Map.merge(header, body)
-      struct!(__MODULE__, msg)
+      {:ok, struct!(__MODULE__, msg)}
     else
       _ -> :error
     end
@@ -153,37 +153,43 @@ defmodule ExICE.DNS.Message do
 
   defp decode_name(_, _), do: :error
 
-  defp decode_type(<<1::16, data::binary>>), do: {:ok, :a, data}
-  defp decode_type(<<2::16, data::binary>>), do: {:ok, :ns, data}
-  defp decode_type(<<3::16, data::binary>>), do: {:ok, :md, data}
-  defp decode_type(<<4::16, data::binary>>), do: {:ok, :mf, data}
-  defp decode_type(<<5::16, data::binary>>), do: {:ok, :cname, data}
-  defp decode_type(<<6::16, data::binary>>), do: {:ok, :soa, data}
-  defp decode_type(<<7::16, data::binary>>), do: {:ok, :mb, data}
-  defp decode_type(<<8::16, data::binary>>), do: {:ok, :mg, data}
-  defp decode_type(<<9::16, data::binary>>), do: {:ok, :mr, data}
-  defp decode_type(<<10::16, data::binary>>), do: {:ok, :null, data}
-  defp decode_type(<<11::16, data::binary>>), do: {:ok, :wks, data}
-  defp decode_type(<<12::16, data::binary>>), do: {:ok, :ptr, data}
-  defp decode_type(<<13::16, data::binary>>), do: {:ok, :hinfo, data}
-  defp decode_type(<<14::16, data::binary>>), do: {:ok, :minfo, data}
-  defp decode_type(<<15::16, data::binary>>), do: {:ok, :mx, data}
-  defp decode_type(<<16::16, data::binary>>), do: {:ok, :txt, data}
-  defp decode_type(<<252::16, data::binary>>), do: {:ok, :afxr, data}
-  defp decode_type(<<253::16, data::binary>>), do: {:ok, :mailb, data}
-  defp decode_type(<<254::16, data::binary>>), do: {:ok, :maila, data}
-  defp decode_type(<<255::16, data::binary>>), do: {:ok, :*, data}
+  defp decode_type(<<type::16, data::binary>>), do: {:ok, do_decode_type(type), data}
   defp decode_type(_), do: :error
 
+  defp do_decode_type(1), do: :a
+  defp do_decode_type(2), do: :ns
+  defp do_decode_type(3), do: :md
+  defp do_decode_type(4), do: :mf
+  defp do_decode_type(5), do: :cname
+  defp do_decode_type(6), do: :soa
+  defp do_decode_type(7), do: :mb
+  defp do_decode_type(8), do: :mg
+  defp do_decode_type(9), do: :mr
+  defp do_decode_type(10), do: :null
+  defp do_decode_type(11), do: :wks
+  defp do_decode_type(12), do: :ptr
+  defp do_decode_type(13), do: :hinfo
+  defp do_decode_type(14), do: :minfo
+  defp do_decode_type(15), do: :mx
+  defp do_decode_type(16), do: :txt
+  defp do_decode_type(252), do: :afxr
+  defp do_decode_type(253), do: :mailb
+  defp do_decode_type(254), do: :maila
+  defp do_decode_type(255), do: :*
+
   # In mDNS, the top bit has special meaning.
   # See RFC 6762, sec. 18.12 and 18.13.
-  defp decode_class(<<top_bit::1, 1::15, data::binary>>), do: {:ok, top_bit == 1, :in, data}
-  defp decode_class(<<top_bit::1, 2::15, data::binary>>), do: {:ok, top_bit == 1, :cs, data}
-  defp decode_class(<<top_bit::1, 3::15, data::binary>>), do: {:ok, top_bit == 1, :ch, data}
-  defp decode_class(<<top_bit::1, 4::15, data::binary>>), do: {:ok, top_bit == 1, :hs, data}
-  defp decode_class(<<top_bit::1, 255::15, data::binary>>), do: {:ok, top_bit == 1, :*, data}
+  defp decode_class(<<top_bit::1, class::15, data::binary>>),
+    do: {:ok, top_bit == 1, do_decode_class(class), data}
+
   defp decode_class(_), do: :error
 
+  defp do_decode_class(1), do: :in
+  defp do_decode_class(2), do: :cs
+  defp do_decode_class(3), do: :ch
+  defp do_decode_class(4), do: :hs
+  defp do_decode_class(255), do: :*
+
   defp decode_ttl(<<ttl::32, data::binary>>), do: {:ok, ttl, data}
   defp decode_ttl(_), do: :error
 

lib/ex_ice/ice_agent/impl.ex

@@ -235,17 +235,35 @@ defmodule ExICE.ICEAgent.Impl do
   def add_remote_candidate(ice_agent, remote_cand) do
     Logger.debug("New remote candidate: #{inspect(remote_cand)}")
 
-    case Candidate.unmarshal(remote_cand) do
-      {:ok, remote_cand} ->
-        ice_agent = do_add_remote_candidate(ice_agent, remote_cand)
-        Logger.debug("Successfully added remote candidate.")
+    resolve_address = fn
+      remote_cand when is_binary(remote_cand.address) ->
+        case ExICE.MDNS.Resolver.gethostbyname(remote_cand.address) do
+          {:ok, addr} ->
+            remote_cand = %Candidate{remote_cand | address: addr}
+            {:ok, remote_cand}
+
+          {:error, _reason} = err ->
+            err
+        end
 
-        ice_agent
-        |> update_connection_state()
-        |> update_ta_timer()
+      remote_cand ->
+        {:ok, remote_cand}
+    end
+
+    with {_, {:ok, remote_cand}} <- {:unmarshal, Candidate.unmarshal(remote_cand)},
+         {_, {:ok, remote_cand}} <- {:resolve_address, resolve_address.(remote_cand)} do
+      ice_agent = do_add_remote_candidate(ice_agent, remote_cand)
+      Logger.info("Successfully added remote candidate.")
+
+      ice_agent
+      |> update_connection_state()
+      |> update_ta_timer()
+    else
+      {operation, {:error, reason}} ->
+        Logger.warning("""
+        Invalid remote candidate. Couldn't #{operation}, reason: #{inspect(reason)}. Ignoring.
+        """)
 
-      {:error, reason} ->
-        Logger.warning("Invalid remote candidate, reason: #{inspect(reason)}. Ignoring.")
         ice_agent
     end
   end

lib/ex_ice/mdns/resolver.ex

@@ -0,0 +1,134 @@
+defmodule ExICE.MDNS.Resolver do
+  @moduledoc false
+  use GenServer, restart: :transient
+
+  require Logger
+
+  @mdns_port 5353
+  @multicast_addr {{224, 0, 0, 251}, @mdns_port}
+  @response_timeout_ms 300
+
+  @spec start_link(module()) :: GenServer.on_start()
+  def start_link(transport_module \\ :gen_udp) do
+    GenServer.start_link(__MODULE__, transport_module, name: __MODULE__)
+  end
+
+  @spec gethostbyname(String.t()) :: {:ok, :inet.ip_address()} | {:error, term()}
+  def gethostbyname(addr) do
+    try do
+      GenServer.call(__MODULE__, {:gethostbyname, addr})
+    catch
+      :exit, {:timeout, _} ->
+        {:error, :timeout}
+    end
+  end
+
+  @impl true
+  def init(transport_module) do
+    Logger.debug("Starting MDNS Resolver")
+    {:ok, %{transport_module: transport_module}, {:continue, nil}}
+  end
+
+  @impl true
+  def handle_continue(_, state) do
+    ret =
+      state.transport_module.open(
+        # Listen on the port specific to mDNS traffic.
+        # `add_membership` option only defines an address.
+        @mdns_port,
+        mode: :binary,
+        reuseaddr: true,
+        active: true,
+        # Allow other apps to bind to @mdns_port.
+        # If there are multiple sockets, bound to the same port,
+        # and subscribed to the same group (in fact, if one socket
+        # subscribes to some group, all other sockets bound to
+        # the same port also join this gorup), all those sockets
+        # will receive every message. In other words, `reuseport` for
+        # multicast works differently than for casual sockets.
+        reuseport: true,
+        # Support running two ICE agents on a single machine.
+        # In other case, our request won't be delivered to the mDNS address owner
+        # running on the same machine (e.g., a web browser).
+        multicast_loop: true,
+        # Receive responses - they are sent to the multicast address.
+        # The second argument specifies interfaces where we should listen
+        # for multicast traffic.
+        # This option works on interfaces i.e. it affects all sockets
+        # bound to the same port.
+        add_membership: {{224, 0, 0, 251}, {0, 0, 0, 0}}
+      )
+
+    case ret do
+      {:ok, socket} ->
+        state = Map.merge(state, %{socket: socket, queries: %{}})
+        {:noreply, state}
+
+      {:error, reason} ->
+        Logger.warning("""
+        Couldn't start MDNS resolver, reason: #{reason}. MDNS candidates won't be resolved.
+        """)
+
+        {:stop, {:shutdown, reason}, state}
+    end
+  end
+
+  @impl true
+  def handle_call({:gethostbyname, addr}, from, state) do
+    Logger.debug("Trying to resolve addr: #{addr}")
+
+    query =
+      %ExICE.DNS.Message{
+        question: [
+          %{
+            qname: addr,
+            qtype: :a,
+            qclass: :in,
+            unicast_response: false
+          }
+        ]
+      }
+      |> ExICE.DNS.Message.encode()
+
+    case state.transport_module.send(state.socket, @multicast_addr, query) do
+      :ok ->
+        state = put_in(state, [:queries, addr], from)
+        Process.send_after(self(), {:response_timeout, addr}, @response_timeout_ms)
+        {:noreply, state}
+
+      {:error, reason} ->
+        {:reply, {:error, reason}, state}
+    end
+  end
+
+  @impl true
+  def handle_info({:udp, _socket, _ip, _port, packet}, state) do
+    case ExICE.DNS.Message.decode(packet) do
+      # only accept query response with one resource record
+      {:ok, %{qr: true, aa: true, answer: [%{type: :a, class: :in, rdata: <<a, b, c, d>>} = rr]}} ->
+        {from, state} = pop_in(state, [:queries, rr.name])
+
+        if from do
+          addr = {a, b, c, d}
+          GenServer.reply(from, {:ok, addr})
+        end
+
+        {:noreply, state}
+
+      _other ->
+        {:noreply, state}
+    end
+  end
+
+  @impl true
+  def handle_info({:response_timeout, addr}, state) do
+    case pop_in(state, [:queries, addr]) do
+      {nil, state} ->
+        {:noreply, state}
+
+      {from, state} ->
+        GenServer.reply(from, {:error, :timeout})
+        {:noreply, state}
+    end
+  end
+end

mix.exs

@@ -33,7 +33,8 @@ defmodule ExICE.MixProject do
 
   def application do
     [
-      extra_applications: [:logger]
+      extra_applications: [:logger],
+      mod: {ExICE.App, []}
     ]
   end
 

test/dns/message_test.exs

@@ -34,8 +34,8 @@ defmodule ExICE.DNS.MessageTest do
       ]
     }
 
-    assert ExICE.DNS.Message.decode(@mdns_query) == query
-    assert ExICE.DNS.Message.encode(query) == @mdns_query
+    assert {:ok, query} == ExICE.DNS.Message.decode(@mdns_query)
+    assert @mdns_query == ExICE.DNS.Message.encode(query)
   end
 
   test "mdns query response" do
@@ -54,7 +54,7 @@ defmodule ExICE.DNS.MessageTest do
       ]
     }
 
-    assert ExICE.DNS.Message.decode(@mdns_query_response) == query_response
-    assert ExICE.DNS.Message.encode(query_response) == @mdns_query_response
+    assert {:ok, query_response} == ExICE.DNS.Message.decode(@mdns_query_response)
+    assert @mdns_query_response == ExICE.DNS.Message.encode(query_response)
   end
 end