clash/dns/util.go

211 lines
4.5 KiB
Go
Raw Normal View History

2018-12-05 13:13:29 +00:00
package dns
import (
2021-11-17 08:03:47 +00:00
"context"
2019-06-28 04:29:08 +00:00
"crypto/tls"
2021-11-17 08:03:47 +00:00
"fmt"
2020-02-17 14:13:15 +00:00
"net"
2022-04-19 17:52:51 +00:00
"net/netip"
"strings"
2018-12-05 13:13:29 +00:00
"time"
"github.com/Dreamacro/clash/common/cache"
2022-04-19 17:52:51 +00:00
"github.com/Dreamacro/clash/common/nnip"
2021-11-17 08:03:47 +00:00
"github.com/Dreamacro/clash/component/dialer"
C "github.com/Dreamacro/clash/constant"
2018-12-05 13:13:29 +00:00
"github.com/Dreamacro/clash/log"
2021-11-17 08:03:47 +00:00
"github.com/Dreamacro/clash/tunnel"
2018-12-05 13:13:29 +00:00
D "github.com/miekg/dns"
)
2022-04-05 12:23:16 +00:00
func putMsgToCache(c *cache.LruCache[string, *D.Msg], key string, msg *D.Msg) {
var ttl uint32
2019-10-14 09:13:23 +00:00
switch {
case len(msg.Answer) != 0:
ttl = msg.Answer[0].Header().Ttl
2019-10-14 09:13:23 +00:00
case len(msg.Ns) != 0:
ttl = msg.Ns[0].Header().Ttl
2019-10-14 09:13:23 +00:00
case len(msg.Extra) != 0:
ttl = msg.Extra[0].Header().Ttl
2019-10-14 09:13:23 +00:00
default:
log.Debugln("[DNS] response msg empty: %#v", msg)
2018-12-05 13:13:29 +00:00
return
}
c.SetWithExpire(key, msg.Copy(), time.Now().Add(time.Second*time.Duration(ttl)))
2019-02-23 12:31:59 +00:00
}
func setMsgTTL(msg *D.Msg, ttl uint32) {
for _, answer := range msg.Answer {
answer.Header().Ttl = ttl
}
for _, ns := range msg.Ns {
ns.Header().Ttl = ttl
}
for _, extra := range msg.Extra {
extra.Header().Ttl = ttl
}
2018-12-05 13:13:29 +00:00
}
2019-06-28 04:29:08 +00:00
func isIPRequest(q D.Question) bool {
return q.Qclass == D.ClassINET && (q.Qtype == D.TypeA || q.Qtype == D.TypeAAAA)
2019-06-28 04:29:08 +00:00
}
func transform(servers []NameServer, resolver *Resolver) []dnsClient {
ret := []dnsClient{}
2019-06-28 04:29:08 +00:00
for _, s := range servers {
switch s.Net {
case "https":
2021-11-17 08:03:47 +00:00
ret = append(ret, newDoHClient(s.Addr, resolver, s.ProxyAdapter))
2019-06-28 04:29:08 +00:00
continue
case "dhcp":
ret = append(ret, newDHCPClient(s.Addr))
continue
case "quic":
2022-04-28 14:21:48 +00:00
ret = append(ret, newDOQ(resolver, s.Addr, s.ProxyAdapter))
continue
2019-06-28 04:29:08 +00:00
}
2020-02-17 14:13:15 +00:00
host, port, _ := net.SplitHostPort(s.Addr)
2019-06-28 04:29:08 +00:00
ret = append(ret, &client{
Client: &D.Client{
Net: s.Net,
TLSConfig: &tls.Config{
// alpn identifier, see https://tools.ietf.org/html/draft-hoffman-dprive-dns-tls-alpn-00#page-6
NextProtos: []string{"dns"},
ServerName: host,
2019-06-28 04:29:08 +00:00
},
UDPSize: 4096,
Timeout: 5 * time.Second,
2019-06-28 04:29:08 +00:00
},
2021-11-17 08:03:47 +00:00
port: port,
host: host,
iface: s.Interface,
r: resolver,
proxyAdapter: s.ProxyAdapter,
2019-06-28 04:29:08 +00:00
})
}
return ret
}
func handleMsgWithEmptyAnswer(r *D.Msg) *D.Msg {
msg := &D.Msg{}
msg.Answer = []D.RR{}
msg.SetRcode(r, D.RcodeSuccess)
msg.Authoritative = true
msg.RecursionAvailable = true
return msg
}
2022-04-19 17:52:51 +00:00
func msgToIP(msg *D.Msg) []netip.Addr {
ips := []netip.Addr{}
for _, answer := range msg.Answer {
switch ans := answer.(type) {
case *D.AAAA:
2022-04-19 17:52:51 +00:00
ips = append(ips, nnip.IpToAddr(ans.AAAA))
case *D.A:
2022-04-19 17:52:51 +00:00
ips = append(ips, nnip.IpToAddr(ans.A))
}
}
return ips
}
2021-11-17 08:03:47 +00:00
func msgToDomain(msg *D.Msg) string {
if len(msg.Question) > 0 {
return strings.TrimRight(msg.Question[0].Name, ".")
}
return ""
}
2021-11-17 08:03:47 +00:00
type wrapPacketConn struct {
net.PacketConn
rAddr net.Addr
}
func (wpc *wrapPacketConn) Read(b []byte) (n int, err error) {
n, _, err = wpc.PacketConn.ReadFrom(b)
return n, err
}
func (wpc *wrapPacketConn) Write(b []byte) (n int, err error) {
return wpc.PacketConn.WriteTo(b, wpc.rAddr)
}
func (wpc *wrapPacketConn) RemoteAddr() net.Addr {
return wpc.rAddr
}
2022-06-06 13:45:08 +00:00
func (wpc *wrapPacketConn) LocalAddr() net.Addr {
if wpc.PacketConn.LocalAddr() == nil {
return &net.UDPAddr{IP: net.IPv4zero, Port: 0}
} else {
return wpc.PacketConn.LocalAddr()
}
}
func dialContextExtra(ctx context.Context, adapterName string, network string, dstIP netip.Addr, port string, opts ...dialer.Option) (net.Conn, error) {
2021-11-17 08:03:47 +00:00
networkType := C.TCP
if network == "udp" {
2022-06-21 14:59:35 +00:00
2021-11-17 08:03:47 +00:00
networkType = C.UDP
}
addrType := C.AtypIPv4
2022-04-19 17:52:51 +00:00
if dstIP.Is6() {
2021-11-17 08:03:47 +00:00
addrType = C.AtypIPv6
}
metadata := &C.Metadata{
NetWork: networkType,
AddrType: addrType,
Host: "",
DstIP: dstIP,
DstPort: port,
}
2022-06-21 14:59:35 +00:00
adapter, ok := tunnel.Proxies()[adapterName]
if !ok {
opts = append(opts, dialer.WithInterface(adapterName))
if C.TCP == networkType {
return dialer.DialContext(ctx, network, dstIP.String()+":"+port, opts...)
} else {
packetConn, err := dialer.ListenPacket(ctx, network, dstIP.String()+":"+port, opts...)
if err != nil {
return nil, err
}
return &wrapPacketConn{
PacketConn: packetConn,
rAddr: metadata.UDPAddr(),
}, nil
}
}
if networkType == C.UDP && !adapter.SupportUDP() {
return nil, fmt.Errorf("proxy adapter [%s] UDP is not supported", adapterName)
}
2021-11-17 08:03:47 +00:00
if networkType == C.UDP {
packetConn, err := adapter.ListenPacketContext(ctx, metadata, opts...)
if err != nil {
return nil, err
}
return &wrapPacketConn{
PacketConn: packetConn,
rAddr: metadata.UDPAddr(),
}, nil
}
return adapter.DialContext(ctx, metadata, opts...)
}