https record test for domains added

data/server_list

@@ -0,0 +1,25 @@
+8.8.8.8
+1.1.1.1
+9.9.9.9
+45.90.28.118
+185.228.168.168
+156.154.70.1
+64.6.64.6
+77.88.8.8
+208.67.222.123
+185.121.177.177
+114.114.114.114
+101.226.4.6
+94.140.14.14
+208.67.220.123
+149.112.121.10
+185.228.168.9
+185.43.135.1
+223.5.5.5
+119.28.28.28
+216.146.35.35
+74.82.42.42
+4.2.2.1
+101.101.101.101
+8.26.56.10
+80.80.80.80

main.go

@@ -12,10 +12,15 @@ import (
 
 func main() {
 	var input_file string
+	var routine_num int
+	var mode string
 	flag.StringVar(&input_file, "input", "", "input file name")
+	flag.IntVar(&routine_num, "routine", 500, "working goroutine number")
+	flag.StringVar(&mode, "mode", "resolver", "probe mode (resolver & domain)")
 	flag.Parse()
 	input_pool := make(chan string, 500)
-	result_pool := make(chan method.CombinedResult)
+	result_pool := make(chan method.CombinedResult, 500)
+	bool_pool := make(chan bool, 500)
 	var test_tasks sync.WaitGroup
 	var process_tasks sync.WaitGroup
 
@@ -28,11 +33,24 @@ func main() {
 	logger := log.New(logfile, "", log.LstdFlags)
 
 	go utils.RetrieveLines(input_pool, input_file)
-	method.CombinedMeasurement(input_pool, result_pool, 500, &test_tasks, logger)
+	if mode == "resolver" {
+		method.CombinedMeasurement(input_pool, result_pool, routine_num, &test_tasks, logger)
+	} else if mode == "domain" {
+		servers := utils.RetrieveLinesToSlice("data/server_list")
+		method.HTTPSRecordMeasurement(servers, input_pool, bool_pool, routine_num, &test_tasks, logger)
+	}
 	process_tasks.Add(1)
+	if mode == "resolver" {
 		go method.CombinedResultProcess(result_pool, &process_tasks)
+	} else if mode == "domain" {
+		go method.HTTPSRecordResultProcess(bool_pool, &process_tasks)
+	}
 	test_tasks.Wait()
+	if mode == "resolver" {
 		close(result_pool)
+	} else if mode == "domain" {
+		close(bool_pool)
+	}
 	process_tasks.Wait()
 	time.Sleep(time.Second)
 }

method/svcb.go

@@ -2,6 +2,9 @@ package method
 
 import (
 	"edns_svcb/utils"
+	"fmt"
+	"log"
+	"sync"
 
 	"github.com/miekg/dns"
 )
@@ -38,16 +41,60 @@ func SVCBSupportTest(addr string) TestResult {
 	return TestResult{Alive: true}
 }
 
-func HTTPSRecordTest(addr, domain string) bool {
+func HTTPSRecordMeasurement(servers []string, domain_pool chan string, result_pool chan bool, routine_num int, wg *sync.WaitGroup, logger *log.Logger) {
+	for i := 0; i < routine_num; i++ {
+		wg.Add(1)
+		go HTTPSRecordTestRoutine(servers, domain_pool, result_pool, wg, logger)
+	}
+}
+
+func HTTPSRecordTestRoutine(server_list []string, domain_pool chan string, result_pool chan bool, wg *sync.WaitGroup, logger *log.Logger) {
+	server_index := 0
+	for {
+		if domain, ok := <-domain_pool; ok {
+			server := server_list[server_index] + ":53"
+			res, err := HTTPSRecordTest(server, domain)
+			if err == nil {
+				logger.Printf("%v : %v", domain, res)
+			} else {
+				logger.Printf("%v : failed (%v) server %v", domain, err, server)
+			}
+			result_pool <- res
+			server_index = (server_index + 1) % len(server_list)
+		} else {
+			break
+		}
+	}
+	wg.Done()
+}
+
+func HTTPSRecordTest(addr, domain string) (bool, error) {
 	res, err := utils.DNSQuery(addr, utils.DNSOptions{Domain: domain, Qtype: dns.TypeHTTPS, RD: true})
 	if err == nil {
 		if len(res.Answer) > 0 {
 			if _, ok := res.Answer[0].(*dns.HTTPS); ok {
-				return true
+				return true, nil
 			}
 		}
 	}
-	return false
+	return false, err
+}
+
+func HTTPSRecordResultProcess(result_pool chan bool, wg *sync.WaitGroup) {
+	total_cnt := 0
+	valid_cnt := 0
+	for {
+		if res, ok := <-result_pool; ok {
+			total_cnt++
+			if res {
+				valid_cnt++
+			}
+		} else {
+			break
+		}
+	}
+	fmt.Printf("Domain HTTPS support Test: total %v https %v\n", total_cnt, valid_cnt)
+	wg.Done()
 }
 
 func SVCBRecordTest(addr, domain string) bool {

utils/other_utils.go

@@ -29,3 +29,21 @@ func RetrieveLines(pool chan string, filename string) {
 	}
 	close(pool)
 }
+
+func RetrieveLinesToSlice(filename string) []string {
+	results := []string{}
+	f, err := os.Open(filename)
+	if err != nil {
+		panic(err)
+	}
+	reader := bufio.NewReader(f)
+	for {
+		s, err := reader.ReadString('\n')
+		if err == io.EOF {
+			break
+		}
+		s = strings.Trim(s, "\n")
+		results = append(results, s)
+	}
+	return results
+}