From 63693225b6293cfd41575006bfef4aa001565077 Mon Sep 17 00:00:00 2001 From: Mzack9999 Date: Sun, 8 Nov 2020 01:43:06 +0100 Subject: [PATCH 01/12] wip - code rework --- client.go | 83 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 83 insertions(+) diff --git a/client.go b/client.go index af0e266..4b86c76 100644 --- a/client.go +++ b/client.go @@ -144,6 +144,47 @@ func (c *Client) Do(msg *dns.Msg) (resp *dns.Msg, err error) { return } +// ResolveEnrich sends a provided dns request and return enriched response +func (c *Client) ResolveEnrich(host string, requestType uint16) (*DNSData, error) { + var ( + dnsdata DNSData + err error + msg dns.Msg + ) + + msg.Id = dns.Id() + msg.RecursionDesired = true + msg.Question = make([]dns.Question, 1) + msg.Question[0] = dns.Question{ + Name: dns.Fqdn(host), + Qtype: requestType, + Qclass: dns.ClassINET, + } + + for i := 0; i < c.maxRetries; i++ { + resolver := c.resolvers[rand.Intn(len(c.resolvers))] + var resp *dns.Msg + resp, err = dns.Exchange(&msg, resolver) + if err != nil { + continue + } + + dnsdata.Raw = resp.String() + dnsdata.StatusCode = dns.RcodeToString[resp.Rcode] + dnsdata.Resolver = resolver + + // In case we got some error from the server, return. + if resp != nil && resp.Rcode != dns.RcodeSuccess { + break + } + + dnsdata.ParseFromMsg(resp) + break + } + + return &dnsdata, err +} + func parse(answer *dns.Msg, requestType uint16) (results []string) { for _, record := range answer.Answer { switch requestType { @@ -184,3 +225,45 @@ func parse(answer *dns.Msg, requestType uint16) (results []string) { return } + +type DNSData struct { + Domain string + TTL int + Resolver string + A []string + AAAA []string + CNAME []string + MX []string + PTR []string + SOA []string + NS []string + TXT []string + Raw string + StatusCode string +} + +// ParseFromMsg and enrich data +func (d *DNSData) ParseFromMsg(msg *dns.Msg) error { + for _, record := range msg.Answer { + switch record.(type) { + case *dns.A: + d.A = append(d.A, record.String()) + case *dns.NS: + d.NS = append(d.NS, record.String()) + case *dns.CNAME: + d.CNAME = append(d.CNAME, record.String()) + case *dns.SOA: + d.SOA = append(d.SOA, record.String()) + case *dns.PTR: + d.PTR = append(d.PTR, record.String()) + case *dns.MX: + d.MX = append(d.MX, record.String()) + case *dns.TXT: + d.TXT = append(d.TXT, record.String()) + case *dns.AAAA: + d.AAAA = append(d.AAAA, record.String()) + } + } + + return nil +} From ce804e3068f3d1837f07cc0b01597f54c1158047 Mon Sep 17 00:00:00 2001 From: Mzack9999 Date: Sun, 8 Nov 2020 18:56:52 +0100 Subject: [PATCH 02/12] rework for dnsx --- client.go | 186 +++++++++++++++++++++++++++++------------------------- 1 file changed, 99 insertions(+), 87 deletions(-) diff --git a/client.go b/client.go index 4b86c76..18d1d54 100644 --- a/client.go +++ b/client.go @@ -1,8 +1,10 @@ package dns import ( + "encoding/json" "errors" "math/rand" + "strings" "sync" "time" @@ -19,12 +21,6 @@ type Client struct { mutex *sync.Mutex } -// Result contains the results from a DNS resolution -type Result struct { - IPs []string - TTL int -} - // New creates a new dns client func New(baseResolvers []string, maxRetries int) *Client { client := Client{ @@ -38,7 +34,7 @@ func New(baseResolvers []string, maxRetries int) *Client { // Resolve is the underlying resolve function that actually resolves a host // and gets the ip records for that host. -func (c *Client) Resolve(host string) (Result, error) { +func (c *Client) Resolve(host string) (DNSData, error) { msg := new(dns.Msg) msg.Id = dns.Id() @@ -53,7 +49,7 @@ func (c *Client) Resolve(host string) (Result, error) { var err error var answer *dns.Msg - result := Result{} + dnsdata := DNSData{} for i := 0; i < c.maxRetries; i++ { c.mutex.Lock() @@ -64,65 +60,26 @@ func (c *Client) Resolve(host string) (Result, error) { if err != nil { continue } + dnsdata.Resolver = append(dnsdata.Resolver, resolver) + dnsdata.Raw = answer.String() + dnsdata.StatusCode = dns.RcodeToString[answer.Rcode] // In case we got some error from the server, return. if answer != nil && answer.Rcode != dns.RcodeSuccess { - return result, errors.New(dns.RcodeToString[answer.Rcode]) + return dnsdata, errors.New(dns.RcodeToString[answer.Rcode]) } for _, record := range answer.Answer { // Add the IP and the TTL to the map if t, ok := record.(*dns.A); ok { - result.IPs = append(result.IPs, t.A.String()) - result.TTL = int(t.Header().Ttl) + dnsdata.A = append(dnsdata.A, t.A.String()) + dnsdata.TTL = int(t.Header().Ttl) } } - return result, nil + return dnsdata, nil } - return result, err -} - -// ResolveRaw is the underlying resolve function that actually resolves a host -// and gets the raw records for that host. -func (c *Client) ResolveRaw(host string, requestType uint16) (results []string, raw string, err error) { - msg := new(dns.Msg) - - msg.Id = dns.Id() - msg.RecursionDesired = true - msg.Question = make([]dns.Question, 1) - msg.Question[0] = dns.Question{ - Name: dns.Fqdn(host), - Qtype: requestType, - Qclass: dns.ClassINET, - } - - var answer *dns.Msg - - for i := 0; i < c.maxRetries; i++ { - c.mutex.Lock() - resolver := c.resolvers[c.rand.Intn(len(c.resolvers))] - c.mutex.Unlock() - - answer, err = dns.Exchange(msg, resolver) - if answer != nil { - raw = answer.String() - } - if err != nil { - continue - } - - // In case we got some error from the server, return. - if answer != nil && answer.Rcode != dns.RcodeSuccess { - return results, raw, errors.New(dns.RcodeToString[answer.Rcode]) - } - - results = append(results, parse(answer, requestType)...) - - return results, raw, nil - } - - return results, raw, err + return dnsdata, err } // Do sends a provided dns request and return the raw native response @@ -144,8 +101,8 @@ func (c *Client) Do(msg *dns.Msg) (resp *dns.Msg, err error) { return } -// ResolveEnrich sends a provided dns request and return enriched response -func (c *Client) ResolveEnrich(host string, requestType uint16) (*DNSData, error) { +// Query sends a provided dns request and return enriched response +func (c *Client) Query(host string, requestType uint16) (*DNSData, error) { var ( dnsdata DNSData err error @@ -171,7 +128,7 @@ func (c *Client) ResolveEnrich(host string, requestType uint16) (*DNSData, error dnsdata.Raw = resp.String() dnsdata.StatusCode = dns.RcodeToString[resp.Rcode] - dnsdata.Resolver = resolver + dnsdata.Resolver = append(dnsdata.Resolver, resolver) // In case we got some error from the server, return. if resp != nil && resp.Rcode != dns.RcodeSuccess { @@ -185,40 +142,83 @@ func (c *Client) ResolveEnrich(host string, requestType uint16) (*DNSData, error return &dnsdata, err } +// QueryMultiple sends a provided dns request and return the data +func (c *Client) QueryMultiple(host string, requestTypes []uint16) (*DNSData, error) { + var ( + dnsdata DNSData + err error + msg dns.Msg + ) + + msg.Id = dns.Id() + msg.RecursionDesired = true + msg.Question = make([]dns.Question, 1) + + for _, requestType := range requestTypes { + msg.Question[0] = dns.Question{ + Name: dns.Fqdn(host), + Qtype: requestType, + Qclass: dns.ClassINET, + } + for i := 0; i < c.maxRetries; i++ { + resolver := c.resolvers[rand.Intn(len(c.resolvers))] + var resp *dns.Msg + resp, err = dns.Exchange(&msg, resolver) + if err != nil { + continue + } + + dnsdata.Raw += resp.String() + dnsdata.StatusCode = dns.RcodeToString[resp.Rcode] + dnsdata.Resolver = append(dnsdata.Resolver, resolver) + + // In case we got some error from the server, return. + if resp != nil && resp.Rcode != dns.RcodeSuccess { + break + } + + dnsdata.ParseFromMsg(resp) + break + } + } + + return &dnsdata, err +} + func parse(answer *dns.Msg, requestType uint16) (results []string) { for _, record := range answer.Answer { switch requestType { case dns.TypeA: if t, ok := record.(*dns.A); ok { - results = append(results, t.String()) + results = append(results, t.A.String()) } case dns.TypeNS: if t, ok := record.(*dns.NS); ok { - results = append(results, t.String()) + results = append(results, t.Ns) } case dns.TypeCNAME: if t, ok := record.(*dns.CNAME); ok { - results = append(results, t.String()) + results = append(results, t.Target) } case dns.TypeSOA: if t, ok := record.(*dns.SOA); ok { - results = append(results, t.String()) + results = append(results, t.Mbox) } case dns.TypePTR: if t, ok := record.(*dns.PTR); ok { - results = append(results, t.String()) + results = append(results, t.Ptr) } case dns.TypeMX: if t, ok := record.(*dns.MX); ok { - results = append(results, t.String()) + results = append(results, t.Mx) } case dns.TypeTXT: if t, ok := record.(*dns.TXT); ok { - results = append(results, t.String()) + results = append(results, t.Txt...) } case dns.TypeAAAA: if t, ok := record.(*dns.AAAA); ok { - results = append(results, t.String()) + results = append(results, t.AAAA.String()) } } } @@ -227,19 +227,19 @@ func parse(answer *dns.Msg, requestType uint16) (results []string) { } type DNSData struct { - Domain string - TTL int - Resolver string - A []string - AAAA []string - CNAME []string - MX []string - PTR []string - SOA []string - NS []string - TXT []string - Raw string - StatusCode string + Domain string `json:"domain,omitempty"` + TTL int `json:"ttl,omitempty"` + Resolver []string `json:"resolver,omitempty"` + A []string `json:"a,omitempty"` + AAAA []string `json:"aaaa,omitempty"` + CNAME []string `json:"cname,omitempty"` + MX []string `json:"mx,omitempty"` + PTR []string `json:"ptr,omitempty"` + SOA []string `json:"soa,omitempty"` + NS []string `json:"ns,omitempty"` + TXT []string `json:"txt,omitempty"` + Raw string `json:"raw,omitempty"` + StatusCode string `json:"status_code,omitempty"` } // ParseFromMsg and enrich data @@ -247,23 +247,35 @@ func (d *DNSData) ParseFromMsg(msg *dns.Msg) error { for _, record := range msg.Answer { switch record.(type) { case *dns.A: - d.A = append(d.A, record.String()) + d.A = append(d.A, trimChars(record.(*dns.A).A.String())) case *dns.NS: - d.NS = append(d.NS, record.String()) + d.NS = append(d.NS, trimChars(record.(*dns.NS).Ns)) case *dns.CNAME: - d.CNAME = append(d.CNAME, record.String()) + d.CNAME = append(d.CNAME, trimChars(record.(*dns.CNAME).Target)) case *dns.SOA: - d.SOA = append(d.SOA, record.String()) + d.SOA = append(d.SOA, trimChars(record.(*dns.SOA).Mbox)) case *dns.PTR: - d.PTR = append(d.PTR, record.String()) + d.PTR = append(d.PTR, trimChars(record.(*dns.PTR).Ptr)) case *dns.MX: - d.MX = append(d.MX, record.String()) + d.MX = append(d.MX, trimChars(record.(*dns.MX).Mx)) case *dns.TXT: - d.TXT = append(d.TXT, record.String()) + for _, txt := range record.(*dns.TXT).Txt { + d.TXT = append(d.TXT, trimChars(txt)) + } case *dns.AAAA: - d.AAAA = append(d.AAAA, record.String()) + d.AAAA = append(d.AAAA, trimChars(record.(*dns.AAAA).AAAA.String())) } } return nil } + +// JSON returns the object as json string +func (d *DNSData) JSON() (string, error) { + b, err := json.Marshal(&d) + return string(b), err +} + +func trimChars(s string) string { + return strings.TrimRight(s, ".") +} From c886e5c3e926d85dd75aea9b0addba08318422f6 Mon Sep 17 00:00:00 2001 From: Mzack9999 Date: Sun, 8 Nov 2020 22:34:11 +0100 Subject: [PATCH 03/12] fixing PTR --- client.go | 50 ++++++++++++-------------------------------------- 1 file changed, 12 insertions(+), 38 deletions(-) diff --git a/client.go b/client.go index 18d1d54..130f491 100644 --- a/client.go +++ b/client.go @@ -103,43 +103,7 @@ func (c *Client) Do(msg *dns.Msg) (resp *dns.Msg, err error) { // Query sends a provided dns request and return enriched response func (c *Client) Query(host string, requestType uint16) (*DNSData, error) { - var ( - dnsdata DNSData - err error - msg dns.Msg - ) - - msg.Id = dns.Id() - msg.RecursionDesired = true - msg.Question = make([]dns.Question, 1) - msg.Question[0] = dns.Question{ - Name: dns.Fqdn(host), - Qtype: requestType, - Qclass: dns.ClassINET, - } - - for i := 0; i < c.maxRetries; i++ { - resolver := c.resolvers[rand.Intn(len(c.resolvers))] - var resp *dns.Msg - resp, err = dns.Exchange(&msg, resolver) - if err != nil { - continue - } - - dnsdata.Raw = resp.String() - dnsdata.StatusCode = dns.RcodeToString[resp.Rcode] - dnsdata.Resolver = append(dnsdata.Resolver, resolver) - - // In case we got some error from the server, return. - if resp != nil && resp.Rcode != dns.RcodeSuccess { - break - } - - dnsdata.ParseFromMsg(resp) - break - } - - return &dnsdata, err + return c.QueryMultiple(host, []uint16{requestType}) } // QueryMultiple sends a provided dns request and return the data @@ -155,8 +119,18 @@ func (c *Client) QueryMultiple(host string, requestTypes []uint16) (*DNSData, er msg.Question = make([]dns.Question, 1) for _, requestType := range requestTypes { + name := dns.Fqdn(host) + // In case of PTR adjust the domain name + if requestType == dns.TypePTR { + var err error + name, err = dns.ReverseAddr(host) + if err != nil { + return nil, err + } + } + msg.Question[0] = dns.Question{ - Name: dns.Fqdn(host), + Name: name, Qtype: requestType, Qclass: dns.ClassINET, } From 577d2b95dea4ba22a64af36452780503af1bffd7 Mon Sep 17 00:00:00 2001 From: Mzack9999 Date: Mon, 9 Nov 2020 19:31:29 +0100 Subject: [PATCH 04/12] adding Edns0 to PTR --- client.go | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/client.go b/client.go index 130f491..d1c3503 100644 --- a/client.go +++ b/client.go @@ -120,6 +120,7 @@ func (c *Client) QueryMultiple(host string, requestTypes []uint16) (*DNSData, er for _, requestType := range requestTypes { name := dns.Fqdn(host) + // In case of PTR adjust the domain name if requestType == dns.TypePTR { var err error @@ -127,13 +128,16 @@ func (c *Client) QueryMultiple(host string, requestTypes []uint16) (*DNSData, er if err != nil { return nil, err } + msg.SetEdns0(4096, false) } - msg.Question[0] = dns.Question{ + question := dns.Question{ Name: name, Qtype: requestType, Qclass: dns.ClassINET, } + msg.Question[0] = question + for i := 0; i < c.maxRetries; i++ { resolver := c.resolvers[rand.Intn(len(c.resolvers))] var resp *dns.Msg From d96f729b2a80b7d70c73a84d1f5ec41c7b42e28a Mon Sep 17 00:00:00 2001 From: Mzack9999 Date: Mon, 9 Nov 2020 22:41:01 +0100 Subject: [PATCH 05/12] adding marshal/unmarshal helpers --- client.go | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/client.go b/client.go index d1c3503..dfcddac 100644 --- a/client.go +++ b/client.go @@ -1,6 +1,8 @@ package dns import ( + "bytes" + "encoding/gob" "encoding/json" "errors" "math/rand" @@ -257,3 +259,23 @@ func (d *DNSData) JSON() (string, error) { func trimChars(s string) string { return strings.TrimRight(s, ".") } + +func (r *DNSData) Marshal() ([]byte, error) { + var b bytes.Buffer + enc := gob.NewEncoder(&b) + err := enc.Encode(r) + if err != nil { + return nil, err + } + + return b.Bytes(), nil +} + +func (r *DNSData) Unmarshal(b []byte) error { + dec := gob.NewDecoder(bytes.NewBuffer(b)) + err := dec.Decode(&r) + if err != nil { + return err + } + return nil +} From 433a16f33345bf1352b915907f4b81ff1b436149 Mon Sep 17 00:00:00 2001 From: Mzack9999 Date: Mon, 9 Nov 2020 22:56:52 +0100 Subject: [PATCH 06/12] wip --- client.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/client.go b/client.go index dfcddac..ae9783e 100644 --- a/client.go +++ b/client.go @@ -36,7 +36,7 @@ func New(baseResolvers []string, maxRetries int) *Client { // Resolve is the underlying resolve function that actually resolves a host // and gets the ip records for that host. -func (c *Client) Resolve(host string) (DNSData, error) { +func (c *Client) Resolve(host string) (*DNSData, error) { msg := new(dns.Msg) msg.Id = dns.Id() @@ -51,7 +51,7 @@ func (c *Client) Resolve(host string) (DNSData, error) { var err error var answer *dns.Msg - dnsdata := DNSData{} + dnsdata := &DNSData{} for i := 0; i < c.maxRetries; i++ { c.mutex.Lock() From cead885aba17b0523c54236489c892ebef265613 Mon Sep 17 00:00:00 2001 From: Mzack9999 Date: Mon, 9 Nov 2020 23:08:05 +0100 Subject: [PATCH 07/12] wip --- client.go | 47 +---------------------------------------------- 1 file changed, 1 insertion(+), 46 deletions(-) diff --git a/client.go b/client.go index ae9783e..a076b54 100644 --- a/client.go +++ b/client.go @@ -4,7 +4,6 @@ import ( "bytes" "encoding/gob" "encoding/json" - "errors" "math/rand" "strings" "sync" @@ -37,51 +36,7 @@ func New(baseResolvers []string, maxRetries int) *Client { // Resolve is the underlying resolve function that actually resolves a host // and gets the ip records for that host. func (c *Client) Resolve(host string) (*DNSData, error) { - msg := new(dns.Msg) - - msg.Id = dns.Id() - msg.RecursionDesired = true - msg.Question = make([]dns.Question, 1) - msg.Question[0] = dns.Question{ - Name: dns.Fqdn(host), - Qtype: dns.TypeA, - Qclass: dns.ClassINET, - } - - var err error - var answer *dns.Msg - - dnsdata := &DNSData{} - - for i := 0; i < c.maxRetries; i++ { - c.mutex.Lock() - resolver := c.resolvers[c.rand.Intn(len(c.resolvers))] - c.mutex.Unlock() - - answer, err = dns.Exchange(msg, resolver) - if err != nil { - continue - } - dnsdata.Resolver = append(dnsdata.Resolver, resolver) - dnsdata.Raw = answer.String() - dnsdata.StatusCode = dns.RcodeToString[answer.Rcode] - - // In case we got some error from the server, return. - if answer != nil && answer.Rcode != dns.RcodeSuccess { - return dnsdata, errors.New(dns.RcodeToString[answer.Rcode]) - } - - for _, record := range answer.Answer { - // Add the IP and the TTL to the map - if t, ok := record.(*dns.A); ok { - dnsdata.A = append(dnsdata.A, t.A.String()) - dnsdata.TTL = int(t.Header().Ttl) - } - } - return dnsdata, nil - } - - return dnsdata, err + return c.Query(host, dns.TypeA) } // Do sends a provided dns request and return the raw native response From b3dfebe0bad5ee3cfaf009962d85c23dce6c0352 Mon Sep 17 00:00:00 2001 From: Mzack9999 Date: Tue, 10 Nov 2020 22:25:33 +0100 Subject: [PATCH 08/12] package rename --- client.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/client.go b/client.go index a076b54..7bb631b 100644 --- a/client.go +++ b/client.go @@ -1,4 +1,4 @@ -package dns +package retryabledns import ( "bytes" @@ -103,6 +103,7 @@ func (c *Client) QueryMultiple(host string, requestTypes []uint16) (*DNSData, er continue } + dnsdata.Domain = host dnsdata.Raw += resp.String() dnsdata.StatusCode = dns.RcodeToString[resp.Rcode] dnsdata.Resolver = append(dnsdata.Resolver, resolver) From 30d487cf6b77a2628286a24fdc3c7564d27cae6f Mon Sep 17 00:00:00 2001 From: Mzack9999 Date: Tue, 10 Nov 2020 22:41:49 +0100 Subject: [PATCH 09/12] adding generic records deduping --- client.go | 41 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 41 insertions(+) diff --git a/client.go b/client.go index 7bb631b..aac64fa 100644 --- a/client.go +++ b/client.go @@ -5,6 +5,8 @@ import ( "encoding/gob" "encoding/json" "math/rand" + "reflect" + "sort" "strings" "sync" "time" @@ -118,6 +120,8 @@ func (c *Client) QueryMultiple(host string, requestTypes []uint16) (*DNSData, er } } + dnsdata.dedupe() + return &dnsdata, err } @@ -216,6 +220,19 @@ func trimChars(s string) string { return strings.TrimRight(s, ".") } +func (r *DNSData) dedupe() { + // dedupe all records + dedupeSlice(&r.Resolver, less(&r.Resolver)) + dedupeSlice(&r.A, less(&r.Resolver)) + dedupeSlice(&r.AAAA, less(&r.Resolver)) + dedupeSlice(&r.CNAME, less(&r.Resolver)) + dedupeSlice(&r.MX, less(&r.Resolver)) + dedupeSlice(&r.PTR, less(&r.Resolver)) + dedupeSlice(&r.SOA, less(&r.Resolver)) + dedupeSlice(&r.NS, less(&r.Resolver)) + dedupeSlice(&r.TXT, less(&r.Resolver)) +} + func (r *DNSData) Marshal() ([]byte, error) { var b bytes.Buffer enc := gob.NewEncoder(&b) @@ -235,3 +252,27 @@ func (r *DNSData) Unmarshal(b []byte) error { } return nil } + +func less(v interface{}) func(i, j int) bool { + s := *v.(*[]string) + return func(i, j int) bool { return s[i] < s[j] } +} + +func dedupeSlice(slicePtr interface{}, less func(i, j int) bool) { + v := reflect.ValueOf(slicePtr).Elem() + if v.Len() <= 1 { + return + } + sort.Slice(v.Interface(), less) + + i := 0 + for j := 1; j < v.Len(); j++ { + if !less(i, j) { + continue + } + i++ + v.Index(i).Set(v.Index(j)) + } + i++ + v.SetLen(i) +} From da4c2ff1d4238516411b70233e1c5f079afb1934 Mon Sep 17 00:00:00 2001 From: Mzack9999 Date: Tue, 10 Nov 2020 22:48:47 +0100 Subject: [PATCH 10/12] wip --- client.go | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/client.go b/client.go index aac64fa..e8be2ae 100644 --- a/client.go +++ b/client.go @@ -223,14 +223,14 @@ func trimChars(s string) string { func (r *DNSData) dedupe() { // dedupe all records dedupeSlice(&r.Resolver, less(&r.Resolver)) - dedupeSlice(&r.A, less(&r.Resolver)) - dedupeSlice(&r.AAAA, less(&r.Resolver)) - dedupeSlice(&r.CNAME, less(&r.Resolver)) - dedupeSlice(&r.MX, less(&r.Resolver)) - dedupeSlice(&r.PTR, less(&r.Resolver)) - dedupeSlice(&r.SOA, less(&r.Resolver)) - dedupeSlice(&r.NS, less(&r.Resolver)) - dedupeSlice(&r.TXT, less(&r.Resolver)) + dedupeSlice(&r.A, less(&r.A)) + dedupeSlice(&r.AAAA, less(&r.AAAA)) + dedupeSlice(&r.CNAME, less(&r.CNAME)) + dedupeSlice(&r.MX, less(&r.MX)) + dedupeSlice(&r.PTR, less(&r.PTR)) + dedupeSlice(&r.SOA, less(&r.SOA)) + dedupeSlice(&r.NS, less(&r.NS)) + dedupeSlice(&r.TXT, less(&r.TXT)) } func (r *DNSData) Marshal() ([]byte, error) { From 303a7b0e86f97dc6cd996792a53231fea27841cf Mon Sep 17 00:00:00 2001 From: Mzack9999 Date: Thu, 12 Nov 2020 18:37:45 +0100 Subject: [PATCH 11/12] adding specific PTR conversion --- client.go | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/client.go b/client.go index e8be2ae..03b01ed 100644 --- a/client.go +++ b/client.go @@ -5,6 +5,7 @@ import ( "encoding/gob" "encoding/json" "math/rand" + "net" "reflect" "sort" "strings" @@ -83,9 +84,11 @@ func (c *Client) QueryMultiple(host string, requestTypes []uint16) (*DNSData, er // In case of PTR adjust the domain name if requestType == dns.TypePTR { var err error - name, err = dns.ReverseAddr(host) - if err != nil { - return nil, err + if net.ParseIP(host) != nil { + name, err = dns.ReverseAddr(host) + if err != nil { + return nil, err + } } msg.SetEdns0(4096, false) } From f75c48070508bfbb8f61b691b81fc5fd33d5b46a Mon Sep 17 00:00:00 2001 From: Mzack9999 Date: Thu, 12 Nov 2020 18:52:34 +0100 Subject: [PATCH 12/12] wip --- client.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/client.go b/client.go index 03b01ed..d0f1d92 100644 --- a/client.go +++ b/client.go @@ -108,7 +108,7 @@ func (c *Client) QueryMultiple(host string, requestTypes []uint16) (*DNSData, er continue } - dnsdata.Domain = host + dnsdata.Host = host dnsdata.Raw += resp.String() dnsdata.StatusCode = dns.RcodeToString[resp.Rcode] dnsdata.Resolver = append(dnsdata.Resolver, resolver) @@ -170,7 +170,7 @@ func parse(answer *dns.Msg, requestType uint16) (results []string) { } type DNSData struct { - Domain string `json:"domain,omitempty"` + Host string `json:"host,omitempty"` TTL int `json:"ttl,omitempty"` Resolver []string `json:"resolver,omitempty"` A []string `json:"a,omitempty"`