201 lines
4.4 KiB
Go
201 lines
4.4 KiB
Go
//go:build !no_doq
|
|
|
|
package dns
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"crypto/tls"
|
|
"fmt"
|
|
"github.com/Dreamacro/clash/component/dialer"
|
|
"github.com/Dreamacro/clash/component/resolver"
|
|
"net"
|
|
"strconv"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/Dreamacro/clash/log"
|
|
"github.com/lucas-clemente/quic-go"
|
|
D "github.com/miekg/dns"
|
|
)
|
|
|
|
const NextProtoDQ = "doq-i00"
|
|
|
|
var bytesPool = sync.Pool{New: func() interface{} { return &bytes.Buffer{} }}
|
|
|
|
type quicClient struct {
|
|
addr string
|
|
r *Resolver
|
|
session quic.Connection
|
|
proxyAdapter string
|
|
sync.RWMutex // protects session and bytesPool
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
func isActive(s quic.Connection) bool {
|
|
select {
|
|
case <-s.Context().Done():
|
|
return false
|
|
default:
|
|
return true
|
|
}
|
|
}
|
|
|
|
// 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() (quic.Connection, error) {
|
|
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()
|
|
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()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
dc.session = session
|
|
return session, nil
|
|
}
|
|
|
|
func (dc *quicClient) openSession() (quic.Connection, error) {
|
|
tlsConfig := &tls.Config{
|
|
InsecureSkipVerify: true,
|
|
NextProtos: []string{
|
|
"http/1.1", "h2", NextProtoDQ,
|
|
},
|
|
SessionTicketsDisabled: false,
|
|
}
|
|
quicConfig := &quic.Config{
|
|
ConnectionIDLength: 12,
|
|
HandshakeIdleTimeout: time.Second * 8,
|
|
MaxIncomingStreams: 4,
|
|
MaxIdleTimeout: time.Second * 45,
|
|
}
|
|
|
|
log.Debugln("opening session to %s", dc.addr)
|
|
var (
|
|
udp net.PacketConn
|
|
err error
|
|
)
|
|
|
|
host, port, err := net.SplitHostPort(dc.addr)
|
|
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(context.Background(), "udp", "")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
} else {
|
|
conn, err := dialContextWithProxyAdapter(context.Background(), dc.proxyAdapter, "udp", ip, port)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
wrapConn, ok := conn.(*wrapPacketConn)
|
|
if !ok {
|
|
return nil, fmt.Errorf("quio create packet failed")
|
|
}
|
|
|
|
udp = wrapConn
|
|
}
|
|
|
|
session, err := quic.Dial(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()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// open a new stream
|
|
return session.OpenStreamSync(ctx)
|
|
}
|