From 1985e049501108f07fc102853c89557d118698c8 Mon Sep 17 00:00:00 2001 From: Tom Limoncelli Date: Wed, 26 Feb 2025 09:38:49 -0500 Subject: [PATCH 1/3] ptr magic --- build/autotype/README.md | 20 ++-- build/autotype/hints.go | 2 +- integrationTest/generated_helpers.go | 9 ++ integrationTest/helpers_integration_test.go | 4 - models/builder_caa.go | 2 - models/generated_types.go | 115 +++++++++++++++++++- models/record.go | 4 +- models/t_parse.go | 45 +------- pkg/js/helpers-types.js | 1 + pkg/js/helpers.js | 3 - pkg/js/parse_tests/032-reverseip.js | 4 +- pkg/js/parse_tests/032-reverseip.json | 27 +++++ pkg/normalize/validate.go | 14 +-- pkg/transform/ptr.go | 7 +- 14 files changed, 182 insertions(+), 75 deletions(-) diff --git a/build/autotype/README.md b/build/autotype/README.md index 3749847295..20af1abebf 100644 --- a/build/autotype/README.md +++ b/build/autotype/README.md @@ -23,11 +23,12 @@ Remove `func cname()` Remove the definition of the type: +Example: + ``` var CNAME = recordBuilder('CNAME'); ``` - - Fix models/t_{type}.go They should call RecordUpdateFields() (see t_mx.go for examples) @@ -42,13 +43,13 @@ fgrep --include='*.go' -r 'SetTargetDSStrings(' -- fix models/t_parse.go -Add to PopulateFromStringFunc - - --- fix record.go +Remove any mention of the type. -func (rc *RecordConfig) Copy() +-- fix models/record.go +Remove any mention of the type in: + func Downcase(recs []*RecordConfig) { + func CanonicalizeTargets(recs []*RecordConfig, origin string) { -- fix pkg/js/parse_tests @@ -60,4 +61,9 @@ update .targets to include the subdomain. jstest.sh 014-caa.js --- fix + +Once all types are using RawRecords... + +Update pkg/normalize/validate.go +func validateRecordTypes(rec *models.RecordConfig, domain string, pTypes []string) error { + diff --git a/build/autotype/hints.go b/build/autotype/hints.go index 8eae92ea8b..447724af3b 100644 --- a/build/autotype/hints.go +++ b/build/autotype/hints.go @@ -53,7 +53,7 @@ func GetHints() ([]string, TypeCatalog) { //addType("SOA", "", nil) // 12 - //addType("PTR", "", nil) + addType("PTR", "", nil) // 15 addType("MX", "", []Field{ diff --git a/integrationTest/generated_helpers.go b/integrationTest/generated_helpers.go index fe111744cb..32fedfab61 100644 --- a/integrationTest/generated_helpers.go +++ b/integrationTest/generated_helpers.go @@ -33,6 +33,15 @@ func cname(name string, target string) *models.RecordConfig { return models.MustCreateRecord(name, rdata, nil, 300, "**current-domain**") } +func ptr(name string, ptr string) *models.RecordConfig { + + rdata, err := models.ParsePTR([]string{ptr}, "", "**current-domain**") + if err != nil { + panic(err) + } + return models.MustCreateRecord(name, rdata, nil, 300, "**current-domain**") +} + func mx(name string, preference uint16, mx string) *models.RecordConfig { spreference := strconv.Itoa(int(preference)) diff --git a/integrationTest/helpers_integration_test.go b/integrationTest/helpers_integration_test.go index 1fe98eca8d..04fea64039 100644 --- a/integrationTest/helpers_integration_test.go +++ b/integrationTest/helpers_integration_test.go @@ -399,10 +399,6 @@ func manyA(namePattern, target string, n int) []*models.RecordConfig { return recs } -func ptr(name, target string) *models.RecordConfig { - return makeRec(name, target, "PTR") -} - func r53alias(name, aliasType, target, evalTargetHealth string) *models.RecordConfig { r := makeRec(name, target, "R53_ALIAS") r.R53Alias = map[string]string{ diff --git a/models/builder_caa.go b/models/builder_caa.go index 96a5054235..202680a959 100644 --- a/models/builder_caa.go +++ b/models/builder_caa.go @@ -9,8 +9,6 @@ func BuilderCAA(rawfields []string, meta map[string]string, origin string) ([]st return rawfields, meta, fmt.Errorf("CAA record must have at least 3 fields") } - fmt.Printf("DEBUG: BuilderCAA: rawfields=%v meta=%+v\n", rawfields, meta) - flag := "0" if meta["caa_critical"] != "" { flag = "128" diff --git a/models/generated_types.go b/models/generated_types.go index 6d96b2befe..617ee5d4b0 100644 --- a/models/generated_types.go +++ b/models/generated_types.go @@ -2,9 +2,11 @@ package models import ( "fmt" + "net/netip" "strconv" "github.com/StackExchange/dnscontrol/v4/pkg/fieldtypes" + "github.com/StackExchange/dnscontrol/v4/pkg/transform" "github.com/qdm12/reprint" ) @@ -12,6 +14,7 @@ func init() { MustRegisterType("A", RegisterOpts{PopulateFromRaw: PopulateFromRawA}) MustRegisterType("NS", RegisterOpts{PopulateFromRaw: PopulateFromRawNS}) MustRegisterType("CNAME", RegisterOpts{PopulateFromRaw: PopulateFromRawCNAME}) + MustRegisterType("PTR", RegisterOpts{PopulateFromRaw: PopulateFromRawPTR}) MustRegisterType("MX", RegisterOpts{PopulateFromRaw: PopulateFromRawMX}) MustRegisterType("AAAA", RegisterOpts{PopulateFromRaw: PopulateFromRawAAAA}) MustRegisterType("SRV", RegisterOpts{PopulateFromRaw: PopulateFromRawSRV}) @@ -24,7 +27,7 @@ func init() { // RecordType is a constraint for DNS records. type RecordType interface { - A | NS | CNAME | MX | AAAA | SRV | NAPTR | DS | DNSKEY | CAA | CFSINGLEREDIRECT + A | NS | CNAME | PTR | MX | AAAA | SRV | NAPTR | DS | DNSKEY | CAA | CFSINGLEREDIRECT } // ImportFromLegacy copies the legacy fields (MxPreference, SrvPort, etc.) to @@ -53,6 +56,11 @@ func (rc *RecordConfig) ImportFromLegacy(origin string) error { CNAME{Target: rc.target}, nil, ) + case "PTR": + return RecordUpdateFields(rc, + PTR{Ptr: rc.target}, + nil, + ) case "MX": return RecordUpdateFields(rc, MX{Preference: rc.MxPreference, Mx: rc.target}, @@ -113,6 +121,11 @@ func (rc *RecordConfig) Seal() error { rc.target = f.Target rc.Comparable = f.Target + case "PTR": + f := rc.Fields.(*PTR) + rc.target = f.Ptr + + rc.Comparable = f.Ptr case "MX": f := rc.Fields.(*MX) rc.MxPreference = f.Preference @@ -196,6 +209,9 @@ func (rc *RecordConfig) Copy() (*RecordConfig, error) { case "CNAME": newR.Fields = &CNAME{} newR.Fields = rc.Fields.(*CNAME) + case "PTR": + newR.Fields = &PTR{} + newR.Fields = rc.Fields.(*PTR) case "MX": newR.Fields = &MX{} newR.Fields = rc.Fields.(*MX) @@ -239,6 +255,10 @@ func PopulateFromFields(rc *RecordConfig, rtype string, fields []string, origin if rdata, err := ParseCNAME(fields, "", origin); err == nil { return RecordUpdateFields(rc, rdata, nil) } + case "PTR": + if rdata, err := ParsePTR(fields, "", origin); err == nil { + return RecordUpdateFields(rc, rdata, nil) + } case "MX": if rdata, err := ParseMX(fields, "", origin); err == nil { return RecordUpdateFields(rc, rdata, nil) @@ -285,6 +305,8 @@ func (rc *RecordConfig) GetTargetField() string { return rc.AsNS().Ns case "CNAME": return rc.AsCNAME().Target + case "PTR": + return rc.AsPTR().Ptr case "MX": return rc.AsMX().Mx case "AAAA": @@ -507,6 +529,97 @@ func (rc *RecordConfig) SetTargetCNAME(target string) error { return RecordUpdateFields(rc, CNAME{Target: target}, nil) } +//// PTR + +// PTR is the fields needed to store a DNS record of type PTR. +type PTR struct { + Ptr string `dns:"cdomain-name"` +} + +// ParsePTR parses rawfields into an PTR struct. +// subdomain should be "" unless this function is being called by the process that turns dnsconfig.js into the "desired" list. +// Setting origin to "" activates a legacy mode that will go away when the SetTarget*() functions are removed. +func ParsePTR(rawfields []string, subdomain, origin string) (PTR, error) { + + // Error checking + if errorCheckFieldCount(rawfields, 1) { + return PTR{}, fmt.Errorf("rtype PTR wants %d field(s), found %d: %+v", 1, len(rawfields)-1, rawfields[1:]) + } + var ptr string + var err error + if ptr, err = fieldtypes.ParseHostnameDot(rawfields[0], subdomain, origin); err != nil { + return PTR{}, err + } + + return PTR{Ptr: ptr}, nil +} + +// PopulateFromRawPTR updates rc to be an PTR record with contents from rawfields, meta and origin. +func PopulateFromRawPTR(rc *RecordConfig, rawfields []string, meta map[string]string, subdomain, origin string) error { + rc.Type = "PTR" + + label := rawfields[0] + //fmt.Printf("DEBUG: RawPTR: called label=%s subdomain=%s origin=%s\n", label, subdomain, origin) + if _, err := netip.ParseAddr(label); err == nil { + // Label is an IP address. + subdomain = "" // PtrMagic mode matches the origin properly, thus subdomain is no longer relevant. + var err error + label, err = transform.PtrNameMagic(label, origin) + if err != nil { + //fmt.Printf("DEBUG: RawPTR: err %v\n", err) + return err + } + //fmt.Printf("DEBUG: RawPTR: step1 %s\n", label) + } + //fmt.Printf("DEBUG: RawPTR: SetLabel3(%q, %q, %q)\n", label, subdomain, origin) + + // First rawfield is the label. + if err := rc.SetLabel3(label, subdomain, origin); err != nil { + return err + } + // { + // fmt.Printf("DEBUG: RawPTR: called %s %s\n", rc.NameFQDN, origin) + // if name, err := transform.PtrNameMagic(rc.NameFQDN, origin); err != nil { + // return err + // } else { + // fmt.Printf("DEBUG: RawPTR: step1 %s\n", name) + // rc.SetLabel(name, origin) + // } + // fmt.Printf("DEBUG: RawPTR: result %s %s\n", rc.Name, rc.NameFQDN) + // } + + // Parse the remaining fields. + rdata, err := ParsePTR(rawfields[1:], subdomain, origin) + if err != nil { + return err + } + + return RecordUpdateFields(rc, rdata, meta) +} + +// AsPTR returns rc.Fields as an PTR struct. +func (rc *RecordConfig) AsPTR() *PTR { + return rc.Fields.(*PTR) +} + +// GetFieldsPTR returns rc.Fields as individual typed values. +func (rc *RecordConfig) GetFieldsPTR() string { + n := rc.AsPTR() + return n.Ptr +} + +// GetFieldsAsStringsPTR returns rc.Fields as individual strings. +func (rc *RecordConfig) GetFieldsAsStringsPTR() [1]string { + n := rc.AsPTR() + return [1]string{n.Ptr} +} + +// SetTargetPTR sets the PTR fields. +func (rc *RecordConfig) SetTargetPTR(ptr string) error { + rc.Type = "PTR" + return RecordUpdateFields(rc, PTR{Ptr: ptr}, nil) +} + //// MX // MX is the fields needed to store a DNS record of type MX. diff --git a/models/record.go b/models/record.go index 9b886ad29f..8d7f21f54c 100644 --- a/models/record.go +++ b/models/record.go @@ -620,7 +620,7 @@ func Downcase(recs []*RecordConfig) { r.Name = strings.ToLower(r.Name) r.NameFQDN = strings.ToLower(r.NameFQDN) switch r.Type { // #rtype_variations - case "AKAMAICDN", "ALIAS", "AAAA", "ANAME", "CNAME", "DNAME", "DS", "DNSKEY", "MX", "NS", "NAPTR", "PTR", "SRV", "TLSA": + case "AKAMAICDN", "ALIAS", "AAAA", "ANAME", "CNAME", "DNAME", "DS", "DNSKEY", "MX", "NS", "NAPTR", "SRV", "TLSA": // Target is case insensitive. Downcase it. r.target = strings.ToLower(r.target) // BUGFIX(tlim): isn't ALIAS in the wrong case statement? @@ -649,7 +649,7 @@ func CanonicalizeTargets(recs []*RecordConfig, origin string) { for _, r := range recs { switch r.Type { // #rtype_variations - case "ALIAS", "ANAME", "CNAME", "DNAME", "DS", "DNSKEY", "MX", "NS", "NAPTR", "PTR", "SRV": + case "ALIAS", "ANAME", "CNAME", "DNAME", "DS", "DNSKEY", "MX", "NS", "NAPTR", "SRV": // Target is a hostname that might be a shortname. Turn it into a FQDN. r.target = dnsutil.AddOrigin(r.target, originFQDN) case "A", "AKAMAICDN", "CAA", "DHCID", "CF_SINGLE_REDIRECT", "CF_REDIRECT", "CF_TEMP_REDIRECT", "CF_WORKER_ROUTE", "HTTPS", "IMPORT_TRANSFORM", "LOC", "SSHFP", "SVCB", "TLSA", "TXT": diff --git a/models/t_parse.go b/models/t_parse.go index 0051910682..fc156ea5f8 100644 --- a/models/t_parse.go +++ b/models/t_parse.go @@ -2,7 +2,6 @@ package models import ( "fmt" - "net" "strings" "github.com/StackExchange/dnscontrol/v4/pkg/rfc1035" @@ -86,48 +85,8 @@ func (rc *RecordConfig) PopulateFromStringFunc(rtype, contents, origin string, t return PopulateFromFields(rc, rtype, fields, origin) } - // switch rtype { - - // case "A": - // if rdata, err := ParseA(fields, origin); err == nil { - // return RecordUpdateFields(rc, rdata, nil) - // } - // case "MX": - // if rdata, err := ParseMX(fields, origin); err == nil { - // return RecordUpdateFields(rc, rdata, nil) - // } - // case "CNAME": - // if rdata, err := ParseCNAME(fields, origin); err == nil { - // return RecordUpdateFields(rc, rdata, nil) - // } - // case "SRV": - // if rdata, err := ParseSRV(fields, origin); err == nil { - // return RecordUpdateFields(rc, rdata, nil) - // } - // case "CAA": - // if rdata, err := ParseCAA(fields, origin); err == nil { - // return RecordUpdateFields(rc, rdata, nil) - // } - // case "DS": - // if rdata, err := ParseDS(fields, origin); err == nil { - // return RecordUpdateFields(rc, rdata, nil) - // } - // case "DNSKEY": - // if rdata, err := ParseDNSKEY(fields, origin); err == nil { - // return RecordUpdateFields(rc, rdata, nil) - // } - // } - // return err - // } - switch rc.Type = rtype; rtype { // #rtype_variations - case "AAAA": - ip := net.ParseIP(contents) - if ip == nil || ip.To16() == nil { - return fmt.Errorf("invalid IP in AAAA record: %s", contents) - } - return rc.SetTargetIP(ip) // Reformat to canonical form. - case "AKAMAICDN", "ALIAS", "ANAME", "CNAME", "NS", "PTR": + case "AKAMAICDN", "ALIAS", "ANAME": return rc.SetTarget(contents) case "DHCID": return rc.SetTarget(contents) @@ -135,8 +94,6 @@ func (rc *RecordConfig) PopulateFromStringFunc(rtype, contents, origin string, t return rc.SetTarget(contents) case "LOC": return rc.SetTargetLOCString(origin, contents) - case "NAPTR": - return rc.SetTargetNAPTRString(contents) case "SOA": return rc.SetTargetSOAString(contents) case "SPF", "TXT": diff --git a/pkg/js/helpers-types.js b/pkg/js/helpers-types.js index ef1ac68a38..e92b993ce6 100644 --- a/pkg/js/helpers-types.js +++ b/pkg/js/helpers-types.js @@ -1,6 +1,7 @@ var A = rawrecordBuilder('A'); var NS = rawrecordBuilder('NS'); var CNAME = rawrecordBuilder('CNAME'); +var PTR = rawrecordBuilder('PTR'); var MX = rawrecordBuilder('MX'); var AAAA = rawrecordBuilder('AAAA'); var SRV = rawrecordBuilder('SRV'); diff --git a/pkg/js/helpers.js b/pkg/js/helpers.js index 8d6992c669..581bfa90ae 100644 --- a/pkg/js/helpers.js +++ b/pkg/js/helpers.js @@ -403,9 +403,6 @@ var HTTPS = recordBuilder('HTTPS', { }, }); -// PTR(name,target, recordModifiers...) -var PTR = recordBuilder('PTR'); - // SOA(name,ns,mbox,refresh,retry,expire,minimum, recordModifiers...) var SOA = recordBuilder('SOA', { args: [ diff --git a/pkg/js/parse_tests/032-reverseip.js b/pkg/js/parse_tests/032-reverseip.js index 1a29d8f003..8d1969d633 100644 --- a/pkg/js/parse_tests/032-reverseip.js +++ b/pkg/js/parse_tests/032-reverseip.js @@ -11,9 +11,9 @@ D(REV('1.2.3.0/24'), REGISTRAR, DnsProvider(BIND), }), ); D_EXTEND(REV("1.2.3.4"), - PTR("4", "silly.example.com."), + PTR("@", "silly.example.com."), ); -D_EXTEND(REV("1.2.3.5"), +D_EXTEND(REV("1.2.3.5/32"), PTR("1.2.3.5", "willy.example.com."), ); D_EXTEND(REV("1.2.3.6"), diff --git a/pkg/js/parse_tests/032-reverseip.json b/pkg/js/parse_tests/032-reverseip.json index 9d3392133c..7c1707a4ea 100644 --- a/pkg/js/parse_tests/032-reverseip.json +++ b/pkg/js/parse_tests/032-reverseip.json @@ -17,18 +17,27 @@ "name": "3.2.1.in-addr.arpa", "records": [ { + "Fields": { + "Ptr": "foo.example.com." + }, "name": "1", "target": "foo.example.com.", "ttl": 300, "type": "PTR" }, { + "Fields": { + "Ptr": "bar.example.com." + }, "name": "2", "target": "bar.example.com.", "ttl": 300, "type": "PTR" }, { + "Fields": { + "Ptr": "baz.example.com." + }, "meta": { "skip_fqdn_check": "true" }, @@ -38,36 +47,54 @@ "type": "PTR" }, { + "Fields": { + "Ptr": "silly.example.com." + }, "name": "4", "target": "silly.example.com.", "ttl": 300, "type": "PTR" }, { + "Fields": { + "Ptr": "willy.example.com." + }, "name": "5", "target": "willy.example.com.", "ttl": 300, "type": "PTR" }, { + "Fields": { + "Ptr": "billy.example.com." + }, "name": "6", "target": "billy.example.com.", "ttl": 300, "type": "PTR" }, { + "Fields": { + "Ptr": "my.example.com." + }, "name": "7", "target": "my.example.com.", "ttl": 300, "type": "PTR" }, { + "Fields": { + "Ptr": "fair.example.com." + }, "name": "8", "target": "fair.example.com.", "ttl": 300, "type": "PTR" }, { + "Fields": { + "Ptr": "lady.example.com." + }, "meta": { "skip_fqdn_check": "true" }, diff --git a/pkg/normalize/validate.go b/pkg/normalize/validate.go index 42b329aab2..bab1278947 100644 --- a/pkg/normalize/validate.go +++ b/pkg/normalize/validate.go @@ -434,13 +434,13 @@ func ValidateAndNormalizeConfig(config *models.DNSConfig) (errs []error) { if err := rec.SetTarget(net.ParseIP(rec.GetTargetField()).String()); err != nil { errs = append(errs, err) } - } else if rec.Type == "PTR" { - var err error - var name string - if name, err = transform.PtrNameMagic(rec.GetLabel(), domain.Name); err != nil { - errs = append(errs, err) - } - rec.SetLabel(name, domain.Name) + // } else if rec.Type == "PTR" { + // var err error + // var name string + // if name, err = transform.PtrNameMagic(rec.GetLabel(), domain.Name); err != nil { + // errs = append(errs, err) + // } + // rec.SetLabel(name, domain.Name) } else if rec.Type == "CAA" { if rec.CaaTag != "issue" && rec.CaaTag != "issuewild" && rec.CaaTag != "iodef" { errs = append(errs, fmt.Errorf("CAA tag %s is invalid", rec.CaaTag)) diff --git a/pkg/transform/ptr.go b/pkg/transform/ptr.go index 4ec0c81cad..be1c0082a2 100644 --- a/pkg/transform/ptr.go +++ b/pkg/transform/ptr.go @@ -17,8 +17,11 @@ func PtrNameMagic(name, domain string) (string, error) { // If the name is already in-addr.arpa or ipv6.arpa, // make sure the domain matches. if strings.HasSuffix(name, ".in-addr.arpa.") || strings.HasSuffix(name, ".ip6.arpa.") { - if strings.HasSuffix(name, "."+domain+".") { - return strings.TrimSuffix(name, "."+domain+"."), nil + name = strings.TrimSuffix(name, ".") + } + if strings.HasSuffix(name, ".in-addr.arpa") || strings.HasSuffix(name, ".ip6.arpa") { + if strings.HasSuffix(name, "."+domain) { + return strings.TrimSuffix(name, "."+domain), nil } return name, fmt.Errorf("PTR record %v in wrong domain (%v)", name, domain) } From e7ebb6ff912a3b48d46375ddf8af7abbe7a7999c Mon Sep 17 00:00:00 2001 From: Tom Limoncelli Date: Wed, 26 Feb 2025 09:57:53 -0500 Subject: [PATCH 2/3] wip! --- build/autotype/makers.go | 21 +++++++++++++++++++++ models/generated_types.go | 20 +++----------------- 2 files changed, 24 insertions(+), 17 deletions(-) diff --git a/build/autotype/makers.go b/build/autotype/makers.go index 9341840e2f..a7dce178e3 100644 --- a/build/autotype/makers.go +++ b/build/autotype/makers.go @@ -60,9 +60,11 @@ package models import ( "fmt" + "net/netip" "strconv" "github.com/StackExchange/dnscontrol/v4/pkg/fieldtypes" + "github.com/StackExchange/dnscontrol/v4/pkg/transform" "github.com/qdm12/reprint" ) @@ -464,8 +466,27 @@ func PopulateFromRaw{{ .Name }}(rc *RecordConfig, rawfields []string, meta map[s rc.TTL = 1 {{- end }} + {{ if eq .Name "PTR" }} + // First rawfield is the label. + label := rawfields[0] + // Activate PTR Magic! (if the label looks like an IP address, REV() it) + if _, err := netip.ParseAddr(label); err == nil { + // Label is an IP address. + var err error + label, err = transform.PtrNameMagic(label, origin) + if err != nil { + return err + } + subdomain = "" // subdomain is no longer relevant if we replace the label. + } + {{- end }} + + {{- if eq .Name "PTR" }} + if err := rc.SetLabel3(label, subdomain, origin); err != nil { + {{- else }} // First rawfield is the label. if err := rc.SetLabel3(rawfields[0], subdomain, origin); err != nil { + {{- end }} return err } diff --git a/models/generated_types.go b/models/generated_types.go index 617ee5d4b0..e15f7cb451 100644 --- a/models/generated_types.go +++ b/models/generated_types.go @@ -558,35 +558,21 @@ func ParsePTR(rawfields []string, subdomain, origin string) (PTR, error) { func PopulateFromRawPTR(rc *RecordConfig, rawfields []string, meta map[string]string, subdomain, origin string) error { rc.Type = "PTR" + // First rawfield is the label. label := rawfields[0] - //fmt.Printf("DEBUG: RawPTR: called label=%s subdomain=%s origin=%s\n", label, subdomain, origin) + // Activate PTR Magic! (if the label looks like an IP address, REV() it) if _, err := netip.ParseAddr(label); err == nil { // Label is an IP address. - subdomain = "" // PtrMagic mode matches the origin properly, thus subdomain is no longer relevant. var err error label, err = transform.PtrNameMagic(label, origin) if err != nil { - //fmt.Printf("DEBUG: RawPTR: err %v\n", err) return err } - //fmt.Printf("DEBUG: RawPTR: step1 %s\n", label) + subdomain = "" // subdomain is no longer relevant if we replace the label. } - //fmt.Printf("DEBUG: RawPTR: SetLabel3(%q, %q, %q)\n", label, subdomain, origin) - - // First rawfield is the label. if err := rc.SetLabel3(label, subdomain, origin); err != nil { return err } - // { - // fmt.Printf("DEBUG: RawPTR: called %s %s\n", rc.NameFQDN, origin) - // if name, err := transform.PtrNameMagic(rc.NameFQDN, origin); err != nil { - // return err - // } else { - // fmt.Printf("DEBUG: RawPTR: step1 %s\n", name) - // rc.SetLabel(name, origin) - // } - // fmt.Printf("DEBUG: RawPTR: result %s %s\n", rc.Name, rc.NameFQDN) - // } // Parse the remaining fields. rdata, err := ParsePTR(rawfields[1:], subdomain, origin) From 568e0d47e409e8f371fb0bc76b020c75c6bc4fd1 Mon Sep 17 00:00:00 2001 From: Tom Limoncelli Date: Wed, 26 Feb 2025 10:07:45 -0500 Subject: [PATCH 3/3] cleanup --- pkg/normalize/validate.go | 7 ------- 1 file changed, 7 deletions(-) diff --git a/pkg/normalize/validate.go b/pkg/normalize/validate.go index bab1278947..121f8e4155 100644 --- a/pkg/normalize/validate.go +++ b/pkg/normalize/validate.go @@ -434,13 +434,6 @@ func ValidateAndNormalizeConfig(config *models.DNSConfig) (errs []error) { if err := rec.SetTarget(net.ParseIP(rec.GetTargetField()).String()); err != nil { errs = append(errs, err) } - // } else if rec.Type == "PTR" { - // var err error - // var name string - // if name, err = transform.PtrNameMagic(rec.GetLabel(), domain.Name); err != nil { - // errs = append(errs, err) - // } - // rec.SetLabel(name, domain.Name) } else if rec.Type == "CAA" { if rec.CaaTag != "issue" && rec.CaaTag != "issuewild" && rec.CaaTag != "iodef" { errs = append(errs, fmt.Errorf("CAA tag %s is invalid", rec.CaaTag))