Update aiodns

This commit is contained in:
Netch
2021-08-14 04:49:50 +08:00
parent b301f851e1
commit e978a9bc83
3 changed files with 178 additions and 147 deletions

View File

@@ -1,11 +1,11 @@
Push-Location (Split-Path $MyInvocation.MyCommand.Path -Parent)
$Env:CGO_ENABLED="0"
$Env:GOROOT_FINAL="/usr"
$Env:CGO_ENABLED='1'
$Env:GOROOT_FINAL='/usr'
$Env:GOOS="windows"
$Env:GOARCH="amd64"
go build -a -trimpath -asmflags "-s -w" -ldflags "-s -w" -o "..\release\aiodns.exe"
$Env:GOOS='windows'
$Env:GOARCH='amd64'
go build -a -buildmode=c-shared -trimpath -asmflags '-s -w' -ldflags '-s -w' -o '..\release\aiodns.bin'
Pop-Location
exit $lastExitCode

View File

@@ -1,48 +0,0 @@
package main
import (
"fmt"
"log"
"github.com/miekg/dns"
)
var (
ChinaDNS = dns.Client{}
OtherDNS = dns.Client{}
)
func handleServerName(w dns.ResponseWriter, m *dns.Msg) {
r := new(dns.Msg)
r.SetReply(m)
for i := 0; i < len(m.Question); i++ {
rr, err := dns.NewRR(fmt.Sprintf("%s PTR Netch", m.Question[i].Name))
if err != nil {
log.Printf("[aiodns][dns.NewRR] %v", err)
return
}
r.Answer = append(m.Answer, rr)
}
_ = w.WriteMsg(r)
}
func handleChinaDNS(w dns.ResponseWriter, m *dns.Msg) {
r, _, err := ChinaDNS.Exchange(m, flags.ChinaDNS)
if err != nil {
log.Printf("[aiodns][handleChinaDNS] %v", err)
}
_ = w.WriteMsg(r)
}
func handleOtherDNS(w dns.ResponseWriter, m *dns.Msg) {
r, _, err := OtherDNS.Exchange(m, flags.OtherDNS)
if err != nil {
log.Printf("[aiodns][handleOtherDNS] %v", err)
}
_ = w.WriteMsg(r)
}

View File

