mihomo/dns/doq.go

204 lines
4.4 KiB
Go
Raw Normal View History

package dns
import (
"bytes"
"context"
"crypto/tls"
"fmt"
2022-04-28 22:21:48 +08:00
"github.com/Dreamacro/clash/component/dialer"
"github.com/Dreamacro/clash/component/resolver"
2022-07-11 12:37:27 +08:00
tlsC "github.com/Dreamacro/clash/component/tls"
2022-06-06 21:45:08 +08:00
"github.com/lucas-clemente/quic-go"
2022-04-28 22:21:48 +08:00
"net"
"strconv"
"sync"
"time"
"github.com/Dreamacro/clash/log"
D "github.com/miekg/dns"
)
const NextProtoDQ = "doq"
var bytesPool = sync.Pool{New: func() interface{} { return &bytes.Buffer{} }}
type quicClient struct {
addr string
2022-04-28 22:21:48 +08:00
r *Resolver
2022-04-13 02:32:55 +08:00
session quic.Connection
2022-04-28 22:21:48 +08:00
proxyAdapter string
sync.RWMutex // protects session and bytesPool
}
2022-04-28 22:21:48 +08:00
func newDOQ(r *Resolver, addr, proxyAdapter string) *quicClient {
return &quicClient{
addr: addr,
r: r,
proxyAdapter: proxyAdapter,
}
}
func (dc *quicClient) Exchange(m *D.Msg) (msg *D.Msg, err error) {
return dc.ExchangeContext(context.Background(), m)
}
func (dc *quicClient) ExchangeContext(ctx context.Context, m *D.Msg) (msg *D.Msg, err error) {
stream, err := dc.openStream(ctx)
if err != nil {
return nil, fmt.Errorf("failed to open new stream to %s", dc.addr)
}
buf, err := m.Pack()
if err != nil {
return nil, err
}
_, err = stream.Write(buf)
if err != nil {
return nil, err
}
// The client MUST send the DNS query over the selected stream, and MUST
// indicate through the STREAM FIN mechanism that no further data will
// be sent on that stream.
// stream.Close() -- closes the write-direction of the stream.
_ = stream.Close()
respBuf := bytesPool.Get().(*bytes.Buffer)
defer bytesPool.Put(respBuf)
defer respBuf.Reset()
n, err := respBuf.ReadFrom(stream)
if err != nil && n == 0 {
return nil, err
}
reply := new(D.Msg)
err = reply.Unpack(respBuf.Bytes())
if err != nil {
return nil, err
}
return reply, nil
}
2022-04-13 02:32:55 +08:00
func isActive(s quic.Connection) bool {
select {
case <-s.Context().Done():
return false
default:
return true
}
}
2022-04-13 02:32:55 +08:00
// getSession - opens or returns an existing quic.Connection
// useCached - if true and cached session exists, return it right away
// otherwise - forcibly creates a new session
func (dc *quicClient) getSession(ctx context.Context) (quic.Connection, error) {
2022-04-13 02:32:55 +08:00
var session quic.Connection
dc.RLock()
session = dc.session
if session != nil && isActive(session) {
dc.RUnlock()
return session, nil
}
if session != nil {
// we're recreating the session, let's create a new one
_ = session.CloseWithError(0, "")
}
dc.RUnlock()
dc.Lock()
defer dc.Unlock()
var err error
session, err = dc.openSession(ctx)
if err != nil {
// This does not look too nice, but QUIC (or maybe quic-go)
// doesn't seem stable enough.
// Maybe retransmissions aren't fully implemented in quic-go?
// Anyways, the simple solution is to make a second try when
// it fails to open the QUIC session.
session, err = dc.openSession(ctx)
if err != nil {
return nil, err
}
}
dc.session = session
return session, nil
}
func (dc *quicClient) openSession(ctx context.Context) (quic.Connection, error) {
2022-07-10 20:44:24 +08:00
tlsConfig := tlsC.MixinTLSConfig(
&tls.Config{
InsecureSkipVerify: false,
NextProtos: []string{
NextProtoDQ,
},
SessionTicketsDisabled: false,
})
quicConfig := &quic.Config{
ConnectionIDLength: 12,
HandshakeIdleTimeout: time.Second * 8,
2022-05-02 05:01:07 +08:00
MaxIncomingStreams: 4,
MaxIdleTimeout: time.Second * 45,
}
log.Debugln("opening session to %s", dc.addr)
2022-04-28 22:21:48 +08:00
var (
udp net.PacketConn
err error
)
host, port, err := net.SplitHostPort(dc.addr)
2022-04-28 22:21:48 +08:00
if err != nil {
return nil, err
}
ip, err := resolver.ResolveIPv4WithResolver(host, dc.r)
if err != nil {
return nil, err
}
p, err := strconv.Atoi(port)
udpAddr := net.UDPAddr{IP: ip.AsSlice(), Port: p}
if dc.proxyAdapter == "" {
udp, err = dialer.ListenPacket(ctx, "udp", "")
2022-04-28 22:21:48 +08:00
if err != nil {
return nil, err
}
} else {
conn, err := dialContextExtra(ctx, dc.proxyAdapter, "udp", ip, port)
if err != nil {
2022-04-28 22:21:48 +08:00
return nil, err
}
2022-04-28 22:21:48 +08:00
wrapConn, ok := conn.(*wrapPacketConn)
if !ok {
2022-06-06 21:45:08 +08:00
return nil, fmt.Errorf("quic create packet failed")
2022-04-28 22:21:48 +08:00
}
2022-05-17 21:30:54 +08:00
udp = wrapConn
2022-04-28 22:21:48 +08:00
}
session, err := quic.DialContext(ctx, udp, &udpAddr, host, tlsConfig, quicConfig)
if err != nil {
return nil, fmt.Errorf("failed to open QUIC session: %w", err)
}
return session, nil
}
func (dc *quicClient) openStream(ctx context.Context) (quic.Stream, error) {
session, err := dc.getSession(ctx)
if err != nil {
return nil, err
}
// open a new stream
return session.OpenStreamSync(ctx)
}