Bump github.com/miekg/dns in the patch-updates group

Bumps the patch-updates group with 1 update: [github.com/miekg/dns](https://github.com/miekg/dns).


Updates `github.com/miekg/dns` from 1.1.70 to 1.1.72
- [Commits](https://github.com/miekg/dns/compare/v1.1.70...v1.1.72)

---
updated-dependencies:
- dependency-name: github.com/miekg/dns
  dependency-version: 1.1.72
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: patch-updates
...

Signed-off-by: dependabot[bot] <support@github.com>
Former-commit-id: 5ddc089fda
Former-commit-id: bedd240d3d

api/api.go

@@ -272,6 +272,9 @@ func (s *API) SetConnectionStatus(isConnected bool) {
 
 	if isConnected {
 		s.connectedAt = time.Now()
+	} else {
+		// Clear peer statuses when disconnected
+		s.peerStatuses = make(map[int]*PeerStatus)
 	}
 }
 

config.go

@@ -89,7 +89,7 @@ func DefaultConfig() *OlmConfig {
 		PingInterval:     "3s",
 		PingTimeout:      "5s",
 		DisableHolepunch: false,
-		OverrideDNS:      true,
+		OverrideDNS:      false,
 		TunnelDNS:        false,
 		// DoNotCreateNewClient: false,
 		sources: make(map[string]string),

dns/dns_proxy.go

@@ -380,7 +380,7 @@ func (p *DNSProxy) handleDNSQuery(udpConn *gonet.UDPConn, queryData []byte, clie
 
 	// Check if we have local records for this query
 	var response *dns.Msg
-	if question.Qtype == dns.TypeA || question.Qtype == dns.TypeAAAA || question.Qtype == dns.TypePTR {
+	if question.Qtype == dns.TypeA || question.Qtype == dns.TypeAAAA {
 		response = p.checkLocalRecords(msg, question)
 	}
 
@@ -410,34 +410,6 @@ func (p *DNSProxy) handleDNSQuery(udpConn *gonet.UDPConn, queryData []byte, clie
 
 // checkLocalRecords checks if we have local records for the query
 func (p *DNSProxy) checkLocalRecords(query *dns.Msg, question dns.Question) *dns.Msg {
-	// Handle PTR queries
-	if question.Qtype == dns.TypePTR {
-		if ptrDomain, ok := p.recordStore.GetPTRRecord(question.Name); ok {
-			logger.Debug("Found local PTR record for %s -> %s", question.Name, ptrDomain)
-
-			// Create response message
-			response := new(dns.Msg)
-			response.SetReply(query)
-			response.Authoritative = true
-
-			// Add PTR answer record
-			rr := &dns.PTR{
-				Hdr: dns.RR_Header{
-					Name:   question.Name,
-					Rrtype: dns.TypePTR,
-					Class:  dns.ClassINET,
-					Ttl:    300, // 5 minutes
-				},
-				Ptr: ptrDomain,
-			}
-			response.Answer = append(response.Answer, rr)
-
-			return response
-		}
-		return nil
-	}
-
-	// Handle A and AAAA queries
 	var recordType RecordType
 	if question.Qtype == dns.TypeA {
 		recordType = RecordTypeA

dns/dns_records.go

@@ -1,7 +1,6 @@
 package dns
 
 import (
-	"fmt"
 	"net"
 	"strings"
 	"sync"
@@ -15,17 +14,15 @@ type RecordType uint16
 const (
 	RecordTypeA    RecordType = RecordType(dns.TypeA)
 	RecordTypeAAAA RecordType = RecordType(dns.TypeAAAA)
-	RecordTypePTR  RecordType = RecordType(dns.TypePTR)
 )
 
-// DNSRecordStore manages local DNS records for A, AAAA, and PTR queries
+// DNSRecordStore manages local DNS records for A and AAAA queries
 type DNSRecordStore struct {
 	mu            sync.RWMutex
 	aRecords      map[string][]net.IP // domain -> list of IPv4 addresses
 	aaaaRecords   map[string][]net.IP // domain -> list of IPv6 addresses
 	aWildcards    map[string][]net.IP // wildcard pattern -> list of IPv4 addresses
 	aaaaWildcards map[string][]net.IP // wildcard pattern -> list of IPv6 addresses
-	ptrRecords    map[string]string   // IP address string -> domain name
 }
 
 // NewDNSRecordStore creates a new DNS record store
@@ -35,7 +32,6 @@ func NewDNSRecordStore() *DNSRecordStore {
 		aaaaRecords:   make(map[string][]net.IP),
 		aWildcards:    make(map[string][]net.IP),
 		aaaaWildcards: make(map[string][]net.IP),
-		ptrRecords:    make(map[string]string),
 	}
 }
 
@@ -43,7 +39,6 @@ func NewDNSRecordStore() *DNSRecordStore {
 // domain should be in FQDN format (e.g., "example.com.")
 // domain can contain wildcards: * (0+ chars) and ? (exactly 1 char)
 // ip should be a valid IPv4 or IPv6 address
-// Automatically adds a corresponding PTR record for non-wildcard domains
 func (s *DNSRecordStore) AddRecord(domain string, ip net.IP) error {
 	s.mu.Lock()
 	defer s.mu.Unlock()
@@ -65,8 +60,6 @@ func (s *DNSRecordStore) AddRecord(domain string, ip net.IP) error {
 			s.aWildcards[domain] = append(s.aWildcards[domain], ip)
 		} else {
 			s.aRecords[domain] = append(s.aRecords[domain], ip)
-			// Automatically add PTR record for non-wildcard domains
-			s.ptrRecords[ip.String()] = domain
 		}
 	} else if ip.To16() != nil {
 		// IPv6 address
@@ -74,8 +67,6 @@ func (s *DNSRecordStore) AddRecord(domain string, ip net.IP) error {
 			s.aaaaWildcards[domain] = append(s.aaaaWildcards[domain], ip)
 		} else {
 			s.aaaaRecords[domain] = append(s.aaaaRecords[domain], ip)
-			// Automatically add PTR record for non-wildcard domains
-			s.ptrRecords[ip.String()] = domain
 		}
 	} else {
 		return &net.ParseError{Type: "IP address", Text: ip.String()}
@@ -84,30 +75,8 @@ func (s *DNSRecordStore) AddRecord(domain string, ip net.IP) error {
 	return nil
 }
 
-// AddPTRRecord adds a PTR record mapping an IP address to a domain name
-// ip should be a valid IPv4 or IPv6 address
-// domain should be in FQDN format (e.g., "example.com.")
-func (s *DNSRecordStore) AddPTRRecord(ip net.IP, domain string) error {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-
-	// Ensure domain ends with a dot (FQDN format)
-	if len(domain) == 0 || domain[len(domain)-1] != '.' {
-		domain = domain + "."
-	}
-
-	// Normalize domain to lowercase FQDN
-	domain = strings.ToLower(dns.Fqdn(domain))
-
-	// Store PTR record using IP string as key
-	s.ptrRecords[ip.String()] = domain
-
-	return nil
-}
-
 // RemoveRecord removes a specific DNS record mapping
 // If ip is nil, removes all records for the domain (including wildcards)
-// Automatically removes corresponding PTR records for non-wildcard domains
 func (s *DNSRecordStore) RemoveRecord(domain string, ip net.IP) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
@@ -129,23 +98,6 @@ func (s *DNSRecordStore) RemoveRecord(domain string, ip net.IP) {
 			delete(s.aWildcards, domain)
 			delete(s.aaaaWildcards, domain)
 		} else {
-			// For non-wildcard domains, remove PTR records for all IPs
-			if ips, ok := s.aRecords[domain]; ok {
-				for _, ipAddr := range ips {
-					// Only remove PTR if it points to this domain
-					if ptrDomain, exists := s.ptrRecords[ipAddr.String()]; exists && ptrDomain == domain {
-						delete(s.ptrRecords, ipAddr.String())
-					}
-				}
-			}
-			if ips, ok := s.aaaaRecords[domain]; ok {
-				for _, ipAddr := range ips {
-					// Only remove PTR if it points to this domain
-					if ptrDomain, exists := s.ptrRecords[ipAddr.String()]; exists && ptrDomain == domain {
-						delete(s.ptrRecords, ipAddr.String())
-					}
-				}
-			}
 			delete(s.aRecords, domain)
 			delete(s.aaaaRecords, domain)
 		}
@@ -167,10 +119,6 @@ func (s *DNSRecordStore) RemoveRecord(domain string, ip net.IP) {
 				if len(s.aRecords[domain]) == 0 {
 					delete(s.aRecords, domain)
 				}
-				// Automatically remove PTR record if it points to this domain
-				if ptrDomain, exists := s.ptrRecords[ip.String()]; exists && ptrDomain == domain {
-					delete(s.ptrRecords, ip.String())
-				}
 			}
 		}
 	} else if ip.To16() != nil {
@@ -188,23 +136,11 @@ func (s *DNSRecordStore) RemoveRecord(domain string, ip net.IP) {
 				if len(s.aaaaRecords[domain]) == 0 {
 					delete(s.aaaaRecords, domain)
 				}
-				// Automatically remove PTR record if it points to this domain
-				if ptrDomain, exists := s.ptrRecords[ip.String()]; exists && ptrDomain == domain {
-					delete(s.ptrRecords, ip.String())
-				}
 			}
 		}
 	}
 }
 
-// RemovePTRRecord removes a PTR record for an IP address
-func (s *DNSRecordStore) RemovePTRRecord(ip net.IP) {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-
-	delete(s.ptrRecords, ip.String())
-}
-
 // GetRecords returns all IP addresses for a domain and record type
 // First checks for exact matches, then checks wildcard patterns
 func (s *DNSRecordStore) GetRecords(domain string, recordType RecordType) []net.IP {
@@ -262,26 +198,6 @@ func (s *DNSRecordStore) GetRecords(domain string, recordType RecordType) []net.
 	return records
 }
 
-// GetPTRRecord returns the domain name for a PTR record query
-// domain should be in reverse DNS format (e.g., "1.0.0.127.in-addr.arpa.")
-func (s *DNSRecordStore) GetPTRRecord(domain string) (string, bool) {
-	s.mu.RLock()
-	defer s.mu.RUnlock()
-
-	// Convert reverse DNS format to IP address
-	ip := reverseDNSToIP(domain)
-	if ip == nil {
-		return "", false
-	}
-
-	// Look up the PTR record
-	if ptrDomain, ok := s.ptrRecords[ip.String()]; ok {
-		return ptrDomain, true
-	}
-
-	return "", false
-}
-
 // HasRecord checks if a domain has any records of the specified type
 // Checks both exact matches and wildcard patterns
 func (s *DNSRecordStore) HasRecord(domain string, recordType RecordType) bool {
@@ -319,21 +235,6 @@ func (s *DNSRecordStore) HasRecord(domain string, recordType RecordType) bool {
 	return false
 }
 
-// HasPTRRecord checks if a PTR record exists for the given reverse DNS domain
-func (s *DNSRecordStore) HasPTRRecord(domain string) bool {
-	s.mu.RLock()
-	defer s.mu.RUnlock()
-
-	// Convert reverse DNS format to IP address
-	ip := reverseDNSToIP(domain)
-	if ip == nil {
-		return false
-	}
-
-	_, ok := s.ptrRecords[ip.String()]
-	return ok
-}
-
 // Clear removes all records from the store
 func (s *DNSRecordStore) Clear() {
 	s.mu.Lock()
@@ -343,7 +244,6 @@ func (s *DNSRecordStore) Clear() {
 	s.aaaaRecords = make(map[string][]net.IP)
 	s.aWildcards = make(map[string][]net.IP)
 	s.aaaaWildcards = make(map[string][]net.IP)
-	s.ptrRecords = make(map[string]string)
 }
 
 // removeIP is a helper function to remove a specific IP from a slice
@@ -423,75 +323,3 @@ func matchWildcardInternal(pattern, domain string, pi, di int) bool {
 
 	return matchWildcardInternal(pattern, domain, pi+1, di+1)
 }
-
-// reverseDNSToIP converts a reverse DNS query name to an IP address
-// Supports both IPv4 (in-addr.arpa) and IPv6 (ip6.arpa) formats
-func reverseDNSToIP(domain string) net.IP {
-	// Normalize to lowercase and ensure FQDN
-	domain = strings.ToLower(dns.Fqdn(domain))
-
-	// Check for IPv4 reverse DNS (in-addr.arpa)
-	if strings.HasSuffix(domain, ".in-addr.arpa.") {
-		// Remove the suffix
-		ipPart := strings.TrimSuffix(domain, ".in-addr.arpa.")
-		// Split by dots and reverse
-		parts := strings.Split(ipPart, ".")
-		if len(parts) != 4 {
-			return nil
-		}
-		// Reverse the octets
-		reversed := make([]string, 4)
-		for i := 0; i < 4; i++ {
-			reversed[i] = parts[3-i]
-		}
-		// Parse as IP
-		return net.ParseIP(strings.Join(reversed, "."))
-	}
-
-	// Check for IPv6 reverse DNS (ip6.arpa)
-	if strings.HasSuffix(domain, ".ip6.arpa.") {
-		// Remove the suffix
-		ipPart := strings.TrimSuffix(domain, ".ip6.arpa.")
-		// Split by dots and reverse
-		parts := strings.Split(ipPart, ".")
-		if len(parts) != 32 {
-			return nil
-		}
-		// Reverse the nibbles and group into 16-bit hex values
-		reversed := make([]string, 32)
-		for i := 0; i < 32; i++ {
-			reversed[i] = parts[31-i]
-		}
-		// Join into IPv6 format (groups of 4 nibbles separated by colons)
-		var ipv6Parts []string
-		for i := 0; i < 32; i += 4 {
-			ipv6Parts = append(ipv6Parts, reversed[i]+reversed[i+1]+reversed[i+2]+reversed[i+3])
-		}
-		// Parse as IP
-		return net.ParseIP(strings.Join(ipv6Parts, ":"))
-	}
-
-	return nil
-}
-
-// IPToReverseDNS converts an IP address to reverse DNS format
-// Returns the domain name for PTR queries (e.g., "1.0.0.127.in-addr.arpa.")
-func IPToReverseDNS(ip net.IP) string {
-	if ip4 := ip.To4(); ip4 != nil {
-		// IPv4: reverse octets and append .in-addr.arpa.
-		return dns.Fqdn(fmt.Sprintf("%d.%d.%d.%d.in-addr.arpa",
-			ip4[3], ip4[2], ip4[1], ip4[0]))
-	}
-
-	if ip6 := ip.To16(); ip6 != nil && ip.To4() == nil {
-		// IPv6: expand to 32 nibbles, reverse, and append .ip6.arpa.
-		var nibbles []string
-		for i := 15; i >= 0; i-- {
-			nibbles = append(nibbles, fmt.Sprintf("%x", ip6[i]&0x0f))
-			nibbles = append(nibbles, fmt.Sprintf("%x", ip6[i]>>4))
-		}
-		return dns.Fqdn(strings.Join(nibbles, ".") + ".ip6.arpa")
-	}
-
-	return ""
-}

dns/dns_records_test.go

@@ -413,452 +413,3 @@ func TestDNSRecordStoreCaseInsensitive(t *testing.T) {
 		t.Error("Expected HasRecord to return true for mixed case wildcard match")
 	}
 }
-
-func TestPTRRecordIPv4(t *testing.T) {
-	store := NewDNSRecordStore()
-
-	// Add PTR record for IPv4
-	ip := net.ParseIP("192.168.1.1")
-	domain := "host.example.com."
-	err := store.AddPTRRecord(ip, domain)
-	if err != nil {
-		t.Fatalf("Failed to add PTR record: %v", err)
-	}
-
-	// Test reverse DNS lookup
-	reverseDomain := "1.1.168.192.in-addr.arpa."
-	result, ok := store.GetPTRRecord(reverseDomain)
-	if !ok {
-		t.Error("Expected PTR record to be found")
-	}
-	if result != domain {
-		t.Errorf("Expected domain %q, got %q", domain, result)
-	}
-
-	// Test HasPTRRecord
-	if !store.HasPTRRecord(reverseDomain) {
-		t.Error("Expected HasPTRRecord to return true")
-	}
-
-	// Test non-existent PTR record
-	_, ok = store.GetPTRRecord("2.1.168.192.in-addr.arpa.")
-	if ok {
-		t.Error("Expected PTR record not to be found for different IP")
-	}
-}
-
-func TestPTRRecordIPv6(t *testing.T) {
-	store := NewDNSRecordStore()
-
-	// Add PTR record for IPv6
-	ip := net.ParseIP("2001:db8::1")
-	domain := "ipv6host.example.com."
-	err := store.AddPTRRecord(ip, domain)
-	if err != nil {
-		t.Fatalf("Failed to add PTR record: %v", err)
-	}
-
-	// Test reverse DNS lookup
-	// 2001:db8::1 = 2001:0db8:0000:0000:0000:0000:0000:0001
-	// Reverse: 1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.b.d.0.1.0.0.2.ip6.arpa.
-	reverseDomain := "1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.b.d.0.1.0.0.2.ip6.arpa."
-	result, ok := store.GetPTRRecord(reverseDomain)
-	if !ok {
-		t.Error("Expected IPv6 PTR record to be found")
-	}
-	if result != domain {
-		t.Errorf("Expected domain %q, got %q", domain, result)
-	}
-
-	// Test HasPTRRecord
-	if !store.HasPTRRecord(reverseDomain) {
-		t.Error("Expected HasPTRRecord to return true for IPv6")
-	}
-}
-
-func TestRemovePTRRecord(t *testing.T) {
-	store := NewDNSRecordStore()
-
-	// Add PTR record
-	ip := net.ParseIP("10.0.0.1")
-	domain := "test.example.com."
-	err := store.AddPTRRecord(ip, domain)
-	if err != nil {
-		t.Fatalf("Failed to add PTR record: %v", err)
-	}
-
-	// Verify it exists
-	reverseDomain := "1.0.0.10.in-addr.arpa."
-	_, ok := store.GetPTRRecord(reverseDomain)
-	if !ok {
-		t.Error("Expected PTR record to exist before removal")
-	}
-
-	// Remove PTR record
-	store.RemovePTRRecord(ip)
-
-	// Verify it's gone
-	_, ok = store.GetPTRRecord(reverseDomain)
-	if ok {
-		t.Error("Expected PTR record to be removed")
-	}
-
-	// Test HasPTRRecord after removal
-	if store.HasPTRRecord(reverseDomain) {
-		t.Error("Expected HasPTRRecord to return false after removal")
-	}
-}
-
-func TestIPToReverseDNS(t *testing.T) {
-	tests := []struct {
-		name     string
-		ip       string
-		expected string
-	}{
-		{
-			name:     "IPv4 simple",
-			ip:       "192.168.1.1",
-			expected: "1.1.168.192.in-addr.arpa.",
-		},
-		{
-			name:     "IPv4 localhost",
-			ip:       "127.0.0.1",
-			expected: "1.0.0.127.in-addr.arpa.",
-		},
-		{
-			name:     "IPv4 with zeros",
-			ip:       "10.0.0.1",
-			expected: "1.0.0.10.in-addr.arpa.",
-		},
-		{
-			name:     "IPv6 simple",
-			ip:       "2001:db8::1",
-			expected: "1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.b.d.0.1.0.0.2.ip6.arpa.",
-		},
-		{
-			name:     "IPv6 localhost",
-			ip:       "::1",
-			expected: "1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.ip6.arpa.",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			ip := net.ParseIP(tt.ip)
-			if ip == nil {
-				t.Fatalf("Failed to parse IP: %s", tt.ip)
-			}
-			result := IPToReverseDNS(ip)
-			if result != tt.expected {
-				t.Errorf("IPToReverseDNS(%s) = %q, want %q", tt.ip, result, tt.expected)
-			}
-		})
-	}
-}
-
-func TestReverseDNSToIP(t *testing.T) {
-	tests := []struct {
-		name        string
-		reverseDNS  string
-		expectedIP  string
-		shouldMatch bool
-	}{
-		{
-			name:        "IPv4 simple",
-			reverseDNS:  "1.1.168.192.in-addr.arpa.",
-			expectedIP:  "192.168.1.1",
-			shouldMatch: true,
-		},
-		{
-			name:        "IPv4 localhost",
-			reverseDNS:  "1.0.0.127.in-addr.arpa.",
-			expectedIP:  "127.0.0.1",
-			shouldMatch: true,
-		},
-		{
-			name:        "IPv6 simple",
-			reverseDNS:  "1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.b.d.0.1.0.0.2.ip6.arpa.",
-			expectedIP:  "2001:db8::1",
-			shouldMatch: true,
-		},
-		{
-			name:        "Invalid IPv4 format",
-			reverseDNS:  "1.1.168.in-addr.arpa.",
-			expectedIP:  "",
-			shouldMatch: false,
-		},
-		{
-			name:        "Invalid IPv6 format",
-			reverseDNS:  "1.0.0.0.ip6.arpa.",
-			expectedIP:  "",
-			shouldMatch: false,
-		},
-		{
-			name:        "Not a reverse DNS domain",
-			reverseDNS:  "example.com.",
-			expectedIP:  "",
-			shouldMatch: false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := reverseDNSToIP(tt.reverseDNS)
-			if tt.shouldMatch {
-				if result == nil {
-					t.Errorf("reverseDNSToIP(%q) returned nil, expected IP", tt.reverseDNS)
-					return
-				}
-				expectedIP := net.ParseIP(tt.expectedIP)
-				if !result.Equal(expectedIP) {
-					t.Errorf("reverseDNSToIP(%q) = %v, want %v", tt.reverseDNS, result, expectedIP)
-				}
-			} else {
-				if result != nil {
-					t.Errorf("reverseDNSToIP(%q) = %v, expected nil", tt.reverseDNS, result)
-				}
-			}
-		})
-	}
-}
-
-func TestPTRRecordCaseInsensitive(t *testing.T) {
-	store := NewDNSRecordStore()
-
-	// Add PTR record with mixed case domain
-	ip := net.ParseIP("192.168.1.1")
-	domain := "MyHost.Example.Com"
-	err := store.AddPTRRecord(ip, domain)
-	if err != nil {
-		t.Fatalf("Failed to add PTR record: %v", err)
-	}
-
-	// Test lookup with different cases in reverse DNS format
-	reverseDomain := "1.1.168.192.in-addr.arpa."
-	result, ok := store.GetPTRRecord(reverseDomain)
-	if !ok {
-		t.Error("Expected PTR record to be found")
-	}
-	// Domain should be normalized to lowercase
-	if result != "myhost.example.com." {
-		t.Errorf("Expected normalized domain %q, got %q", "myhost.example.com.", result)
-	}
-
-	// Test with uppercase reverse DNS
-	reverseDomainUpper := "1.1.168.192.IN-ADDR.ARPA."
-	result, ok = store.GetPTRRecord(reverseDomainUpper)
-	if !ok {
-		t.Error("Expected PTR record to be found with uppercase reverse DNS")
-	}
-	if result != "myhost.example.com." {
-		t.Errorf("Expected normalized domain %q, got %q", "myhost.example.com.", result)
-	}
-}
-
-func TestClearPTRRecords(t *testing.T) {
-	store := NewDNSRecordStore()
-
-	// Add some PTR records
-	ip1 := net.ParseIP("192.168.1.1")
-	ip2 := net.ParseIP("192.168.1.2")
-	store.AddPTRRecord(ip1, "host1.example.com.")
-	store.AddPTRRecord(ip2, "host2.example.com.")
-
-	// Add some A records too
-	store.AddRecord("test.example.com.", net.ParseIP("10.0.0.1"))
-
-	// Verify PTR records exist
-	if !store.HasPTRRecord("1.1.168.192.in-addr.arpa.") {
-		t.Error("Expected PTR record to exist before clear")
-	}
-
-	// Clear all records
-	store.Clear()
-
-	// Verify PTR records are gone
-	if store.HasPTRRecord("1.1.168.192.in-addr.arpa.") {
-		t.Error("Expected PTR record to be cleared")
-	}
-	if store.HasPTRRecord("2.1.168.192.in-addr.arpa.") {
-		t.Error("Expected PTR record to be cleared")
-	}
-
-	// Verify A records are also gone
-	if store.HasRecord("test.example.com.", RecordTypeA) {
-		t.Error("Expected A record to be cleared")
-	}
-}
-
-func TestAutomaticPTRRecordOnAdd(t *testing.T) {
-	store := NewDNSRecordStore()
-
-	// Add an A record - should automatically add PTR record
-	domain := "host.example.com."
-	ip := net.ParseIP("192.168.1.100")
-	err := store.AddRecord(domain, ip)
-	if err != nil {
-		t.Fatalf("Failed to add A record: %v", err)
-	}
-
-	// Verify PTR record was automatically created
-	reverseDomain := "100.1.168.192.in-addr.arpa."
-	result, ok := store.GetPTRRecord(reverseDomain)
-	if !ok {
-		t.Error("Expected PTR record to be automatically created")
-	}
-	if result != domain {
-		t.Errorf("Expected PTR to point to %q, got %q", domain, result)
-	}
-
-	// Add AAAA record - should also automatically add PTR record
-	domain6 := "ipv6host.example.com."
-	ip6 := net.ParseIP("2001:db8::1")
-	err = store.AddRecord(domain6, ip6)
-	if err != nil {
-		t.Fatalf("Failed to add AAAA record: %v", err)
-	}
-
-	// Verify IPv6 PTR record was automatically created
-	reverseDomain6 := "1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.b.d.0.1.0.0.2.ip6.arpa."
-	result6, ok := store.GetPTRRecord(reverseDomain6)
-	if !ok {
-		t.Error("Expected IPv6 PTR record to be automatically created")
-	}
-	if result6 != domain6 {
-		t.Errorf("Expected PTR to point to %q, got %q", domain6, result6)
-	}
-}
-
-func TestAutomaticPTRRecordOnRemove(t *testing.T) {
-	store := NewDNSRecordStore()
-
-	// Add an A record (with automatic PTR)
-	domain := "host.example.com."
-	ip := net.ParseIP("192.168.1.100")
-	store.AddRecord(domain, ip)
-
-	// Verify PTR exists
-	reverseDomain := "100.1.168.192.in-addr.arpa."
-	if !store.HasPTRRecord(reverseDomain) {
-		t.Error("Expected PTR record to exist after adding A record")
-	}
-
-	// Remove the A record
-	store.RemoveRecord(domain, ip)
-
-	// Verify PTR was automatically removed
-	if store.HasPTRRecord(reverseDomain) {
-		t.Error("Expected PTR record to be automatically removed")
-	}
-
-	// Verify A record is also gone
-	ips := store.GetRecords(domain, RecordTypeA)
-	if len(ips) != 0 {
-		t.Errorf("Expected A record to be removed, got %d records", len(ips))
-	}
-}
-
-func TestAutomaticPTRRecordOnRemoveAll(t *testing.T) {
-	store := NewDNSRecordStore()
-
-	// Add multiple IPs for the same domain
-	domain := "host.example.com."
-	ip1 := net.ParseIP("192.168.1.100")
-	ip2 := net.ParseIP("192.168.1.101")
-	store.AddRecord(domain, ip1)
-	store.AddRecord(domain, ip2)
-
-	// Verify both PTR records exist
-	reverseDomain1 := "100.1.168.192.in-addr.arpa."
-	reverseDomain2 := "101.1.168.192.in-addr.arpa."
-	if !store.HasPTRRecord(reverseDomain1) {
-		t.Error("Expected first PTR record to exist")
-	}
-	if !store.HasPTRRecord(reverseDomain2) {
-		t.Error("Expected second PTR record to exist")
-	}
-
-	// Remove all records for the domain
-	store.RemoveRecord(domain, nil)
-
-	// Verify both PTR records were removed
-	if store.HasPTRRecord(reverseDomain1) {
-		t.Error("Expected first PTR record to be removed")
-	}
-	if store.HasPTRRecord(reverseDomain2) {
-		t.Error("Expected second PTR record to be removed")
-	}
-}
-
-func TestNoPTRForWildcardRecords(t *testing.T) {
-	store := NewDNSRecordStore()
-
-	// Add wildcard record - should NOT create PTR record
-	domain := "*.example.com."
-	ip := net.ParseIP("192.168.1.100")
-	err := store.AddRecord(domain, ip)
-	if err != nil {
-		t.Fatalf("Failed to add wildcard record: %v", err)
-	}
-
-	// Verify no PTR record was created
-	reverseDomain := "100.1.168.192.in-addr.arpa."
-	_, ok := store.GetPTRRecord(reverseDomain)
-	if ok {
-		t.Error("Expected no PTR record for wildcard domain")
-	}
-
-	// Verify wildcard A record exists
-	if !store.HasRecord("host.example.com.", RecordTypeA) {
-		t.Error("Expected wildcard A record to exist")
-	}
-}
-
-func TestPTRRecordOverwrite(t *testing.T) {
-	store := NewDNSRecordStore()
-
-	// Add first domain with IP
-	domain1 := "host1.example.com."
-	ip := net.ParseIP("192.168.1.100")
-	store.AddRecord(domain1, ip)
-
-	// Verify PTR points to first domain
-	reverseDomain := "100.1.168.192.in-addr.arpa."
-	result, ok := store.GetPTRRecord(reverseDomain)
-	if !ok {
-		t.Fatal("Expected PTR record to exist")
-	}
-	if result != domain1 {
-		t.Errorf("Expected PTR to point to %q, got %q", domain1, result)
-	}
-
-	// Add second domain with same IP - should overwrite PTR
-	domain2 := "host2.example.com."
-	store.AddRecord(domain2, ip)
-
-	// Verify PTR now points to second domain (last one added)
-	result, ok = store.GetPTRRecord(reverseDomain)
-	if !ok {
-		t.Fatal("Expected PTR record to still exist")
-	}
-	if result != domain2 {
-		t.Errorf("Expected PTR to point to %q (overwritten), got %q", domain2, result)
-	}
-
-	// Remove first domain - PTR should remain pointing to second domain
-	store.RemoveRecord(domain1, ip)
-	result, ok = store.GetPTRRecord(reverseDomain)
-	if !ok {
-		t.Error("Expected PTR record to still exist after removing first domain")
-	}
-	if result != domain2 {
-		t.Errorf("Expected PTR to still point to %q, got %q", domain2, result)
-	}
-
-	// Remove second domain - PTR should now be gone
-	store.RemoveRecord(domain2, ip)
-	_, ok = store.GetPTRRecord(reverseDomain)
-	if ok {
-		t.Error("Expected PTR record to be removed after removing second domain")
-	}
-}

go.mod

@@ -7,7 +7,7 @@ require (
 	github.com/fosrl/newt v1.9.0
 	github.com/godbus/dbus/v5 v5.2.2
 	github.com/gorilla/websocket v1.5.3
-	github.com/miekg/dns v1.1.70
+	github.com/miekg/dns v1.1.72
 	golang.org/x/sys v0.40.0
 	golang.zx2c4.com/wireguard v0.0.0-20250521234502-f333402bd9cb
 	golang.zx2c4.com/wireguard/wgctrl v0.0.0-20241231184526-a9ab2273dd10

go.sum

@@ -10,8 +10,8 @@ github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
 github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
 github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
-github.com/miekg/dns v1.1.70 h1:DZ4u2AV35VJxdD9Fo9fIWm119BsQL5cZU1cQ9s0LkqA=
+github.com/miekg/dns v1.1.72 h1:vhmr+TF2A3tuoGNkLDFK9zi36F2LS+hKTRW0Uf8kbzI=
-github.com/miekg/dns v1.1.70/go.mod h1:+EuEPhdHOsfk6Wk5TT2CzssZdqkmFhf8r+aVyDEToIs=
+github.com/miekg/dns v1.1.72/go.mod h1:+EuEPhdHOsfk6Wk5TT2CzssZdqkmFhf8r+aVyDEToIs=
 github.com/vishvananda/netlink v1.3.1 h1:3AEMt62VKqz90r0tmNhog0r/PpWKmrEShJU0wJW6bV0=
 github.com/vishvananda/netlink v1.3.1/go.mod h1:ARtKouGSTGchR8aMwmkzC0qiNPrrWO5JS/XMVl45+b4=
 github.com/vishvananda/netns v0.0.5 h1:DfiHV+j8bA32MFM7bfEunvT8IAqQ/NzSJHtcmW5zdEY=

olm/olm.go

@@ -8,7 +8,6 @@ import (
 	_ "net/http/pprof"
 	"os"
 	"sync"
-	"syscall"
 	"time"
 
 	"github.com/fosrl/newt/bind"
@@ -576,7 +575,7 @@ func (o *Olm) Close() {
 		// If we never created a device from the FD, close it explicitly
 		// This can happen if tunnel is stopped during registration before handleConnect
 		logger.Debug("Closing unused TUN file descriptor %d", o.tunnelConfig.FileDescriptorTun)
-		if err := syscall.Close(int(o.tunnelConfig.FileDescriptorTun)); err != nil {
+		if err := closeFD(o.tunnelConfig.FileDescriptorTun); err != nil {
 			logger.Error("Failed to close TUN file descriptor: %v", err)
 		} else {
 			logger.Info("Closed unused TUN file descriptor")

olm/olm_unix.go

@@ -0,0 +1,10 @@
+//go:build !windows
+
+package olm
+
+import "syscall"
+
+// closeFD closes a file descriptor in a platform-specific way
+func closeFD(fd uint32) error {
+	return syscall.Close(int(fd))
+}

olm/olm_windows.go

@@ -0,0 +1,10 @@
+//go:build windows
+
+package olm
+
+import "syscall"
+
+// closeFD closes a file descriptor in a platform-specific way
+func closeFD(fd uint32) error {
+	return syscall.Close(syscall.Handle(fd))
+}