mdns

README

Forked from hashicorp/mdns with a selection of PRs merged, because they were starting to pile up and stagnate.

I'll add each author of a PR that's merged as a collaborator to this repo. See where that takes us.

mdns

Simple mDNS client/server library in Golang. mDNS or Multicast DNS can be used to discover services on the local network without the use of an authoritative DNS server. This enables peer-to-peer discovery. It is important to note that many networks restrict the use of multicasting, which prevents mDNS from functioning. Notably, multicast cannot be used in any sort of cloud, or shared infrastructure environment. However it works well in most office, home, or private infrastructure environments.

Using the library is very simple, here is an example of publishing a service entry:

package main

import (
	"github.com/Gaboose/mdns"
	"os"
)

func main() {

	// Setup our service export
	host, _ := os.Hostname()
	info := []string{"My awesome service"}
	service, _ := mdns.NewMDNSService(host, "_foobar._tcp", "", "", 8000, nil, info)

	// Create the mDNS server, defer shutdown
	server, _ := mdns.NewServer(&mdns.Config{Zone: service})

	defer server.Shutdown()
}

Doing a lookup for service providers is also very simple:

package main

import (
	"fmt"
	"github.com/Gaboose/mdns"
)

func main() {

	// Make a channel for results and start listening
	entriesCh := make(chan *mdns.ServiceEntry, 8)
	go func() {
		for entry := range entriesCh {
			fmt.Printf("Got new entry: %v\n", entry)
		}
	}()

	// Start the lookup
	err := mdns.Lookup("_foobar._tcp", entriesCh)
	if err != nil {
		fmt.Println(err)
	}

	close(entriesCh)
}

Documentation

Index

• Variables
• func Lookup(service string, entries chan<- *ServiceEntry) error
• func Query(params *QueryParam) error
• type Config
• type MDNSService
  • func NewMDNSService(instance, service, domain, hostName string, port int, ips []net.IP, ...) (*MDNSService, error)
  • func (m *MDNSService) Records(q dns.Question) []dns.RR
• type QueryParam
  • func DefaultParams(service string) *QueryParam
• type Server
  • func NewServer(config *Config) (*Server, error)
  • func (s *Server) Shutdown() error
• type ServiceEntry
• type Zone

Variables

var Log = log.New(os.Stderr, "", log.LstdFlags)

Functions

func Lookup

func Lookup(service string, entries chan<- *ServiceEntry) error

Lookup is the same as Query, however it uses all the default parameters

func Query

func Query(params *QueryParam) error

Query looks up a given service, in a domain, waiting at most for a timeout before finishing the query. The results are streamed to a channel. Sends will not block, so clients should make sure to either read or buffer.

Types

type Config

type Config struct {
	// Zone must be provided to support responding to queries
	Zone Zone

	// Iface if provided binds the multicast listener to the given
	// interface. If not provided, the system default multicase interface
	// is used.
	Iface *net.Interface
}

Config is used to configure the mDNS server

type MDNSService

type MDNSService struct {
	Instance string   // Instance name (e.g. "hostService name")
	Service  string   // Service name (e.g. "_http._tcp.")
	Domain   string   // If blank, assumes "local"
	HostName string   // Host machine DNS name (e.g. "mymachine.net.")
	Port     int      // Service Port
	IPs      []net.IP // IP addresses for the service's host
	TXT      []string // Service TXT records
	// contains filtered or unexported fields
}

MDNSService is used to export a named service by implementing a Zone

func NewMDNSService

func NewMDNSService(instance, service, domain, hostName string, port int, ips []net.IP, txt []string) (*MDNSService, error)

NewMDNSService returns a new instance of MDNSService.

If domain, hostName, or ips is set to the zero value, then a default value will be inferred from the operating system.

TODO(reddaly): This interface may need to change to account for "unique record" conflict rules of the mDNS protocol. Upon startup, the server should check to ensure that the instance name does not conflict with other instance names, and, if required, select a new name. There may also be conflicting hostName A/AAAA records.

func (*MDNSService) Records

func (m *MDNSService) Records(q dns.Question) []dns.RR

Records returns DNS records in response to a DNS question.

type QueryParam

type QueryParam struct {
	Service             string               // Service to lookup
	Domain              string               // Lookup domain, default "local"
	Timeout             time.Duration        // Lookup timeout, default 1 second
	Interface           *net.Interface       // Multicast interface to use
	Entries             chan<- *ServiceEntry // Entries Channel
	WantUnicastResponse bool                 // Unicast response desired, as per 5.4 in RFC
}

QueryParam is used to customize how a Lookup is performed

func DefaultParams

func DefaultParams(service string) *QueryParam

DefaultParams is used to return a default set of QueryParam's

type Server

type Server struct {
	// contains filtered or unexported fields
}

mDNS server is used to listen for mDNS queries and respond if we have a matching local record

func NewServer

func NewServer(config *Config) (*Server, error)

NewServer is used to create a new mDNS server from a config

func (*Server) Shutdown

func (s *Server) Shutdown() error

Shutdown is used to shutdown the listener

type ServiceEntry

type ServiceEntry struct {
	Name   string
	Host   string
	AddrV4 net.IP
	AddrV6 net.IP
	Port   int
	Info   string

	Addr net.IP // @Deprecated
	// contains filtered or unexported fields
}

ServiceEntry is returned after we query for a service

type Zone

type Zone interface {
	// Records returns DNS records in response to a DNS question.
	Records(q dns.Question) []dns.RR
}

Zone is the interface used to integrate with the server and to serve records dynamically