Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func Listen

func Listen(entries chan<- *ServiceEntry, exit chan struct{}) error

    Listen listens indefinitely for multicast updates

    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
        
        	// Port If it is not 0, replace the port 5353 with this port number.
        	Port int
        
        	// GetMachineIP is a function to return the IP of the local machine
        	GetMachineIP GetMachineIP
        	// LocalhostChecking if enabled asks the server to also send responses to 0.0.0.0 if the target IP
        	// is this host (as defined by GetMachineIP). Useful in case machine is on a VPN which blocks comms on non standard ports
        	LocalhostChecking bool
        }

          Config is used to configure the mDNS server

          type DNSSDService

          type DNSSDService struct {
          	MDNSService *MDNSService
          }

            DNSSDService is a service that complies with the DNS-SD (RFC 6762) and MDNS (RFC 6762) specs for local, multicast-DNS-based discovery.

            DNSSDService implements the Zone interface and wraps an MDNSService instance. To deploy an mDNS service that is compliant with DNS-SD, it's recommended to register only the wrapped instance with the server.

            Example usage:

                service := &mdns.DNSSDService{
                  MDNSService: &mdns.MDNSService{
            	       Instance: "My Foobar Service",
            	       Service: "_foobar._tcp",
            	       Port:    8000,
                   }
                 }
                 server, err := mdns.NewServer(&mdns.Config{Zone: service})
                 if err != nil {
                   log.Fatalf("Error creating server: %v", err)
                 }
                 defer server.Shutdown()
            

            func (*DNSSDService) Records

            func (s *DNSSDService) Records(q dns.Question) []dns.RR

              Records returns DNS records in response to a DNS question.

              This function returns the DNS response of the underlying MDNSService instance. It also returns a PTR record for a request for " _services._dns-sd._udp.<Domain>", as described in section 9 of RFC 6763 ("Service Type Enumeration"), to allow browsing of the underlying MDNSService instance.

              type GetMachineIP

              type GetMachineIP func() net.IP

                GetMachineIP is a func which returns the outbound IP of this machine. Used by the server to determine whether to attempt send the response on a local address

                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
                	TTL      uint32
                	// 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"
                      	Type                uint16               // Lookup type, defaults to dns.TypePTR
                      	Context             context.Context      // Context
                      	Timeout             time.Duration        // Lookup timeout, default 1 second. Ignored if Context is provided
                      	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
                          }

                            Server is an mDNS server 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) SendMulticast

                              func (s *Server) SendMulticast(msg *dns.Msg) error

                                SendMulticast us used to send a multicast response packet

                                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
                                  	InfoFields []string
                                  	TTL        int
                                  	Type       uint16
                                  
                                  	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