dns: query in udp when client requests in udp and no forwarder specified

This commit is contained in:
nadoo committed 2018-08-02 00:11:22 +08:00
1 parent 8d20331096
commit 9acaff5b4a
4 files changed
+118 -72

No files matched your search

+85 -35
View File
@@ -41,7 +41,7 @@ func NewClient(dialer proxy.Dialer, upServers []string) (*Client, error) {
// Exchange handles request msg and returns response msg
// reqBytes = reqLen + reqMsg
func (c *Client) Exchange(reqBytes []byte, clientAddr string) ([]byte, error) {
func (c *Client) Exchange(reqBytes []byte, clientAddr string, preferTCP bool) ([]byte, error) {
req, err := UnmarshalMessage(reqBytes[2:])
if err != nil {
return nil, err
@@ -58,37 +58,14 @@ func (c *Client) Exchange(reqBytes []byte, clientAddr string) ([]byte, error) {
}
}
dnsServer := c.GetServer(req.Question.QNAME)
rc, err := c.dialer.NextDialer(req.Question.QNAME+":53").Dial("tcp", dnsServer)
dnsServer, network, respBytes, err := c.exchange(req.Question.QNAME, reqBytes, preferTCP)
if err != nil {
log.F("[dns] failed to connect to server %v: %v", dnsServer, err)
return nil, err
}
defer rc.Close()
if err = binary.Write(rc, binary.BigEndian, reqBytes); err != nil {
log.F("[dns] failed to write req message: %v", err)
return nil, err
}
var respLen uint16
if err = binary.Read(rc, binary.BigEndian, &respLen); err != nil {
log.F("[dns] failed to read response length: %v", err)
return nil, err
}
respBytes := make([]byte, respLen+2)
binary.BigEndian.PutUint16(respBytes[:2], respLen)
_, err = io.ReadFull(rc, respBytes[2:])
if err != nil {
log.F("[dns] error in read respMsg %s\n", err)
return nil, err
}
if req.Question.QTYPE != QTypeA && req.Question.QTYPE != QTypeAAAA {
log.F("[dns] %s <-> %s, type: %d, %s",
clientAddr, dnsServer, req.Question.QTYPE, req.Question.QNAME)
log.F("[dns] %s <-> %s(%s), type: %d, %s",
clientAddr, dnsServer, network, req.Question.QTYPE, req.Question.QNAME)
return respBytes, nil
}
@@ -104,28 +81,101 @@ func (c *Client) Exchange(reqBytes []byte, clientAddr string) ([]byte, error) {
for _, h := range c.handlers {
h(resp.Question.QNAME, answer.IP)
}
if answer.IP != "" {
ips = append(ips, answer.IP)
}
if answer.TTL != 0 {
ttl = int(answer.TTL)
}
}
}
// add to cache
c.cache.Put(getKey(resp.Question), respBytes, ttl)
if len(ips) != 0 {
c.cache.Put(getKey(resp.Question), respBytes, ttl)
}
log.F("[dns] %s <-> %s, type: %d, %s: %s",
clientAddr, dnsServer, resp.Question.QTYPE, resp.Question.QNAME, strings.Join(ips, ","))
log.F("[dns] %s <-> %s(%s), type: %d, %s: %s",
clientAddr, dnsServer, network, resp.Question.QTYPE, resp.Question.QNAME, strings.Join(ips, ","))
return respBytes, nil
}
// exchange choose a upstream dns server based on qname, communicate with it on the network
func (c *Client) exchange(qname string, reqBytes []byte, preferTCP bool) (server, network string, respBytes []byte, err error) {
// use tcp to connect upstream server default
network = "tcp"
dialer := c.dialer.NextDialer(qname + ":53")
// If client uses udp and no forwarders specified, use udp
if !preferTCP && dialer.Addr() == "DIRECT" {
network = "udp"
}
server = c.GetServer(qname)
rc, err := dialer.Dial(network, server)
if err != nil {
log.F("[dns] failed to connect to server %v: %v", server, err)
return
}
switch network {
case "tcp":
respBytes, err = c.exchangeTCP(rc, reqBytes)
case "udp":
respBytes, err = c.exchangeUDP(rc, reqBytes)
}
return
}
// exchangeTCP exchange with server over tcp
func (c *Client) exchangeTCP(rc net.Conn, reqBytes []byte) ([]byte, error) {
defer rc.Close()
if _, err := rc.Write(reqBytes); err != nil {
log.F("[dns] failed to write req message: %v", err)
return nil, err
}
var respLen uint16
if err := binary.Read(rc, binary.BigEndian, &respLen); err != nil {
log.F("[dns] failed to read response length: %v", err)
return nil, err
}
respBytes := make([]byte, respLen+2)
binary.BigEndian.PutUint16(respBytes[:2], respLen)
_, err := io.ReadFull(rc, respBytes[2:])
if err != nil {
log.F("[dns] error in read respMsg %s\n", err)
return nil, err
}
return respBytes, nil
}
// exchangeUDP exchange with server over udp
func (c *Client) exchangeUDP(rc net.Conn, reqBytes []byte) ([]byte, error) {
defer rc.Close()
if _, err := rc.Write(reqBytes[2:]); err != nil {
log.F("[dns] failed to write req message: %v", err)
return nil, err
}
reqBytes = make([]byte, 2+UDPMaxLen)
n, err := rc.Read(reqBytes[2:])
if err != nil {
return nil, err
}
binary.BigEndian.PutUint16(reqBytes[:2], uint16(n))
return reqBytes[:2+n], nil
}
// SetServer .
func (c *Client) SetServer(domain string, servers ...string) {
c.upServerMap[domain] = append(c.upServerMap[domain], servers...)
@@ -193,7 +243,7 @@ func (c *Client) GenResponse(domain string, ip string) (*Message, error) {
m := NewMessage(0, Response)
m.SetQuestion(NewQuestion(qtype, domain))
rr := &RR{NAME: domain, TYPE: qtype, CLASS: CLASSIN,
rr := &RR{NAME: domain, TYPE: qtype, CLASS: ClassINET,
RDLENGTH: rdlen, RDATA: rdata}
m.AddAnswer(rr)