init

pkg/monitor/monitor.go

@@ -0,0 +1,290 @@
+package monitor
+
+import (
+	"fmt"
+	"os/exec"
+	"runtime"
+	"strconv"
+	"strings"
+	"syscall"
+	"time"
+
+	"github.com/dean2021/goss"
+	"github.com/shirou/gopsutil/v3/cpu"
+	"github.com/shirou/gopsutil/v3/disk"
+	"github.com/shirou/gopsutil/v3/host"
+	"github.com/shirou/gopsutil/v3/load"
+	"github.com/shirou/gopsutil/v3/mem"
+	"github.com/shirou/gopsutil/v3/net"
+	"github.com/shirou/gopsutil/v3/process"
+
+	"github.com/nezhahq/agent/model"
+)
+
+var (
+	Version           string
+	expectDiskFsTypes = []string{
+		"apfs", "ext4", "ext3", "ext2", "f2fs", "reiserfs", "jfs", "btrfs",
+		"fuseblk", "zfs", "simfs", "ntfs", "fat32", "exfat", "xfs", "fuse.rclone",
+	}
+	excludeNetInterfaces = []string{
+		"lo", "tun", "docker", "veth", "br-", "vmbr", "vnet", "kube",
+	}
+)
+
+var (
+	netInSpeed, netOutSpeed, netInTransfer, netOutTransfer, lastUpdateNetStats uint64
+	cachedBootTime                                                             time.Time
+)
+
+// GetHost 获取主机硬件信息
+func GetHost(agentConfig *model.AgentConfig) *model.Host {
+	var ret model.Host
+
+	var cpuType string
+	hi, err := host.Info()
+	if err != nil {
+		println("host.Info error:", err)
+	} else {
+		if hi.VirtualizationSystem != "" {
+			cpuType = "Virtual"
+		} else {
+			cpuType = "Physical"
+		}
+		ret.Platform = hi.Platform
+		ret.PlatformVersion = hi.PlatformVersion
+		ret.Arch = hi.KernelArch
+		ret.Virtualization = hi.VirtualizationSystem
+		ret.BootTime = hi.BootTime
+	}
+
+	cpuModelCount := make(map[string]int)
+	ci, err := cpu.Info()
+	if err != nil {
+		println("cpu.Info error:", err)
+	} else {
+		for i := 0; i < len(ci); i++ {
+			cpuModelCount[ci[i].ModelName]++
+		}
+		for model, count := range cpuModelCount {
+			ret.CPU = append(ret.CPU, fmt.Sprintf("%s %d %s Core", model, count, cpuType))
+		}
+	}
+
+	ret.DiskTotal, _ = getDiskTotalAndUsed(agentConfig)
+
+	mv, err := mem.VirtualMemory()
+	if err != nil {
+		println("mem.VirtualMemory error:", err)
+	} else {
+		ret.MemTotal = mv.Total
+		if runtime.GOOS != "windows" {
+			ret.SwapTotal = mv.SwapTotal
+		}
+	}
+
+	if runtime.GOOS == "windows" {
+		ms, err := mem.SwapMemory()
+		if err != nil {
+			println("mem.SwapMemory error:", err)
+		} else {
+			ret.SwapTotal = ms.Total
+		}
+	}
+
+	cachedBootTime = time.Unix(int64(hi.BootTime), 0)
+
+	ret.IP = CachedIP
+	ret.CountryCode = strings.ToLower(cachedCountry)
+	ret.Version = Version
+
+	return &ret
+}
+
+func GetState(agentConfig *model.AgentConfig, skipConnectionCount bool, skipProcsCount bool) *model.HostState {
+	var ret model.HostState
+
+	cp, err := cpu.Percent(0, false)
+	if err != nil {
+		println("cpu.Percent error:", err)
+	} else {
+		ret.CPU = cp[0]
+	}
+
+	vm, err := mem.VirtualMemory()
+	if err != nil {
+		println("mem.VirtualMemory error:", err)
+	} else {
+		ret.MemUsed = vm.Total - vm.Available
+		if runtime.GOOS != "windows" {
+			ret.SwapUsed = vm.SwapTotal - vm.SwapFree
+		}
+	}
+	if runtime.GOOS == "windows" {
+		// gopsutil 在 Windows 下不能正确取 swap
+		ms, err := mem.SwapMemory()
+		if err != nil {
+			println("mem.SwapMemory error:", err)
+		} else {
+			ret.SwapUsed = ms.Used
+		}
+	}
+
+	_, ret.DiskUsed = getDiskTotalAndUsed(agentConfig)
+
+	loadStat, err := load.Avg()
+	if err != nil {
+		println("load.Avg error:", err)
+	} else {
+		ret.Load1 = loadStat.Load1
+		ret.Load5 = loadStat.Load5
+		ret.Load15 = loadStat.Load15
+	}
+
+	var procs []int32
+	if !skipProcsCount {
+		procs, err = process.Pids()
+		if err != nil {
+			println("process.Pids error:", err)
+		} else {
+			ret.ProcessCount = uint64(len(procs))
+		}
+	}
+
+	var tcpConnCount, udpConnCount uint64
+	if !skipConnectionCount {
+		ss_err := true
+		if runtime.GOOS == "linux" {
+			tcpStat, err_tcp := goss.ConnectionsWithProtocol(goss.AF_INET, syscall.IPPROTO_TCP)
+			udpStat, err_udp := goss.ConnectionsWithProtocol(goss.AF_INET, syscall.IPPROTO_UDP)
+			if err_tcp == nil && err_udp == nil {
+				ss_err = false
+				tcpConnCount = uint64(len(tcpStat))
+				udpConnCount = uint64(len(udpStat))
+			}
+			if strings.Contains(CachedIP, ":") {
+				tcpStat6, err_tcp := goss.ConnectionsWithProtocol(goss.AF_INET6, syscall.IPPROTO_TCP)
+				udpStat6, err_udp := goss.ConnectionsWithProtocol(goss.AF_INET6, syscall.IPPROTO_UDP)
+				if err_tcp == nil && err_udp == nil {
+					ss_err = false
+					tcpConnCount += uint64(len(tcpStat6))
+					udpConnCount += uint64(len(udpStat6))
+				}
+			}
+		}
+		if ss_err {
+			conns, _ := net.Connections("all")
+			for i := 0; i < len(conns); i++ {
+				switch conns[i].Type {
+				case syscall.SOCK_STREAM:
+					tcpConnCount++
+				case syscall.SOCK_DGRAM:
+					udpConnCount++
+				}
+			}
+		}
+	}
+
+	ret.NetInTransfer, ret.NetOutTransfer = netInTransfer, netOutTransfer
+	ret.NetInSpeed, ret.NetOutSpeed = netInSpeed, netOutSpeed
+	ret.Uptime = uint64(time.Since(cachedBootTime).Seconds())
+	ret.TcpConnCount, ret.UdpConnCount = tcpConnCount, udpConnCount
+
+	return &ret
+}
+
+// TrackNetworkSpeed NIC监控，统计流量与速度
+func TrackNetworkSpeed(agentConfig *model.AgentConfig) {
+	var innerNetInTransfer, innerNetOutTransfer uint64
+	nc, err := net.IOCounters(true)
+	if err == nil {
+		for _, v := range nc {
+			if len(agentConfig.NICAllowlist) > 0 {
+				if !agentConfig.NICAllowlist[v.Name] {
+					continue
+				}
+			} else {
+				if isListContainsStr(excludeNetInterfaces, v.Name) {
+					continue
+				}
+			}
+			innerNetInTransfer += v.BytesRecv
+			innerNetOutTransfer += v.BytesSent
+		}
+		now := uint64(time.Now().Unix())
+		diff := now - lastUpdateNetStats
+		if diff > 0 {
+			netInSpeed = (innerNetInTransfer - netInTransfer) / diff
+			netOutSpeed = (innerNetOutTransfer - netOutTransfer) / diff
+		}
+		netInTransfer = innerNetInTransfer
+		netOutTransfer = innerNetOutTransfer
+		lastUpdateNetStats = now
+	}
+}
+
+func getDiskTotalAndUsed(agentConfig *model.AgentConfig) (total uint64, used uint64) {
+	devices := make(map[string]string)
+
+	if len(agentConfig.HardDrivePartitionAllowlist) > 0 {
+		// 如果配置了白名单，使用白名单的列表
+		for i, v := range agentConfig.HardDrivePartitionAllowlist {
+			devices[strconv.Itoa(i)] = v
+		}
+	} else {
+		// 否则使用默认过滤规则
+		diskList, _ := disk.Partitions(false)
+		for _, d := range diskList {
+			fsType := strings.ToLower(d.Fstype)
+			// 不统计 K8s 的虚拟挂载点：https://github.com/shirou/gopsutil/issues/1007
+			if devices[d.Device] == "" && isListContainsStr(expectDiskFsTypes, fsType) && !strings.Contains(d.Mountpoint, "/var/lib/kubelet") {
+				devices[d.Device] = d.Mountpoint
+			}
+		}
+	}
+
+	for _, mountPath := range devices {
+		diskUsageOf, err := disk.Usage(mountPath)
+		if err == nil {
+			total += diskUsageOf.Total
+			used += diskUsageOf.Used
+		}
+	}
+
+	// Fallback 到这个方法,仅统计根路径,适用于OpenVZ之类的.
+	if runtime.GOOS == "linux" && total == 0 && used == 0 {
+		cmd := exec.Command("df")
+		out, err := cmd.CombinedOutput()
+		if err == nil {
+			s := strings.Split(string(out), "\n")
+			for _, c := range s {
+				info := strings.Fields(c)
+				if len(info) == 6 {
+					if info[5] == "/" {
+						total, _ = strconv.ParseUint(info[1], 0, 64)
+						used, _ = strconv.ParseUint(info[2], 0, 64)
+						// 默认获取的是1K块为单位的.
+						total = total * 1024
+						used = used * 1024
+					}
+				}
+			}
+		}
+	}
+
+	return
+}
+
+func isListContainsStr(list []string, str string) bool {
+	for i := 0; i < len(list); i++ {
+		if strings.Contains(str, list[i]) {
+			return true
+		}
+	}
+	return false
+}
+
+func println(v ...interface{}) {
+	fmt.Printf("NEZHA@%s>> ", time.Now().Format("2006-01-02 15:04:05"))
+	fmt.Println(v...)
+}

