init

Author: jamiesun

.editorconfig

@@ -0,0 +1,23 @@
+root = true
+
+# all files
+[*.go]
+indent_style = tab
+indent_size = 4
+insert_final_newline = true
+
+[*.py]
+indent_style = space
+indent_size = 4
+
+[Makefile]
+indent_style = tab
+
+[*.js]
+charset = utf-8
+indent_style = space
+indent_size = 4
+
+[*.json]
+indent_style = space
+indent_size = 2

.gitattributes

@@ -0,0 +1,2 @@
+data/geoip.data filter=lfs diff=lfs merge=lfs -text
+data/geosite.data filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,6 @@
+.idea
+.vscode
+release
+__debug_bin
+.DS_Store
+build

Corefile

@@ -0,0 +1,25 @@
+. {
+    dnssrc locals.conf {
+        expire 30s
+        path_reload 3s
+        max_fails 0
+        health_check 30s
+        to 114.114.114.114 223.5.5.5
+        policy round_robin
+        bootstrap 172.21.66.1
+        debug
+    }
+
+    dnssrc 172.21.66.137 192.168.0.1/24 {
+        expire 1s
+        path_reload 3s
+        max_fails 0
+        health_check 30s
+        to json-doh://dns.google/resolve
+        to 1.1.1.1
+        to 9.9.9.9
+        policy round_robin
+        bootstrap 172.21.66.1
+        debug
+    }
+}

README.md

@@ -0,0 +1,8 @@
+# dnssrc
+
+*datahub* - a CoreDNS Data Manage Plugin
+
+
+# Example
+
+

data/geoip.dat

@@ -0,0 +1,13 @@
+module github.com/ca17/datahub
+
+go 1.16
+
+require (
+	github.com/c-robinson/iplib v1.0.3
+	github.com/coredns/caddy v1.1.1
+	github.com/coredns/coredns v1.8.6
+	github.com/m13253/dns-over-https/v2 v2.3.0
+	github.com/mdlayher/netlink v1.4.2
+	github.com/miekg/dns v1.1.43
+	github.com/prometheus/client_golang v1.11.0
+)

data/geosite.dat

@@ -0,0 +1,24 @@
+package main
+
+import (
+	_ "github.com/ca17/dnssrc/plugin/dnssrc"
+	"github.com/coredns/coredns/core/dnsserver"
+	_ "github.com/coredns/coredns/core/plugin"
+	"github.com/coredns/coredns/coremain"
+)
+
+func index(slice []string, item string) int {
+    for i := range slice {
+        if slice[i] == item {
+            return i
+        }
+    }
+    return -1
+}
+
+func main() {
+	// insert dnssrc before forward
+	idx := index(dnsserver.Directives, "geoip")
+	dnsserver.Directives = append(dnsserver.Directives[:idx], append([]string{"datahub"}, dnsserver.Directives[idx:]...)...)
+	coremain.Run()
+}

go.mod

