224 lines
6.7 KiB
Go
224 lines
6.7 KiB
Go
// Copyright 2015 Bytemark Computer Consulting Ltd. All rights reserved
|
|
// Licensed under the GNU General Public License, version 2. See the LICENSE
|
|
// file for more details
|
|
|
|
// Simple DSL for pipebackend. Usage:
|
|
//
|
|
// // Create new handle. You have to specify a default TTL here.
|
|
// x := dsl.New()
|
|
// root := regexp.QuoteMeta("example.com")
|
|
//
|
|
// // most zones need SOA + NS records
|
|
// x.SOA(root, func(c *dsl.Context) {
|
|
// c.Reply("ns1.example.com hostmaster.example.com 1 3600 1800 86400 3600")
|
|
// })
|
|
//
|
|
// // Zones need NS records too. All replies will be returned
|
|
// x.NS(root, func(c *dsl.Context) {
|
|
// c.Reply("ns1.example.com")
|
|
// c.Reply("ns2.example.com")
|
|
// c.Reply("ns3.example.com")
|
|
// })
|
|
//
|
|
// // You don't have to use anonymous functions, of course
|
|
// func answer(c *dsl.Context) {
|
|
// switch c.Query.QType {
|
|
// case "A" : c.Reply("169.254.0.1")
|
|
// case "AAAA": c.Reply("fe80::1" )
|
|
// }
|
|
// }
|
|
// x.A(root, answer)
|
|
// x.AAAA(root, answer)
|
|
//
|
|
// // Setting c.Error at any point will suppress *all* replies from being
|
|
// // sent back. Instead, a FAIL response with the c.Error.Error() as the
|
|
// // content is returned to powerdns
|
|
// x.SSHFP(root, func(c *dsl.Context) {
|
|
// c.Reply("1 1 f1d2d2f924e986ac86fdf7b36c94bcdf32beec15")
|
|
// c.Error = errors.New("Don't use SSHFP on unsigned zones")
|
|
// c.Reply("1 2 e242ed3bffccdf271b7fbaf34ed72d089537b42f")
|
|
// })
|
|
//
|
|
// // You can do anything in a callback, but be aware that powerdns has a
|
|
// // time limit on responses and there is no request concurrency within a
|
|
// // single pipe connection. pdns achieves concurrency through multiple
|
|
// // backend connections instead
|
|
// c := make(chan string)
|
|
// x.MX(root, func(c *dsl.Context) {
|
|
// c.Reply(<-c)
|
|
// })
|
|
//
|
|
// // If your regexp includes capture groups, they are quoted back to you.
|
|
// // Here's a simple DNS echo server. Note the use of ReplyExtra to allow
|
|
// // a non-default TTL to be set.
|
|
// //
|
|
// // Don't forget: DNS is supposed to be case-insensitive. Be careful.
|
|
// c.TXT(`(.*)\.` + root, func(c *dsl.Context) {
|
|
// c.ReplyTTL(c.Query.QName, c.Matches[0], 0)
|
|
// })
|
|
//
|
|
// // Dispatch is up to you. It will probably look like this, but you
|
|
// // might want to add logging around the request or something more
|
|
// // complicated (different DSL instance depending on backend version?)
|
|
// func doit(b *backend.Backend, q *backend.Query) ([]*backend.Response, error) {
|
|
// if q.QClass == "IN" {
|
|
// return x.Lookup(q)
|
|
// }
|
|
// return nil, errors.New("Only IN QClass is supported")
|
|
// }
|
|
//
|
|
// pipe := backend.New( r, w, "Example backend" )
|
|
// err1 := pipe.Negotiate() // do check for errors
|
|
// err2 := pipe.Run(doit)
|
|
//
|
|
//
|
|
//
|
|
package dsl
|
|
|
|
import (
|
|
"github.com/BytemarkHosting/go-pdns/pipe/backend"
|
|
"regexp"
|
|
)
|
|
|
|
// Instances of this struct are used to hold onto registered callbacks, etc.
|
|
type DSL struct {
|
|
callbacks map[string][]callbackNode
|
|
qtypeSort []string
|
|
defaultTTL int
|
|
|
|
beforeCallback Callback
|
|
}
|
|
|
|
// Get a new builder with a default TTL of one hour
|
|
func New() *DSL {
|
|
return NewWithTTL(3600)
|
|
}
|
|
|
|
// Get a new builder, specifying a default TTL explicitly
|
|
func NewWithTTL(ttl int) *DSL {
|
|
return &DSL{
|
|
callbacks: make(map[string][]callbackNode),
|
|
qtypeSort: make([]string, 0),
|
|
defaultTTL: ttl,
|
|
}
|
|
}
|
|
|
|
// Callbacks are registered against the DSL instance and run against incoming
|
|
// queries if the regexp they are registered with matches the QName of the query
|
|
type Callback func(c *Context)
|
|
|
|
type callbackNode struct {
|
|
matcher *regexp.Regexp
|
|
fn Callback
|
|
}
|
|
|
|
// Register a callback to run before every request. Set c.Error to halt
|
|
// processing, or mutate the context however you like.
|
|
func (d *DSL) Before(f Callback) {
|
|
d.beforeCallback = f
|
|
}
|
|
|
|
// Register a callback to be run whenever a query with a QName matching the
|
|
// regular expression comes in. The regex is provided as a string (matcher)
|
|
// to keep ordinary invocations short; it's compiled immediately with
|
|
// regexp.MustCompile. Don't forget to anchor your regexes!
|
|
//
|
|
// If match groups are included in the regex, then any matched text is placed in
|
|
// the Context the callback receives.
|
|
//
|
|
// Callbacks are run with slightly obtuse ordering: all callbacks of a qtype
|
|
// are run in the order they were registered. We iterate the list of qtypes
|
|
// in the order that a callback with a matching qtype was *first* registered.
|
|
// If your pdns server has the "noshuffle" configuration directive, the order
|
|
// will be reflected in the responses returned by it; future concurrent DSL
|
|
// should maintain this ordering.
|
|
func (d *DSL) Register(qtype string, re *regexp.Regexp, f Callback) {
|
|
|
|
// Maintain our obtuse sense of order
|
|
alreadyIn := false
|
|
for _, prospect := range d.qtypeSort {
|
|
if prospect == qtype {
|
|
alreadyIn = true
|
|
break
|
|
}
|
|
}
|
|
if !alreadyIn {
|
|
d.qtypeSort = append(d.qtypeSort, qtype)
|
|
}
|
|
|
|
node := callbackNode{matcher: re, fn: f}
|
|
d.callbacks[qtype] = append(d.callbacks[qtype], node)
|
|
}
|
|
|
|
// Once we're concurrent, this method will create the context and return it
|
|
func (d *DSL) runNode(c *Context, node *callbackNode) {
|
|
matches := node.matcher.FindStringSubmatch(c.Query.QName)
|
|
|
|
if matches != nil && len(matches) > 0 {
|
|
// Probably unnecessary, but ensure that the previous value of
|
|
// Matches is preserved. This could also be = nil
|
|
oldmatches := c.Matches
|
|
defer func(c *Context) { c.Matches = oldmatches }(c)
|
|
|
|
// The first match is the whole thing, followed by the capture
|
|
// groups. We're only interested in the latter.
|
|
c.Matches = matches[1:]
|
|
|
|
if d.beforeCallback != nil {
|
|
d.beforeCallback(c)
|
|
}
|
|
|
|
if c.Error == nil {
|
|
node.fn(c)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Run all registered callbacks against the query. If any callbacks report an
|
|
// error, we halt and return the error only (partially constructed responses are
|
|
// discarded).
|
|
//
|
|
// For now, callbacks are run sequentially, rather than in parallel. There could
|
|
// be a speedup to running each callback in its own goroutine. Currently, all
|
|
// callbacks share the same context instance; we'd have to change that if we
|
|
// ran them in parallel.
|
|
func (d *DSL) Lookup(q *backend.Query) ([]*backend.Response, error) {
|
|
c := Context{
|
|
DefaultTTL: d.defaultTTL,
|
|
Query: q,
|
|
Answers: make([]*backend.Response, 0),
|
|
Error: nil,
|
|
}
|
|
|
|
var runOn []string
|
|
if q.QType == "ANY" {
|
|
runOn = d.qtypeSort
|
|
} else {
|
|
runOn = []string{q.QType}
|
|
}
|
|
|
|
for _, qtype := range runOn {
|
|
c.QType = qtype
|
|
for _, node := range d.callbacks[qtype] {
|
|
d.runNode(&c, &node)
|
|
if c.Error != nil {
|
|
return nil, c.Error
|
|
}
|
|
}
|
|
}
|
|
|
|
return c.Answers, nil
|
|
}
|
|
|
|
// Reports the registered callbacks, in order. Handy for testing or status.
|
|
func (d *DSL) String() string {
|
|
out := ""
|
|
for _, qtype := range d.qtypeSort {
|
|
out = out + qtype + "\t:"
|
|
for _, node := range d.callbacks[qtype] {
|
|
out = out + "\t" + node.matcher.String() + "\n"
|
|
}
|
|
}
|
|
return out
|
|
}
|