pkg/monitor/myip.go

@@ -0,0 +1,125 @@
+package monitor
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"time"
+
+	fakeUa "github.com/EDDYCJY/fake-useragent"
+
+	"github.com/nezhahq/agent/pkg/util"
+)
+
+type geoIP struct {
+	CountryCode  string `json:"country_code,omitempty"`
+	CountryCode2 string `json:"countryCode,omitempty"`
+	IP           string `json:"ip,omitempty"`
+	Query        string `json:"query,omitempty"`
+	Location     struct {
+		CountryCode string `json:"country_code,omitempty"`
+	} `json:"location,omitempty"`
+}
+
+func (ip *geoIP) Unmarshal(body []byte) error {
+	if err := util.Json.Unmarshal(body, ip); err != nil {
+		return err
+	}
+	if ip.IP == "" && ip.Query != "" {
+		ip.IP = ip.Query
+	}
+	if ip.CountryCode == "" && ip.CountryCode2 != "" {
+		ip.CountryCode = ip.CountryCode2
+	}
+	if ip.CountryCode == "" && ip.Location.CountryCode != "" {
+		ip.CountryCode = ip.Location.CountryCode
+	}
+	return nil
+}
+
+var (
+	geoIPApiList = []string{
+		"http://api.myip.la/en?json",
+		"https://api.ip.sb/geoip",
+		"https://ipapi.co/json",
+		"http://ip-api.com/json/",
+		// "https://extreme-ip-lookup.com/json/", // 不精确
+		// "https://ip.seeip.org/geoip", // 不精确
+		// "https://freegeoip.app/json/", // 需要 Key
+	}
+	CachedIP, cachedCountry string
+	httpClientV4            = util.NewSingleStackHTTPClient(time.Second*20, time.Second*5, time.Second*10, false)
+	httpClientV6            = util.NewSingleStackHTTPClient(time.Second*20, time.Second*5, time.Second*10, true)
+)
+
+// UpdateIP 每30分钟更新一次IP地址与国家码的缓存
+func UpdateIP() {
+	for {
+		ipv4 := fetchGeoIP(geoIPApiList, false)
+		ipv6 := fetchGeoIP(geoIPApiList, true)
+		if ipv4.IP == "" && ipv6.IP == "" {
+			time.Sleep(time.Minute)
+			continue
+		}
+		if ipv4.IP == "" || ipv6.IP == "" {
+			CachedIP = fmt.Sprintf("%s%s", ipv4.IP, ipv6.IP)
+		} else {
+			CachedIP = fmt.Sprintf("%s/%s", ipv4.IP, ipv6.IP)
+		}
+		if ipv4.CountryCode != "" {
+			cachedCountry = ipv4.CountryCode
+		} else if ipv6.CountryCode != "" {
+			cachedCountry = ipv6.CountryCode
+		}
+		time.Sleep(time.Minute * 30)
+	}
+}
+
+func fetchGeoIP(servers []string, isV6 bool) geoIP {
+	var ip geoIP
+	var resp *http.Response
+	var err error
+
+	// 双栈支持参差不齐，不能随机请求，有些 IPv6 取不到 IP
+	for i := 0; i < len(servers); i++ {
+		if isV6 {
+			resp, err = httpGetWithUA(httpClientV6, servers[i])
+		} else {
+			resp, err = httpGetWithUA(httpClientV4, servers[i])
+		}
+		if err == nil {
+			body, err := io.ReadAll(resp.Body)
+			if err != nil {
+				continue
+			}
+			resp.Body.Close()
+			if err := ip.Unmarshal(body); err != nil {
+				continue
+			}
+			// 没取到 v6 IP
+			if isV6 && !strings.Contains(ip.IP, ":") {
+				continue
+			}
+			// 没取到 v4 IP
+			if !isV6 && !strings.Contains(ip.IP, ".") {
+				continue
+			}
+			// 未获取到国家码
+			if ip.CountryCode == "" {
+				continue
+			}
+			return ip
+		}
+	}
+	return ip
+}
+
+func httpGetWithUA(client *http.Client, url string) (*http.Response, error) {
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Add("User-Agent", fakeUa.Random())
+	return client.Do(req)
+}