@@ -0,0 +1,115 @@
+//     Copyright (C) 2020-2021, IrineSistiana
+//
+//     This file is part of mosdns.
+//
+//     mosdns is free software: you can redistribute it and/or modify
+//     it under the terms of the GNU General Public License as published by
+//     the Free Software Foundation, either version 3 of the License, or
+//     (at your option) any later version.
+//
+//     mosdns is distributed in the hope that it will be useful,
+//     but WITHOUT ANY WARRANTY; without even the implied warranty of
+//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//     GNU General Public License for more details.
+//
+//     You should have received a copy of the GNU General Public License
+//     along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+package loader
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/ca17/datahub/plugin/pkg/v2data"
+	"github.com/golang/protobuf/proto"
+)
+
+var matcherCache = NewCache()
+
+const (
+	cacheTTL = time.Second * 30
+)
+
+// mustHaveAttr checks if attr has all wanted attrs.
+func mustHaveAttr(attr, wanted []string) bool {
+	if len(wanted) == 0 {
+		return true
+	}
+	if len(attr) == 0 {
+		return false
+	}
+
+	for _, w := range wanted {
+		ok := false
+		for _, got := range attr {
+			if got == w {
+				ok = true
+				break
+			}
+		}
+		if !ok { // this attr is not in d.
+			return false
+		}
+	}
+	return true
+}
+
+func LoadGeoSiteFromDAT(file, countryCode string) (*v2data.GeoSite, error) {
+	geoSiteList, err := LoadGeoSiteList(file)
+	if err != nil {
+		return nil, err
+	}
+
+	countryCode = strings.ToUpper(countryCode)
+	entry := geoSiteList.GetEntry()
+	for i := range entry {
+		if strings.ToUpper(entry[i].CountryCode) == countryCode {
+			return entry[i], nil
+		}
+	}
+
+	return nil, fmt.Errorf("can not find category %s in %s", countryCode, file)
+}
+
+func LoadGeoSiteList(file string) (*v2data.GeoSiteList, error) {
+	data, raw, err := matcherCache.LoadFromCacheOrRawDisk(file)
+	if err != nil {
+		return nil, err
+	}
+	// load from cache
+	if geoSiteList, ok := data.(*v2data.GeoSiteList); ok {
+		return geoSiteList, nil
+	}
+
+	// load from disk
+	geoSiteList := new(v2data.GeoSiteList)
+	if err := proto.Unmarshal(raw, geoSiteList); err != nil {
+		return nil, err
+	}
+
+	return geoSiteList, nil
+}
+
+
+func LoadGeoIPListFromDAT(file string) (*v2data.GeoIPList, error) {
+	data, raw, err := matcherCache.LoadFromCacheOrRawDisk(file)
+	if err != nil {
+		return nil, err
+	}
+	// load from cache
+	if geoIPList, ok := data.(*v2data.GeoIPList); ok {
+		return geoIPList, nil
+	}
+
+	// load from disk
+	geoIPList := new(v2data.GeoIPList)
+	if err := proto.Unmarshal(raw, geoIPList); err != nil {
+		return nil, err
+	}
+
+	// cache the file
+	matcherCache.Put(file, geoIPList, cacheTTL)
+	return geoIPList, nil
+}

main.go

@@ -0,0 +1,87 @@
+//     Copyright (C) 2020-2021, IrineSistiana
+//
+//     This key is part of mosdns.
+//
+//     mosdns is free software: you can redistribute it and/or modify
+//     it under the terms of the GNU General Public License as published by
+//     the Free Software Foundation, either version 3 of the License, or
+//     (at your option) any later version.
+//
+//     mosdns is distributed in the hope that it will be useful,
+//     but WITHOUT ANY WARRANTY; without even the implied warranty of
+//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//     GNU General Public License for more details.
+//
+//     You should have received a copy of the GNU General Public License
+//     along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+package loader
+
+import (
+	"io/ioutil"
+	"os"
+	"sync"
+	"time"
+)
+
+type LoadOnceCache struct {
+	l     sync.Mutex
+	cache map[string]interface{}
+}
+
+func NewCache() *LoadOnceCache {
+	return &LoadOnceCache{
+		cache: make(map[string]interface{}),
+	}
+}
+
+func (c *LoadOnceCache) Put(key string, data interface{}, ttl time.Duration) {
+	if ttl <= 0 {
+		return
+	}
+
+	c.l.Lock()
+	defer c.l.Unlock()
+
+	c.cache[key] = data
+
+	rm := func() { c.Remove(key) }
+	time.AfterFunc(ttl, rm)
+}
+
+func (c *LoadOnceCache) Remove(key string) {
+	c.l.Lock()
+	defer c.l.Unlock()
+
+	delete(c.cache, key)
+}
+
+func (c *LoadOnceCache) Load(key string) (interface{}, bool) {
+	c.l.Lock()
+	defer c.l.Unlock()
+
+	data, ok := c.cache[key]
+	return data, ok
+}
+
+func (c *LoadOnceCache) LoadFromCacheOrRawDisk(file string) (interface{}, []byte, error) {
+	// load from cache
+	data, ok := c.Load(file)
+	if ok {
+		return data, nil, nil
+	}
+
+	// load from disk
+	f, err := os.Open(file)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer f.Close()
+
+	b, err := ioutil.ReadAll(f)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return nil, b, nil
+}