Initial commit

pipe/backend/backend.go

@@ -0,0 +1,174 @@
+// 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
+
+// Handler for the PowerDNS pipebackend protocol, as documented here:
+// https://doc.powerdns.com/md/authoritative/backend-pipe/
+//
+// Can speak all three (at time of writing) protocol versions.
+//
+// Usage:
+//
+//	backend := backend.New(
+
+package backend
+
+import (
+	"bufio"
+	"errors"
+	"fmt"
+	"io"
+	"strconv"
+	"strings"
+)
+
+type Backend struct {
+	// The text the backend will serve to a successful hello message
+	Banner string
+
+	// The protocol version negotiated with the remote end
+	ProtocolVersion int
+
+	io *bufio.ReadWriter
+}
+
+// A callback of this type is executed whenever a query is received. If an error
+// is returned, the responses are ignored and the error text is returned to the
+// backend. Otherwise, the responses are serialised and sent back in order.
+type Callback func(b *Backend, q *Query) ([]*Response, error)
+
+// Build a new backend object. The banner is reported to the client upon
+// successful negotiation; the io can be anything.
+func New(r io.Reader, w io.Writer, banner string) *Backend {
+	io := bufio.NewReadWriter(
+		bufio.NewReader(r),
+		bufio.NewWriter(w),
+	)
+	return &Backend{Banner: banner, io: io}
+}
+
+// Does initial handshake with peer. Returns nil, or an error
+// Note that the pipebackend protocol documentation states that if negotiation
+// fails, the process should retry, not exit itself.
+func (b *Backend) Negotiate() error {
+	hello, err := b.io.ReadString('\n')
+	if err != nil {
+		return err
+	}
+
+	// We're not interested in the trailing newlines
+	parts := strings.Split(strings.TrimRight(hello, "\r\n"), "\t")
+
+	if len(parts) != 2 || parts[0] != "HELO" {
+		return errors.New("Bad hello from client")
+	}
+
+	version, err := strconv.Atoi(parts[1])
+	if version < 1 || version > 3 || err != nil {
+		return errors.New("Unknown protocol version requested")
+	}
+
+	_, err = b.io.WriteString(fmt.Sprintf("OK\t%s\n", b.Banner))
+	if err == nil {
+		err = b.io.Flush()
+	}
+
+	if err == nil {
+		b.ProtocolVersion = version
+	}
+	return err
+}
+
+func (b *Backend) handleQ(data string, callback Callback) ([]*Response, error) {
+	query := Query{ProtocolVersion: b.ProtocolVersion}
+
+	err := query.fromData(data)
+	if err != nil {
+		return nil, err
+	}
+
+	return callback(b, &query)
+}
+
+// TODO
+func (b *Backend) handleAXFR() ([]*Response, error) {
+	return nil, errors.New("AXFR requests not supported")
+}
+
+// Reads lines in a loop, processing them by executing the provided callback
+// and writing appropriate output in response, sequentially, until we hit an
+// error or our IO hits EOF
+func (b *Backend) Run(callback Callback) error {
+	responses := make([]*Response, 0)
+
+	for {
+		line, err := b.io.ReadString('\n')
+		if err != nil {
+			if err == io.EOF {
+				return nil
+			}
+			return err
+		}
+		parts := strings.SplitN(strings.TrimRight(line, "\n"), "\t", 2)
+		if len(parts) == 2 {
+
+		}
+
+		switch parts[0] {
+		case "Q":
+			responses, err = b.handleQ(parts[1], callback)
+		case "PING":
+			responses, err = nil, nil // We just need to return END
+		case "AXFR":
+			responses, err = b.handleAXFR()
+		default:
+			responses, err = nil, errors.New("Bad command")
+		}
+
+		if err != nil {
+			// avoid protocol errors
+			clean := strings.Replace(err.Error(), "\n", " ", -1)
+			msg := fmt.Sprintf("LOG\tError handling line: %s\nFAIL\n", clean)
+			_, err := b.io.WriteString(msg)
+			if err != nil {
+				return fmt.Errorf("%s while writing FAIL response", err)
+			}
+			//
+			err = b.io.Flush()
+			if err != nil {
+				return fmt.Errorf("%s while flushing FAIL response", err)
+			}
+			continue
+		}
+
+		// DATA (if there are any records to return)
+		for _, response := range responses {
+			// Always output a line of the right protocol version
+			// TODO: panic if it's set to a wrong non-zero value?
+			response.ProtocolVersion = b.ProtocolVersion
+			data, err := response.String()
+			if err != nil {
+				data = "LOG\tError serialising response: " + err.Error() + "\n"
+			}
+			_, err = b.io.WriteString(data)
+			if err != nil {
+				return fmt.Errorf("%s while writing DATA response", err)
+			}
+		}
+
+		// END
+		_, err = b.io.WriteString("END\n")
+		if err == nil {
+			err = b.io.Flush()
+		}
+
+		if err != nil {
+			return fmt.Errorf("%s while writing END", err)
+		}
+	}
+
+	// We should never hit this at the moment.
+	// TODO: graceful signal handling - intercept and ensure current query
+	// completes before breaking the above loop and returning nil here
+	return nil
+}