1164 lines
47 KiB
Go
1164 lines
47 KiB
Go
// AUTOGENERATED helper methods for IANA-registered RRTYPES. Do not edit.
|
|
// See generate_dsl_helpers.sh for details
|
|
package dsl
|
|
|
|
import (
|
|
"fmt"
|
|
"regexp"
|
|
)
|
|
|
|
var RRTypes = []string{
|
|
"A",
|
|
"AAAA",
|
|
"AFSDB",
|
|
"APL",
|
|
"ATMA",
|
|
"AXFR",
|
|
"CAA",
|
|
"CDNSKEY",
|
|
"CDS",
|
|
"CERT",
|
|
"CNAME",
|
|
"DHCID",
|
|
"DLV",
|
|
"DNAME",
|
|
"DNSKEY",
|
|
"DS",
|
|
"EID",
|
|
"GID",
|
|
"GPOS",
|
|
"HINFO",
|
|
"HIP",
|
|
"IPSECKEY",
|
|
"ISDN",
|
|
"IXFR",
|
|
"KEY",
|
|
"KX",
|
|
"LOC",
|
|
"LP",
|
|
"MAILA",
|
|
"MAILB",
|
|
"MB",
|
|
"MD",
|
|
"MF",
|
|
"MG",
|
|
"MINFO",
|
|
"MR",
|
|
"MX",
|
|
"NAPTR",
|
|
"NID",
|
|
"NIMLOC",
|
|
"NINFO",
|
|
"NS",
|
|
"NSAP",
|
|
"NSEC",
|
|
"NULL",
|
|
"NXT",
|
|
"OPENPGPKEY",
|
|
"OPT",
|
|
"PTR",
|
|
"PX",
|
|
"RKEY",
|
|
"RP",
|
|
"RRSIG",
|
|
"RT",
|
|
"SIG",
|
|
"SINK",
|
|
"SOA",
|
|
"SPF",
|
|
"SRV",
|
|
"SSHFP",
|
|
"TA",
|
|
"TALINK",
|
|
"TKEY",
|
|
"TLSA",
|
|
"TSIG",
|
|
"TXT",
|
|
"TYPE",
|
|
"UID",
|
|
"UINFO",
|
|
"UNSPEC",
|
|
"URI",
|
|
"WKS",
|
|
}
|
|
|
|
// Helper function to register a callback for A queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "A" string directly.
|
|
func (d *DSL) A(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("A", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for AAAA queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "AAAA" string directly.
|
|
func (d *DSL) AAAA(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("AAAA", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for AFSDB queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "AFSDB" string directly.
|
|
func (d *DSL) AFSDB(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("AFSDB", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for APL queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "APL" string directly.
|
|
func (d *DSL) APL(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("APL", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for ATMA queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "ATMA" string directly.
|
|
func (d *DSL) ATMA(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("ATMA", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for AXFR queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "AXFR" string directly.
|
|
func (d *DSL) AXFR(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("AXFR", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for CAA queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "CAA" string directly.
|
|
func (d *DSL) CAA(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("CAA", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for CDNSKEY queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "CDNSKEY" string directly.
|
|
func (d *DSL) CDNSKEY(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("CDNSKEY", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for CDS queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "CDS" string directly.
|
|
func (d *DSL) CDS(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("CDS", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for CERT queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "CERT" string directly.
|
|
func (d *DSL) CERT(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("CERT", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for CNAME queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "CNAME" string directly.
|
|
func (d *DSL) CNAME(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("CNAME", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for DHCID queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "DHCID" string directly.
|
|
func (d *DSL) DHCID(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("DHCID", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for DLV queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "DLV" string directly.
|
|
func (d *DSL) DLV(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("DLV", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for DNAME queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "DNAME" string directly.
|
|
func (d *DSL) DNAME(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("DNAME", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for DNSKEY queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "DNSKEY" string directly.
|
|
func (d *DSL) DNSKEY(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("DNSKEY", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for DS queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "DS" string directly.
|
|
func (d *DSL) DS(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("DS", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for EID queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "EID" string directly.
|
|
func (d *DSL) EID(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("EID", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for GID queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "GID" string directly.
|
|
func (d *DSL) GID(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("GID", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for GPOS queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "GPOS" string directly.
|
|
func (d *DSL) GPOS(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("GPOS", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for HINFO queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "HINFO" string directly.
|
|
func (d *DSL) HINFO(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("HINFO", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for HIP queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "HIP" string directly.
|
|
func (d *DSL) HIP(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("HIP", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for IPSECKEY queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "IPSECKEY" string directly.
|
|
func (d *DSL) IPSECKEY(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("IPSECKEY", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for ISDN queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "ISDN" string directly.
|
|
func (d *DSL) ISDN(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("ISDN", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for IXFR queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "IXFR" string directly.
|
|
func (d *DSL) IXFR(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("IXFR", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for KEY queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "KEY" string directly.
|
|
func (d *DSL) KEY(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("KEY", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for KX queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "KX" string directly.
|
|
func (d *DSL) KX(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("KX", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for LOC queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "LOC" string directly.
|
|
func (d *DSL) LOC(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("LOC", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for LP queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "LP" string directly.
|
|
func (d *DSL) LP(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("LP", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for MAILA queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "MAILA" string directly.
|
|
func (d *DSL) MAILA(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("MAILA", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for MAILB queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "MAILB" string directly.
|
|
func (d *DSL) MAILB(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("MAILB", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for MB queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "MB" string directly.
|
|
func (d *DSL) MB(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("MB", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for MD queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "MD" string directly.
|
|
func (d *DSL) MD(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("MD", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for MF queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "MF" string directly.
|
|
func (d *DSL) MF(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("MF", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for MG queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "MG" string directly.
|
|
func (d *DSL) MG(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("MG", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for MINFO queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "MINFO" string directly.
|
|
func (d *DSL) MINFO(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("MINFO", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for MR queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "MR" string directly.
|
|
func (d *DSL) MR(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("MR", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for MX queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "MX" string directly.
|
|
func (d *DSL) MX(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("MX", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for NAPTR queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "NAPTR" string directly.
|
|
func (d *DSL) NAPTR(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("NAPTR", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for NID queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "NID" string directly.
|
|
func (d *DSL) NID(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("NID", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for NIMLOC queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "NIMLOC" string directly.
|
|
func (d *DSL) NIMLOC(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("NIMLOC", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for NINFO queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "NINFO" string directly.
|
|
func (d *DSL) NINFO(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("NINFO", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for NS queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "NS" string directly.
|
|
func (d *DSL) NS(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("NS", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for NSAP queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "NSAP" string directly.
|
|
func (d *DSL) NSAP(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("NSAP", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for NSEC queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "NSEC" string directly.
|
|
func (d *DSL) NSEC(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("NSEC", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for NULL queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "NULL" string directly.
|
|
func (d *DSL) NULL(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("NULL", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for NXT queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "NXT" string directly.
|
|
func (d *DSL) NXT(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("NXT", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for OPENPGPKEY queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "OPENPGPKEY" string directly.
|
|
func (d *DSL) OPENPGPKEY(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("OPENPGPKEY", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for OPT queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "OPT" string directly.
|
|
func (d *DSL) OPT(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("OPT", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for PTR queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "PTR" string directly.
|
|
func (d *DSL) PTR(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("PTR", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for PX queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "PX" string directly.
|
|
func (d *DSL) PX(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("PX", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for RKEY queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "RKEY" string directly.
|
|
func (d *DSL) RKEY(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("RKEY", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for RP queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "RP" string directly.
|
|
func (d *DSL) RP(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("RP", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for RRSIG queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "RRSIG" string directly.
|
|
func (d *DSL) RRSIG(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("RRSIG", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for RT queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "RT" string directly.
|
|
func (d *DSL) RT(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("RT", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for SIG queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "SIG" string directly.
|
|
func (d *DSL) SIG(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("SIG", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for SINK queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "SINK" string directly.
|
|
func (d *DSL) SINK(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("SINK", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for SOA queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "SOA" string directly.
|
|
func (d *DSL) SOA(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("SOA", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for SPF queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "SPF" string directly.
|
|
func (d *DSL) SPF(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("SPF", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for SRV queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "SRV" string directly.
|
|
func (d *DSL) SRV(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("SRV", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for SSHFP queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "SSHFP" string directly.
|
|
func (d *DSL) SSHFP(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("SSHFP", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for TA queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "TA" string directly.
|
|
func (d *DSL) TA(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("TA", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for TALINK queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "TALINK" string directly.
|
|
func (d *DSL) TALINK(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("TALINK", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for TKEY queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "TKEY" string directly.
|
|
func (d *DSL) TKEY(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("TKEY", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for TLSA queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "TLSA" string directly.
|
|
func (d *DSL) TLSA(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("TLSA", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for TSIG queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "TSIG" string directly.
|
|
func (d *DSL) TSIG(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("TSIG", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for TXT queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "TXT" string directly.
|
|
func (d *DSL) TXT(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("TXT", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for TYPE queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "TYPE" string directly.
|
|
func (d *DSL) TYPE(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("TYPE", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for UID queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "UID" string directly.
|
|
func (d *DSL) UID(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("UID", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for UINFO queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "UINFO" string directly.
|
|
func (d *DSL) UINFO(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("UINFO", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for UNSPEC queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "UNSPEC" string directly.
|
|
func (d *DSL) UNSPEC(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("UNSPEC", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for URI queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "URI" string directly.
|
|
func (d *DSL) URI(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("URI", re, f)
|
|
}
|
|
|
|
// Helper function to register a callback for WKS queries.
|
|
// The matcher is given as a string, which is compiled to a regular expression
|
|
// (using regexp.MustCompile) with the following rules:
|
|
//
|
|
// * The regexp is anchored to the start of the match string("^" at start)
|
|
// * The case-insensitivity option is added "(?i)"
|
|
// * The regexp is anchored to the end of the match string ("$" at end)
|
|
//
|
|
// If any of these options are unwelcome, you can use the DSL.Register and pass
|
|
// a regexp and the "WKS" string directly.
|
|
func (d *DSL) WKS(matcher string, f Callback) {
|
|
re := regexp.MustCompile(fmt.Sprintf("^(?i)%s$", matcher))
|
|
d.Register("WKS", re, f)
|
|
}
|