Initial Commit

Signed-off-by: Khash Sajadi <[email protected]>

Author: khash

.gitignore

@@ -13,3 +13,4 @@
 
 # Dependency directories (remove the comment below to include it)
 # vendor/
+/.idea

README.md

@@ -1,2 +1,78 @@
-# corednsmysql
+# mysql
 MySQL backend for CoreDNS
+
+## Supported Record Types
+
+A, AAAA, CNAME, SOA, TXT, NS, MX, CAA and SRV. This backend doesn't support AXFR requests. It also doesn't support wildcard records yet.
+
+## Setup
+
+Add this as an external plugin in `plugin.cfg` file: 
+
+```
+mysql:github.com/cloud66-oss/coredns_mysql
+```
+
+then run
+ 
+```shell script
+$ go generate
+$ go build
+```
+
+Add any required modules to CoreDNS code as prompted.
+
+## Configuration
+
+In the Corefile, `mysql` can be configured with the following parameters:
+
+`dsn` DSN for MySQL as per https://github.com/go-sql-driver/mysql examples.
+`table_prefix` Prefix for the MySQL tables. Defaults to `coredns_`.
+`max_lifetime` Duration (in Golang format) for a SQL connection. Default is 1 minute.
+`max_open_connections` Maximum number of open connections to the database server. Default is 10.
+`max_idle_connections` Maximum number of idle connections in the database connection pool. Default is 10.
+`ttl` Default TTL for records without a specified TTL in seconds. Default is 360 (seconds)
+
+## Database Setup
+This plugin doesn't create or migrate database schema for its use yet. To create the database and tables, use the following table structure (note the table name prefix):
+
+```sql
+CREATE TABLE `coredns_records` (
+    `id` INT NOT NULL AUTO_INCREMENT,
+	`zone` VARCHAR(255) NOT NULL,
+	`name` VARCHAR(255) NOT NULL,
+	`ttl` INT DEFAULT NULL,
+	`content` TEXT,
+	`record_type` VARCHAR(255) NOT NULL,
+	PRIMARY KEY (`id`)
+) ENGINE = INNODB AUTO_INCREMENT = 6 DEFAULT CHARSET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci;
+```
+
+## Record setup
+Each record served by this plugin, should belong to the zone it is allowed to server by CoreDNS. Here are some examples:
+
+```sql
+-- Insert batch #1
+INSERT INTO coredns_records (zone, name, ttl, content, record_type) VALUES
+('test.', 'foo', 30, '{"ip": "1.1.1.1"}', 'A'),
+('test.', 'foo', '60', '{"ip": "1.1.1.0"}', 'A'),
+('test.', 'foo', 30, '{"text": "hello"}', 'TXT'),
+('test.', 'foo', 30, '{"host" : "foo.test.","priority" : 10}', 'MX');
+```
+
+These can be queries using `dig` like this:
+
+```shell script
+$ dig A MX foo.test 
+```
+
+### Acknowledgements and Credits
+This plugin, is inspired by https://github.com/wenerme/coredns-pdsql and https://github.com/arvancloud/redis
+
+### Development 
+To develop this plugin further, make sure you can compile CoreDNS locally and get this repo (`go get github.com/cloud66-oss/coredns_mysql`). You can switch the CoreDNS mod file to look for the plugin code locally while you're developing it:
+
+Put `replace github.com/cloud66-oss/coredns_mysql => LOCAL_PATH_TO_THE_SOURCE_CODE` at the end of the `go.mod` file in CoreDNS code. 
+
+Pull requests and bug reports are welcome!
+

go.mod

@@ -0,0 +1,11 @@
+module github.com/cloud66-oss/coredns_mysql
+
+go 1.16
+
+require (
+	github.com/coredns/caddy v1.1.0
+	github.com/coredns/coredns v1.8.4
+	github.com/go-sql-driver/mysql v1.6.0
+	github.com/miekg/dns v1.1.42
+	golang.org/x/net v0.0.0-20210525063256-abc453219eb5
+)

go.sum

