Madness

A query-only mDNS (multicast DNS) client for Elixir.

Madness sends DNS queries over multicast UDP and returns responses as lazy streams or asynchronous messages. It supports both IPv4 and IPv6 networks.

Features

• Stream and message modes - Consume responses as a lazy Stream or receive them as process messages
• IPv4 and IPv6 - Full support for both address families
• Automatic record parsing - A, AAAA, PTR, SRV, TXT, CNAME, NS, MX, SOA, NSEC
• Additional records included - Responses include records from the Additional section
• NSEC early termination - Queries complete early when negative responses are received
• Multi-interface support - Query on all interfaces or a specific one
• Unicast responses - QU bit support for reduced network traffic

Installation

Add madness to your list of dependencies in mix.exs:

def deps do
  [
    {:madness, "~> 0.1.0"}
  ]
end

Quick Start

# Discover HTTP services on the local network
Madness.request({"_http._tcp.local", :ptr})
|> Enum.to_list()

# Get the address of a specific device
Madness.request({"mydevice.local", :a})
|> Enum.take(1)

# Query for multiple record types at once
Madness.request([
  {"mydevice.local", :a},
  {"mydevice.local", :aaaa}
])
|> Enum.to_list()

Usage

Stream Mode (default)

Returns a lazy stream that yields Madness.Record structs:

Madness.request({"_http._tcp.local", :ptr})
|> Stream.filter(&(&1.type == :ptr))
|> Enum.to_list()

Message Mode

Returns {:ok, ref} and sends messages to the calling process:

{:ok, ref} = Madness.request({"_http._tcp.local", :ptr}, into: :self)

receive do
  {^ref, %Madness.Record{} = record} -> IO.inspect(record)
  {^ref, :done} -> IO.puts("Query complete")
end

This mode is useful for GenServer integration:

def handle_info({ref, %Madness.Record{} = record}, state) do
  # Process record...
  {:noreply, state}
end

def handle_info({ref, :done}, state) do
  # Query complete
  {:noreply, state}
end

Options

Additional Records

mDNS responders typically include related records in the Additional section. For example, a PTR query response often includes SRV, TXT, and address records:

Madness.request({"_http._tcp.local", :ptr})
|> Enum.group_by(& &1.type)
# => %{
#   ptr: [%Record{data: "MyServer._http._tcp.local", ...}],
#   srv: [%Record{data: {0, 0, 80, "myserver.local"}, ...}],
#   txt: [%Record{data: ["path=/"], ...}],
#   a: [%Record{data: {192, 168, 1, 100}, ...}]
# }

Check metadata.section to distinguish :answer from :additional records.

Early Termination

For non-PTR queries, Madness exits early when all questions are answered. This includes NSEC negative responses - if a device responds with an NSEC record indicating a record type doesn’t exist, the query completes without waiting for the full timeout.

PTR queries always wait for the timeout since multiple responders may reply.

Common Service Types

Record Types

License

MIT