mirror of
https://github.com/SagerNet/sing-box.git
synced 2025-04-04 12:27:36 +03:00
625 lines
16 KiB
Go
625 lines
16 KiB
Go
package resolved
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"net/netip"
|
|
"os"
|
|
"os/user"
|
|
"path/filepath"
|
|
"strconv"
|
|
"strings"
|
|
"syscall"
|
|
|
|
"github.com/sagernet/sing-box/adapter"
|
|
"github.com/sagernet/sing-box/common/process"
|
|
C "github.com/sagernet/sing-box/constant"
|
|
"github.com/sagernet/sing-box/dns"
|
|
"github.com/sagernet/sing-box/log"
|
|
"github.com/sagernet/sing/common"
|
|
E "github.com/sagernet/sing/common/exceptions"
|
|
F "github.com/sagernet/sing/common/format"
|
|
M "github.com/sagernet/sing/common/metadata"
|
|
|
|
"github.com/godbus/dbus/v5"
|
|
mDNS "github.com/miekg/dns"
|
|
)
|
|
|
|
type resolve1Manager Service
|
|
|
|
type Address struct {
|
|
IfIndex int32
|
|
Family int32
|
|
Address []byte
|
|
}
|
|
|
|
type Name struct {
|
|
IfIndex int32
|
|
Hostname string
|
|
}
|
|
|
|
type ResourceRecord struct {
|
|
IfIndex int32
|
|
Type uint16
|
|
Class uint16
|
|
Data []byte
|
|
}
|
|
|
|
type SRVRecord struct {
|
|
Priority uint16
|
|
Weight uint16
|
|
Port uint16
|
|
Hostname string
|
|
Addresses []Address
|
|
CNAME string
|
|
}
|
|
|
|
type TXTRecord []byte
|
|
|
|
type LinkDNS struct {
|
|
Family int32
|
|
Address []byte
|
|
}
|
|
|
|
type LinkDNSEx struct {
|
|
Family int32
|
|
Address []byte
|
|
Port uint16
|
|
Name string
|
|
}
|
|
|
|
type LinkDomain struct {
|
|
Domain string
|
|
RoutingOnly bool
|
|
}
|
|
|
|
func (t *resolve1Manager) getLink(ifIndex int32) (*TransportLink, *dbus.Error) {
|
|
link, loaded := t.links[ifIndex]
|
|
if !loaded {
|
|
link = &TransportLink{}
|
|
t.links[ifIndex] = link
|
|
iif, err := t.network.InterfaceFinder().ByIndex(int(ifIndex))
|
|
if err != nil {
|
|
return nil, wrapError(err)
|
|
}
|
|
link.iif = iif
|
|
}
|
|
return link, nil
|
|
}
|
|
|
|
func (t *resolve1Manager) getSenderProcess(sender dbus.Sender) (int32, error) {
|
|
var senderPid int32
|
|
dbusObject := t.systemBus.Object("org.freedesktop.DBus", "/org/freedesktop/DBus")
|
|
if dbusObject == nil {
|
|
return 0, E.New("missing dbus object")
|
|
}
|
|
err := dbusObject.Call("org.freedesktop.DBus.GetConnectionUnixProcessID", 0, string(sender)).Store(&senderPid)
|
|
if err != nil {
|
|
return 0, E.Cause(err, "GetConnectionUnixProcessID")
|
|
}
|
|
return senderPid, nil
|
|
}
|
|
|
|
func (t *resolve1Manager) createMetadata(sender dbus.Sender) adapter.InboundContext {
|
|
var metadata adapter.InboundContext
|
|
metadata.Inbound = t.Tag()
|
|
metadata.InboundType = C.TypeResolved
|
|
senderPid, err := t.getSenderProcess(sender)
|
|
if err != nil {
|
|
return metadata
|
|
}
|
|
var processInfo process.Info
|
|
metadata.ProcessInfo = &processInfo
|
|
processInfo.ProcessID = uint32(senderPid)
|
|
|
|
processPath, err := os.Readlink(F.ToString("/proc/", senderPid, "/exe"))
|
|
if err == nil {
|
|
processInfo.ProcessPath = processPath
|
|
} else {
|
|
processPath, err = os.Readlink(F.ToString("/proc/", senderPid, "/comm"))
|
|
if err == nil {
|
|
processInfo.ProcessPath = processPath
|
|
}
|
|
}
|
|
|
|
var uidFound bool
|
|
statusContent, err := os.ReadFile(F.ToString("/proc/", senderPid, "/status"))
|
|
if err == nil {
|
|
for _, line := range strings.Split(string(statusContent), "\n") {
|
|
line = strings.TrimSpace(line)
|
|
if strings.HasPrefix(line, "Uid:") {
|
|
fields := strings.Fields(line)
|
|
if len(fields) >= 2 {
|
|
uid, parseErr := strconv.ParseUint(fields[1], 10, 32)
|
|
if parseErr != nil {
|
|
break
|
|
}
|
|
processInfo.UserId = int32(uid)
|
|
uidFound = true
|
|
if osUser, _ := user.LookupId(F.ToString(uid)); osUser != nil {
|
|
processInfo.User = osUser.Username
|
|
}
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if !uidFound {
|
|
metadata.ProcessInfo.UserId = -1
|
|
}
|
|
return metadata
|
|
}
|
|
|
|
func (t *resolve1Manager) logRequest(sender dbus.Sender, message ...any) context.Context {
|
|
ctx := log.ContextWithNewID(t.ctx)
|
|
metadata := t.createMetadata(sender)
|
|
if metadata.ProcessInfo != nil {
|
|
var prefix string
|
|
if metadata.ProcessInfo.ProcessPath != "" {
|
|
prefix = filepath.Base(metadata.ProcessInfo.ProcessPath)
|
|
} else if metadata.ProcessInfo.User != "" {
|
|
prefix = F.ToString("user:", metadata.ProcessInfo.User)
|
|
} else if metadata.ProcessInfo.UserId != 0 {
|
|
prefix = F.ToString("uid:", metadata.ProcessInfo.UserId)
|
|
}
|
|
t.logger.InfoContext(ctx, "(", prefix, ") ", F.ToString(message...))
|
|
} else {
|
|
t.logger.InfoContext(ctx, F.ToString(message...))
|
|
}
|
|
return adapter.WithContext(ctx, &metadata)
|
|
}
|
|
|
|
func familyToString(family int32) string {
|
|
switch family {
|
|
case syscall.AF_UNSPEC:
|
|
return "AF_UNSPEC"
|
|
case syscall.AF_INET:
|
|
return "AF_INET"
|
|
case syscall.AF_INET6:
|
|
return "AF_INET6"
|
|
default:
|
|
return F.ToString(family)
|
|
}
|
|
}
|
|
|
|
func (t *resolve1Manager) ResolveHostname(sender dbus.Sender, ifIndex int32, hostname string, family int32, flags uint64) (addresses []Address, canonical string, outflags uint64, err *dbus.Error) {
|
|
t.linkAccess.Lock()
|
|
link, err := t.getLink(ifIndex)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t.linkAccess.Unlock()
|
|
var strategy C.DomainStrategy
|
|
switch family {
|
|
case syscall.AF_UNSPEC:
|
|
strategy = C.DomainStrategyAsIS
|
|
case syscall.AF_INET:
|
|
strategy = C.DomainStrategyIPv4Only
|
|
case syscall.AF_INET6:
|
|
strategy = C.DomainStrategyIPv6Only
|
|
}
|
|
ctx := t.logRequest(sender, "ResolveHostname ", link.iif.Name, " ", hostname, " ", familyToString(family), " ", flags)
|
|
responseAddresses, lookupErr := t.dnsRouter.Lookup(ctx, hostname, adapter.DNSQueryOptions{
|
|
LookupStrategy: strategy,
|
|
})
|
|
if lookupErr != nil {
|
|
err = wrapError(err)
|
|
return
|
|
}
|
|
addresses = common.Map(responseAddresses, func(it netip.Addr) Address {
|
|
var addrFamily int32
|
|
if it.Is4() {
|
|
addrFamily = syscall.AF_INET
|
|
} else {
|
|
addrFamily = syscall.AF_INET6
|
|
}
|
|
return Address{
|
|
IfIndex: ifIndex,
|
|
Family: addrFamily,
|
|
Address: it.AsSlice(),
|
|
}
|
|
})
|
|
canonical = mDNS.CanonicalName(hostname)
|
|
return
|
|
}
|
|
|
|
func (t *resolve1Manager) ResolveAddress(sender dbus.Sender, ifIndex int32, family int32, address []byte, flags uint64) (names []Name, outflags uint64, err *dbus.Error) {
|
|
t.linkAccess.Lock()
|
|
link, err := t.getLink(ifIndex)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t.linkAccess.Unlock()
|
|
addr, ok := netip.AddrFromSlice(address)
|
|
if !ok {
|
|
err = wrapError(E.New("invalid address"))
|
|
return
|
|
}
|
|
var nibbles []string
|
|
for i := len(address) - 1; i >= 0; i-- {
|
|
b := address[i]
|
|
nibbles = append(nibbles, fmt.Sprintf("%x", b&0x0F))
|
|
nibbles = append(nibbles, fmt.Sprintf("%x", b>>4))
|
|
}
|
|
var ptrDomain string
|
|
if addr.Is4() {
|
|
ptrDomain = strings.Join(nibbles, ".") + ".in-addr.arpa."
|
|
} else {
|
|
ptrDomain = strings.Join(nibbles, ".") + ".ip6.arpa."
|
|
}
|
|
request := &mDNS.Msg{
|
|
MsgHdr: mDNS.MsgHdr{
|
|
RecursionDesired: true,
|
|
},
|
|
Question: []mDNS.Question{
|
|
{
|
|
Name: mDNS.Fqdn(ptrDomain),
|
|
Qtype: mDNS.TypePTR,
|
|
Qclass: mDNS.ClassINET,
|
|
},
|
|
},
|
|
}
|
|
ctx := t.logRequest(sender, "ResolveAddress ", link.iif.Name, familyToString(family), addr, flags)
|
|
response, lookupErr := t.dnsRouter.Exchange(ctx, request, adapter.DNSQueryOptions{})
|
|
if lookupErr != nil {
|
|
err = wrapError(err)
|
|
return
|
|
}
|
|
if response.Rcode != mDNS.RcodeSuccess {
|
|
err = rcodeError(response.Rcode)
|
|
return
|
|
}
|
|
for _, rawRR := range response.Answer {
|
|
switch rr := rawRR.(type) {
|
|
case *mDNS.PTR:
|
|
names = append(names, Name{
|
|
IfIndex: ifIndex,
|
|
Hostname: rr.Ptr,
|
|
})
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
func (t *resolve1Manager) ResolveRecord(sender dbus.Sender, ifIndex int32, family int32, hostname string, qClass uint16, qType uint16, flags uint64) (records []ResourceRecord, outflags uint64, err *dbus.Error) {
|
|
t.linkAccess.Lock()
|
|
link, err := t.getLink(ifIndex)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t.linkAccess.Unlock()
|
|
request := &mDNS.Msg{
|
|
MsgHdr: mDNS.MsgHdr{
|
|
RecursionDesired: true,
|
|
},
|
|
Question: []mDNS.Question{
|
|
{
|
|
Name: mDNS.Fqdn(hostname),
|
|
Qtype: qType,
|
|
Qclass: qClass,
|
|
},
|
|
},
|
|
}
|
|
ctx := t.logRequest(sender, "ResolveRecord ", link.iif.Name, familyToString(family), hostname, mDNS.Class(qClass), mDNS.Type(qType), flags)
|
|
response, exchangeErr := t.dnsRouter.Exchange(ctx, request, adapter.DNSQueryOptions{})
|
|
if exchangeErr != nil {
|
|
err = wrapError(exchangeErr)
|
|
return
|
|
}
|
|
if response.Rcode != mDNS.RcodeSuccess {
|
|
err = rcodeError(response.Rcode)
|
|
return
|
|
}
|
|
for _, rr := range response.Answer {
|
|
var record ResourceRecord
|
|
record.IfIndex = ifIndex
|
|
record.Type = rr.Header().Rrtype
|
|
record.Class = rr.Header().Class
|
|
data := make([]byte, mDNS.Len(rr))
|
|
_, unpackErr := mDNS.PackRR(rr, data, 0, nil, false)
|
|
if unpackErr != nil {
|
|
err = wrapError(unpackErr)
|
|
}
|
|
record.Data = data
|
|
}
|
|
return
|
|
}
|
|
|
|
func (t *resolve1Manager) ResolveService(sender dbus.Sender, ifIndex int32, hostname string, sType string, domain string, family int32, flags uint64) (srvData []SRVRecord, txtData []TXTRecord, canonicalName string, canonicalType string, canonicalDomain string, outflags uint64, err *dbus.Error) {
|
|
t.linkAccess.Lock()
|
|
link, err := t.getLink(ifIndex)
|
|
if err != nil {
|
|
return
|
|
}
|
|
t.linkAccess.Unlock()
|
|
|
|
serviceName := hostname
|
|
if hostname != "" && !strings.HasSuffix(hostname, ".") {
|
|
serviceName += "."
|
|
}
|
|
serviceName += sType
|
|
if !strings.HasSuffix(serviceName, ".") {
|
|
serviceName += "."
|
|
}
|
|
serviceName += domain
|
|
if !strings.HasSuffix(serviceName, ".") {
|
|
serviceName += "."
|
|
}
|
|
|
|
ctx := t.logRequest(sender, "ResolveService ", link.iif.Name, " ", hostname, " ", sType, " ", domain, " ", familyToString(family), " ", flags)
|
|
|
|
srvRequest := &mDNS.Msg{
|
|
MsgHdr: mDNS.MsgHdr{
|
|
RecursionDesired: true,
|
|
},
|
|
Question: []mDNS.Question{
|
|
{
|
|
Name: serviceName,
|
|
Qtype: mDNS.TypeSRV,
|
|
Qclass: mDNS.ClassINET,
|
|
},
|
|
},
|
|
}
|
|
|
|
srvResponse, exchangeErr := t.dnsRouter.Exchange(ctx, srvRequest, adapter.DNSQueryOptions{})
|
|
if exchangeErr != nil {
|
|
err = wrapError(exchangeErr)
|
|
return
|
|
}
|
|
if srvResponse.Rcode != mDNS.RcodeSuccess {
|
|
err = rcodeError(srvResponse.Rcode)
|
|
return
|
|
}
|
|
|
|
txtRequest := &mDNS.Msg{
|
|
MsgHdr: mDNS.MsgHdr{
|
|
RecursionDesired: true,
|
|
},
|
|
Question: []mDNS.Question{
|
|
{
|
|
Name: serviceName,
|
|
Qtype: mDNS.TypeTXT,
|
|
Qclass: mDNS.ClassINET,
|
|
},
|
|
},
|
|
}
|
|
|
|
txtResponse, exchangeErr := t.dnsRouter.Exchange(ctx, txtRequest, adapter.DNSQueryOptions{})
|
|
if exchangeErr != nil {
|
|
err = wrapError(exchangeErr)
|
|
return
|
|
}
|
|
|
|
for _, rawRR := range srvResponse.Answer {
|
|
switch rr := rawRR.(type) {
|
|
case *mDNS.SRV:
|
|
var srvRecord SRVRecord
|
|
srvRecord.Priority = rr.Priority
|
|
srvRecord.Weight = rr.Weight
|
|
srvRecord.Port = rr.Port
|
|
srvRecord.Hostname = rr.Target
|
|
|
|
var strategy C.DomainStrategy
|
|
switch family {
|
|
case syscall.AF_UNSPEC:
|
|
strategy = C.DomainStrategyAsIS
|
|
case syscall.AF_INET:
|
|
strategy = C.DomainStrategyIPv4Only
|
|
case syscall.AF_INET6:
|
|
strategy = C.DomainStrategyIPv6Only
|
|
}
|
|
|
|
addrs, lookupErr := t.dnsRouter.Lookup(ctx, rr.Target, adapter.DNSQueryOptions{
|
|
LookupStrategy: strategy,
|
|
})
|
|
if lookupErr == nil {
|
|
srvRecord.Addresses = common.Map(addrs, func(it netip.Addr) Address {
|
|
var addrFamily int32
|
|
if it.Is4() {
|
|
addrFamily = syscall.AF_INET
|
|
} else {
|
|
addrFamily = syscall.AF_INET6
|
|
}
|
|
return Address{
|
|
IfIndex: ifIndex,
|
|
Family: addrFamily,
|
|
Address: it.AsSlice(),
|
|
}
|
|
})
|
|
}
|
|
for _, a := range srvResponse.Answer {
|
|
if cname, ok := a.(*mDNS.CNAME); ok && cname.Header().Name == rr.Target {
|
|
srvRecord.CNAME = cname.Target
|
|
break
|
|
}
|
|
}
|
|
srvData = append(srvData, srvRecord)
|
|
}
|
|
}
|
|
for _, rawRR := range txtResponse.Answer {
|
|
switch rr := rawRR.(type) {
|
|
case *mDNS.TXT:
|
|
data := make([]byte, mDNS.Len(rr))
|
|
_, packErr := mDNS.PackRR(rr, data, 0, nil, false)
|
|
if packErr == nil {
|
|
txtData = append(txtData, data)
|
|
}
|
|
}
|
|
}
|
|
canonicalName = mDNS.CanonicalName(hostname)
|
|
canonicalType = mDNS.CanonicalName(sType)
|
|
canonicalDomain = mDNS.CanonicalName(domain)
|
|
return
|
|
}
|
|
|
|
func (t *resolve1Manager) SetLinkDNS(sender dbus.Sender, ifIndex int32, addresses []LinkDNS) *dbus.Error {
|
|
t.linkAccess.Lock()
|
|
defer t.linkAccess.Unlock()
|
|
link, err := t.getLink(ifIndex)
|
|
if err != nil {
|
|
return wrapError(err)
|
|
}
|
|
link.address = addresses
|
|
if len(addresses) > 0 {
|
|
t.logRequest(sender, "SetLinkDNS ", link.iif.Name, " ", strings.Join(common.Map(addresses, func(it LinkDNS) string {
|
|
return M.AddrFromIP(it.Address).String()
|
|
}), ", "))
|
|
} else {
|
|
t.logRequest(sender, "SetLinkDNS ", link.iif.Name, " (empty)")
|
|
}
|
|
return t.postUpdate(link)
|
|
}
|
|
|
|
func (t *resolve1Manager) SetLinkDNSEx(sender dbus.Sender, ifIndex int32, addresses []LinkDNSEx) *dbus.Error {
|
|
t.linkAccess.Lock()
|
|
defer t.linkAccess.Unlock()
|
|
link, err := t.getLink(ifIndex)
|
|
if err != nil {
|
|
return wrapError(err)
|
|
}
|
|
link.addressEx = addresses
|
|
if len(addresses) > 0 {
|
|
t.logRequest(sender, "SetLinkDNSEx ", link.iif.Name, " ", strings.Join(common.Map(addresses, func(it LinkDNSEx) string {
|
|
return M.SocksaddrFrom(M.AddrFromIP(it.Address), it.Port).String()
|
|
}), ", "))
|
|
} else {
|
|
t.logRequest(sender, "SetLinkDNSEx ", link.iif.Name, " (empty)")
|
|
}
|
|
return t.postUpdate(link)
|
|
}
|
|
|
|
func (t *resolve1Manager) SetLinkDomains(sender dbus.Sender, ifIndex int32, domains []LinkDomain) *dbus.Error {
|
|
t.linkAccess.Lock()
|
|
defer t.linkAccess.Unlock()
|
|
link, err := t.getLink(ifIndex)
|
|
if err != nil {
|
|
return wrapError(err)
|
|
}
|
|
link.domain = domains
|
|
if len(domains) > 0 {
|
|
t.logRequest(sender, "SetLinkDomains ", link.iif.Name, " ", strings.Join(common.Map(domains, func(domain LinkDomain) string {
|
|
if !domain.RoutingOnly {
|
|
return domain.Domain
|
|
} else {
|
|
return "~" + domain.Domain
|
|
}
|
|
}), ", "))
|
|
} else {
|
|
t.logRequest(sender, "SetLinkDomains ", link.iif.Name, " (empty)")
|
|
}
|
|
return t.postUpdate(link)
|
|
}
|
|
|
|
func (t *resolve1Manager) SetLinkDefaultRoute(sender dbus.Sender, ifIndex int32, defaultRoute bool) *dbus.Error {
|
|
t.linkAccess.Lock()
|
|
defer t.linkAccess.Unlock()
|
|
link, err := t.getLink(ifIndex)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
link.defaultRoute = defaultRoute
|
|
t.defaultRouteSequence = append(t.defaultRouteSequence, ifIndex)
|
|
var defaultRouteString string
|
|
if defaultRoute {
|
|
defaultRouteString = "yes"
|
|
} else {
|
|
defaultRouteString = "no"
|
|
}
|
|
t.logRequest(sender, "SetLinkDefaultRoute ", link.iif.Name, " ", defaultRouteString)
|
|
return t.postUpdate(link)
|
|
}
|
|
|
|
func (t *resolve1Manager) SetLinkLLMNR(ifIndex int32, llmnrMode string) *dbus.Error {
|
|
return nil
|
|
}
|
|
|
|
func (t *resolve1Manager) SetLinkMulticastDNS(ifIndex int32, mdnsMode string) *dbus.Error {
|
|
return nil
|
|
}
|
|
|
|
func (t *resolve1Manager) SetLinkDNSOverTLS(sender dbus.Sender, ifIndex int32, dotMode string) *dbus.Error {
|
|
t.linkAccess.Lock()
|
|
defer t.linkAccess.Unlock()
|
|
link, err := t.getLink(ifIndex)
|
|
if err != nil {
|
|
return wrapError(err)
|
|
}
|
|
switch dotMode {
|
|
case "yes":
|
|
link.dnsOverTLS = true
|
|
case "":
|
|
dotMode = "no"
|
|
fallthrough
|
|
case "opportunistic", "no":
|
|
link.dnsOverTLS = false
|
|
}
|
|
t.logRequest(sender, "SetLinkDNSOverTLS ", link.iif.Name, " ", dotMode)
|
|
return t.postUpdate(link)
|
|
}
|
|
|
|
func (t *resolve1Manager) SetLinkDNSSEC(ifIndex int32, dnssecMode string) *dbus.Error {
|
|
return nil
|
|
}
|
|
|
|
func (t *resolve1Manager) SetLinkDNSSECNegativeTrustAnchors(ifIndex int32, domains []string) *dbus.Error {
|
|
return nil
|
|
}
|
|
|
|
func (t *resolve1Manager) RevertLink(sender dbus.Sender, ifIndex int32) *dbus.Error {
|
|
t.linkAccess.Lock()
|
|
defer t.linkAccess.Unlock()
|
|
link, err := t.getLink(ifIndex)
|
|
if err != nil {
|
|
return wrapError(err)
|
|
}
|
|
delete(t.links, ifIndex)
|
|
t.logRequest(sender, "RevertLink ", link.iif.Name)
|
|
return t.postUpdate(link)
|
|
}
|
|
|
|
// TODO: implement RegisterService, UnregisterService
|
|
|
|
func (t *resolve1Manager) RegisterService(sender dbus.Sender, identifier string, nameTemplate string, serviceType string, port uint16, priority uint16, weight uint16, txtRecords []TXTRecord) (objectPath dbus.ObjectPath, dbusErr *dbus.Error) {
|
|
return "", wrapError(E.New("not implemented"))
|
|
}
|
|
|
|
func (t *resolve1Manager) UnregisterService(sender dbus.Sender, servicePath dbus.ObjectPath) error {
|
|
return wrapError(E.New("not implemented"))
|
|
}
|
|
|
|
func (t *resolve1Manager) ResetStatistics() *dbus.Error {
|
|
return nil
|
|
}
|
|
|
|
func (t *resolve1Manager) FlushCaches(sender dbus.Sender) *dbus.Error {
|
|
t.dnsRouter.ClearCache()
|
|
t.logRequest(sender, "FlushCaches")
|
|
return nil
|
|
}
|
|
|
|
func (t *resolve1Manager) ResetServerFeatures() *dbus.Error {
|
|
return nil
|
|
}
|
|
|
|
func (t *resolve1Manager) postUpdate(link *TransportLink) *dbus.Error {
|
|
if t.updateCallback != nil {
|
|
return wrapError(t.updateCallback(link))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func rcodeError(rcode int) *dbus.Error {
|
|
return dbus.NewError("org.freedesktop.resolve1.DnsError."+mDNS.RcodeToString[rcode], []any{mDNS.RcodeToString[rcode]})
|
|
}
|
|
|
|
func wrapError(err error) *dbus.Error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
var rcode dns.RcodeError
|
|
if errors.As(err, &rcode) {
|
|
return rcodeError(int(rcode))
|
|
}
|
|
return dbus.MakeFailedError(err)
|
|
}
|