pkg/monitor/myip_test.go

@@ -0,0 +1,30 @@
+package monitor
+
+import (
+	"io"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestGeoIPApi(t *testing.T) {
+	for i := 0; i < len(geoIPApiList); i++ {
+		resp, err := httpGetWithUA(httpClientV4, geoIPApiList[i])
+		assert.Nil(t, err)
+		body, err := io.ReadAll(resp.Body)
+		assert.Nil(t, err)
+		resp.Body.Close()
+		var ip geoIP
+		err = ip.Unmarshal(body)
+		assert.Nil(t, err)
+		t.Logf("%s %s %s", geoIPApiList[i], ip.CountryCode, ip.IP)
+		assert.True(t, ip.IP != "")
+		assert.True(t, ip.CountryCode != "")
+	}
+}
+
+func TestFetchGeoIP(t *testing.T) {
+	ip := fetchGeoIP(geoIPApiList, false)
+	assert.NotEmpty(t, ip.IP)
+	assert.NotEmpty(t, ip.CountryCode)
+}

pkg/processgroup/process_group.go

@@ -0,0 +1,54 @@
+//go:build !windows
+// +build !windows
+
+package processgroup
+
+import (
+	"os/exec"
+	"sync"
+	"syscall"
+)
+
+type ProcessExitGroup struct {
+	cmds []*exec.Cmd
+}
+
+func NewProcessExitGroup() (ProcessExitGroup, error) {
+	return ProcessExitGroup{}, nil
+}
+
+func (g *ProcessExitGroup) killChildProcess(c *exec.Cmd) error {
+	pgid, err := syscall.Getpgid(c.Process.Pid)
+	if err != nil {
+		// Fall-back on error. Kill the main process only.
+		c.Process.Kill()
+	}
+	// Kill the whole process group.
+	syscall.Kill(-pgid, syscall.SIGTERM)
+	return c.Wait()
+}
+
+func (g *ProcessExitGroup) Dispose() []error {
+	var errors []error
+	mutex := new(sync.Mutex)
+	wg := new(sync.WaitGroup)
+	wg.Add(len(g.cmds))
+	for _, c := range g.cmds {
+		go func(c *exec.Cmd) {
+			defer wg.Done()
+			if err := g.killChildProcess(c); err != nil {
+				mutex.Lock()
+				defer mutex.Unlock()
+				errors = append(errors, err)
+			}
+		}(c)
+	}
+	wg.Wait()
+	return errors
+}
+
+func (g *ProcessExitGroup) AddProcess(cmd *exec.Cmd) error {
+	cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
+	g.cmds = append(g.cmds, cmd)
+	return nil
+}

pkg/processgroup/process_group_windows.go

@@ -0,0 +1,30 @@
+//go:build windows
+
+package processgroup
+
+import (
+	"fmt"
+	"os/exec"
+)
+
+type ProcessExitGroup struct {
+	cmds []*exec.Cmd
+}
+
+func NewProcessExitGroup() (ProcessExitGroup, error) {
+	return ProcessExitGroup{}, nil
+}
+
+func (g *ProcessExitGroup) Dispose() error {
+	for _, c := range g.cmds {
+		if err := exec.Command("taskkill", "/F", "/T", "/PID", fmt.Sprint(c.Process.Pid)).Run(); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (g *ProcessExitGroup) AddProcess(cmd *exec.Cmd) error {
+	g.cmds = append(g.cmds, cmd)
+	return nil
+}

pkg/pty/pty.go

@@ -0,0 +1,73 @@
+//go:build !windows
+// +build !windows
+
+package pty
+
+import (
+	"errors"
+	"os"
+	"os/exec"
+	"syscall"
+
+	opty "github.com/creack/pty"
+)
+
+var defaultShells = []string{"zsh", "fish", "bash", "sh"}
+
+type Pty struct {
+	tty *os.File
+	cmd *exec.Cmd
+}
+
+func DownloadDependency() {
+}
+
+func Start() (*Pty, error) {
+	var shellPath string
+	for i := 0; i < len(defaultShells); i++ {
+		shellPath, _ = exec.LookPath(defaultShells[i])
+		if shellPath != "" {
+			break
+		}
+	}
+	if shellPath == "" {
+		return nil, errors.New("没有可用终端")
+	}
+	cmd := exec.Command(shellPath) // #nosec
+	cmd.Env = append(os.Environ(), "TERM=xterm")
+	tty, err := opty.Start(cmd)
+	return &Pty{tty: tty, cmd: cmd}, err
+}
+
+func (pty *Pty) Write(p []byte) (n int, err error) {
+	return pty.tty.Write(p)
+}
+
+func (pty *Pty) Read(p []byte) (n int, err error) {
+	return pty.tty.Read(p)
+}
+
+func (pty *Pty) Setsize(cols, rows uint32) error {
+	return opty.Setsize(pty.tty, &opty.Winsize{
+		Cols: uint16(cols),
+		Rows: uint16(rows),
+	})
+}
+
+func (pty *Pty) killChildProcess(c *exec.Cmd) error {
+	pgid, err := syscall.Getpgid(c.Process.Pid)
+	if err != nil {
+		// Fall-back on error. Kill the main process only.
+		c.Process.Kill()
+	}
+	// Kill the whole process group.
+	syscall.Kill(-pgid, syscall.SIGKILL) // SIGKILL 直接杀掉 SIGTERM 发送信号，等待进程自己退出
+	return c.Wait()
+}
+
+func (pty *Pty) Close() error {
+	if err := pty.tty.Close(); err != nil {
+		return err
+	}
+	return pty.killChildProcess(pty.cmd)
+}

pkg/pty/pty_windows.go

@@ -0,0 +1,106 @@
+//go:build windows
+
+package pty
+
+import (
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+
+	"github.com/artdarek/go-unzip"
+	"github.com/iamacarpet/go-winpty"
+)
+
+type Pty struct {
+	tty *winpty.WinPTY
+}
+
+func DownloadDependency() {
+	executablePath, err := getExecutableFilePath()
+	if err != nil {
+		fmt.Println("NEZHA>> wintty 获取文件路径失败", err)
+		return
+	}
+
+	winptyAgentExe := filepath.Join(executablePath, "winpty-agent.exe")
+	winptyAgentDll := filepath.Join(executablePath, "winpty.dll")
+
+	fe, errFe := os.Stat(winptyAgentExe)
+	fd, errFd := os.Stat(winptyAgentDll)
+	if errFe == nil && fe.Size() > 300000 && errFd == nil && fd.Size() > 300000 {
+		return
+	}
+
+	resp, err := http.Get("https://dn-dao-github-mirror.daocloud.io/rprichard/winpty/releases/download/0.4.3/winpty-0.4.3-msvc2015.zip")
+	if err != nil {
+		log.Println("NEZHA>> wintty 下载失败", err)
+		return
+	}
+	defer resp.Body.Close()
+	content, err := io.ReadAll(resp.Body)
+	if err != nil {
+		log.Println("NEZHA>> wintty 下载失败", err)
+		return
+	}
+	if err := os.WriteFile("./wintty.zip", content, os.FileMode(0777)); err != nil {
+		log.Println("NEZHA>> wintty 写入失败", err)
+		return
+	}
+	if err := unzip.New("./wintty.zip", "./wintty").Extract(); err != nil {
+		fmt.Println("NEZHA>> wintty 解压失败", err)
+		return
+	}
+	arch := "x64"
+	if runtime.GOARCH != "amd64" {
+		arch = "ia32"
+	}
+
+	os.Rename("./wintty/"+arch+"/bin/winpty-agent.exe", winptyAgentExe)
+	os.Rename("./wintty/"+arch+"/bin/winpty.dll", winptyAgentDll)
+	os.RemoveAll("./wintty")
+	os.RemoveAll("./wintty.zip")
+}
+
+func getExecutableFilePath() (string, error) {
+	ex, err := os.Executable()
+	if err != nil {
+		return "", err
+	}
+	return filepath.Dir(ex), nil
+}
+
+func Start() (*Pty, error) {
+	shellPath, err := exec.LookPath("powershell.exe")
+	if err != nil || shellPath == "" {
+		shellPath = "cmd.exe"
+	}
+	path, err := getExecutableFilePath()
+	if err != nil {
+		return nil, err
+	}
+	tty, err := winpty.OpenDefault(path, shellPath)
+	return &Pty{tty: tty}, err
+}
+
+func (pty *Pty) Write(p []byte) (n int, err error) {
+	return pty.tty.StdIn.Write(p)
+}
+
+func (pty *Pty) Read(p []byte) (n int, err error) {
+	return pty.tty.StdOut.Read(p)
+}
+
+func (pty *Pty) Setsize(cols, rows uint32) error {
+	pty.tty.SetSize(cols, rows)
+	return nil
+}
+
+func (pty *Pty) Close() error {
+	pty.tty.Close()
+	return nil
+}

pkg/util/http.go

@@ -0,0 +1,92 @@
+package util
+
+import (
+	"context"
+	"errors"
+	"net"
+	"net/http"
+	"strings"
+	"time"
+)
+
+func NewSingleStackHTTPClient(httpTimeout, dialTimeout, keepAliveTimeout time.Duration, ipv6 bool) *http.Client {
+	dialer := &net.Dialer{
+		Timeout:   dialTimeout,
+		KeepAlive: keepAliveTimeout,
+	}
+
+	transport := &http.Transport{
+		Proxy:             http.ProxyFromEnvironment,
+		ForceAttemptHTTP2: false,
+		DialContext: func(ctx context.Context, network string, addr string) (net.Conn, error) {
+			ip, err := resolveIP(addr, ipv6)
+			if err != nil {
+				return nil, err
+			}
+			return dialer.DialContext(ctx, network, ip)
+		},
+	}
+
+	return &http.Client{
+		Transport: transport,
+		Timeout:   httpTimeout,
+	}
+}
+
+func resolveIP(addr string, ipv6 bool) (string, error) {
+	url := strings.Split(addr, ":")
+
+	dnsServers := []string{"[2606:4700:4700::1001]", "[2001:4860:4860::8844]", "[2400:3200::1]", "[2400:3200:baba::1]"}
+	if !ipv6 {
+		dnsServers = []string{"1.0.0.1", "8.8.4.4", "223.5.5.5", "223.6.6.6"}
+	}
+
+	res, err := net.LookupIP(url[0])
+	if err != nil {
+		for i := 0; i < len(dnsServers); i++ {
+			r := &net.Resolver{
+				PreferGo: true,
+				Dial: func(ctx context.Context, network, address string) (net.Conn, error) {
+					d := net.Dialer{
+						Timeout: time.Second * 10,
+					}
+					return d.DialContext(ctx, "udp", dnsServers[i]+":53")
+				},
+			}
+			res, err = r.LookupIP(context.Background(), "ip", url[0])
+			if err == nil {
+				break
+			}
+		}
+	}
+
+	if err != nil {
+		return "", err
+	}
+
+	var ipv4Resolved, ipv6Resolved bool
+
+	for i := 0; i < len(res); i++ {
+		ip := res[i].String()
+		if strings.Contains(ip, ".") && !ipv6 {
+			ipv4Resolved = true
+			url[0] = ip
+			break
+		}
+		if strings.Contains(ip, ":") && ipv6 {
+			ipv6Resolved = true
+			url[0] = "[" + ip + "]"
+			break
+		}
+	}
+
+	if ipv6 && !ipv6Resolved {
+		return "", errors.New("the AAAA record not resolved")
+	}
+
+	if !ipv6 && !ipv4Resolved {
+		return "", errors.New("the A record not resolved")
+	}
+
+	return strings.Join(url, ":"), nil
+}

pkg/util/util.go

@@ -0,0 +1,13 @@
+package util
+
+import (
+	"os"
+
+	jsoniter "github.com/json-iterator/go"
+)
+
+var Json = jsoniter.ConfigCompatibleWithStandardLibrary
+
+func IsWindows() bool {
+	return os.PathSeparator == '\\' && os.PathListSeparator == ';'
+}