mirror of
https://github.com/soypat/lneto.git
synced 2026-09-10 16:49:37 +00:00
Add mdns package and Client implementation (#55)
* add mdns * define mdns.Client * fix some mdns stuff * refine dns package for use with mdns * remove Querier and Responder and replace with Client * add record setting methods on dns.record to reuse record buffer * protect against unbounded client answer growth * round off sharp mdns edges; reduce allocs * add mutlicast to stacks; add xnet tests for mdns * fix documentation on acceptmulticast field * mdns working
This commit is contained in:
Pat Whittingslow
GitHub
+263
@@ -0,0 +1,263 @@
|
||||
package mdns
|
||||
|
||||
import (
|
||||
"math"
|
||||
"net"
|
||||
|
||||
"github.com/soypat/lneto"
|
||||
"github.com/soypat/lneto/dns"
|
||||
"github.com/soypat/lneto/internal"
|
||||
)
|
||||
|
||||
const (
|
||||
// Port is the mDNS UDP port (RFC 6762 §1).
|
||||
Port = 5353
|
||||
|
||||
// Default TTL for mDNS records (RFC 6762 §11).
|
||||
DefaultTTL uint32 = 120
|
||||
// classCacheFlush is bit 15 of the Class field, indicating the record
|
||||
// is from a unique source and should replace cached entries (RFC 6762 §10.2).
|
||||
classCacheFlush uint16 = 1 << 15
|
||||
mdnsTxID = 0
|
||||
mdnsFlags = 0
|
||||
)
|
||||
|
||||
type querierState uint8
|
||||
|
||||
const (
|
||||
querierIdle querierState = iota
|
||||
querierSendQuery // Query ready to be sent.
|
||||
querierAwaitResponse // Waiting for answers.
|
||||
querierFailed // failed query
|
||||
querierDone // Answers collected.
|
||||
)
|
||||
|
||||
// Client provides both querying and service multicast DNS functionality
|
||||
// once configured and attached to MDNS port 5353.
|
||||
//
|
||||
// Clients are attached to MDNS ports and function until manual detachment
|
||||
// due to their dual design: they double as a querier and service discovery.
|
||||
type Client struct {
|
||||
connID uint64
|
||||
closed bool
|
||||
lport uint16
|
||||
ip []byte
|
||||
// Query State:
|
||||
qstate querierState
|
||||
qcode dns.RCode
|
||||
qerr error
|
||||
// qmsg is used for queries to marshal/unmarshal our
|
||||
// outgoing queries and responses to our queries.
|
||||
qans []dns.Resource
|
||||
qqst []dns.Question
|
||||
// Response state:
|
||||
services []Service // Stores services we'd broadcast.
|
||||
rans []dns.Resource
|
||||
rqst []dns.Question
|
||||
}
|
||||
|
||||
type ClientConfig struct {
|
||||
LocalPort uint16
|
||||
Services []Service
|
||||
MulticastAddr []byte
|
||||
}
|
||||
|
||||
func (c *Client) Configure(cfg ClientConfig) error {
|
||||
if cfg.LocalPort == 0 {
|
||||
return lneto.ErrZeroSource
|
||||
}
|
||||
c.reset(cfg.LocalPort)
|
||||
c.services = append(c.services[:0], cfg.Services...)
|
||||
c.ip = append(c.ip[:0], cfg.MulticastAddr...)
|
||||
internal.SliceReuse(&c.rqst, len(cfg.Services))
|
||||
// Each service can produce up to 4 answer records (PTR+SRV+TXT+A).
|
||||
nrans := 2 * len(cfg.Services)
|
||||
if nrans > 0 {
|
||||
nrans = max(4, nrans)
|
||||
}
|
||||
internal.SliceReuse(&c.rans, nrans)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (c *Client) Protocol() uint64 { return uint64(lneto.IPProtoUDP) }
|
||||
|
||||
func (c *Client) LocalPort() uint16 { return c.lport }
|
||||
|
||||
func (c *Client) ConnectionID() *uint64 { return &c.connID }
|
||||
|
||||
type ResolveConfig struct {
|
||||
Questions []dns.Question
|
||||
MaxResponseAnswers uint16
|
||||
}
|
||||
|
||||
func (c *Client) StartResolve(cfg ResolveConfig) error {
|
||||
nq := len(cfg.Questions)
|
||||
if nq > math.MaxUint16 || nq == 0 || cfg.MaxResponseAnswers == 0 {
|
||||
return lneto.ErrInvalidConfig
|
||||
}
|
||||
c.qreset(querierSendQuery)
|
||||
internal.SliceReuse(&c.qans, int(cfg.MaxResponseAnswers))
|
||||
internal.SliceReuse(&c.qqst, nq)
|
||||
c.qqst = c.qqst[:nq]
|
||||
for i := range c.qqst {
|
||||
c.qqst[i].CopyFrom(cfg.Questions[i])
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (c *Client) reset(localport uint16) {
|
||||
*c = Client{
|
||||
connID: c.connID + 1,
|
||||
lport: localport,
|
||||
// Ensure memory reused:
|
||||
qqst: c.qqst[:0],
|
||||
qans: c.qans[:0],
|
||||
services: c.services[:0],
|
||||
rans: c.rans[:0],
|
||||
ip: c.ip[:0],
|
||||
}
|
||||
}
|
||||
|
||||
// qreset resets the current query state. It is only a partial reset of a Client.
|
||||
func (c *Client) qreset(state querierState) {
|
||||
c.qstate = state
|
||||
}
|
||||
|
||||
// Encapsulate writes a pending mDNS packet into carrierData[offsetToFrame:].
|
||||
// Pending responses take priority over outgoing queries.
|
||||
func (c *Client) Encapsulate(carrierData []byte, offsetToIP, offsetToFrame int) (n int, err error) {
|
||||
if c.isClosed() {
|
||||
return 0, net.ErrClosed
|
||||
}
|
||||
if len(c.rans) > 0 {
|
||||
// Pending response to an incoming query.
|
||||
n, err = c.encapsResponse(carrierData[offsetToFrame:])
|
||||
} else if c.qstate == querierSendQuery {
|
||||
n, err = c.encapsQuery(carrierData[offsetToFrame:])
|
||||
}
|
||||
if n > 0 && offsetToIP >= 0 {
|
||||
// Set Multicast IP destination and Ethernet MAC.
|
||||
internal.SetMulticast(carrierData, offsetToIP, c.ip)
|
||||
}
|
||||
return n, err
|
||||
}
|
||||
|
||||
// Demux processes an incoming mDNS response packet. Answers are accumulated
|
||||
// into the internal message. Once sufficient answers are collected or a
|
||||
// timeout occurs the querier transitions to querierDone.
|
||||
func (c *Client) Demux(carrierData []byte, frameOffset int) error {
|
||||
if c.isClosed() {
|
||||
return net.ErrClosed
|
||||
}
|
||||
frame := carrierData[frameOffset:]
|
||||
f, err := dns.NewFrame(frame)
|
||||
if err != nil {
|
||||
return err
|
||||
} else if f.TxID() != 0 {
|
||||
return lneto.ErrPacketDrop
|
||||
}
|
||||
flags := f.Flags()
|
||||
isresponse := flags.IsResponse()
|
||||
if isresponse && c.qstate == querierAwaitResponse {
|
||||
c.qcode = flags.ResponseCode()
|
||||
// Decode response into our message, collecting answers.
|
||||
_, _, c.qerr = dns.DecodeMessage(nil, &c.qans, nil, nil, frame)
|
||||
if c.qerr != nil {
|
||||
c.qstate = querierFailed
|
||||
return c.qerr
|
||||
}
|
||||
c.qstate = querierDone
|
||||
return nil // success.
|
||||
}
|
||||
freeAns := cap(c.rans) - len(c.rans)
|
||||
if !isresponse && len(c.services) > 0 && freeAns > 0 {
|
||||
// Incoming query — match against our services.
|
||||
var query dns.Message
|
||||
query.LimitResourceDecoding(f.QDCount(), 0, 0, 0)
|
||||
_, _, err = query.Decode(frame)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
for i := range query.Questions {
|
||||
q := &query.Questions[i]
|
||||
for j := range c.services {
|
||||
if matchQuestion(q, &c.services[j]) {
|
||||
addServiceAnswers(&c.rans, q, &c.services[j])
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (c *Client) encapsQuery(frame []byte) (int, error) {
|
||||
msg := dns.Message{
|
||||
Questions: c.qqst,
|
||||
}
|
||||
msglen := msg.Len()
|
||||
if int(msglen) > len(frame) {
|
||||
c.qerr = lneto.ErrShortBuffer
|
||||
c.qstate = querierFailed
|
||||
return 0, c.qerr
|
||||
}
|
||||
// mDNS queries use txid=0 and no flags (RFC 6762 §18.1).
|
||||
data, err := msg.AppendTo(frame[:0], mdnsTxID, mdnsFlags)
|
||||
if err != nil {
|
||||
c.qerr = err
|
||||
c.qstate = querierFailed
|
||||
return 0, err
|
||||
} else if len(data) != int(msglen) {
|
||||
panic("bad dns length calculation") // panic since this is a big bug in lneto.
|
||||
}
|
||||
c.qstate = querierAwaitResponse
|
||||
return len(data), nil
|
||||
}
|
||||
|
||||
func (c *Client) encapsResponse(frame []byte) (int, error) {
|
||||
var msg dns.Message
|
||||
msg.Answers = c.rans
|
||||
msglen := msg.Len()
|
||||
if int(msglen) > len(frame) {
|
||||
return 0, lneto.ErrShortBuffer
|
||||
}
|
||||
// mDNS responses: txid=0, QR=1, AA=1 (RFC 6762 §18.4, §6).
|
||||
flags := dns.HeaderFlags(1<<15 | 1<<10)
|
||||
data, err := msg.AppendTo(frame[:0], 0, flags)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return len(data), nil
|
||||
}
|
||||
|
||||
// Abort closes the client, causing all subsequent Encapsulate/Demux calls to return [net.ErrClosed].
|
||||
func (c *Client) Abort() {
|
||||
c.closed = true
|
||||
}
|
||||
|
||||
func (c *Client) isClosed() bool {
|
||||
return c.closed
|
||||
}
|
||||
|
||||
// AnswersCopyTo checks if [Client.StartResolve] ended succesfully before
|
||||
// doing a deep copy of answers received to the argument buffer using [dns.Resource.CopyFrom].
|
||||
func (c *Client) AnswersCopyTo(dst []dns.Resource) (n int, done bool, err error) {
|
||||
if len(dst) == 0 {
|
||||
return 0, false, lneto.ErrShortBuffer
|
||||
} else if c.qstate == querierIdle {
|
||||
return 0, false, net.ErrClosed
|
||||
} else if c.qstate == querierFailed {
|
||||
return 0, false, c.qerr
|
||||
} else if c.qstate != querierDone {
|
||||
return 0, false, nil
|
||||
}
|
||||
for i := range min(len(dst), len(c.qans)) {
|
||||
dst[i].CopyFrom(c.qans[i])
|
||||
n++
|
||||
}
|
||||
rcode := c.qcode
|
||||
if rcode != 0 {
|
||||
return n, true, rcode
|
||||
}
|
||||
return n, true, nil
|
||||
}
|
||||
@@ -0,0 +1,122 @@
|
||||
package mdns
|
||||
|
||||
import (
|
||||
"github.com/soypat/lneto/dns"
|
||||
)
|
||||
|
||||
// Service describes a service to advertise via mDNS.
|
||||
// A single Service produces PTR, SRV, TXT, and A resource records.
|
||||
//
|
||||
// i.e: To generate a hostname styled A record like the one
|
||||
// linux machines provide to reach them at hostname.local:
|
||||
//
|
||||
// s := Service{
|
||||
// Host: dns.NewName("yourhostname.local"),
|
||||
// Addr: ipAddressSlice,
|
||||
// }
|
||||
type Service struct {
|
||||
// Name is the fully-qualified service instance name in wire format,
|
||||
// e.g. "My Web Server._http._tcp.local".
|
||||
Name dns.Name
|
||||
// Host is the hostname in wire format, e.g. "mydevice.local".
|
||||
Host dns.Name
|
||||
// TXTData is raw TXT record data (length-prefixed strings).
|
||||
TXTData []byte
|
||||
// Addr is the IP address for the A record.
|
||||
Addr []byte
|
||||
// TTL is the record TTL in seconds. Zero uses DefaultTTL.
|
||||
TTL uint32
|
||||
// Port is the TCP/UDP port for the SRV record.
|
||||
Port uint16
|
||||
}
|
||||
|
||||
func (s *Service) ttl() uint32 {
|
||||
if s.TTL == 0 {
|
||||
return DefaultTTL
|
||||
}
|
||||
return s.TTL
|
||||
}
|
||||
|
||||
// serviceType extracts the service type portion of the instance name.
|
||||
// For "_http._tcp.local" it returns the same; for "My Web._http._tcp.local"
|
||||
// it returns "_http._tcp.local" by trimming the first label.
|
||||
// Returns a view into the original Name data — zero allocation.
|
||||
func (s *Service) serviceType() dns.Name {
|
||||
var totalLabels int
|
||||
s.Name.VisitLabels(func(label []byte) {
|
||||
totalLabels++
|
||||
})
|
||||
if totalLabels <= 3 {
|
||||
return s.Name
|
||||
}
|
||||
return s.Name.TrimLabels(1)
|
||||
}
|
||||
|
||||
// matchQuestion reports whether the question matches the given service.
|
||||
func matchQuestion(q *dns.Question, svc *Service) bool {
|
||||
switch q.Type {
|
||||
case dns.TypePTR:
|
||||
svcType := svc.serviceType()
|
||||
return dns.NamesEqual(q.Name, svcType)
|
||||
case dns.TypeSRV, dns.TypeTXT:
|
||||
return dns.NamesEqual(q.Name, svc.Name)
|
||||
case dns.TypeA:
|
||||
return dns.NamesEqual(q.Name, svc.Host)
|
||||
case dns.TypeALL:
|
||||
svcType := svc.serviceType()
|
||||
return dns.NamesEqual(q.Name, svc.Name) || dns.NamesEqual(q.Name, svc.Host) || dns.NamesEqual(q.Name, svcType)
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// addServiceAnswers adds the appropriate answer records for a matched question.
|
||||
// It grows ans in-place, reusing existing Resource buffers when available.
|
||||
func addServiceAnswers(dst *[]dns.Resource, q *dns.Question, svc *Service) {
|
||||
cacheFlush := dns.Class(uint16(dns.ClassINET) | classCacheFlush)
|
||||
ttl := svc.ttl()
|
||||
txtData := svc.TXTData
|
||||
avail := cap(*dst) - len(*dst)
|
||||
switch q.Type {
|
||||
case dns.TypePTR:
|
||||
if avail < 1 {
|
||||
return
|
||||
}
|
||||
setPTR(growSlice(dst), svc)
|
||||
case dns.TypeSRV:
|
||||
if avail < 2 {
|
||||
return
|
||||
}
|
||||
growSlice(dst).SetSRV(svc.Name, cacheFlush, ttl, 0, 0, svc.Port, svc.Host)
|
||||
growSlice(dst).SetA(svc.Host, cacheFlush, ttl, svc.Addr)
|
||||
case dns.TypeTXT:
|
||||
if avail < 1 {
|
||||
return
|
||||
}
|
||||
growSlice(dst).SetTXT(svc.Name, cacheFlush, ttl, txtData)
|
||||
case dns.TypeA:
|
||||
if avail < 1 {
|
||||
return
|
||||
}
|
||||
growSlice(dst).SetA(svc.Host, cacheFlush, ttl, svc.Addr)
|
||||
case dns.TypeALL:
|
||||
if avail < 4 {
|
||||
return
|
||||
}
|
||||
setPTR(growSlice(dst), svc)
|
||||
growSlice(dst).SetSRV(svc.Name, cacheFlush, ttl, 0, 0, svc.Port, svc.Host)
|
||||
growSlice(dst).SetTXT(svc.Name, cacheFlush, ttl, txtData)
|
||||
growSlice(dst).SetA(svc.Host, cacheFlush, ttl, svc.Addr)
|
||||
}
|
||||
}
|
||||
|
||||
// growSlice grows the slice by one element and returns a pointer to the new last element.
|
||||
// Panics if at capacity — callers must check available space before calling.
|
||||
func growSlice[T any](s *[]T) *T {
|
||||
*s = (*s)[:len(*s)+1]
|
||||
return &(*s)[len(*s)-1]
|
||||
}
|
||||
|
||||
func setPTR(ans *dns.Resource, svc *Service) {
|
||||
svcType := svc.serviceType()
|
||||
ans.SetPTR(svcType, dns.ClassINET, svc.ttl(), svc.Name)
|
||||
}
|
||||
@@ -0,0 +1,409 @@
|
||||
package mdns
|
||||
|
||||
import (
|
||||
"encoding/binary"
|
||||
"net"
|
||||
"testing"
|
||||
|
||||
"github.com/soypat/lneto/dns"
|
||||
)
|
||||
|
||||
func mustNewName(s string) dns.Name {
|
||||
n, err := dns.NewName(s)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
return n
|
||||
}
|
||||
|
||||
func testService() Service {
|
||||
return Service{
|
||||
Name: mustNewName("My Web._http._tcp.local"),
|
||||
Host: mustNewName("mydevice.local"),
|
||||
Addr: []byte{192, 168, 1, 50},
|
||||
Port: 80,
|
||||
}
|
||||
}
|
||||
|
||||
func newQuerier(t *testing.T, questions []dns.Question, maxAnswers uint16) *Client {
|
||||
t.Helper()
|
||||
var c Client
|
||||
err := c.Configure(ClientConfig{LocalPort: Port})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
err = c.StartResolve(ResolveConfig{
|
||||
Questions: questions,
|
||||
MaxResponseAnswers: maxAnswers,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return &c
|
||||
}
|
||||
|
||||
func newResponder(t *testing.T, services []Service) *Client {
|
||||
t.Helper()
|
||||
var c Client
|
||||
err := c.Configure(ClientConfig{
|
||||
LocalPort: Port,
|
||||
Services: services,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return &c
|
||||
}
|
||||
|
||||
// queryRespond performs the full query->demux->encapsulate->demux cycle
|
||||
// between a querier and responder, returning the response length.
|
||||
func queryRespond(t *testing.T, querier, responder *Client, buf []byte) int {
|
||||
t.Helper()
|
||||
n, err := querier.Encapsulate(buf, -1, 0)
|
||||
if err != nil || n == 0 {
|
||||
t.Fatal("querier encapsulate:", err, n)
|
||||
}
|
||||
if err = responder.Demux(buf[:n], 0); err != nil {
|
||||
t.Fatal("responder demux:", err)
|
||||
}
|
||||
n, err = responder.Encapsulate(buf, -1, 0)
|
||||
if err != nil {
|
||||
t.Fatal("responder encapsulate:", err)
|
||||
}
|
||||
if n > 0 {
|
||||
if err = querier.Demux(buf[:n], 0); err != nil {
|
||||
t.Fatal("querier demux:", err)
|
||||
}
|
||||
}
|
||||
return n
|
||||
}
|
||||
|
||||
func TestClientQueryPTR(t *testing.T) {
|
||||
svc := testService()
|
||||
responder := newResponder(t, []Service{svc})
|
||||
querier := newQuerier(t, []dns.Question{{
|
||||
Name: mustNewName("_http._tcp.local"),
|
||||
Type: dns.TypePTR,
|
||||
Class: dns.ClassINET,
|
||||
}}, 8)
|
||||
|
||||
var buf [1024]byte
|
||||
|
||||
// Querier encapsulates query.
|
||||
n, err := querier.Encapsulate(buf[:], -1, 0)
|
||||
if err != nil || n == 0 {
|
||||
t.Fatal("querier encapsulate:", err, n)
|
||||
}
|
||||
|
||||
// Verify query wire format: txid=0, flags=0.
|
||||
f, _ := dns.NewFrame(buf[:n])
|
||||
if f.TxID() != 0 {
|
||||
t.Errorf("mDNS query txid=%d, want 0", f.TxID())
|
||||
}
|
||||
if f.Flags() != 0 {
|
||||
t.Errorf("mDNS query flags=%d, want 0", f.Flags())
|
||||
}
|
||||
if f.QDCount() != 1 {
|
||||
t.Errorf("mDNS query QDCount=%d, want 1", f.QDCount())
|
||||
}
|
||||
|
||||
// Responder demuxes and encapsulates response.
|
||||
if err = responder.Demux(buf[:n], 0); err != nil {
|
||||
t.Fatal("responder demux:", err)
|
||||
}
|
||||
n, err = responder.Encapsulate(buf[:], -1, 0)
|
||||
if err != nil || n == 0 {
|
||||
t.Fatal("responder encapsulate:", err, n)
|
||||
}
|
||||
|
||||
// Verify response wire format: QR=1, AA=1.
|
||||
f, _ = dns.NewFrame(buf[:n])
|
||||
flags := f.Flags()
|
||||
if !flags.IsResponse() {
|
||||
t.Error("mDNS response missing QR bit")
|
||||
}
|
||||
if !flags.IsAuthorativeAnswer() {
|
||||
t.Error("mDNS response missing AA bit")
|
||||
}
|
||||
if f.ANCount() == 0 {
|
||||
t.Fatal("mDNS response has 0 answers")
|
||||
}
|
||||
|
||||
// Querier demuxes response and reads answers.
|
||||
if err = querier.Demux(buf[:n], 0); err != nil {
|
||||
t.Fatal("querier demux:", err)
|
||||
}
|
||||
var answers [8]dns.Resource
|
||||
nans, done, err := querier.AnswersCopyTo(answers[:])
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
} else if !done {
|
||||
t.Fatal("expected done")
|
||||
} else if nans == 0 {
|
||||
t.Fatal("querier got 0 answers")
|
||||
}
|
||||
|
||||
// The PTR answer data should contain the instance name in wire format.
|
||||
ptrData := answers[0].RawData()
|
||||
if len(ptrData) == 0 {
|
||||
t.Fatal("PTR answer has no data")
|
||||
}
|
||||
var ptrName dns.Name
|
||||
_, err = ptrName.Decode(ptrData, 0)
|
||||
if err != nil {
|
||||
t.Fatal("decode PTR name:", err)
|
||||
}
|
||||
if ptrName.String() != svc.Name.String() {
|
||||
t.Errorf("PTR target=%q, want %q", ptrName.String(), svc.Name.String())
|
||||
}
|
||||
}
|
||||
|
||||
func TestClientQuerySRV(t *testing.T) {
|
||||
svc := testService()
|
||||
responder := newResponder(t, []Service{svc})
|
||||
querier := newQuerier(t, []dns.Question{{
|
||||
Name: mustNewName("My Web._http._tcp.local"),
|
||||
Type: dns.TypeSRV,
|
||||
Class: dns.ClassINET,
|
||||
}}, 8)
|
||||
|
||||
var buf [1024]byte
|
||||
queryRespond(t, querier, responder, buf[:])
|
||||
|
||||
var answers [8]dns.Resource
|
||||
nans, done, err := querier.AnswersCopyTo(answers[:])
|
||||
if err != nil || !done {
|
||||
t.Fatal("expected done without error:", err)
|
||||
}
|
||||
// SRV query should return SRV + A record.
|
||||
if nans < 2 {
|
||||
t.Fatalf("expected at least 2 answers (SRV+A), got %d", nans)
|
||||
}
|
||||
|
||||
// First answer should be SRV. Parse priority(2)+weight(2)+port(2)+target.
|
||||
srvData := answers[0].RawData()
|
||||
if len(srvData) < 6 {
|
||||
t.Fatalf("SRV data too short: %d bytes", len(srvData))
|
||||
}
|
||||
gotPort := binary.BigEndian.Uint16(srvData[4:6])
|
||||
if gotPort != svc.Port {
|
||||
t.Errorf("SRV port=%d, want %d", gotPort, svc.Port)
|
||||
}
|
||||
var srvTarget dns.Name
|
||||
_, err = srvTarget.Decode(srvData, 6)
|
||||
if err != nil {
|
||||
t.Fatal("decode SRV target:", err)
|
||||
}
|
||||
if srvTarget.String() != svc.Host.String() {
|
||||
t.Errorf("SRV target=%q, want %q", srvTarget.String(), svc.Host.String())
|
||||
}
|
||||
|
||||
// Second answer should be A record with 4-byte IP.
|
||||
aData := answers[1].RawData()
|
||||
if len(aData) != 4 {
|
||||
t.Fatalf("A record data length=%d, want 4", len(aData))
|
||||
}
|
||||
if [4]byte(aData) != [4]byte(svc.Addr) {
|
||||
t.Errorf("A record addr=%v, want %v", aData, svc.Addr)
|
||||
}
|
||||
}
|
||||
|
||||
func TestClientQueryARecord(t *testing.T) {
|
||||
svc := testService()
|
||||
responder := newResponder(t, []Service{svc})
|
||||
querier := newQuerier(t, []dns.Question{{
|
||||
Name: mustNewName("mydevice.local"),
|
||||
Type: dns.TypeA,
|
||||
Class: dns.ClassINET,
|
||||
}}, 4)
|
||||
|
||||
var buf [1024]byte
|
||||
queryRespond(t, querier, responder, buf[:])
|
||||
|
||||
var answers [4]dns.Resource
|
||||
nans, done, err := querier.AnswersCopyTo(answers[:])
|
||||
if err != nil || !done {
|
||||
t.Fatal("expected done without error:", err)
|
||||
}
|
||||
if nans != 1 {
|
||||
t.Fatalf("expected 1 answer, got %d", nans)
|
||||
}
|
||||
aData := answers[0].RawData()
|
||||
if [4]byte(aData) != [4]byte(svc.Addr) {
|
||||
t.Errorf("A record addr=%v, want %v", aData, svc.Addr)
|
||||
}
|
||||
}
|
||||
|
||||
// TODO: TestClientAnnounce — test unsolicited announcement of all registered services.
|
||||
// func TestClientAnnounce(t *testing.T) { ... }
|
||||
|
||||
// TODO: TestClientProbeFinish — test probing sequence for name uniqueness (RFC 6762 §8.1).
|
||||
// func TestClientProbeFinish(t *testing.T) { ... }
|
||||
|
||||
func TestClientIgnoresQueriesWithoutServices(t *testing.T) {
|
||||
// A querier-only client should ignore incoming queries.
|
||||
querier := newQuerier(t, []dns.Question{{
|
||||
Name: mustNewName("_http._tcp.local"),
|
||||
Type: dns.TypePTR,
|
||||
Class: dns.ClassINET,
|
||||
}}, 4)
|
||||
|
||||
// Encapsulate query, then feed it back — should be ignored (not a response).
|
||||
var buf [512]byte
|
||||
n, _ := querier.Encapsulate(buf[:], -1, 0)
|
||||
err := querier.Demux(buf[:n], 0)
|
||||
if err != nil {
|
||||
t.Fatal("demux query:", err)
|
||||
}
|
||||
// No response should be pending.
|
||||
n, _ = querier.Encapsulate(buf[:], -1, 0)
|
||||
if n != 0 {
|
||||
t.Error("querier without services should not respond to queries")
|
||||
}
|
||||
}
|
||||
|
||||
func TestClientResponderIgnoresResponses(t *testing.T) {
|
||||
svc := testService()
|
||||
responder := newResponder(t, []Service{svc})
|
||||
|
||||
// Build a response packet (QR=1).
|
||||
var msg dns.Message
|
||||
var buf [512]byte
|
||||
const responseFlags = dns.HeaderFlags(1 << 15)
|
||||
data, err := msg.AppendTo(buf[:0], 0, responseFlags)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
// Feed a response to the responder — should be ignored.
|
||||
err = responder.Demux(data, 0)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
// Nothing should be pending.
|
||||
n, _ := responder.Encapsulate(buf[:], -1, 0)
|
||||
if n != 0 {
|
||||
t.Error("responder should not respond to responses")
|
||||
}
|
||||
}
|
||||
|
||||
func TestClientUnmatchedQuery(t *testing.T) {
|
||||
svc := testService()
|
||||
responder := newResponder(t, []Service{svc})
|
||||
|
||||
// Query for a name the responder doesn't know.
|
||||
querier := newQuerier(t, []dns.Question{{
|
||||
Name: mustNewName("_ftp._tcp.local"),
|
||||
Type: dns.TypePTR,
|
||||
Class: dns.ClassINET,
|
||||
}}, 4)
|
||||
|
||||
var buf [1024]byte
|
||||
n, _ := querier.Encapsulate(buf[:], -1, 0)
|
||||
responder.Demux(buf[:n], 0)
|
||||
|
||||
// Responder should have nothing pending.
|
||||
n, _ = responder.Encapsulate(buf[:], -1, 0)
|
||||
if n != 0 {
|
||||
t.Error("responder should not respond to unmatched query")
|
||||
}
|
||||
}
|
||||
|
||||
func TestClientMultipleResponders(t *testing.T) {
|
||||
// Two responder clients advertising different instances of the same service type.
|
||||
svc1 := Service{
|
||||
Name: mustNewName("Device A._http._tcp.local"),
|
||||
Host: mustNewName("device-a.local"),
|
||||
Addr: []byte{192, 168, 1, 10},
|
||||
Port: 80,
|
||||
}
|
||||
svc2 := Service{
|
||||
Name: mustNewName("Device B._http._tcp.local"),
|
||||
Host: mustNewName("device-b.local"),
|
||||
Addr: []byte{192, 168, 1, 11},
|
||||
Port: 8080,
|
||||
}
|
||||
|
||||
responder1 := newResponder(t, []Service{svc1})
|
||||
responder2 := newResponder(t, []Service{svc2})
|
||||
querier := newQuerier(t, []dns.Question{{
|
||||
Name: mustNewName("_http._tcp.local"),
|
||||
Type: dns.TypePTR,
|
||||
Class: dns.ClassINET,
|
||||
}}, 8)
|
||||
|
||||
var buf [1024]byte
|
||||
|
||||
// Querier sends query.
|
||||
n, _ := querier.Encapsulate(buf[:], -1, 0)
|
||||
query := make([]byte, n)
|
||||
copy(query, buf[:n])
|
||||
|
||||
// Both responders process the query.
|
||||
responder1.Demux(query, 0)
|
||||
responder2.Demux(query, 0)
|
||||
|
||||
// Querier receives response from responder 1.
|
||||
n, _ = responder1.Encapsulate(buf[:], -1, 0)
|
||||
querier.Demux(buf[:n], 0)
|
||||
|
||||
var answers [8]dns.Resource
|
||||
nans, _, err := querier.AnswersCopyTo(answers[:])
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if nans < 1 {
|
||||
t.Fatalf("expected at least 1 answer from first responder, got %d", nans)
|
||||
}
|
||||
|
||||
// Start a new resolve to receive from responder 2.
|
||||
querier.StartResolve(ResolveConfig{
|
||||
Questions: []dns.Question{{
|
||||
Name: mustNewName("_http._tcp.local"),
|
||||
Type: dns.TypePTR,
|
||||
Class: dns.ClassINET,
|
||||
}},
|
||||
MaxResponseAnswers: 8,
|
||||
})
|
||||
// Re-send query for second responder.
|
||||
n, _ = querier.Encapsulate(buf[:], -1, 0)
|
||||
|
||||
n, _ = responder2.Encapsulate(buf[:], -1, 0)
|
||||
querier.Demux(buf[:n], 0)
|
||||
|
||||
nans, _, err = querier.AnswersCopyTo(answers[:])
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if nans < 1 {
|
||||
t.Fatalf("expected at least 1 answer from second responder, got %d", nans)
|
||||
}
|
||||
}
|
||||
|
||||
func TestClientAbort(t *testing.T) {
|
||||
svc := testService()
|
||||
responder := newResponder(t, []Service{svc})
|
||||
|
||||
responder.Abort()
|
||||
|
||||
// Demux on aborted client should return ErrClosed.
|
||||
var buf [512]byte
|
||||
var msg dns.Message
|
||||
msg.AddQuestions([]dns.Question{{
|
||||
Name: mustNewName("_http._tcp.local"),
|
||||
Type: dns.TypePTR,
|
||||
Class: dns.ClassINET,
|
||||
}})
|
||||
data, _ := msg.AppendTo(buf[:0], 0, 0)
|
||||
err := responder.Demux(data, 0)
|
||||
if err != net.ErrClosed {
|
||||
t.Errorf("expected net.ErrClosed, got %v", err)
|
||||
}
|
||||
|
||||
// Encapsulate on aborted client should return ErrClosed.
|
||||
_, err = responder.Encapsulate(buf[:], -1, 0)
|
||||
if err != net.ErrClosed {
|
||||
t.Errorf("expected net.ErrClosed, got %v", err)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user