mirror of
https://github.com/router-for-me/CLIProxyAPI.git
synced 2026-11-17 23:32:30 +08:00
Validate draft TXT values and RFC 3986 paths without legacy schema mixing; preserve first-key-wins and legacy base-path compatibility. Validate RFC 6335 names, filter unusable addresses, and display scoped IPv6 and WebSocket URLs. Replace the single-packet browser with per-interface RR caching, source validation, TTL and cache-flush handling, PTR maintenance and known-answer suppression. Add deterministic split-order, capacity, expiry, scope and schema regression tests.
2851 lines
74 KiB
Go
2851 lines
74 KiB
Go
package discovery
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"crypto/rand"
|
|
"encoding/binary"
|
|
"fmt"
|
|
"net"
|
|
"os"
|
|
"runtime"
|
|
"sort"
|
|
"strings"
|
|
"sync"
|
|
"sync/atomic"
|
|
"time"
|
|
|
|
"github.com/libp2p/zeroconf/v2"
|
|
log "github.com/sirupsen/logrus"
|
|
"golang.org/x/net/dns/dnsmessage"
|
|
"golang.org/x/net/ipv4"
|
|
"golang.org/x/net/ipv6"
|
|
)
|
|
|
|
const (
|
|
maxDNSLabelBytes = 63
|
|
maxHostCollisionAttempts = 8
|
|
mdnsCacheFlushBit = 1 << 15
|
|
mdnsServiceRecordTTL = 3200
|
|
mdnsHostRecordTTL = 120
|
|
mdnsLegacyRecordTTL = 10
|
|
mdnsPort = 5353
|
|
mdnsHostProbeCount = 3
|
|
mdnsHostProbeInterval = 250 * time.Millisecond
|
|
mdnsAnnounceRepetitions = 2
|
|
mdnsAnnounceInterval = time.Second
|
|
dnsTypeNSEC = dnsmessage.Type(47)
|
|
)
|
|
|
|
var (
|
|
mdnsGroupAddrIPv4 = &net.UDPAddr{IP: net.IPv4(224, 0, 0, 251), Port: mdnsPort}
|
|
mdnsGroupAddrIPv6 = &net.UDPAddr{IP: net.ParseIP("ff02::fb"), Port: mdnsPort}
|
|
mdnsWildcardAddrIPv4 = &net.UDPAddr{IP: net.IPv4(224, 0, 0, 0), Port: mdnsPort}
|
|
mdnsWildcardAddrIPv6 = &net.UDPAddr{IP: net.ParseIP("ff02::"), Port: mdnsPort}
|
|
)
|
|
|
|
type zeroconfServer interface {
|
|
Shutdown()
|
|
}
|
|
|
|
type registerProxyFunc func(instance, service, domain string, port int, host string, ips []string, text []string, ifaces []net.Interface, opts ...zeroconf.ServerOption) (zeroconfServer, error)
|
|
type hostConflictProbeFunc func(ctx context.Context, hostFQDN string, ifaces []net.Interface, localIPs []string) (bool, error)
|
|
|
|
func validateRegisterProxyArgs(instance, service, domain string, port int, host string, ips []string) error {
|
|
if strings.TrimSpace(instance) == "" {
|
|
return fmt.Errorf("missing service instance name")
|
|
}
|
|
if strings.TrimSpace(service) == "" {
|
|
return fmt.Errorf("missing service name")
|
|
}
|
|
if strings.TrimSpace(host) == "" {
|
|
return fmt.Errorf("missing host name")
|
|
}
|
|
if port <= 0 || port > 65535 {
|
|
return fmt.Errorf("invalid port %d", port)
|
|
}
|
|
for _, ip := range ips {
|
|
if net.ParseIP(strings.TrimSpace(ip)) == nil {
|
|
return fmt.Errorf("failed to parse given IP: %v", ip)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func defaultRegisterProxy(instance, service, domain string, port int, host string, ips []string, text []string, ifaces []net.Interface, _ ...zeroconf.ServerOption) (zeroconfServer, error) {
|
|
if errValid := validateRegisterProxyArgs(instance, service, domain, port, host, ips); errValid != nil {
|
|
return nil, errValid
|
|
}
|
|
resp, err := newHostRecordResponderWithRebind(nil, host, domain, ips, ifaces, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if hr, ok := resp.(*hostRecordResponder); ok && hr != nil {
|
|
hr.configureService(instance, service, domain, port, text)
|
|
hr.announceService()
|
|
}
|
|
return resp, nil
|
|
}
|
|
|
|
func formatHostFQDN(host, domain string) string {
|
|
h := strings.TrimSuffix(strings.TrimSpace(host), ".")
|
|
d := strings.Trim(strings.TrimSpace(domain), ".")
|
|
if d == "" {
|
|
d = "local"
|
|
}
|
|
if !strings.HasSuffix(strings.ToLower(h), "."+strings.ToLower(d)) {
|
|
h = h + "." + d
|
|
}
|
|
return h + "."
|
|
}
|
|
|
|
func splitIPv4AndIPv6(ips []string) (v4 [][4]byte, v6 [][16]byte) {
|
|
for _, raw := range ips {
|
|
ip := net.ParseIP(strings.TrimSpace(raw))
|
|
if ip == nil || ip.IsLoopback() || ip.IsUnspecified() {
|
|
continue
|
|
}
|
|
if ip4 := ip.To4(); ip4 != nil {
|
|
v4 = append(v4, [4]byte(ip4))
|
|
continue
|
|
}
|
|
if ip16 := ip.To16(); ip16 != nil {
|
|
v6 = append(v6, [16]byte(ip16))
|
|
}
|
|
}
|
|
return v4, v6
|
|
}
|
|
|
|
func packWireDomainName(fqdn string) []byte {
|
|
trimmed := strings.Trim(strings.TrimSpace(fqdn), ".")
|
|
if trimmed == "" {
|
|
return []byte{0}
|
|
}
|
|
parts := strings.Split(trimmed, ".")
|
|
var out []byte
|
|
for _, part := range parts {
|
|
if len(part) == 0 || len(part) > maxDNSLabelBytes {
|
|
return nil
|
|
}
|
|
out = append(out, byte(len(part)))
|
|
out = append(out, part...)
|
|
}
|
|
out = append(out, 0)
|
|
return out
|
|
}
|
|
|
|
func buildHostNSECRData(hostFQDN string, hasA, hasAAAA bool) []byte {
|
|
wireName := packWireDomainName(hostFQDN)
|
|
if len(wireName) == 0 || (!hasA && !hasAAAA) {
|
|
return nil
|
|
}
|
|
var bitmap [4]byte
|
|
bitmapLen := 0
|
|
if hasA {
|
|
bitmap[0] |= 1 << (7 - 1) // TypeA = 1
|
|
bitmapLen = 1
|
|
}
|
|
if hasAAAA {
|
|
bitmap[3] |= 1 << (7 - (28 - 24)) // TypeAAAA = 28
|
|
bitmapLen = 4
|
|
}
|
|
out := append(wireName, 0x00, byte(bitmapLen))
|
|
return append(out, bitmap[:bitmapLen]...)
|
|
}
|
|
|
|
func buildHostAddressReply(query []byte, hostFQDN string, ips []string, legacyUnicast bool) (reply []byte, unicast bool) {
|
|
return buildHostAddressReplyFiltered(query, hostFQDN, ips, legacyUnicast, nil)
|
|
}
|
|
|
|
func buildHostAddressReplyFiltered(query []byte, hostFQDN string, ips []string, legacyUnicast bool, onlyQU *bool) (reply []byte, unicast bool) {
|
|
normQuery := rewriteWireLabelChar(query, '.', dotInLabelSentinel)
|
|
var p dnsmessage.Parser
|
|
hdr, err := p.Start(normQuery)
|
|
if err != nil || hdr.Response {
|
|
return nil, false
|
|
}
|
|
questions, errQ := p.AllQuestions()
|
|
if errQ != nil || len(questions) == 0 {
|
|
return nil, false
|
|
}
|
|
if errSkipAns := p.SkipAllAnswers(); errSkipAns != nil {
|
|
return nil, false
|
|
}
|
|
if errSkipAuth := p.SkipAllAuthorities(); errSkipAuth != nil {
|
|
return nil, false
|
|
}
|
|
|
|
var wantA, wantAAAA, extraA, extraAAAA bool
|
|
var matchedQuestions []dnsmessage.Question
|
|
seenQ := make(map[string]struct{}, len(questions))
|
|
for _, q := range questions {
|
|
isQU := uint16(q.Class)&mdnsCacheFlushBit != 0
|
|
if onlyQU != nil && isQU != *onlyQU {
|
|
continue
|
|
}
|
|
if !strings.EqualFold(q.Name.String(), hostFQDN) {
|
|
continue
|
|
}
|
|
baseClass := uint16(q.Class) &^ mdnsCacheFlushBit
|
|
if baseClass != uint16(dnsmessage.ClassINET) && baseClass != uint16(dnsmessage.ClassANY) {
|
|
continue
|
|
}
|
|
switch q.Type {
|
|
case dnsmessage.TypeA:
|
|
wantA = true
|
|
extraAAAA = true
|
|
case dnsmessage.TypeAAAA:
|
|
wantAAAA = true
|
|
extraA = true
|
|
case dnsmessage.TypeALL:
|
|
wantA = true
|
|
wantAAAA = true
|
|
default:
|
|
continue
|
|
}
|
|
qKey := fmt.Sprintf("%s\x00%d\x00%d", strings.ToLower(q.Name.String()), q.Type, baseClass)
|
|
if _, dup := seenQ[qKey]; !dup {
|
|
seenQ[qKey] = struct{}{}
|
|
matchedQuestions = append(matchedQuestions, dnsmessage.Question{
|
|
Name: q.Name,
|
|
Type: q.Type,
|
|
Class: dnsmessage.Class(baseClass),
|
|
})
|
|
}
|
|
if isQU {
|
|
unicast = true
|
|
}
|
|
}
|
|
if !wantA && !wantAAAA {
|
|
return nil, false
|
|
}
|
|
if legacyUnicast {
|
|
unicast = true
|
|
}
|
|
|
|
v4, v6 := splitIPv4AndIPv6(ips)
|
|
if len(v4) == 0 && len(v6) == 0 {
|
|
return nil, false
|
|
}
|
|
hasAnswerA := wantA && len(v4) > 0
|
|
hasAnswerAAAA := wantAAAA && len(v6) > 0
|
|
needNSEC := (wantA && len(v4) == 0) || (wantAAAA && len(v6) == 0)
|
|
|
|
name, errName := dnsmessage.NewName(hostFQDN)
|
|
if errName != nil {
|
|
return nil, false
|
|
}
|
|
rrClass := dnsmessage.ClassINET | dnsmessage.Class(mdnsCacheFlushBit)
|
|
ttl := uint32(mdnsHostRecordTTL)
|
|
if legacyUnicast {
|
|
rrClass = dnsmessage.ClassINET
|
|
ttl = mdnsLegacyRecordTTL
|
|
}
|
|
builder := dnsmessage.NewBuilder(nil, dnsmessage.Header{
|
|
ID: hdr.ID,
|
|
Response: true,
|
|
Authoritative: true,
|
|
})
|
|
builder.EnableCompression()
|
|
if legacyUnicast && len(matchedQuestions) > 0 {
|
|
if errStartQ := builder.StartQuestions(); errStartQ != nil {
|
|
return nil, false
|
|
}
|
|
for _, mq := range matchedQuestions {
|
|
if errQAdd := builder.Question(mq); errQAdd != nil {
|
|
return nil, false
|
|
}
|
|
}
|
|
}
|
|
if errAns := builder.StartAnswers(); errAns != nil {
|
|
return nil, false
|
|
}
|
|
if hasAnswerA {
|
|
for _, addr := range v4 {
|
|
if errAdd := builder.AResource(dnsmessage.ResourceHeader{
|
|
Name: name,
|
|
Type: dnsmessage.TypeA,
|
|
Class: rrClass,
|
|
TTL: ttl,
|
|
}, dnsmessage.AResource{A: addr}); errAdd != nil {
|
|
return nil, false
|
|
}
|
|
}
|
|
}
|
|
if hasAnswerAAAA {
|
|
for _, addr := range v6 {
|
|
if errAdd := builder.AAAAResource(dnsmessage.ResourceHeader{
|
|
Name: name,
|
|
Type: dnsmessage.TypeAAAA,
|
|
Class: rrClass,
|
|
TTL: ttl,
|
|
}, dnsmessage.AAAAResource{AAAA: addr}); errAdd != nil {
|
|
return nil, false
|
|
}
|
|
}
|
|
}
|
|
if needNSEC {
|
|
nsecData := buildHostNSECRData(hostFQDN, len(v4) > 0, len(v6) > 0)
|
|
if len(nsecData) == 0 {
|
|
return nil, false
|
|
}
|
|
if errNSEC := builder.UnknownResource(dnsmessage.ResourceHeader{
|
|
Name: name,
|
|
Type: dnsTypeNSEC,
|
|
Class: rrClass,
|
|
TTL: ttl,
|
|
}, dnsmessage.UnknownResource{
|
|
Type: dnsTypeNSEC,
|
|
Data: nsecData,
|
|
}); errNSEC != nil {
|
|
return nil, false
|
|
}
|
|
}
|
|
|
|
addExtraA := !hasAnswerA && extraA && len(v4) > 0
|
|
addExtraAAAA := !hasAnswerAAAA && extraAAAA && len(v6) > 0
|
|
if addExtraA || addExtraAAAA {
|
|
if errExt := builder.StartAdditionals(); errExt != nil {
|
|
return nil, false
|
|
}
|
|
if addExtraA {
|
|
for _, addr := range v4 {
|
|
_ = builder.AResource(dnsmessage.ResourceHeader{
|
|
Name: name,
|
|
Type: dnsmessage.TypeA,
|
|
Class: rrClass,
|
|
TTL: ttl,
|
|
}, dnsmessage.AResource{A: addr})
|
|
}
|
|
}
|
|
if addExtraAAAA {
|
|
for _, addr := range v6 {
|
|
_ = builder.AAAAResource(dnsmessage.ResourceHeader{
|
|
Name: name,
|
|
Type: dnsmessage.TypeAAAA,
|
|
Class: rrClass,
|
|
TTL: ttl,
|
|
}, dnsmessage.AAAAResource{AAAA: addr})
|
|
}
|
|
}
|
|
}
|
|
|
|
out, errFinish := builder.Finish()
|
|
if errFinish != nil {
|
|
return nil, false
|
|
}
|
|
return rewriteWireLabelChar(out, dotInLabelSentinel, '.'), unicast
|
|
}
|
|
|
|
func buildHostGoodbyePacket(hostFQDN string, ips []string) []byte {
|
|
v4, v6 := splitIPv4AndIPv6(ips)
|
|
if len(v4) == 0 && len(v6) == 0 {
|
|
return nil
|
|
}
|
|
name, errName := dnsmessage.NewName(hostFQDN)
|
|
if errName != nil {
|
|
return nil
|
|
}
|
|
rrClass := dnsmessage.ClassINET | dnsmessage.Class(mdnsCacheFlushBit)
|
|
builder := dnsmessage.NewBuilder(nil, dnsmessage.Header{
|
|
Response: true,
|
|
Authoritative: true,
|
|
})
|
|
builder.EnableCompression()
|
|
if errAns := builder.StartAnswers(); errAns != nil {
|
|
return nil
|
|
}
|
|
for _, addr := range v4 {
|
|
if errAdd := builder.AResource(dnsmessage.ResourceHeader{
|
|
Name: name,
|
|
Type: dnsmessage.TypeA,
|
|
Class: rrClass,
|
|
TTL: 0,
|
|
}, dnsmessage.AResource{A: addr}); errAdd != nil {
|
|
return nil
|
|
}
|
|
}
|
|
for _, addr := range v6 {
|
|
if errAdd := builder.AAAAResource(dnsmessage.ResourceHeader{
|
|
Name: name,
|
|
Type: dnsmessage.TypeAAAA,
|
|
Class: rrClass,
|
|
TTL: 0,
|
|
}, dnsmessage.AAAAResource{AAAA: addr}); errAdd != nil {
|
|
return nil
|
|
}
|
|
}
|
|
out, errFinish := builder.Finish()
|
|
if errFinish != nil {
|
|
return nil
|
|
}
|
|
return out
|
|
}
|
|
|
|
const dotInLabelSentinel byte = '\x01'
|
|
|
|
type mdnsServiceConfig struct {
|
|
serviceTypeName string
|
|
serviceName string
|
|
instanceName string
|
|
subtypes []string
|
|
port uint16
|
|
text []string
|
|
}
|
|
|
|
func rewriteWireName(buf []byte, off int, fromByte, toByte byte) int {
|
|
for off < len(buf) {
|
|
b := buf[off]
|
|
if b == 0 {
|
|
return off + 1
|
|
}
|
|
if b&0xC0 == 0xC0 {
|
|
if off+2 > len(buf) {
|
|
return -1
|
|
}
|
|
return off + 2
|
|
}
|
|
if b >= 64 {
|
|
return -1
|
|
}
|
|
end := off + 1 + int(b)
|
|
if end > len(buf) {
|
|
return -1
|
|
}
|
|
for i := off + 1; i < end; i++ {
|
|
if buf[i] == fromByte {
|
|
buf[i] = toByte
|
|
}
|
|
}
|
|
off = end
|
|
}
|
|
return -1
|
|
}
|
|
|
|
func rewriteWireLabelChar(pkt []byte, fromByte, toByte byte) []byte {
|
|
if len(pkt) < 12 {
|
|
return pkt
|
|
}
|
|
buf := bytes.Clone(pkt)
|
|
qd := int(binary.BigEndian.Uint16(buf[4:6]))
|
|
an := int(binary.BigEndian.Uint16(buf[6:8]))
|
|
ns := int(binary.BigEndian.Uint16(buf[8:10]))
|
|
ar := int(binary.BigEndian.Uint16(buf[10:12]))
|
|
off := 12
|
|
for i := 0; i < qd; i++ {
|
|
off = rewriteWireName(buf, off, fromByte, toByte)
|
|
if off < 0 || off+4 > len(buf) {
|
|
return buf
|
|
}
|
|
off += 4
|
|
}
|
|
totalRR := an + ns + ar
|
|
for i := 0; i < totalRR; i++ {
|
|
off = rewriteWireName(buf, off, fromByte, toByte)
|
|
if off < 0 || off+10 > len(buf) {
|
|
return buf
|
|
}
|
|
rrType := dnsmessage.Type(binary.BigEndian.Uint16(buf[off : off+2]))
|
|
rdLen := int(binary.BigEndian.Uint16(buf[off+8 : off+10]))
|
|
rdataStart := off + 10
|
|
rdataEnd := rdataStart + rdLen
|
|
if rdataEnd > len(buf) {
|
|
return buf
|
|
}
|
|
switch rrType {
|
|
case dnsmessage.TypePTR, dnsmessage.TypeCNAME, dnsmessage.TypeNS:
|
|
_ = rewriteWireName(buf[:rdataEnd], rdataStart, fromByte, toByte)
|
|
case dnsmessage.TypeSRV:
|
|
if rdLen >= 6 {
|
|
_ = rewriteWireName(buf[:rdataEnd], rdataStart+6, fromByte, toByte)
|
|
}
|
|
}
|
|
off = rdataEnd
|
|
}
|
|
return buf
|
|
}
|
|
|
|
func parseMDNSServiceConfig(instance, service, domain string, port int, text []string) mdnsServiceConfig {
|
|
cleanDom := strings.Trim(strings.TrimSpace(domain), ".")
|
|
if cleanDom == "" {
|
|
cleanDom = "local"
|
|
}
|
|
parts := strings.Split(service, ",")
|
|
baseSvc := strings.Trim(strings.TrimSpace(parts[0]), ".")
|
|
svcName := baseSvc + "." + cleanDom + "."
|
|
cleanInst := strings.ReplaceAll(strings.Trim(strings.TrimSpace(instance), "."), ".", string(dotInLabelSentinel))
|
|
var subs []string
|
|
for _, sub := range parts[1:] {
|
|
s := strings.Trim(strings.TrimSpace(sub), ".")
|
|
if s != "" {
|
|
subs = append(subs, s+"._sub."+svcName)
|
|
}
|
|
}
|
|
return mdnsServiceConfig{
|
|
serviceTypeName: "_services._dns-sd._udp." + cleanDom + ".",
|
|
serviceName: svcName,
|
|
instanceName: cleanInst + "." + svcName,
|
|
subtypes: subs,
|
|
port: uint16(port),
|
|
text: append([]string(nil), text...),
|
|
}
|
|
}
|
|
|
|
func appendHostAddrResources(builder *dnsmessage.Builder, hostName dnsmessage.Name, rrClass dnsmessage.Class, ttl uint32, v4 [][4]byte, v6 [][16]byte) error {
|
|
for _, addr := range v4 {
|
|
if err := builder.AResource(dnsmessage.ResourceHeader{
|
|
Name: hostName,
|
|
Type: dnsmessage.TypeA,
|
|
Class: rrClass,
|
|
TTL: ttl,
|
|
}, dnsmessage.AResource{A: addr}); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
for _, addr := range v6 {
|
|
if err := builder.AAAAResource(dnsmessage.ResourceHeader{
|
|
Name: hostName,
|
|
Type: dnsmessage.TypeAAAA,
|
|
Class: rrClass,
|
|
TTL: ttl,
|
|
}, dnsmessage.AAAAResource{AAAA: addr}); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func buildServicePacket(svc mdnsServiceConfig, hostFQDN string, ips []string, ttl uint32) []byte {
|
|
v4, v6 := splitIPv4AndIPv6(ips)
|
|
if svc.serviceName == "" {
|
|
if ttl == 0 {
|
|
return buildHostGoodbyePacket(hostFQDN, ips)
|
|
}
|
|
return nil
|
|
}
|
|
svcTypeName, err1 := dnsmessage.NewName(svc.serviceTypeName)
|
|
svcName, err2 := dnsmessage.NewName(svc.serviceName)
|
|
instName, err3 := dnsmessage.NewName(svc.instanceName)
|
|
hostName, err4 := dnsmessage.NewName(hostFQDN)
|
|
if err1 != nil || err2 != nil || err3 != nil || err4 != nil {
|
|
return nil
|
|
}
|
|
var subNames []dnsmessage.Name
|
|
for _, sub := range svc.subtypes {
|
|
if sn, errS := dnsmessage.NewName(sub); errS == nil {
|
|
subNames = append(subNames, sn)
|
|
}
|
|
}
|
|
|
|
svcTTL := ttl
|
|
hostTTL := ttl
|
|
if ttl > 0 {
|
|
svcTTL = mdnsServiceRecordTTL
|
|
hostTTL = mdnsHostRecordTTL
|
|
}
|
|
flushClass := dnsmessage.ClassINET | dnsmessage.Class(mdnsCacheFlushBit)
|
|
builder := dnsmessage.NewBuilder(nil, dnsmessage.Header{
|
|
Response: true,
|
|
Authoritative: true,
|
|
})
|
|
builder.EnableCompression()
|
|
if errAns := builder.StartAnswers(); errAns != nil {
|
|
return nil
|
|
}
|
|
if err := builder.SRVResource(dnsmessage.ResourceHeader{
|
|
Name: instName,
|
|
Type: dnsmessage.TypeSRV,
|
|
Class: flushClass,
|
|
TTL: svcTTL,
|
|
}, dnsmessage.SRVResource{Port: svc.port, Target: hostName}); err != nil {
|
|
return nil
|
|
}
|
|
if err := builder.TXTResource(dnsmessage.ResourceHeader{
|
|
Name: instName,
|
|
Type: dnsmessage.TypeTXT,
|
|
Class: flushClass,
|
|
TTL: svcTTL,
|
|
}, dnsmessage.TXTResource{TXT: svc.text}); err != nil {
|
|
return nil
|
|
}
|
|
if err := builder.PTRResource(dnsmessage.ResourceHeader{
|
|
Name: svcName,
|
|
Type: dnsmessage.TypePTR,
|
|
Class: dnsmessage.ClassINET,
|
|
TTL: svcTTL,
|
|
}, dnsmessage.PTRResource{PTR: instName}); err != nil {
|
|
return nil
|
|
}
|
|
if err := builder.PTRResource(dnsmessage.ResourceHeader{
|
|
Name: svcTypeName,
|
|
Type: dnsmessage.TypePTR,
|
|
Class: dnsmessage.ClassINET,
|
|
TTL: svcTTL,
|
|
}, dnsmessage.PTRResource{PTR: svcName}); err != nil {
|
|
return nil
|
|
}
|
|
for _, sn := range subNames {
|
|
if err := builder.PTRResource(dnsmessage.ResourceHeader{
|
|
Name: sn,
|
|
Type: dnsmessage.TypePTR,
|
|
Class: dnsmessage.ClassINET,
|
|
TTL: svcTTL,
|
|
}, dnsmessage.PTRResource{PTR: instName}); err != nil {
|
|
return nil
|
|
}
|
|
}
|
|
if err := appendHostAddrResources(&builder, hostName, flushClass, hostTTL, v4, v6); err != nil {
|
|
return nil
|
|
}
|
|
out, errFinish := builder.Finish()
|
|
if errFinish != nil {
|
|
return nil
|
|
}
|
|
return rewriteWireLabelChar(out, dotInLabelSentinel, '.')
|
|
}
|
|
|
|
func ptrKnownKey(ownerName, targetName string) string {
|
|
return strings.ToLower(ownerName) + "\x00" + strings.ToLower(targetName)
|
|
}
|
|
|
|
func collectKnownPTRAnswers(p *dnsmessage.Parser, replyTTL uint32) (map[string]struct{}, error) {
|
|
var known map[string]struct{}
|
|
for {
|
|
rh, errH := p.AnswerHeader()
|
|
if errH != nil {
|
|
if errH == dnsmessage.ErrSectionDone {
|
|
return known, nil
|
|
}
|
|
return nil, errH
|
|
}
|
|
if rh.Type != dnsmessage.TypePTR || rh.TTL < replyTTL/2 {
|
|
if errSkip := p.SkipAnswer(); errSkip != nil {
|
|
return nil, errSkip
|
|
}
|
|
continue
|
|
}
|
|
ptr, errPTR := p.PTRResource()
|
|
if errPTR != nil {
|
|
return nil, errPTR
|
|
}
|
|
if known == nil {
|
|
known = make(map[string]struct{})
|
|
}
|
|
known[ptrKnownKey(rh.Name.String(), ptr.PTR.String())] = struct{}{}
|
|
}
|
|
}
|
|
|
|
func isKnownPTRAnswer(known map[string]struct{}, ownerName, targetName string) bool {
|
|
if len(known) == 0 {
|
|
return false
|
|
}
|
|
_, ok := known[ptrKnownKey(ownerName, targetName)]
|
|
return ok
|
|
}
|
|
|
|
func buildServiceQueryReply(query []byte, svc mdnsServiceConfig, hostFQDN string, ips []string, legacyUnicast bool) (reply []byte, unicast bool) {
|
|
return buildServiceQueryReplyFiltered(query, svc, hostFQDN, ips, legacyUnicast, nil)
|
|
}
|
|
|
|
func buildServiceQueryReplyFiltered(query []byte, svc mdnsServiceConfig, hostFQDN string, ips []string, legacyUnicast bool, onlyQU *bool) (reply []byte, unicast bool) {
|
|
if svc.serviceName == "" {
|
|
return nil, false
|
|
}
|
|
normQuery := rewriteWireLabelChar(query, '.', dotInLabelSentinel)
|
|
var p dnsmessage.Parser
|
|
hdr, err := p.Start(normQuery)
|
|
if err != nil || hdr.Response {
|
|
return nil, false
|
|
}
|
|
questions, errQ := p.AllQuestions()
|
|
if errQ != nil || len(questions) == 0 {
|
|
return nil, false
|
|
}
|
|
|
|
svcTTL := uint32(mdnsServiceRecordTTL)
|
|
hostTTL := uint32(mdnsHostRecordTTL)
|
|
rrClass := dnsmessage.ClassINET | dnsmessage.Class(mdnsCacheFlushBit)
|
|
if legacyUnicast {
|
|
svcTTL = mdnsLegacyRecordTTL
|
|
hostTTL = mdnsLegacyRecordTTL
|
|
rrClass = dnsmessage.ClassINET
|
|
unicast = true
|
|
}
|
|
|
|
knownPTRs, errKnown := collectKnownPTRAnswers(&p, svcTTL)
|
|
if errKnown != nil {
|
|
return nil, false
|
|
}
|
|
|
|
svcTypeName, err1 := dnsmessage.NewName(svc.serviceTypeName)
|
|
svcName, err2 := dnsmessage.NewName(svc.serviceName)
|
|
instName, err3 := dnsmessage.NewName(svc.instanceName)
|
|
hostName, err4 := dnsmessage.NewName(hostFQDN)
|
|
if err1 != nil || err2 != nil || err3 != nil || err4 != nil {
|
|
return nil, false
|
|
}
|
|
|
|
var matchedQuestions []dnsmessage.Question
|
|
var answerTypeEnum, answerBrowse, answerLookup bool
|
|
var browseSubtypes []dnsmessage.Name
|
|
seenSubtypes := make(map[string]struct{}, len(svc.subtypes))
|
|
seenQ := make(map[string]struct{}, len(questions))
|
|
|
|
for _, q := range questions {
|
|
isQU := uint16(q.Class)&mdnsCacheFlushBit != 0
|
|
if onlyQU != nil && isQU != *onlyQU {
|
|
continue
|
|
}
|
|
baseClass := uint16(q.Class) &^ mdnsCacheFlushBit
|
|
if baseClass != uint16(dnsmessage.ClassINET) && baseClass != uint16(dnsmessage.ClassANY) {
|
|
continue
|
|
}
|
|
qNameStr := q.Name.String()
|
|
switch {
|
|
case strings.EqualFold(qNameStr, svc.serviceTypeName):
|
|
if q.Type != dnsmessage.TypePTR && q.Type != dnsmessage.TypeALL {
|
|
continue
|
|
}
|
|
if isKnownPTRAnswer(knownPTRs, svc.serviceTypeName, svc.serviceName) {
|
|
continue
|
|
}
|
|
answerTypeEnum = true
|
|
case strings.EqualFold(qNameStr, svc.serviceName):
|
|
if q.Type != dnsmessage.TypePTR && q.Type != dnsmessage.TypeALL {
|
|
continue
|
|
}
|
|
if isKnownPTRAnswer(knownPTRs, svc.serviceName, svc.instanceName) {
|
|
continue
|
|
}
|
|
answerBrowse = true
|
|
case strings.EqualFold(qNameStr, svc.instanceName):
|
|
if q.Type != dnsmessage.TypeSRV && q.Type != dnsmessage.TypeTXT && q.Type != dnsmessage.TypePTR && q.Type != dnsmessage.TypeALL {
|
|
continue
|
|
}
|
|
answerLookup = true
|
|
default:
|
|
matchedSub := ""
|
|
for _, sub := range svc.subtypes {
|
|
if strings.EqualFold(qNameStr, sub) {
|
|
matchedSub = sub
|
|
break
|
|
}
|
|
}
|
|
if matchedSub == "" || (q.Type != dnsmessage.TypePTR && q.Type != dnsmessage.TypeALL) {
|
|
continue
|
|
}
|
|
if isKnownPTRAnswer(knownPTRs, matchedSub, svc.instanceName) {
|
|
continue
|
|
}
|
|
if _, dupSub := seenSubtypes[matchedSub]; !dupSub {
|
|
seenSubtypes[matchedSub] = struct{}{}
|
|
if sn, errSN := dnsmessage.NewName(matchedSub); errSN == nil {
|
|
browseSubtypes = append(browseSubtypes, sn)
|
|
}
|
|
}
|
|
}
|
|
qKey := fmt.Sprintf("%s\x00%d\x00%d", strings.ToLower(qNameStr), q.Type, baseClass)
|
|
if _, dup := seenQ[qKey]; !dup {
|
|
seenQ[qKey] = struct{}{}
|
|
matchedQuestions = append(matchedQuestions, dnsmessage.Question{
|
|
Name: q.Name,
|
|
Type: q.Type,
|
|
Class: dnsmessage.Class(baseClass),
|
|
})
|
|
}
|
|
if isQU {
|
|
unicast = true
|
|
}
|
|
}
|
|
|
|
if !answerTypeEnum && !answerBrowse && !answerLookup && len(browseSubtypes) == 0 {
|
|
return nil, false
|
|
}
|
|
|
|
v4, v6 := splitIPv4AndIPv6(ips)
|
|
builder := dnsmessage.NewBuilder(nil, dnsmessage.Header{
|
|
ID: hdr.ID,
|
|
Response: true,
|
|
Authoritative: true,
|
|
})
|
|
builder.EnableCompression()
|
|
if legacyUnicast && len(matchedQuestions) > 0 {
|
|
if errQ := builder.StartQuestions(); errQ != nil {
|
|
return nil, false
|
|
}
|
|
for _, mq := range matchedQuestions {
|
|
if errAddQ := builder.Question(mq); errAddQ != nil {
|
|
return nil, false
|
|
}
|
|
}
|
|
}
|
|
if errAns := builder.StartAnswers(); errAns != nil {
|
|
return nil, false
|
|
}
|
|
|
|
if answerTypeEnum {
|
|
if err := builder.PTRResource(dnsmessage.ResourceHeader{
|
|
Name: svcTypeName,
|
|
Type: dnsmessage.TypePTR,
|
|
Class: dnsmessage.ClassINET,
|
|
TTL: svcTTL,
|
|
}, dnsmessage.PTRResource{PTR: svcName}); err != nil {
|
|
return nil, false
|
|
}
|
|
}
|
|
if answerBrowse {
|
|
if err := builder.PTRResource(dnsmessage.ResourceHeader{
|
|
Name: svcName,
|
|
Type: dnsmessage.TypePTR,
|
|
Class: dnsmessage.ClassINET,
|
|
TTL: svcTTL,
|
|
}, dnsmessage.PTRResource{PTR: instName}); err != nil {
|
|
return nil, false
|
|
}
|
|
}
|
|
for _, sn := range browseSubtypes {
|
|
if err := builder.PTRResource(dnsmessage.ResourceHeader{
|
|
Name: sn,
|
|
Type: dnsmessage.TypePTR,
|
|
Class: dnsmessage.ClassINET,
|
|
TTL: svcTTL,
|
|
}, dnsmessage.PTRResource{PTR: instName}); err != nil {
|
|
return nil, false
|
|
}
|
|
}
|
|
if answerLookup {
|
|
if err := builder.SRVResource(dnsmessage.ResourceHeader{
|
|
Name: instName,
|
|
Type: dnsmessage.TypeSRV,
|
|
Class: rrClass,
|
|
TTL: svcTTL,
|
|
}, dnsmessage.SRVResource{Port: svc.port, Target: hostName}); err != nil {
|
|
return nil, false
|
|
}
|
|
if err := builder.TXTResource(dnsmessage.ResourceHeader{
|
|
Name: instName,
|
|
Type: dnsmessage.TypeTXT,
|
|
Class: rrClass,
|
|
TTL: svcTTL,
|
|
}, dnsmessage.TXTResource{TXT: svc.text}); err != nil {
|
|
return nil, false
|
|
}
|
|
if !answerBrowse {
|
|
_ = builder.PTRResource(dnsmessage.ResourceHeader{
|
|
Name: svcName,
|
|
Type: dnsmessage.TypePTR,
|
|
Class: dnsmessage.ClassINET,
|
|
TTL: svcTTL,
|
|
}, dnsmessage.PTRResource{PTR: instName})
|
|
}
|
|
if err := appendHostAddrResources(&builder, hostName, rrClass, hostTTL, v4, v6); err != nil {
|
|
return nil, false
|
|
}
|
|
} else if answerBrowse || len(browseSubtypes) > 0 {
|
|
if errExt := builder.StartAdditionals(); errExt != nil {
|
|
return nil, false
|
|
}
|
|
_ = builder.SRVResource(dnsmessage.ResourceHeader{
|
|
Name: instName,
|
|
Type: dnsmessage.TypeSRV,
|
|
Class: dnsmessage.ClassINET,
|
|
TTL: svcTTL,
|
|
}, dnsmessage.SRVResource{Port: svc.port, Target: hostName})
|
|
_ = builder.TXTResource(dnsmessage.ResourceHeader{
|
|
Name: instName,
|
|
Type: dnsmessage.TypeTXT,
|
|
Class: dnsmessage.ClassINET,
|
|
TTL: svcTTL,
|
|
}, dnsmessage.TXTResource{TXT: svc.text})
|
|
_ = appendHostAddrResources(&builder, hostName, dnsmessage.ClassINET, hostTTL, v4, v6)
|
|
}
|
|
|
|
out, errFinish := builder.Finish()
|
|
if errFinish != nil {
|
|
return nil, false
|
|
}
|
|
return rewriteWireLabelChar(out, dotInLabelSentinel, '.'), unicast
|
|
}
|
|
|
|
type hostRecordResponder struct {
|
|
mu sync.Mutex
|
|
inner zeroconfServer
|
|
svc mdnsServiceConfig
|
|
baseHost string
|
|
osHost string
|
|
domain string
|
|
attempt int
|
|
hostFQDN string
|
|
fixedIPs []string
|
|
ifaces []net.Interface
|
|
rebindInner func(string) (zeroconfServer, error)
|
|
probeConflict hostConflictProbeFunc
|
|
onSend func(hostFQDN string, unicast bool, pkt []byte)
|
|
inConflict bool
|
|
stopped bool
|
|
ipv4conn *ipv4.PacketConn
|
|
ipv6conn *ipv6.PacketConn
|
|
stopCh chan struct{}
|
|
wg sync.WaitGroup
|
|
shutdownOnce sync.Once
|
|
}
|
|
|
|
func (r *hostRecordResponder) configureService(instance, service, domain string, port int, text []string) {
|
|
r.mu.Lock()
|
|
r.svc = parseMDNSServiceConfig(instance, service, domain, port, text)
|
|
r.mu.Unlock()
|
|
}
|
|
|
|
func (r *hostRecordResponder) sendIfHostCurrent(expectedHostFQDN string, unicast bool, buf []byte, ifIndex int, from net.Addr) bool {
|
|
if len(buf) == 0 || expectedHostFQDN == "" {
|
|
return false
|
|
}
|
|
r.mu.Lock()
|
|
defer r.mu.Unlock()
|
|
if r.stopped || r.hostFQDN == "" || r.hostFQDN != expectedHostFQDN {
|
|
return false
|
|
}
|
|
if r.onSend != nil {
|
|
r.onSend(expectedHostFQDN, unicast, buf)
|
|
}
|
|
if unicast && from != nil {
|
|
r.sendUnicast(buf, ifIndex, from)
|
|
return true
|
|
}
|
|
r.sendMulticast(buf, ifIndex)
|
|
return true
|
|
}
|
|
|
|
func (r *hostRecordResponder) announceServiceOnce() {
|
|
r.mu.Lock()
|
|
if r.stopped || r.hostFQDN == "" || r.svc.serviceName == "" {
|
|
r.mu.Unlock()
|
|
return
|
|
}
|
|
svc := r.svc
|
|
hostFQDN := r.hostFQDN
|
|
r.mu.Unlock()
|
|
|
|
for _, iface := range r.ifaces {
|
|
ips := r.ipsForInterface(iface.Index)
|
|
if len(ips) == 0 {
|
|
continue
|
|
}
|
|
if pkt := buildServicePacket(svc, hostFQDN, ips, mdnsServiceRecordTTL); len(pkt) > 0 {
|
|
_ = r.sendIfHostCurrent(hostFQDN, false, pkt, iface.Index, nil)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (r *hostRecordResponder) announceService() {
|
|
r.scheduleServiceAnnouncements(mdnsAnnounceRepetitions, mdnsAnnounceInterval, r.announceServiceOnce)
|
|
}
|
|
|
|
func (r *hostRecordResponder) scheduleServiceAnnouncements(repetitions int, initialDelay time.Duration, sendOnce func()) {
|
|
if repetitions < 1 || sendOnce == nil {
|
|
return
|
|
}
|
|
r.mu.Lock()
|
|
if r.stopped || r.hostFQDN == "" || r.svc.serviceName == "" {
|
|
r.mu.Unlock()
|
|
return
|
|
}
|
|
if repetitions > 1 {
|
|
r.wg.Add(1)
|
|
}
|
|
r.mu.Unlock()
|
|
|
|
sendOnce()
|
|
if repetitions <= 1 {
|
|
return
|
|
}
|
|
go func() {
|
|
defer r.wg.Done()
|
|
delay := initialDelay
|
|
for i := 1; i < repetitions; i++ {
|
|
timer := time.NewTimer(delay)
|
|
select {
|
|
case <-r.stopCh:
|
|
timer.Stop()
|
|
return
|
|
case <-timer.C:
|
|
sendOnce()
|
|
delay *= 2
|
|
}
|
|
}
|
|
}()
|
|
}
|
|
|
|
func newHostRecordResponder(inner zeroconfServer, host, domain string, fixedIPs []string, ifaces []net.Interface) (zeroconfServer, error) {
|
|
return newHostRecordResponderWithRebind(inner, host, domain, fixedIPs, ifaces, nil)
|
|
}
|
|
|
|
func newHostRecordResponderWithRebind(inner zeroconfServer, host, domain string, fixedIPs []string, ifaces []net.Interface, rebind func(string) (zeroconfServer, error)) (zeroconfServer, error) {
|
|
ipv4conn, err4 := openMDNSConn4(ifaces)
|
|
ipv6conn, err6 := openMDNSConn6(ifaces)
|
|
if ipv4conn == nil && ipv6conn == nil {
|
|
if inner != nil {
|
|
inner.Shutdown()
|
|
}
|
|
return nil, fmt.Errorf("discovery: failed to start host record responder (ipv4: %v, ipv6: %v)", err4, err6)
|
|
}
|
|
r := &hostRecordResponder{
|
|
inner: inner,
|
|
baseHost: host,
|
|
osHost: extractCleanHost(),
|
|
domain: domain,
|
|
attempt: 1,
|
|
hostFQDN: formatHostFQDN(host, domain),
|
|
fixedIPs: append([]string(nil), fixedIPs...),
|
|
ifaces: append([]net.Interface(nil), ifaces...),
|
|
rebindInner: rebind,
|
|
probeConflict: probeHostConflictOnLAN,
|
|
ipv4conn: ipv4conn,
|
|
ipv6conn: ipv6conn,
|
|
stopCh: make(chan struct{}),
|
|
}
|
|
if r.ipv4conn != nil {
|
|
r.wg.Add(1)
|
|
go r.recv4()
|
|
}
|
|
if r.ipv6conn != nil {
|
|
r.wg.Add(1)
|
|
go r.recv6()
|
|
}
|
|
return r, nil
|
|
}
|
|
|
|
func openMDNSConn4(ifaces []net.Interface) (*ipv4.PacketConn, error) {
|
|
udpConn, err := net.ListenUDP("udp4", mdnsWildcardAddrIPv4)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
pkConn := ipv4.NewPacketConn(udpConn)
|
|
_ = pkConn.SetControlMessage(ipv4.FlagInterface|ipv4.FlagDst, true)
|
|
joined := 0
|
|
var lastErr error
|
|
for i := range ifaces {
|
|
if errJoin := pkConn.JoinGroup(&ifaces[i], mdnsGroupAddrIPv4); errJoin == nil {
|
|
joined++
|
|
} else {
|
|
lastErr = errJoin
|
|
}
|
|
}
|
|
if joined == 0 {
|
|
_ = pkConn.Close()
|
|
if lastErr == nil {
|
|
lastErr = fmt.Errorf("no multicast interfaces joined")
|
|
}
|
|
return nil, lastErr
|
|
}
|
|
_ = pkConn.SetMulticastTTL(255)
|
|
return pkConn, nil
|
|
}
|
|
|
|
func openMDNSConn6(ifaces []net.Interface) (*ipv6.PacketConn, error) {
|
|
udpConn, err := net.ListenUDP("udp6", mdnsWildcardAddrIPv6)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
pkConn := ipv6.NewPacketConn(udpConn)
|
|
_ = pkConn.SetControlMessage(ipv6.FlagInterface|ipv6.FlagDst, true)
|
|
joined := 0
|
|
var lastErr error
|
|
for i := range ifaces {
|
|
if errJoin := pkConn.JoinGroup(&ifaces[i], mdnsGroupAddrIPv6); errJoin == nil {
|
|
joined++
|
|
} else {
|
|
lastErr = errJoin
|
|
}
|
|
}
|
|
if joined == 0 {
|
|
_ = pkConn.Close()
|
|
if lastErr == nil {
|
|
lastErr = fmt.Errorf("no multicast interfaces joined")
|
|
}
|
|
return nil, lastErr
|
|
}
|
|
_ = pkConn.SetMulticastHopLimit(255)
|
|
return pkConn, nil
|
|
}
|
|
|
|
func (r *hostRecordResponder) ifaceAllowed(ifIndex int) bool {
|
|
if ifIndex == 0 {
|
|
return true
|
|
}
|
|
for _, iface := range r.ifaces {
|
|
if iface.Index == ifIndex {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (r *hostRecordResponder) ipsForInterface(ifIndex int) []string {
|
|
if len(r.fixedIPs) > 0 {
|
|
return r.fixedIPs
|
|
}
|
|
if ifIndex != 0 {
|
|
for _, iface := range r.ifaces {
|
|
if iface.Index == ifIndex {
|
|
addrs, err := iface.Addrs()
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
return extractInterfaceAddrs(addrs)
|
|
}
|
|
}
|
|
if iface, err := net.InterfaceByIndex(ifIndex); err == nil && iface != nil {
|
|
if addrs, errAddrs := iface.Addrs(); errAddrs == nil {
|
|
return extractInterfaceAddrs(addrs)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
return extractInterfaceIPs(r.ifaces)
|
|
}
|
|
|
|
func (r *hostRecordResponder) recv4() {
|
|
defer r.wg.Done()
|
|
buf := make([]byte, 65536)
|
|
for {
|
|
select {
|
|
case <-r.stopCh:
|
|
return
|
|
default:
|
|
n, cm, from, err := r.ipv4conn.ReadFrom(buf)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
ifIndex := 0
|
|
isMulticastDst := false
|
|
if cm != nil {
|
|
ifIndex = cm.IfIndex
|
|
if len(cm.Dst) > 0 {
|
|
isMulticastDst = cm.Dst.IsMulticast()
|
|
}
|
|
}
|
|
r.handlePacketWithMeta(buf[:n], ifIndex, from, isMulticastDst)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (r *hostRecordResponder) recv6() {
|
|
defer r.wg.Done()
|
|
buf := make([]byte, 65536)
|
|
for {
|
|
select {
|
|
case <-r.stopCh:
|
|
return
|
|
default:
|
|
n, cm, from, err := r.ipv6conn.ReadFrom(buf)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
ifIndex := 0
|
|
isMulticastDst := false
|
|
if cm != nil {
|
|
ifIndex = cm.IfIndex
|
|
if len(cm.Dst) > 0 {
|
|
isMulticastDst = cm.Dst.IsMulticast()
|
|
}
|
|
}
|
|
r.handlePacketWithMeta(buf[:n], ifIndex, from, isMulticastDst)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (r *hostRecordResponder) currentHostFQDN() string {
|
|
r.mu.Lock()
|
|
defer r.mu.Unlock()
|
|
return r.hostFQDN
|
|
}
|
|
|
|
func (r *hostRecordResponder) goodbyePacketsLocked(hostFQDN string) map[int][]byte {
|
|
if hostFQDN == "" {
|
|
return nil
|
|
}
|
|
if len(r.fixedIPs) > 0 && r.inner != nil {
|
|
return nil
|
|
}
|
|
out := make(map[int][]byte, len(r.ifaces))
|
|
for _, iface := range r.ifaces {
|
|
ips := r.ipsForInterface(iface.Index)
|
|
if len(ips) == 0 {
|
|
continue
|
|
}
|
|
var pkt []byte
|
|
if r.svc.serviceName != "" {
|
|
pkt = buildServicePacket(r.svc, hostFQDN, ips, 0)
|
|
} else {
|
|
pkt = buildHostGoodbyePacket(hostFQDN, ips)
|
|
}
|
|
if len(pkt) > 0 {
|
|
out[iface.Index] = pkt
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
func (r *hostRecordResponder) goodbyePacketsForHost(hostFQDN string) map[int][]byte {
|
|
r.mu.Lock()
|
|
defer r.mu.Unlock()
|
|
return r.goodbyePacketsLocked(hostFQDN)
|
|
}
|
|
|
|
func (r *hostRecordResponder) sendGoodbyeLocked(hostFQDN string) {
|
|
for ifIndex, pkt := range r.goodbyePacketsLocked(hostFQDN) {
|
|
r.sendMulticast(pkt, ifIndex)
|
|
}
|
|
}
|
|
|
|
func (r *hostRecordResponder) sendGoodbyeForHost(hostFQDN string) {
|
|
r.mu.Lock()
|
|
defer r.mu.Unlock()
|
|
r.sendGoodbyeLocked(hostFQDN)
|
|
}
|
|
|
|
func (r *hostRecordResponder) withdrawConflictedHost(observedFQDN string) {
|
|
r.mu.Lock()
|
|
if r.stopped || r.hostFQDN == "" || r.hostFQDN != observedFQDN {
|
|
r.mu.Unlock()
|
|
return
|
|
}
|
|
oldFQDN := r.hostFQDN
|
|
oldInner := r.inner
|
|
r.hostFQDN = ""
|
|
r.inner = nil
|
|
r.sendGoodbyeLocked(oldFQDN)
|
|
r.mu.Unlock()
|
|
|
|
if oldInner != nil {
|
|
oldInner.Shutdown()
|
|
}
|
|
}
|
|
|
|
func (r *hostRecordResponder) handleConflict(observedFQDN string) {
|
|
r.mu.Lock()
|
|
if r.stopped || r.inConflict || r.hostFQDN == "" || r.hostFQDN != observedFQDN {
|
|
r.mu.Unlock()
|
|
return
|
|
}
|
|
if r.attempt >= maxHostCollisionAttempts {
|
|
r.mu.Unlock()
|
|
log.Warnf("discovery: conflict attempts exhausted for %s; withdrawing host advertisement", observedFQDN)
|
|
r.withdrawConflictedHost(observedFQDN)
|
|
return
|
|
}
|
|
r.inConflict = true
|
|
startAttempt := r.attempt + 1
|
|
baseHost := r.baseHost
|
|
osHost := r.osHost
|
|
domain := r.domain
|
|
rebind := r.rebindInner
|
|
probe := r.probeConflict
|
|
r.mu.Unlock()
|
|
|
|
defer func() {
|
|
r.mu.Lock()
|
|
r.inConflict = false
|
|
r.mu.Unlock()
|
|
}()
|
|
|
|
localIPs := r.allLocalIPs()
|
|
nextHost, nextAttempt, errResolve := resolveAdvertisedHostCandidate(context.Background(), baseHost, startAttempt, osHost, domain, r.ifaces, localIPs, probe)
|
|
if errResolve != nil {
|
|
log.Warnf("discovery: unable to resolve replacement host after conflict on %s: %v; withdrawing host advertisement", observedFQDN, errResolve)
|
|
r.withdrawConflictedHost(observedFQDN)
|
|
return
|
|
}
|
|
|
|
var nextInner zeroconfServer
|
|
if rebind != nil {
|
|
var errRebind error
|
|
nextInner, errRebind = rebind(nextHost)
|
|
if errRebind != nil || nextInner == nil {
|
|
log.Warnf("discovery: failed to rebind service under replacement host %s: %v; withdrawing host advertisement", nextHost, errRebind)
|
|
r.withdrawConflictedHost(observedFQDN)
|
|
return
|
|
}
|
|
}
|
|
|
|
r.mu.Lock()
|
|
if r.stopped || r.hostFQDN != observedFQDN {
|
|
r.mu.Unlock()
|
|
if nextInner != nil {
|
|
nextInner.Shutdown()
|
|
}
|
|
return
|
|
}
|
|
oldFQDN := r.hostFQDN
|
|
oldInner := r.inner
|
|
r.attempt = nextAttempt
|
|
r.hostFQDN = formatHostFQDN(nextHost, domain)
|
|
if nextInner != nil {
|
|
r.inner = nextInner
|
|
}
|
|
r.sendGoodbyeLocked(oldFQDN)
|
|
r.mu.Unlock()
|
|
|
|
if oldInner != nil && nextInner != nil && oldInner != nextInner {
|
|
oldInner.Shutdown()
|
|
}
|
|
r.announceService()
|
|
}
|
|
|
|
func (r *hostRecordResponder) allLocalIPs() []string {
|
|
if len(r.fixedIPs) > 0 {
|
|
return r.fixedIPs
|
|
}
|
|
return extractInterfaceIPs(r.ifaces)
|
|
}
|
|
|
|
func hostAnswerHasForeignIP(answerIPs, localIPs []string) bool {
|
|
if len(answerIPs) == 0 {
|
|
return false
|
|
}
|
|
if len(localIPs) == 0 {
|
|
return true
|
|
}
|
|
localSet := make(map[string]struct{}, len(localIPs))
|
|
for _, raw := range localIPs {
|
|
if ip := net.ParseIP(strings.TrimSpace(raw)); ip != nil {
|
|
localSet[ip.String()] = struct{}{}
|
|
}
|
|
}
|
|
for _, raw := range answerIPs {
|
|
ip := net.ParseIP(strings.TrimSpace(raw))
|
|
if ip == nil {
|
|
continue
|
|
}
|
|
if _, ok := localSet[ip.String()]; !ok {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func isOnLinkSource(from net.Addr, ifIndex int, ifaces []net.Interface, configuredIPs []string) bool {
|
|
uaddr, ok := from.(*net.UDPAddr)
|
|
if !ok || uaddr == nil || uaddr.IP == nil {
|
|
return false
|
|
}
|
|
if uaddr.IP.IsLoopback() || uaddr.IP.IsLinkLocalUnicast() {
|
|
return true
|
|
}
|
|
checkedKernelAddrs := false
|
|
for _, iface := range ifaces {
|
|
if ifIndex != 0 && iface.Index != ifIndex {
|
|
continue
|
|
}
|
|
addrs, err := iface.Addrs()
|
|
if err != nil || len(addrs) == 0 {
|
|
continue
|
|
}
|
|
checkedKernelAddrs = true
|
|
for _, addr := range addrs {
|
|
switch v := addr.(type) {
|
|
case *net.IPNet:
|
|
if v.Contains(uaddr.IP) {
|
|
return true
|
|
}
|
|
case *net.IPAddr:
|
|
if v.IP.Equal(uaddr.IP) {
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if !checkedKernelAddrs {
|
|
for _, iface := range ifaces {
|
|
addrs, err := iface.Addrs()
|
|
if err != nil || len(addrs) == 0 {
|
|
continue
|
|
}
|
|
checkedKernelAddrs = true
|
|
for _, addr := range addrs {
|
|
switch v := addr.(type) {
|
|
case *net.IPNet:
|
|
if v.Contains(uaddr.IP) {
|
|
return true
|
|
}
|
|
case *net.IPAddr:
|
|
if v.IP.Equal(uaddr.IP) {
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for _, raw := range configuredIPs {
|
|
ip := net.ParseIP(strings.TrimSpace(raw))
|
|
if ip == nil || isLocalInterfaceIP(ip, ifaces) {
|
|
continue
|
|
}
|
|
if ip4 := ip.To4(); ip4 != nil {
|
|
mask := net.CIDRMask(24, 32)
|
|
subnet := net.IPNet{IP: ip4.Mask(mask), Mask: mask}
|
|
if subnet.Contains(uaddr.IP) {
|
|
return true
|
|
}
|
|
continue
|
|
}
|
|
if ip16 := ip.To16(); ip16 != nil {
|
|
mask := net.CIDRMask(64, 128)
|
|
subnet := net.IPNet{IP: ip16.Mask(mask), Mask: mask}
|
|
if subnet.Contains(uaddr.IP) {
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func isValidMDNSResponseSource(from net.Addr, ifIndex int, ifaces []net.Interface, configuredIPs []string) bool {
|
|
uaddr, ok := from.(*net.UDPAddr)
|
|
if !ok || uaddr == nil || uaddr.Port != mdnsPort {
|
|
return false
|
|
}
|
|
return isOnLinkSource(from, ifIndex, ifaces, configuredIPs)
|
|
}
|
|
|
|
func isValidMDNSResponsePeer(from net.Addr, ifIndex int, ifaces []net.Interface, configuredIPs []string, isMulticastDst bool) bool {
|
|
uaddr, ok := from.(*net.UDPAddr)
|
|
if !ok || uaddr == nil || uaddr.Port != mdnsPort || uaddr.IP == nil {
|
|
return false
|
|
}
|
|
if isMulticastDst {
|
|
return true
|
|
}
|
|
return isOnLinkSource(from, ifIndex, ifaces, configuredIPs)
|
|
}
|
|
|
|
func (r *hostRecordResponder) handlePacket(pkt []byte, ifIndex int, from net.Addr) {
|
|
r.handlePacketWithMeta(pkt, ifIndex, from, false)
|
|
}
|
|
|
|
type mdnsQueryReply struct {
|
|
payload []byte
|
|
unicast bool
|
|
}
|
|
|
|
func buildCombinedQueryReplies(pkt []byte, svc mdnsServiceConfig, hostFQDN string, ips []string, legacyUnicast bool) []mdnsQueryReply {
|
|
var out []mdnsQueryReply
|
|
if legacyUnicast {
|
|
if hostReply, hostUnicast := buildHostAddressReplyFiltered(pkt, hostFQDN, ips, true, nil); len(hostReply) > 0 {
|
|
out = append(out, mdnsQueryReply{payload: hostReply, unicast: hostUnicast})
|
|
}
|
|
if svc.serviceName != "" {
|
|
if svcReply, svcUnicast := buildServiceQueryReplyFiltered(pkt, svc, hostFQDN, ips, true, nil); len(svcReply) > 0 {
|
|
out = append(out, mdnsQueryReply{payload: svcReply, unicast: svcUnicast})
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
for _, wantQU := range []bool{false, true} {
|
|
qu := wantQU
|
|
if hostReply, hostUnicast := buildHostAddressReplyFiltered(pkt, hostFQDN, ips, false, &qu); len(hostReply) > 0 {
|
|
out = append(out, mdnsQueryReply{payload: hostReply, unicast: hostUnicast})
|
|
}
|
|
if svc.serviceName != "" {
|
|
if svcReply, svcUnicast := buildServiceQueryReplyFiltered(pkt, svc, hostFQDN, ips, false, &qu); len(svcReply) > 0 {
|
|
out = append(out, mdnsQueryReply{payload: svcReply, unicast: svcUnicast})
|
|
}
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
func (r *hostRecordResponder) handlePacketWithMeta(pkt []byte, ifIndex int, from net.Addr, isMulticastDst bool) {
|
|
if !r.ifaceAllowed(ifIndex) {
|
|
return
|
|
}
|
|
r.mu.Lock()
|
|
hostFQDN := r.hostFQDN
|
|
svc := r.svc
|
|
r.mu.Unlock()
|
|
if hostFQDN == "" {
|
|
return
|
|
}
|
|
ips := r.ipsForInterface(ifIndex)
|
|
if len(ips) == 0 {
|
|
return
|
|
}
|
|
allLocal := r.allLocalIPs()
|
|
if !isMulticastDst && from != nil && !isOnLinkSource(from, ifIndex, r.ifaces, allLocal) {
|
|
return
|
|
}
|
|
if answerIPs := extractHostAnswerIPs(pkt, hostFQDN); len(answerIPs) > 0 {
|
|
if isValidMDNSResponsePeer(from, ifIndex, r.ifaces, allLocal, isMulticastDst) && hostAnswerHasForeignIP(answerIPs, allLocal) {
|
|
r.handleConflict(hostFQDN)
|
|
}
|
|
return
|
|
}
|
|
if hasHostResponseRecord(pkt, hostFQDN) {
|
|
if isValidMDNSResponsePeer(from, ifIndex, r.ifaces, allLocal, isMulticastDst) {
|
|
r.handleConflict(hostFQDN)
|
|
}
|
|
return
|
|
}
|
|
legacyUnicast := false
|
|
if uaddr, ok := from.(*net.UDPAddr); ok && uaddr != nil && uaddr.Port != mdnsPort {
|
|
legacyUnicast = true
|
|
}
|
|
for _, rep := range buildCombinedQueryReplies(pkt, svc, hostFQDN, ips, legacyUnicast) {
|
|
_ = r.sendIfHostCurrent(hostFQDN, rep.unicast && from != nil, rep.payload, ifIndex, from)
|
|
}
|
|
}
|
|
|
|
func (r *hostRecordResponder) sendUnicast(buf []byte, ifIndex int, from net.Addr) {
|
|
uaddr, ok := from.(*net.UDPAddr)
|
|
if !ok || uaddr == nil {
|
|
return
|
|
}
|
|
if uaddr.IP.To4() != nil {
|
|
if r.ipv4conn == nil {
|
|
return
|
|
}
|
|
if ifIndex != 0 && supportsPerInterfaceAddrs(runtime.GOOS) {
|
|
wcm := ipv4.ControlMessage{IfIndex: ifIndex}
|
|
_, _ = r.ipv4conn.WriteTo(buf, &wcm, uaddr)
|
|
return
|
|
}
|
|
_, _ = r.ipv4conn.WriteTo(buf, nil, uaddr)
|
|
return
|
|
}
|
|
if r.ipv6conn == nil {
|
|
return
|
|
}
|
|
if ifIndex != 0 && supportsPerInterfaceAddrs(runtime.GOOS) {
|
|
wcm := ipv6.ControlMessage{IfIndex: ifIndex}
|
|
_, _ = r.ipv6conn.WriteTo(buf, &wcm, uaddr)
|
|
return
|
|
}
|
|
_, _ = r.ipv6conn.WriteTo(buf, nil, uaddr)
|
|
}
|
|
|
|
func (r *hostRecordResponder) sendMulticast(buf []byte, ifIndex int) {
|
|
if r.ipv4conn != nil {
|
|
if ifIndex != 0 {
|
|
r.writeMulticast4(buf, ifIndex)
|
|
} else {
|
|
for _, iface := range r.ifaces {
|
|
r.writeMulticast4(buf, iface.Index)
|
|
}
|
|
}
|
|
}
|
|
if r.ipv6conn != nil {
|
|
if ifIndex != 0 {
|
|
r.writeMulticast6(buf, ifIndex)
|
|
} else {
|
|
for _, iface := range r.ifaces {
|
|
r.writeMulticast6(buf, iface.Index)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func (r *hostRecordResponder) writeMulticast4(buf []byte, ifIndex int) {
|
|
if supportsPerInterfaceAddrs(runtime.GOOS) {
|
|
wcm := ipv4.ControlMessage{IfIndex: ifIndex}
|
|
_, _ = r.ipv4conn.WriteTo(buf, &wcm, mdnsGroupAddrIPv4)
|
|
return
|
|
}
|
|
if iface, err := net.InterfaceByIndex(ifIndex); err == nil && iface != nil {
|
|
_ = r.ipv4conn.SetMulticastInterface(iface)
|
|
}
|
|
_, _ = r.ipv4conn.WriteTo(buf, nil, mdnsGroupAddrIPv4)
|
|
}
|
|
|
|
func (r *hostRecordResponder) writeMulticast6(buf []byte, ifIndex int) {
|
|
if supportsPerInterfaceAddrs(runtime.GOOS) {
|
|
wcm := ipv6.ControlMessage{IfIndex: ifIndex}
|
|
_, _ = r.ipv6conn.WriteTo(buf, &wcm, mdnsGroupAddrIPv6)
|
|
return
|
|
}
|
|
if iface, err := net.InterfaceByIndex(ifIndex); err == nil && iface != nil {
|
|
_ = r.ipv6conn.SetMulticastInterface(iface)
|
|
}
|
|
_, _ = r.ipv6conn.WriteTo(buf, nil, mdnsGroupAddrIPv6)
|
|
}
|
|
|
|
func (r *hostRecordResponder) sendGoodbye() {
|
|
r.sendGoodbyeForHost(r.currentHostFQDN())
|
|
}
|
|
|
|
func (r *hostRecordResponder) Shutdown() {
|
|
r.shutdownOnce.Do(func() {
|
|
r.mu.Lock()
|
|
r.stopped = true
|
|
inner := r.inner
|
|
r.inner = nil
|
|
r.mu.Unlock()
|
|
|
|
r.sendGoodbye()
|
|
close(r.stopCh)
|
|
if r.ipv4conn != nil {
|
|
_ = r.ipv4conn.Close()
|
|
}
|
|
if r.ipv6conn != nil {
|
|
_ = r.ipv6conn.Close()
|
|
}
|
|
r.wg.Wait()
|
|
if inner != nil {
|
|
inner.Shutdown()
|
|
}
|
|
})
|
|
}
|
|
|
|
// ZeroconfAdvertiser wraps libp2p/zeroconf/v2 Server with defensive lifecycle management.
|
|
type ZeroconfAdvertiser struct {
|
|
mu sync.Mutex
|
|
server zeroconfServer
|
|
inFlight bool
|
|
closed bool
|
|
registerProxy registerProxyFunc
|
|
interfaceIPs func([]net.Interface) []string
|
|
osHostname func() (string, error)
|
|
probeHostConflict hostConflictProbeFunc
|
|
}
|
|
|
|
// NewZeroconfAdvertiser returns a new ZeroconfAdvertiser.
|
|
func NewZeroconfAdvertiser() *ZeroconfAdvertiser {
|
|
return &ZeroconfAdvertiser{}
|
|
}
|
|
|
|
func cleanHostname(h string) string {
|
|
h = strings.TrimSpace(h)
|
|
h = strings.TrimSuffix(h, ".")
|
|
if len(h) >= 6 && strings.EqualFold(h[len(h)-6:], ".local") {
|
|
h = h[:len(h)-6]
|
|
}
|
|
h = strings.TrimSuffix(h, ".")
|
|
if h == "" {
|
|
return "localhost"
|
|
}
|
|
return h
|
|
}
|
|
|
|
// extractCleanHost returns bare hostname without any .local suffix
|
|
// to prevent libp2p/zeroconf/v2 from appending a duplicate .local. (e.g. on macOS).
|
|
func extractCleanHost() string {
|
|
h, err := os.Hostname()
|
|
if err != nil || h == "" {
|
|
return "localhost"
|
|
}
|
|
return cleanHostname(h)
|
|
}
|
|
|
|
func sanitizeDNSLabel(s string) string {
|
|
var b strings.Builder
|
|
prevHyphen := false
|
|
for i := 0; i < len(s); i++ {
|
|
c := s[i]
|
|
switch {
|
|
case c >= 'a' && c <= 'z', c >= '0' && c <= '9':
|
|
b.WriteByte(c)
|
|
prevHyphen = false
|
|
case c >= 'A' && c <= 'Z':
|
|
b.WriteByte(c + ('a' - 'A'))
|
|
prevHyphen = false
|
|
default:
|
|
if b.Len() > 0 && !prevHyphen {
|
|
b.WriteByte('-')
|
|
prevHyphen = true
|
|
}
|
|
}
|
|
}
|
|
return strings.Trim(b.String(), "-")
|
|
}
|
|
|
|
// buildAdvertisedHost derives a proxy-specific RFC 1123 host label from the
|
|
// instance name so mDNS advertisement never claims or flushes the OS-owned
|
|
// <hostname>.local. record.
|
|
func buildAdvertisedHost(instanceName, osHost string) string {
|
|
clean := sanitizeDNSLabel(instanceName)
|
|
var rest string
|
|
switch {
|
|
case clean == "cpa":
|
|
rest = "0001"
|
|
case strings.HasPrefix(clean, "cpa-"):
|
|
rest = strings.TrimPrefix(clean, "cpa-")
|
|
default:
|
|
rest = clean
|
|
}
|
|
rest = strings.Trim(rest, "-")
|
|
if rest == "" {
|
|
rest = "0001"
|
|
}
|
|
|
|
const prefix = "cpa-"
|
|
maxRest := maxDNSLabelBytes - len(prefix)
|
|
if len(rest) > maxRest {
|
|
if len(rest) > 5 && rest[len(rest)-5] == '-' && isValidHex4(rest[len(rest)-4:]) {
|
|
suffix := rest[len(rest)-5:]
|
|
head := strings.TrimRight(rest[:maxRest-len(suffix)], "-")
|
|
if head == "" {
|
|
rest = strings.TrimPrefix(suffix, "-")
|
|
} else {
|
|
rest = head + suffix
|
|
}
|
|
} else {
|
|
rest = strings.TrimRight(rest[:maxRest], "-")
|
|
}
|
|
if rest == "" {
|
|
rest = "0001"
|
|
}
|
|
}
|
|
|
|
label := prefix + rest
|
|
cleanOS := strings.ToLower(cleanHostname(osHost))
|
|
if cleanOS != "" && cleanOS != "localhost" && strings.EqualFold(label, cleanOS) {
|
|
const altSuffix = "-svc"
|
|
if len(label)+len(altSuffix) <= maxDNSLabelBytes {
|
|
label += altSuffix
|
|
} else {
|
|
trimmed := strings.TrimRight(label[:maxDNSLabelBytes-len(altSuffix)], "-")
|
|
if trimmed == "" {
|
|
label = "cpa-0001" + altSuffix
|
|
} else {
|
|
label = trimmed + altSuffix
|
|
}
|
|
}
|
|
}
|
|
return label
|
|
}
|
|
|
|
func appendHostCollisionSuffix(baseLabel string, attempt int) string {
|
|
if attempt <= 1 {
|
|
return baseLabel
|
|
}
|
|
suffix := fmt.Sprintf("-%d", attempt)
|
|
if len(baseLabel)+len(suffix) <= maxDNSLabelBytes {
|
|
return baseLabel + suffix
|
|
}
|
|
trimmed := strings.TrimRight(baseLabel[:maxDNSLabelBytes-len(suffix)], "-")
|
|
if trimmed == "" {
|
|
return "cpa" + suffix
|
|
}
|
|
return trimmed + suffix
|
|
}
|
|
|
|
func extractHostAnswerIPs(pkt []byte, hostFQDN string) []string {
|
|
normPkt := rewriteWireLabelChar(pkt, '.', dotInLabelSentinel)
|
|
var p dnsmessage.Parser
|
|
hdr, err := p.Start(normPkt)
|
|
if err != nil || !hdr.Response {
|
|
return nil
|
|
}
|
|
if errSkipQ := p.SkipAllQuestions(); errSkipQ != nil {
|
|
return nil
|
|
}
|
|
var ips []string
|
|
collect := func(nextHeader func() (dnsmessage.ResourceHeader, error), skip func() error) bool {
|
|
for {
|
|
rh, errH := nextHeader()
|
|
if errH != nil {
|
|
return errH == dnsmessage.ErrSectionDone
|
|
}
|
|
if !strings.EqualFold(rh.Name.String(), hostFQDN) || rh.TTL == 0 {
|
|
if errSkip := skip(); errSkip != nil {
|
|
return false
|
|
}
|
|
continue
|
|
}
|
|
switch rh.Type {
|
|
case dnsmessage.TypeA:
|
|
r, errA := p.AResource()
|
|
if errA != nil {
|
|
return false
|
|
}
|
|
ips = append(ips, net.IP(r.A[:]).String())
|
|
case dnsmessage.TypeAAAA:
|
|
r, errAAAA := p.AAAAResource()
|
|
if errAAAA != nil {
|
|
return false
|
|
}
|
|
ips = append(ips, net.IP(r.AAAA[:]).String())
|
|
default:
|
|
if errSkip := skip(); errSkip != nil {
|
|
return false
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if !collect(p.AnswerHeader, p.SkipAnswer) {
|
|
return ips
|
|
}
|
|
if errSkipAuth := p.SkipAllAuthorities(); errSkipAuth != nil {
|
|
return ips
|
|
}
|
|
_ = collect(p.AdditionalHeader, p.SkipAdditional)
|
|
return ips
|
|
}
|
|
|
|
func hasHostResponseRecord(pkt []byte, hostFQDN string) bool {
|
|
normPkt := rewriteWireLabelChar(pkt, '.', dotInLabelSentinel)
|
|
var p dnsmessage.Parser
|
|
hdr, err := p.Start(normPkt)
|
|
if err != nil || !hdr.Response {
|
|
return false
|
|
}
|
|
if errSkipQ := p.SkipAllQuestions(); errSkipQ != nil {
|
|
return false
|
|
}
|
|
found := false
|
|
scan := func(nextHeader func() (dnsmessage.ResourceHeader, error), skip func() error) bool {
|
|
for {
|
|
rh, errH := nextHeader()
|
|
if errH != nil {
|
|
return errH == dnsmessage.ErrSectionDone
|
|
}
|
|
if errSkip := skip(); errSkip != nil {
|
|
return false
|
|
}
|
|
if rh.TTL > 0 && strings.EqualFold(rh.Name.String(), hostFQDN) {
|
|
found = true
|
|
return false
|
|
}
|
|
}
|
|
}
|
|
if !scan(p.AnswerHeader, p.SkipAnswer) || found {
|
|
return found
|
|
}
|
|
if errSkipAuth := p.SkipAllAuthorities(); errSkipAuth != nil {
|
|
return false
|
|
}
|
|
_ = scan(p.AdditionalHeader, p.SkipAdditional)
|
|
return found
|
|
}
|
|
|
|
func extractHostAuthorityIPs(pkt []byte, hostFQDN string) (uint16, []string, bool) {
|
|
normPkt := rewriteWireLabelChar(pkt, '.', dotInLabelSentinel)
|
|
var p dnsmessage.Parser
|
|
hdr, err := p.Start(normPkt)
|
|
if err != nil || hdr.Response {
|
|
return 0, nil, false
|
|
}
|
|
qs, errQ := p.AllQuestions()
|
|
if errQ != nil || len(qs) == 0 {
|
|
return 0, nil, false
|
|
}
|
|
matchedQ := false
|
|
for _, q := range qs {
|
|
if strings.EqualFold(q.Name.String(), hostFQDN) {
|
|
matchedQ = true
|
|
break
|
|
}
|
|
}
|
|
if !matchedQ {
|
|
return 0, nil, false
|
|
}
|
|
if errSkipAns := p.SkipAllAnswers(); errSkipAns != nil {
|
|
return 0, nil, false
|
|
}
|
|
var ips []string
|
|
hasOtherType := false
|
|
for {
|
|
rh, errH := p.AuthorityHeader()
|
|
if errH != nil {
|
|
break
|
|
}
|
|
if !strings.EqualFold(rh.Name.String(), hostFQDN) || rh.TTL == 0 {
|
|
if errSkip := p.SkipAuthority(); errSkip != nil {
|
|
break
|
|
}
|
|
continue
|
|
}
|
|
switch rh.Type {
|
|
case dnsmessage.TypeA:
|
|
r, errA := p.AResource()
|
|
if errA != nil {
|
|
return hdr.ID, ips, hasOtherType
|
|
}
|
|
ips = append(ips, net.IP(r.A[:]).String())
|
|
case dnsmessage.TypeAAAA:
|
|
r, errAAAA := p.AAAAResource()
|
|
if errAAAA != nil {
|
|
return hdr.ID, ips, hasOtherType
|
|
}
|
|
ips = append(ips, net.IP(r.AAAA[:]).String())
|
|
default:
|
|
if errSkip := p.SkipAuthority(); errSkip != nil {
|
|
return hdr.ID, ips, hasOtherType
|
|
}
|
|
hasOtherType = true
|
|
}
|
|
}
|
|
return hdr.ID, ips, hasOtherType
|
|
}
|
|
|
|
func canonicalHostRecordList(ips []string) [][]byte {
|
|
v4, v6 := splitIPv4AndIPv6(ips)
|
|
records := make([][]byte, 0, len(v4)+len(v6))
|
|
for _, addr := range v4 {
|
|
rec := append([]byte{0, byte(dnsmessage.TypeA)}, addr[:]...)
|
|
records = append(records, rec)
|
|
}
|
|
for _, addr := range v6 {
|
|
rec := append([]byte{0, byte(dnsmessage.TypeAAAA)}, addr[:]...)
|
|
records = append(records, rec)
|
|
}
|
|
sort.Slice(records, func(i, j int) bool {
|
|
return bytes.Compare(records[i], records[j]) < 0
|
|
})
|
|
dedup := records[:0]
|
|
for _, rec := range records {
|
|
if len(dedup) == 0 || !bytes.Equal(dedup[len(dedup)-1], rec) {
|
|
dedup = append(dedup, rec)
|
|
}
|
|
}
|
|
return dedup
|
|
}
|
|
|
|
// compareHostRecordSets compares two proposed record sets lexicographically per RFC 6762 §8.2.
|
|
// Returns -1 if localIPs < peerIPs (local loses), +1 if localIPs > peerIPs (local wins), 0 if equal.
|
|
func compareHostRecordSets(localIPs, peerIPs []string) int {
|
|
ours := canonicalHostRecordList(localIPs)
|
|
theirs := canonicalHostRecordList(peerIPs)
|
|
limit := min(len(ours), len(theirs))
|
|
for i := 0; i < limit; i++ {
|
|
if cmp := bytes.Compare(ours[i], theirs[i]); cmp != 0 {
|
|
return cmp
|
|
}
|
|
}
|
|
switch {
|
|
case len(ours) < len(theirs):
|
|
return -1
|
|
case len(ours) > len(theirs):
|
|
return 1
|
|
default:
|
|
return 0
|
|
}
|
|
}
|
|
|
|
func isLocalInterfaceIP(target net.IP, ifaces []net.Interface) bool {
|
|
if target == nil {
|
|
return false
|
|
}
|
|
for _, iface := range ifaces {
|
|
if interfaceHasIP(iface, target) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func isOwnLoopbackProbe(pkt, ownQuery []byte, from net.Addr, ownPorts map[int]struct{}, ifaces []net.Interface) bool {
|
|
if len(ownQuery) == 0 || !bytes.Equal(pkt, ownQuery) {
|
|
return false
|
|
}
|
|
uaddr, ok := from.(*net.UDPAddr)
|
|
if !ok || uaddr == nil {
|
|
return false
|
|
}
|
|
if _, portMatch := ownPorts[uaddr.Port]; !portMatch {
|
|
return false
|
|
}
|
|
return isLocalInterfaceIP(uaddr.IP, ifaces)
|
|
}
|
|
|
|
func isHostProbeConflict(pkt []byte, hostFQDN string, localIPs []string, ownPort, peerPort int) bool {
|
|
if hasHostResponseRecord(pkt, hostFQDN) {
|
|
return true
|
|
}
|
|
theirID, authIPs, hasOtherType := extractHostAuthorityIPs(pkt, hostFQDN)
|
|
if hasOtherType {
|
|
return true
|
|
}
|
|
if len(authIPs) == 0 {
|
|
return false
|
|
}
|
|
cmp := compareHostRecordSets(localIPs, authIPs)
|
|
if cmp < 0 {
|
|
return true
|
|
}
|
|
if cmp > 0 {
|
|
return false
|
|
}
|
|
if ownPort > 0 && peerPort > 0 && ownPort != peerPort {
|
|
return ownPort < peerPort
|
|
}
|
|
return theirID != 0
|
|
}
|
|
|
|
func ifaceInList(ifIndex int, ifaces []net.Interface) bool {
|
|
if ifIndex <= 0 {
|
|
return false
|
|
}
|
|
for _, iface := range ifaces {
|
|
if iface.Index == ifIndex {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func isValidProbePeer(from net.Addr, ifIndex int, ifaces []net.Interface, configuredIPs []string, isMulticast, isResponse bool) bool {
|
|
uaddr, ok := from.(*net.UDPAddr)
|
|
if !ok || uaddr == nil || uaddr.IP == nil {
|
|
return false
|
|
}
|
|
if isResponse && uaddr.Port != mdnsPort {
|
|
return false
|
|
}
|
|
if isMulticast || ifaceInList(ifIndex, ifaces) {
|
|
return true
|
|
}
|
|
return isOnLinkSource(from, ifIndex, ifaces, configuredIPs)
|
|
}
|
|
|
|
func buildHostProbeQuery(hostFQDN string, probeID uint16, localIPs []string) ([]byte, error) {
|
|
qName, errName := dnsmessage.NewName(hostFQDN)
|
|
if errName != nil {
|
|
return nil, errName
|
|
}
|
|
builder := dnsmessage.NewBuilder(nil, dnsmessage.Header{ID: probeID})
|
|
builder.EnableCompression()
|
|
if errStartQ := builder.StartQuestions(); errStartQ != nil {
|
|
return nil, errStartQ
|
|
}
|
|
if errQ := builder.Question(dnsmessage.Question{
|
|
Name: qName,
|
|
Type: dnsmessage.TypeALL,
|
|
Class: dnsmessage.ClassINET,
|
|
}); errQ != nil {
|
|
return nil, errQ
|
|
}
|
|
v4, v6 := splitIPv4AndIPv6(localIPs)
|
|
if len(v4) > 0 || len(v6) > 0 {
|
|
if errAuth := builder.StartAuthorities(); errAuth != nil {
|
|
return nil, errAuth
|
|
}
|
|
for _, addr := range v4 {
|
|
if errAdd := builder.AResource(dnsmessage.ResourceHeader{
|
|
Name: qName,
|
|
Type: dnsmessage.TypeA,
|
|
Class: dnsmessage.ClassINET,
|
|
TTL: mdnsHostRecordTTL,
|
|
}, dnsmessage.AResource{A: addr}); errAdd != nil {
|
|
return nil, errAdd
|
|
}
|
|
}
|
|
for _, addr := range v6 {
|
|
if errAdd := builder.AAAAResource(dnsmessage.ResourceHeader{
|
|
Name: qName,
|
|
Type: dnsmessage.TypeAAAA,
|
|
Class: dnsmessage.ClassINET,
|
|
TTL: mdnsHostRecordTTL,
|
|
}, dnsmessage.AAAAResource{AAAA: addr}); errAdd != nil {
|
|
return nil, errAdd
|
|
}
|
|
}
|
|
}
|
|
return builder.Finish()
|
|
}
|
|
|
|
func randomProbeID() uint16 {
|
|
var b [2]byte
|
|
if _, err := rand.Read(b[:]); err == nil {
|
|
if id := binary.BigEndian.Uint16(b[:]); id != 0 {
|
|
return id
|
|
}
|
|
}
|
|
return uint16(os.Getpid()&0x7FFF) | 1
|
|
}
|
|
|
|
func awaitProbeConflictResult(conflictCh <-chan bool, doneCh <-chan struct{}, detected *atomic.Bool, ctx context.Context, stopReaders func()) (bool, error) {
|
|
select {
|
|
case <-conflictCh:
|
|
if stopReaders != nil {
|
|
stopReaders()
|
|
}
|
|
<-doneCh
|
|
return true, nil
|
|
case <-doneCh:
|
|
if detected != nil && detected.Load() {
|
|
return true, nil
|
|
}
|
|
select {
|
|
case <-conflictCh:
|
|
return true, nil
|
|
default:
|
|
}
|
|
if ctx != nil && ctx.Err() != nil {
|
|
return false, ctx.Err()
|
|
}
|
|
return false, nil
|
|
}
|
|
}
|
|
|
|
func runHostProbeSchedule(ctx context.Context, probeCount int, probeInterval time.Duration, sendProbe func() error, conflictCh <-chan bool, doneCh <-chan struct{}, detected *atomic.Bool, stopReaders func()) (bool, error) {
|
|
if probeCount < 1 {
|
|
probeCount = 1
|
|
}
|
|
var ctxDone <-chan struct{}
|
|
if ctx != nil {
|
|
ctxDone = ctx.Done()
|
|
}
|
|
for i := 0; i < probeCount; i++ {
|
|
if ctx != nil && ctx.Err() != nil {
|
|
if stopReaders != nil {
|
|
stopReaders()
|
|
}
|
|
<-doneCh
|
|
if detected != nil && detected.Load() {
|
|
return true, nil
|
|
}
|
|
return false, ctx.Err()
|
|
}
|
|
if errSend := sendProbe(); errSend != nil {
|
|
if stopReaders != nil {
|
|
stopReaders()
|
|
}
|
|
<-doneCh
|
|
return false, errSend
|
|
}
|
|
timer := time.NewTimer(probeInterval)
|
|
select {
|
|
case <-conflictCh:
|
|
timer.Stop()
|
|
if stopReaders != nil {
|
|
stopReaders()
|
|
}
|
|
<-doneCh
|
|
return true, nil
|
|
case <-ctxDone:
|
|
timer.Stop()
|
|
if stopReaders != nil {
|
|
stopReaders()
|
|
}
|
|
<-doneCh
|
|
if detected != nil && detected.Load() {
|
|
return true, nil
|
|
}
|
|
return false, ctx.Err()
|
|
case <-doneCh:
|
|
timer.Stop()
|
|
if detected != nil && detected.Load() {
|
|
return true, nil
|
|
}
|
|
select {
|
|
case <-conflictCh:
|
|
return true, nil
|
|
default:
|
|
}
|
|
if ctx != nil && ctx.Err() != nil {
|
|
return false, ctx.Err()
|
|
}
|
|
return false, fmt.Errorf("discovery: host conflict probe readers terminated before probe window completed")
|
|
case <-timer.C:
|
|
if detected != nil && detected.Load() {
|
|
if stopReaders != nil {
|
|
stopReaders()
|
|
}
|
|
<-doneCh
|
|
return true, nil
|
|
}
|
|
}
|
|
}
|
|
if stopReaders != nil {
|
|
stopReaders()
|
|
}
|
|
return awaitProbeConflictResult(conflictCh, doneCh, detected, ctx, stopReaders)
|
|
}
|
|
|
|
func probeHostConflictOnLAN(ctx context.Context, hostFQDN string, ifaces []net.Interface, localIPs []string) (bool, error) {
|
|
if len(ifaces) == 0 {
|
|
return false, fmt.Errorf("discovery: cannot probe host conflict with empty interface list")
|
|
}
|
|
if ctx != nil {
|
|
if errCtx := ctx.Err(); errCtx != nil {
|
|
return false, errCtx
|
|
}
|
|
if deadline, ok := ctx.Deadline(); ok && time.Until(deadline) < time.Duration(mdnsHostProbeCount)*mdnsHostProbeInterval {
|
|
return false, context.DeadlineExceeded
|
|
}
|
|
}
|
|
probeID := randomProbeID()
|
|
queryBytes, errQuery := buildHostProbeQuery(hostFQDN, probeID, localIPs)
|
|
if errQuery != nil {
|
|
return false, errQuery
|
|
}
|
|
|
|
type probeConn struct {
|
|
conn *net.UDPConn
|
|
pconn4 *ipv4.PacketConn
|
|
pconn6 *ipv6.PacketConn
|
|
isMulticastDst bool
|
|
}
|
|
var conns []probeConn
|
|
defer func() {
|
|
for _, c := range conns {
|
|
_ = c.conn.Close()
|
|
}
|
|
}()
|
|
|
|
ownPorts := make(map[int]struct{}, 2)
|
|
ownPort4 := 0
|
|
ownPort6 := 0
|
|
if mConn4, errM4 := net.ListenUDP("udp4", mdnsWildcardAddrIPv4); errM4 == nil {
|
|
mp4 := ipv4.NewPacketConn(mConn4)
|
|
_ = mp4.SetControlMessage(ipv4.FlagInterface|ipv4.FlagDst, true)
|
|
joined := 0
|
|
for i := range ifaces {
|
|
if mp4.JoinGroup(&ifaces[i], mdnsGroupAddrIPv4) == nil {
|
|
joined++
|
|
}
|
|
}
|
|
if joined > 0 {
|
|
_ = mp4.SetMulticastTTL(255)
|
|
conns = append(conns, probeConn{conn: mConn4, pconn4: mp4, isMulticastDst: true})
|
|
} else {
|
|
_ = mConn4.Close()
|
|
}
|
|
}
|
|
if mConn6, errM6 := net.ListenUDP("udp6", mdnsWildcardAddrIPv6); errM6 == nil {
|
|
mp6 := ipv6.NewPacketConn(mConn6)
|
|
_ = mp6.SetControlMessage(ipv6.FlagInterface|ipv6.FlagDst, true)
|
|
joined := 0
|
|
for i := range ifaces {
|
|
if mp6.JoinGroup(&ifaces[i], mdnsGroupAddrIPv6) == nil {
|
|
joined++
|
|
}
|
|
}
|
|
if joined > 0 {
|
|
_ = mp6.SetMulticastHopLimit(255)
|
|
conns = append(conns, probeConn{conn: mConn6, pconn6: mp6, isMulticastDst: true})
|
|
} else {
|
|
_ = mConn6.Close()
|
|
}
|
|
}
|
|
|
|
var pConn4 *ipv4.PacketConn
|
|
var pConn6 *ipv6.PacketConn
|
|
var lastInitErr error
|
|
if uConn4, errListen4 := net.ListenUDP("udp4", &net.UDPAddr{IP: net.IPv4zero, Port: 0}); errListen4 != nil {
|
|
lastInitErr = errListen4
|
|
} else {
|
|
pConn4 = ipv4.NewPacketConn(uConn4)
|
|
_ = pConn4.SetControlMessage(ipv4.FlagInterface|ipv4.FlagDst, true)
|
|
conns = append(conns, probeConn{conn: uConn4, pconn4: pConn4, isMulticastDst: false})
|
|
if laddr, ok := uConn4.LocalAddr().(*net.UDPAddr); ok && laddr != nil {
|
|
ownPorts[laddr.Port] = struct{}{}
|
|
ownPort4 = laddr.Port
|
|
}
|
|
}
|
|
if uConn6, errListen6 := net.ListenUDP("udp6", &net.UDPAddr{IP: net.IPv6zero, Port: 0}); errListen6 != nil {
|
|
lastInitErr = errListen6
|
|
} else {
|
|
pConn6 = ipv6.NewPacketConn(uConn6)
|
|
_ = pConn6.SetControlMessage(ipv6.FlagInterface|ipv6.FlagDst, true)
|
|
conns = append(conns, probeConn{conn: uConn6, pconn6: pConn6, isMulticastDst: false})
|
|
if laddr, ok := uConn6.LocalAddr().(*net.UDPAddr); ok && laddr != nil {
|
|
ownPorts[laddr.Port] = struct{}{}
|
|
ownPort6 = laddr.Port
|
|
}
|
|
}
|
|
if pConn4 == nil && pConn6 == nil {
|
|
if lastInitErr == nil {
|
|
lastInitErr = fmt.Errorf("no probe sockets available")
|
|
}
|
|
return false, fmt.Errorf("discovery: failed to initialize mDNS host conflict probe for %s: %w", hostFQDN, lastInitErr)
|
|
}
|
|
|
|
sendOnce := func() error {
|
|
var lastErr error
|
|
sentPerIface := make([]int, len(ifaces))
|
|
if pConn4 != nil {
|
|
for i := range ifaces {
|
|
if errSet := pConn4.SetMulticastInterface(&ifaces[i]); errSet != nil {
|
|
lastErr = errSet
|
|
continue
|
|
}
|
|
if _, errWrite := pConn4.WriteTo(queryBytes, nil, mdnsGroupAddrIPv4); errWrite == nil {
|
|
sentPerIface[i]++
|
|
} else {
|
|
lastErr = errWrite
|
|
}
|
|
}
|
|
}
|
|
if pConn6 != nil {
|
|
for i := range ifaces {
|
|
if errSet := pConn6.SetMulticastInterface(&ifaces[i]); errSet != nil {
|
|
lastErr = errSet
|
|
continue
|
|
}
|
|
if _, errWrite := pConn6.WriteTo(queryBytes, nil, mdnsGroupAddrIPv6); errWrite == nil {
|
|
sentPerIface[i]++
|
|
} else {
|
|
lastErr = errWrite
|
|
}
|
|
}
|
|
}
|
|
for i := range ifaces {
|
|
if sentPerIface[i] == 0 {
|
|
if lastErr == nil {
|
|
lastErr = fmt.Errorf("no probe packets sent")
|
|
}
|
|
return fmt.Errorf("discovery: failed to send mDNS host conflict probe for %s on interface %s: %w", hostFQDN, ifaces[i].Name, lastErr)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
var detected atomic.Bool
|
|
conflictCh := make(chan bool, len(conns))
|
|
var wg sync.WaitGroup
|
|
for _, pc := range conns {
|
|
wg.Add(1)
|
|
go func(entry probeConn) {
|
|
defer wg.Done()
|
|
buf := make([]byte, 4096)
|
|
for {
|
|
if ctx != nil && ctx.Err() != nil {
|
|
return
|
|
}
|
|
var (
|
|
n int
|
|
ifIndex int
|
|
fromAddr net.Addr
|
|
errRead error
|
|
isMcast bool
|
|
)
|
|
switch {
|
|
case entry.pconn4 != nil:
|
|
var cm *ipv4.ControlMessage
|
|
n, cm, fromAddr, errRead = entry.pconn4.ReadFrom(buf)
|
|
if cm != nil {
|
|
ifIndex = cm.IfIndex
|
|
if len(cm.Dst) > 0 {
|
|
isMcast = cm.Dst.IsMulticast()
|
|
}
|
|
}
|
|
case entry.pconn6 != nil:
|
|
var cm *ipv6.ControlMessage
|
|
n, cm, fromAddr, errRead = entry.pconn6.ReadFrom(buf)
|
|
if cm != nil {
|
|
ifIndex = cm.IfIndex
|
|
if len(cm.Dst) > 0 {
|
|
isMcast = cm.Dst.IsMulticast()
|
|
}
|
|
}
|
|
default:
|
|
n, fromAddr, errRead = entry.conn.ReadFromUDP(buf)
|
|
}
|
|
if errRead != nil {
|
|
return
|
|
}
|
|
pkt := buf[:n]
|
|
if isOwnLoopbackProbe(pkt, queryBytes, fromAddr, ownPorts, ifaces) {
|
|
continue
|
|
}
|
|
isResp := hasHostResponseRecord(pkt, hostFQDN)
|
|
if !isValidProbePeer(fromAddr, ifIndex, ifaces, localIPs, isMcast, isResp) {
|
|
continue
|
|
}
|
|
peerPort := 0
|
|
ownPort := ownPort4
|
|
if uaddr, ok := fromAddr.(*net.UDPAddr); ok && uaddr != nil {
|
|
peerPort = uaddr.Port
|
|
if uaddr.IP != nil && uaddr.IP.To4() == nil && ownPort6 != 0 {
|
|
ownPort = ownPort6
|
|
}
|
|
}
|
|
if isHostProbeConflict(pkt, hostFQDN, localIPs, ownPort, peerPort) {
|
|
detected.Store(true)
|
|
conflictCh <- true
|
|
return
|
|
}
|
|
}
|
|
}(pc)
|
|
}
|
|
|
|
doneCh := make(chan struct{})
|
|
go func() {
|
|
wg.Wait()
|
|
close(doneCh)
|
|
}()
|
|
|
|
var stopOnce sync.Once
|
|
stopReaders := func() {
|
|
stopOnce.Do(func() {
|
|
for _, c := range conns {
|
|
_ = c.conn.Close()
|
|
}
|
|
})
|
|
}
|
|
return runHostProbeSchedule(ctx, mdnsHostProbeCount, mdnsHostProbeInterval, sendOnce, conflictCh, doneCh, &detected, stopReaders)
|
|
}
|
|
|
|
func resolveAdvertisedHostCandidate(ctx context.Context, baseHost string, startAttempt int, osHost, domain string, ifaces []net.Interface, localIPs []string, probeConflict hostConflictProbeFunc) (string, int, error) {
|
|
cleanOS := strings.ToLower(cleanHostname(osHost))
|
|
if probeConflict == nil {
|
|
probeConflict = probeHostConflictOnLAN
|
|
}
|
|
if startAttempt < 1 {
|
|
startAttempt = 1
|
|
}
|
|
for attempt := startAttempt; attempt <= maxHostCollisionAttempts; attempt++ {
|
|
if ctx != nil && ctx.Err() != nil {
|
|
return "", 0, ctx.Err()
|
|
}
|
|
candidate := appendHostCollisionSuffix(baseHost, attempt)
|
|
if cleanOS != "" && cleanOS != "localhost" && strings.EqualFold(candidate, cleanOS) {
|
|
continue
|
|
}
|
|
conflict, errProbe := probeConflict(ctx, formatHostFQDN(candidate, domain), ifaces, localIPs)
|
|
if errProbe != nil {
|
|
return "", 0, errProbe
|
|
}
|
|
if !conflict {
|
|
return candidate, attempt, nil
|
|
}
|
|
}
|
|
return "", 0, fmt.Errorf("discovery: unable to resolve non-conflicting mDNS host label for %q after %d attempts", baseHost, maxHostCollisionAttempts)
|
|
}
|
|
|
|
func resolveAdvertisedHost(ctx context.Context, instanceName, osHost, domain string, ifaces []net.Interface, localIPs []string, probeConflict hostConflictProbeFunc) (string, error) {
|
|
baseHost := buildAdvertisedHost(instanceName, osHost)
|
|
candidate, _, err := resolveAdvertisedHostCandidate(ctx, baseHost, 1, osHost, domain, ifaces, localIPs, probeConflict)
|
|
return candidate, err
|
|
}
|
|
|
|
func extractInterfaceAddrs(addrs []net.Addr) []string {
|
|
var v4, v6Global, v6LinkLocal []string
|
|
for _, addr := range addrs {
|
|
var ip net.IP
|
|
switch v := addr.(type) {
|
|
case *net.IPNet:
|
|
ip = v.IP
|
|
case *net.IPAddr:
|
|
ip = v.IP
|
|
}
|
|
if ip == nil || ip.IsLoopback() || ip.IsUnspecified() {
|
|
continue
|
|
}
|
|
if ip4 := ip.To4(); ip4 != nil {
|
|
v4 = append(v4, ip4.String())
|
|
continue
|
|
}
|
|
if ip16 := ip.To16(); ip16 != nil {
|
|
if ip16.IsGlobalUnicast() {
|
|
v6Global = append(v6Global, ip16.String())
|
|
} else if ip16.IsLinkLocalUnicast() {
|
|
v6LinkLocal = append(v6LinkLocal, ip16.String())
|
|
}
|
|
}
|
|
}
|
|
if len(v6Global) > 0 {
|
|
return append(v4, v6Global...)
|
|
}
|
|
return append(v4, v6LinkLocal...)
|
|
}
|
|
|
|
// extractInterfaceIPs collects non-loopback IP addresses from the selected interfaces.
|
|
func extractInterfaceIPs(ifaces []net.Interface) []string {
|
|
var ips []string
|
|
for _, iface := range ifaces {
|
|
addrs, err := iface.Addrs()
|
|
if err != nil {
|
|
continue
|
|
}
|
|
ips = append(ips, extractInterfaceAddrs(addrs)...)
|
|
}
|
|
return ips
|
|
}
|
|
|
|
func supportsPerInterfaceAddrs(goos string) bool {
|
|
switch goos {
|
|
case "darwin", "ios", "linux":
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
func sameIPSet(a, b []string) bool {
|
|
if len(a) == 0 || len(b) == 0 {
|
|
return len(a) == len(b)
|
|
}
|
|
setA := make(map[string]struct{}, len(a))
|
|
for _, raw := range a {
|
|
trimmed := strings.TrimSpace(raw)
|
|
if ip := net.ParseIP(trimmed); ip != nil {
|
|
setA[ip.String()] = struct{}{}
|
|
} else if trimmed != "" {
|
|
setA[trimmed] = struct{}{}
|
|
}
|
|
}
|
|
setB := make(map[string]struct{}, len(b))
|
|
for _, raw := range b {
|
|
trimmed := strings.TrimSpace(raw)
|
|
if ip := net.ParseIP(trimmed); ip != nil {
|
|
setB[ip.String()] = struct{}{}
|
|
} else if trimmed != "" {
|
|
setB[trimmed] = struct{}{}
|
|
}
|
|
}
|
|
if len(setA) != len(setB) {
|
|
return false
|
|
}
|
|
for k := range setA {
|
|
if _, ok := setB[k]; !ok {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func resolveRegisterProxyIPs(ifaces []net.Interface, advertisedIPs []string, goos string, lookupIPs func([]net.Interface) []string) ([]string, error) {
|
|
if lookupIPs == nil {
|
|
lookupIPs = extractInterfaceIPs
|
|
}
|
|
interfaceIPs := lookupIPs(ifaces)
|
|
ips := advertisedIPs
|
|
if len(ips) == 0 {
|
|
ips = interfaceIPs
|
|
}
|
|
if len(ips) == 0 {
|
|
return nil, fmt.Errorf("discovery: no usable IP addresses found on specified interfaces")
|
|
}
|
|
if supportsPerInterfaceAddrs(goos) && len(interfaceIPs) > 0 && (len(advertisedIPs) == 0 || (len(ifaces) > 1 && sameIPSet(advertisedIPs, interfaceIPs))) {
|
|
return nil, nil
|
|
}
|
|
return ips, nil
|
|
}
|
|
|
|
// Start registers and starts mDNS advertisement for the primary service type
|
|
// and any configured API protocol subtypes.
|
|
func (a *ZeroconfAdvertiser) Start(ctx context.Context, spec ServiceSpec) (err error) {
|
|
if ctx != nil && ctx.Err() != nil {
|
|
return ctx.Err()
|
|
}
|
|
if len(spec.Interfaces) == 0 {
|
|
return fmt.Errorf("discovery: cannot start advertiser with empty interface list (refusing fallback to all interfaces)")
|
|
}
|
|
if spec.Port < 1 || spec.Port > 65535 {
|
|
return fmt.Errorf("discovery: invalid service port %d (must be between 1 and 65535)", spec.Port)
|
|
}
|
|
|
|
a.mu.Lock()
|
|
if a.server != nil || a.inFlight {
|
|
a.mu.Unlock()
|
|
return fmt.Errorf("discovery: advertiser already started")
|
|
}
|
|
a.inFlight = true
|
|
a.closed = false
|
|
a.mu.Unlock()
|
|
|
|
var server zeroconfServer
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
err = fmt.Errorf("discovery: panic starting advertiser: %v", r)
|
|
log.Errorf("%v", err)
|
|
}
|
|
a.mu.Lock()
|
|
a.inFlight = false
|
|
if err != nil {
|
|
hold := a.server
|
|
a.server = nil
|
|
a.mu.Unlock()
|
|
if hold != nil {
|
|
hold.Shutdown()
|
|
}
|
|
if server != nil && hold != server {
|
|
server.Shutdown()
|
|
}
|
|
return
|
|
}
|
|
a.mu.Unlock()
|
|
}()
|
|
|
|
domain := spec.Domain
|
|
if domain == "" {
|
|
domain = DefaultDomain
|
|
}
|
|
serviceType := spec.ServiceType
|
|
if serviceType == "" {
|
|
serviceType = DefaultServiceType
|
|
}
|
|
|
|
proxyIPs, errIPs := resolveRegisterProxyIPs(spec.Interfaces, spec.AdvertisedIPs, runtime.GOOS, a.interfaceIPs)
|
|
if errIPs != nil {
|
|
return errIPs
|
|
}
|
|
|
|
spec.InstanceName = sanitizeInstanceName(spec.InstanceName)
|
|
if spec.InstanceName == "" {
|
|
spec.InstanceName = DefaultInstancePrefix + "0001"
|
|
}
|
|
cleanHost := extractCleanHost()
|
|
if a.osHostname != nil {
|
|
if rawHost, errHost := a.osHostname(); errHost == nil && rawHost != "" {
|
|
cleanHost = cleanHostname(rawHost)
|
|
} else {
|
|
cleanHost = "localhost"
|
|
}
|
|
}
|
|
localIPs := spec.AdvertisedIPs
|
|
if len(localIPs) == 0 {
|
|
if a.interfaceIPs != nil {
|
|
localIPs = a.interfaceIPs(spec.Interfaces)
|
|
} else {
|
|
localIPs = extractInterfaceIPs(spec.Interfaces)
|
|
}
|
|
}
|
|
probeConflict := a.probeHostConflict
|
|
if probeConflict == nil && a.registerProxy != nil {
|
|
probeConflict = func(context.Context, string, []net.Interface, []string) (bool, error) { return false, nil }
|
|
}
|
|
baseHost := buildAdvertisedHost(spec.InstanceName, cleanHost)
|
|
advertisedHost, initialAttempt, errHost := resolveAdvertisedHostCandidate(ctx, baseHost, 1, cleanHost, domain, spec.Interfaces, localIPs, probeConflict)
|
|
if errHost != nil {
|
|
return errHost
|
|
}
|
|
if ctx != nil && ctx.Err() != nil {
|
|
return ctx.Err()
|
|
}
|
|
|
|
primaryService := serviceType
|
|
for _, sub := range spec.Subtypes {
|
|
if clean := sanitizeSubtype(sub); clean != "" {
|
|
primaryService += "," + clean
|
|
}
|
|
}
|
|
|
|
registerProxy := a.registerProxy
|
|
if registerProxy == nil {
|
|
registerProxy = defaultRegisterProxy
|
|
}
|
|
|
|
var errRegister error
|
|
server, errRegister = registerProxy(
|
|
spec.InstanceName,
|
|
primaryService,
|
|
domain,
|
|
spec.Port,
|
|
advertisedHost,
|
|
proxyIPs,
|
|
spec.TextRecords,
|
|
spec.Interfaces,
|
|
)
|
|
if errRegister != nil {
|
|
return fmt.Errorf("discovery: failed to register primary service %s: %w", primaryService, errRegister)
|
|
}
|
|
if hr, ok := server.(*hostRecordResponder); ok && hr != nil {
|
|
hr.mu.Lock()
|
|
hr.baseHost = baseHost
|
|
hr.osHost = cleanHost
|
|
hr.attempt = initialAttempt
|
|
if probeConflict != nil {
|
|
hr.probeConflict = probeConflict
|
|
}
|
|
hr.mu.Unlock()
|
|
}
|
|
if ctx != nil && ctx.Err() != nil {
|
|
return ctx.Err()
|
|
}
|
|
|
|
a.mu.Lock()
|
|
defer a.mu.Unlock()
|
|
if a.closed {
|
|
return fmt.Errorf("discovery: advertiser stopped before start completed")
|
|
}
|
|
a.server = server
|
|
server = nil
|
|
return nil
|
|
}
|
|
|
|
// Stop shuts down the mDNS advertisement server and sends goodbye packets.
|
|
func (a *ZeroconfAdvertiser) Stop() error {
|
|
a.mu.Lock()
|
|
a.closed = true
|
|
server := a.server
|
|
a.server = nil
|
|
a.mu.Unlock()
|
|
if server == nil {
|
|
return nil
|
|
}
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
log.Warnf("discovery: panic during advertiser shutdown: %v", r)
|
|
}
|
|
}()
|
|
server.Shutdown()
|
|
return nil
|
|
}
|
|
|
|
// ZeroconfBrowser provides DNS-SD browsing with fallback support.
|
|
type ZeroconfBrowser struct {
|
|
ifaces []net.Interface
|
|
}
|
|
|
|
// NewZeroconfBrowser creates a new ZeroconfBrowser.
|
|
func NewZeroconfBrowser(ifaces ...net.Interface) *ZeroconfBrowser {
|
|
return &ZeroconfBrowser{ifaces: append([]net.Interface(nil), ifaces...)}
|
|
}
|
|
|
|
const (
|
|
maxDiscoveredServices = 256
|
|
maxBrowseTXTRecords = 64
|
|
maxBrowseTXTBytes = 16 * 1024
|
|
maxDiscoveredAddresses = 64
|
|
maxDiscoveredMetadataItems = 32
|
|
maxMetadataItemBytes = 64
|
|
)
|
|
|
|
func browseEntryWithinLimits(entry *zeroconf.ServiceEntry) bool {
|
|
if entry == nil || len(entry.Text) > maxBrowseTXTRecords {
|
|
return false
|
|
}
|
|
total := 0
|
|
for _, record := range entry.Text {
|
|
if len(record) > maxTXTRecordBytes {
|
|
return false
|
|
}
|
|
total += len(record) + 1
|
|
if total > maxBrowseTXTBytes {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
// Browse performs a standard mDNS browse query for the given service type.
|
|
func (b *ZeroconfBrowser) Browse(ctx context.Context, serviceType, domain string) ([]DiscoveredService, error) {
|
|
if ctx == nil {
|
|
ctx = context.TODO()
|
|
}
|
|
if domain == "" {
|
|
domain = DefaultDomain
|
|
}
|
|
if serviceType == "" {
|
|
serviceType = DefaultServiceType
|
|
}
|
|
|
|
var errQuery error
|
|
serviceType, domain, errQuery = normalizeBrowseQuery(serviceType, domain)
|
|
if errQuery != nil {
|
|
return nil, errQuery
|
|
}
|
|
ifaces := b.ifaces
|
|
if len(ifaces) == 0 {
|
|
var errFilter error
|
|
ifaces, errFilter = FilterInterfaces(nil, nil)
|
|
if errFilter != nil {
|
|
return nil, fmt.Errorf("discovery: filter browse interfaces: %w", errFilter)
|
|
}
|
|
}
|
|
return browseLAN(ctx, ifaces, serviceType, domain)
|
|
}
|
|
|
|
func appendUniqueStrings(dst, src []string) []string {
|
|
for _, value := range src {
|
|
value = strings.TrimSpace(value)
|
|
if value == "" || len(value) > maxMetadataItemBytes || len(dst) >= maxDiscoveredMetadataItems {
|
|
continue
|
|
}
|
|
duplicate := false
|
|
for _, existing := range dst {
|
|
if existing == value {
|
|
duplicate = true
|
|
break
|
|
}
|
|
}
|
|
if !duplicate {
|
|
dst = append(dst, value)
|
|
}
|
|
}
|
|
return dst
|
|
}
|
|
|
|
func parseTXTList(value string) []string {
|
|
var result []string
|
|
for len(value) > 0 && len(result) < maxDiscoveredMetadataItems {
|
|
item := value
|
|
if before, after, ok := strings.Cut(value, ","); ok {
|
|
item = before
|
|
value = after
|
|
} else {
|
|
value = ""
|
|
}
|
|
item = strings.TrimSpace(item)
|
|
if item == "" || len(item) > maxMetadataItemBytes {
|
|
continue
|
|
}
|
|
result = appendUniqueStrings(result, []string{item})
|
|
}
|
|
return result
|
|
}
|
|
|
|
// BrowseWithFallback discovers all AI gateways on the LAN (_ai-gateway._tcp) and prioritizes CPA instances.
|
|
func (b *ZeroconfBrowser) BrowseWithFallback(ctx context.Context) ([]DiscoveredService, error) {
|
|
return b.BrowseWithFallbackServiceType(ctx, DefaultServiceType)
|
|
}
|
|
|
|
// BrowseWithFallbackServiceType discovers services of the requested type and prioritizes CPA instances.
|
|
func (b *ZeroconfBrowser) BrowseWithFallbackServiceType(ctx context.Context, serviceType string) ([]DiscoveredService, error) {
|
|
if strings.TrimSpace(serviceType) == "" {
|
|
serviceType = DefaultServiceType
|
|
}
|
|
allGateways, errMain := b.Browse(ctx, serviceType, DefaultDomain)
|
|
if errMain != nil && len(allGateways) == 0 {
|
|
return nil, errMain
|
|
}
|
|
|
|
// Partition: prioritize CPA instances first, then other standard AI gateways
|
|
var cpaGateways []DiscoveredService
|
|
var otherGateways []DiscoveredService
|
|
for _, gw := range allGateways {
|
|
if gw.Product == ProductCPA {
|
|
cpaGateways = append(cpaGateways, gw)
|
|
} else {
|
|
otherGateways = append(otherGateways, gw)
|
|
}
|
|
}
|
|
|
|
return append(cpaGateways, otherGateways...), nil
|
|
}
|
|
|
|
// entryToDiscovered converts a zeroconf entry and reports whether its TXT
|
|
// record satisfies draft-su-ai-gateway-discovery-00 (or the legacy CPA schema).
|
|
func entryToDiscovered(e *zeroconf.ServiceEntry) (DiscoveredService, bool) {
|
|
port := e.Port
|
|
if port < 1 || port > 65535 {
|
|
port = 0
|
|
}
|
|
svc := DiscoveredService{
|
|
InstanceName: e.Instance,
|
|
ServiceType: e.Service,
|
|
Domain: e.Domain,
|
|
Host: e.HostName,
|
|
Port: port,
|
|
IPv4: filterUsableIPs(e.AddrIPv4),
|
|
IPv6: filterUsableIPs(e.AddrIPv6),
|
|
}
|
|
if e.HostName == "." || !browseEntryWithinLimits(e) {
|
|
return svc, false
|
|
}
|
|
parsed := ParseTXTRecords(e.Text)
|
|
if _, draft := parsed[txtKeyVersion]; draft && !validateDraftTXTRecords(e.Text) {
|
|
return svc, false
|
|
}
|
|
usable := applyTXTMetadata(&svc, parsed)
|
|
return svc, usable
|
|
}
|
|
|
|
func filterUsableIPs(ips []net.IP) []net.IP {
|
|
usable := make([]net.IP, 0, min(len(ips), maxDiscoveredAddresses))
|
|
for _, ip := range ips {
|
|
if ip == nil || ip.To16() == nil || ip.IsLoopback() || ip.IsUnspecified() || ip.IsMulticast() || ip.Equal(net.IPv4bcast) {
|
|
continue
|
|
}
|
|
usable = append(usable, append(net.IP(nil), ip...))
|
|
if len(usable) >= maxDiscoveredAddresses {
|
|
break
|
|
}
|
|
}
|
|
return usable
|
|
}
|