@@ -0,0 +1,129 @@
+package coredns_mysql
+
+import (
+	"time"
+
+	"github.com/coredns/coredns/plugin"
+	"github.com/coredns/coredns/request"
+	_ "github.com/go-sql-driver/mysql"
+	"github.com/miekg/dns"
+	"golang.org/x/net/context"
+)
+
+type CoreDNSMySql struct {
+	Next           plugin.Handler
+	Dsn string
+	TablePrefix string
+	MaxLifetime time.Duration
+	MaxOpenConnections int
+	MaxIdleConnections int
+	Ttl            uint32
+
+	tableName string
+	lastZoneUpdate time.Time
+	zoneUpdateTime time.Duration
+	zones []string
+}
+
+// ServeDNS implements the plugin.Handler interface.
+func (handler *CoreDNSMySql) ServeDNS(ctx context.Context, w dns.ResponseWriter, r *dns.Msg) (int, error) {
+	state := request.Request{W: w, Req: r}
+
+	qName := state.Name()
+	qType := state.Type()
+
+	if time.Since(handler.lastZoneUpdate) > handler.zoneUpdateTime {
+		err := handler.loadZones()
+		if err != nil {
+			return handler.errorResponse(state, dns.RcodeServerFailure, err)
+		}
+	}
+
+	qZone := plugin.Zones(handler.zones).Matches(qName)
+	if qZone == "" {
+		return plugin.NextOrFailure(handler.Name(), handler.Next, ctx, w, r)
+	}
+
+	records, err := handler.findRecord(qZone, qName, qType)
+	if err != nil {
+		return handler.errorResponse(state, dns.RcodeServerFailure, err)
+	}
+
+	if len(records) == 0 {
+		// no record found but we are going to return a SOA
+		rec := &Record{
+			Name: qName,
+			RecordType: "SOA",
+			Content: "{}",
+		}
+		records = append(records, rec)
+	}
+
+	if qType == "AXFR" {
+		return handler.errorResponse(state, dns.RcodeNotImplemented, nil)
+	}
+
+	answers := make([]dns.RR, 0, 10)
+	extras := make([]dns.RR, 0, 10)
+
+	for _, record := range records {
+		var answer dns.RR
+		switch record.RecordType {
+		case "A":
+			answer, extras, err = record.AsARecord()
+		case "AAAA":
+			answer, extras, err = record.AsAAAARecord()
+		case "CNAME":
+			answer, extras, err = record.AsCNAMERecord()
+		case "SOA":
+			answer, extras, err = record.AsSOARecord()
+		case "SRV":
+			answer, extras, err = record.AsSRVRecord()
+		case "NS":
+			answer, extras, err = record.AsNSRecord()
+		case "MX":
+			answer, extras, err = record.AsMXRecord()
+		case "TXT":
+			answer, extras, err = record.AsTXTRecord()
+		case "CAA":
+			answer, extras, err = record.AsCAARecord()
+		default:
+			return handler.errorResponse(state, dns.RcodeNotImplemented, nil)
+		}
+
+		if err != nil {
+			return handler.errorResponse(state, dns.RcodeServerFailure, err)
+		}
+		if answer != nil {
+			answers = append(answers, answer)
+		}
+	}
+
+	m := new(dns.Msg)
+	m.SetReply(r)
+	m.Authoritative = true
+	m.RecursionAvailable = false
+	m.Compress = true
+
+	m.Answer = append(m.Answer, answers...)
+	m.Extra = append(m.Extra, extras...)
+
+	state.SizeAndDo(m)
+	m = state.Scrub(m)
+	_ = w.WriteMsg(m)
+	return dns.RcodeSuccess, nil
+}
+
+// Name implements the Handler interface.
+func (handler *CoreDNSMySql) Name() string { return "handler" }
+
+func (handler *CoreDNSMySql) errorResponse(state request.Request, rCode int, err error) (int, error) {
+	m := new(dns.Msg)
+	m.SetRcode(state.Req, rCode)
+	m.Authoritative, m.RecursionAvailable, m.Compress = true, false, true
+
+	state.SizeAndDo(m)
+	_ = state.W.WriteMsg(m)
+	// Return success as the rCode to signal we have written to the client.
+	return dns.RcodeSuccess, err
+}

handler.go

@@ -0,0 +1,113 @@
+package coredns_mysql
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/miekg/dns"
+)
+
+func (handler *CoreDNSMySql) findRecord(zone string, name string, types ...string) ([]*Record, error) {
+	db, err := handler.db()
+	if err != nil {
+		return nil, err
+	}
+	defer db.Close()
+
+	query := strings.TrimSuffix(name, "." + zone)
+	sqlQuery := fmt.Sprintf("SELECT name, zone, ttl, record_type, content FROM %s WHERE zone = ? AND name = ? AND record_type IN ('%s')",
+		handler.tableName,
+		strings.Join(types, "','"))
+	result, err := db.Query(sqlQuery, zone, query)
+	if err != nil {
+		return nil, err
+	}
+
+	var recordName string
+	var recordZone string
+	var recordType string
+	var ttl uint32
+	var content string
+	records := make([]*Record, 0)
+	for result.Next() {
+		err = result.Scan(&recordName, &recordZone, &ttl, &recordType, &content)
+		if err != nil {
+			return nil, err
+		}
+
+		records = append(records, &Record{
+			Name: recordName,
+			Zone: recordZone,
+			RecordType: recordType,
+			Ttl: ttl,
+			Content: content,
+			handler: handler,
+		})
+	}
+
+	return records, nil
+}
+
+func (handler *CoreDNSMySql) loadZones() error {
+	db, err := handler.db()
+	if err != nil {
+		return err
+	}
+	defer db.Close()
+
+	result, err := db.Query("SELECT DISTINCT zone FROM " + handler.tableName)
+	if err != nil {
+		return err
+	}
+
+	var zone string
+	zones := make([]string, 0)
+	for result.Next() {
+		err = result.Scan(&zone)
+		if err != nil {
+			return err
+		}
+
+		zones = append(zones, zone)
+	}
+
+	handler.lastZoneUpdate = time.Now()
+	handler.zones = zones
+
+	return nil
+}
+
+func (handler *CoreDNSMySql) hosts(zone string, name string) ([]dns.RR, error) {
+	recs, err := handler.findRecord(zone, name, "A", "AAAA", "CNAME")
+	if err != nil {
+		return nil, err
+	}
+
+	answers := make([]dns.RR, 0)
+
+	for _, rec := range recs {
+		switch rec.RecordType {
+		case "A":
+			aRec, _, err := rec.AsARecord()
+			if err != nil {
+				return nil, err
+			}
+			answers = append(answers, aRec)
+		case "AAAA":
+			aRec, _, err := rec.AsAAAARecord()
+			if err != nil {
+				return nil, err
+			}
+			answers = append(answers, aRec)
+		case "CNAME":
+			aRec, _, err := rec.AsCNAMERecord()
+			if err != nil {
+				return nil, err
+			}
+			answers = append(answers, aRec)
+		}
+	}
+
+	return answers, nil
+}