@@ -1,94 +1,173 @@
package main
import (
"bufio"
"flag"
"log"
"net"
"net/url"
"os"
"strings"
"github.com/miekg/dns"
)
var (
flags struct {
Path string
Listen string
ChinaDNS string
OtherDNS string
}
)
func main() {
flag.StringVar(&flags.Path, "c", "", "")
flag.StringVar(&flags.Listen, "l", ":53", "Listen")
flag.StringVar(&flags.ChinaDNS, "cdns", "tls://223.5.5.5:853", "China DNS")
flag.StringVar(&flags.OtherDNS, "odns", "tls://1.1.1.1:853", "Other DNS")
flag.Parse()
{
{
info, err := url.Parse(flags.ChinaDNS)
if err != nil {
log.Fatalf("[aiodns][main][url.Parse] %v", err)
}
switch info.Scheme {
case "tls":
ChinaDNS.Net = "tcp-tls"
default:
ChinaDNS.Net = "tcp"
}
flags.ChinaDNS = info.Host
}
{
info, err := url.Parse(flags.OtherDNS)
if err != nil {
log.Fatalf("[aiodns][main][url.Parse] %v", err)
}
switch info.Scheme {
case "tls":
OtherDNS.Net = "tcp-tls"
default:
OtherDNS.Net = "tcp"
}
flags.OtherDNS = info.Host
}
}
mux := dns.NewServeMux()
if flags.Path != "" {
file, err := os.Open(flags.Path)
if err != nil {
log.Fatalf("[aiodns][main][os.Open] %v", err)
}
scan := bufio.NewScanner(file)
for scan.Scan() {
mux.HandleFunc(dns.Fqdn(strings.TrimSpace(scan.Text())), handleChinaDNS)
}
}
mux.HandleFunc("in-addr.arpa.", handleServerName)
mux.HandleFunc(".", handleOtherDNS)
tcpSocket, err := net.Listen("tcp", flags.Listen)
if err != nil {
log.Fatalf("[aiodns][main][net.Listen] %v", err)
}
udpSocket, err := net.ListenPacket("udp", flags.Listen)
if err != nil {
log.Fatalf("[aiodns][main][net.ListenPacket] %v", err)
}
log.Printf("[aiodns] Started")
go dns.ActivateAndServe(tcpSocket, nil, mux)
dns.ActivateAndServe(nil, udpSocket, mux)
}
package main
import (
"bufio"
"fmt"
"net"
"net/url"
"os"
"strings"
"github.com/miekg/dns"
)
import "C"
const (
TYPE_REST = iota
TYPE_LIST
TYPE_LISN
TYPE_CDNS
TYPE_ODNS
)
var (
Path string
Listen string
ChinaDNS string
OtherDNS string
CDNS = dns.Client{}
ODNS = dns.Client{}
mux *dns.ServeMux
tcpSocket net.Listener
udpSocket net.PacketConn
)
//export aiodns_dial
func aiodns_dial(name int, value *C.char) bool {
switch name {
case TYPE_REST:
Path = ""
Listen = ""
ChinaDNS = ""
OtherDNS = ""
case TYPE_LIST:
Path = C.GoString(value)
case TYPE_LISN:
Listen = C.GoString(value)
case TYPE_CDNS:
{
info, err := url.Parse(C.GoString(value))
if err != nil {
fmt.Printf("[aiodns][dial] url.Parse: %v\n", err)
return false
}
switch info.Scheme {
case "tls":
CDNS.Net = "tcp-tls"
default:
CDNS.Net = "tcp"
}
ChinaDNS = info.Host
}
case TYPE_ODNS:
{
info, err := url.Parse(C.GoString(value))
if err != nil {
fmt.Printf("[aiodns][dial] url.Parse: %v\n", err)
return false
}
switch info.Scheme {
case "tls":
ODNS.Net = "tcp-tls"
default:
ODNS.Net = "tcp"
}
OtherDNS = info.Host
}
default:
return false
}
return true
}
//export aiodns_init
func aiodns_init() bool {
mux = dns.NewServeMux()
if Path != "" {
file, err := os.Open(Path)
if err != nil {
fmt.Printf("[aiodns][init] os.Open: %v\n", err)
return false
}
defer file.Close()
scan := bufio.NewScanner(file)
for scan.Scan() {
mux.HandleFunc(dns.Fqdn(strings.TrimSpace(scan.Text())), handleChinaDNS)
}
}
mux.HandleFunc("in-addr.arpa.", handleServerName)
mux.HandleFunc(".", handleOtherDNS)
var err error
tcpSocket, err = net.Listen("tcp", Listen)
if err != nil {
fmt.Printf("[aiodns][init] net.Listen: %v\n", err)
return false
}
udpSocket, err = net.ListenPacket("udp", Listen)
if err != nil {
fmt.Printf("[aiodns][init] net.ListenPacket: %v\n", err)
return false
}
go dns.ActivateAndServe(tcpSocket, nil, mux)
go dns.ActivateAndServe(nil, udpSocket, mux)
fmt.Println("[aiodns] Started")
return true
}
//export aiodns_free
func aiodns_free() {
}
func handleServerName(w dns.ResponseWriter, m *dns.Msg) {
r := new(dns.Msg)
r.SetReply(m)
for i := 0; i < len(m.Question); i++ {
rr, err := dns.NewRR(fmt.Sprintf("%s PTR Netch", m.Question[i].Name))
if err != nil {
fmt.Printf("[aiodns][dns.NewRR] %v\n", err)
return
}
r.Answer = append(m.Answer, rr)
}
_ = w.WriteMsg(r)
}
func handleChinaDNS(w dns.ResponseWriter, m *dns.Msg) {
r, _, err := CDNS.Exchange(m, ChinaDNS)
if err != nil {
fmt.Printf("[aiodns] handleChinaDNS: %v\n", err)
}
_ = w.WriteMsg(r)
}
func handleOtherDNS(w dns.ResponseWriter, m *dns.Msg) {
r, _, err := ODNS.Exchange(m, OtherDNS)
if err != nil {
fmt.Printf("[aiodns] handleOtherDNS: %v\n", err)
}
_ = w.WriteMsg(r)
}
func main() {
}