improve: pass logger instead of using global logger

internal/config/log.go

@@ -10,9 +10,13 @@ import (
 	log "github.com/sirupsen/logrus"
 )
 
+var Logger *log.Logger
+
 func initLog() {
+	Logger = log.New()
+
 	if Settings.Log.DebugLevel {
-		log.SetLevel(log.DebugLevel)
+		Logger.SetLevel(log.DebugLevel)
 	}
 
 	if Settings.Log.WriteFile {
@@ -22,7 +26,7 @@ func initLog() {
 		}
 		err := os.MkdirAll(Settings.Log.FilePath, os.ModePerm)
 		if err != nil {
-			log.Fatalln(err)
+			Logger.Fatalln(err)
 		}
 
 		if Settings.Log.FileName == "" {
@@ -31,15 +35,15 @@ func initLog() {
 
 		f, err := os.OpenFile(Settings.Log.FilePath+Settings.Log.FileName, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0644)
 		if err != nil {
-			log.Fatalln(err)
+			Logger.Fatalln(err)
 		}
 
 		//设置双重输出
 		mw := io.MultiWriter(os.Stdout, f)
-		log.SetOutput(mw)
+		Logger.SetOutput(mw)
 
 		//设置输出格式
-		log.SetFormatter(&nested.Formatter{
+		Logger.SetFormatter(&nested.Formatter{
 			HideKeys:        true,
 			NoColors:        Settings.Log.WriteFile,
 			TimestampFormat: "2006-01-02 15:04:05",

internal/controllers/guardian.go

@@ -5,12 +5,13 @@ import (
 	"time"
 
 	"github.com/Mmx233/BitSrunLoginGo/tools"
-	log "github.com/sirupsen/logrus"
 )
 
 // Guardian 守护模式逻辑
 func Guardian() {
-	log.Infoln("[以守护模式启动]")
+	logger := config.Logger
+
+	logger.Infoln("[以守护模式启动]")
 
 	GuardianDuration := time.Duration(config.Settings.Guardian.Duration) * time.Second
 
@@ -20,16 +21,16 @@ func Guardian() {
 			if config.Settings.Basic.Interfaces == "" { //单网卡
 				err := Login(nil, true)
 				if err != nil {
-					log.Errorln("登录出错: ", err)
+					logger.Errorln("登录出错: ", err)
 				}
 			} else { //多网卡
-				interfaces, err := tools.GetInterfaceAddr(config.Settings.Basic.Interfaces)
+				interfaces, err := tools.GetInterfaceAddr(logger, config.Settings.Basic.Interfaces)
 				if err == nil {
 					for _, eth := range interfaces {
-						log.Debugf("使用 %s 网口登录 ", eth.Name)
+						logger.Debugf("使用 %s 网口登录 ", eth.Name)
 						err = Login(&eth, true)
 						if err != nil {
-							log.Errorln("网口 ", eth.Name+" 登录出错: ", err)
+							logger.Errorln("网口 ", eth.Name+" 登录出错: ", err)
 						}
 					}
 				}

internal/controllers/login.go

@@ -5,18 +5,21 @@ import (
 	"github.com/Mmx233/BitSrunLoginGo/internal/config"
 	"github.com/Mmx233/BitSrunLoginGo/internal/config/flags"
 	"github.com/Mmx233/BitSrunLoginGo/internal/pkg/dns"
+	"github.com/Mmx233/BitSrunLoginGo/internal/pkg/http_client"
 	"github.com/Mmx233/BitSrunLoginGo/pkg/srun"
 	"github.com/Mmx233/BitSrunLoginGo/tools"
-	log "github.com/sirupsen/logrus"
 	"net/http"
 )
 
 // Login 登录逻辑
 func Login(eth *tools.Eth, debugOutput bool) error {
+	logger := config.Logger
+
 	// 登录配置初始化
-	httpClient := tools.HttpPackSelect(eth).Client
+	httpClient := http_client.HttpPackSelect(eth).Client
 	srunClient := srun.New(&srun.Conf{
-		Https: config.Settings.Basic.Https,
+		Logger: logger,
+		Https:  config.Settings.Basic.Https,
 		LoginInfo: srun.LoginInfo{
 			Form: *config.Form,
 			Meta: *config.Meta,
@@ -30,42 +33,42 @@ func Login(eth *tools.Eth, debugOutput bool) error {
 	// Reality 与 Acid
 	var acidOnReality bool
 	if config.Settings.Reality.Enable {
-		log.Debugln("开始 Reality 流程")
+		logger.Debugln("开始 Reality 流程")
 		acid, _, err := srunDetector.Reality(config.Settings.Reality.Addr, flags.AutoAcid)
 		if err != nil {
-			log.Warnln("Reality 请求异常:", err)
+			logger.Warnln("Reality 请求异常:", err)
 		} else if flags.AutoAcid && acid != "" {
 			acidOnReality = true
-			log.Debugf("使用嗅探 acid: %s", acid)
+			logger.Debugf("使用嗅探 acid: %s", acid)
 			srunClient.LoginInfo.Meta.Acid = acid
 		}
 	}
 	if !acidOnReality && flags.AutoAcid {
-		log.Debugln("开始嗅探 acid")
+		logger.Debugln("开始嗅探 acid")
 		acid, err := srunDetector.DetectAcid()
 		if err != nil {
 			if errors.Is(err, srun.ErrAcidCannotFound) {
-				log.Warnln("找不到 acid，使用配置 acid")
+				logger.Warnln("找不到 acid，使用配置 acid")
 			} else {
-				log.Warnf("嗅探 acid 失败，使用配置 acid: %v", err)
+				logger.Warnf("嗅探 acid 失败，使用配置 acid: %v", err)
 			}
 		} else {
-			log.Debugf("使用嗅探 acid: %s", acid)
+			logger.Debugf("使用嗅探 acid: %s", acid)
 			srunClient.LoginInfo.Meta.Acid = acid
 		}
 	}
 
 	if flags.AutoEnc {
-		log.Debugln("开始嗅探 enc")
+		logger.Debugln("开始嗅探 enc")
 		enc, err := srunDetector.DetectEnc()
 		if err != nil {
 			if errors.Is(err, srun.ErrEnvCannotFound) {
-				log.Warnln("找不到 enc，使用配置 enc")
+				logger.Warnln("找不到 enc，使用配置 enc")
 			} else {
-				log.Warnf("嗅探 enc 失败，使用配置 enc: %v", err)
+				logger.Warnf("嗅探 enc 失败，使用配置 enc: %v", err)
 			}
 		} else {
-			log.Debugf("使用嗅探 enc: %s", enc)
+			logger.Debugf("使用嗅探 enc: %s", enc)
 			srunClient.LoginInfo.Meta.Enc = enc
 		}
 	}
@@ -73,9 +76,9 @@ func Login(eth *tools.Eth, debugOutput bool) error {
 	// 选择输出函数
 	var output func(args ...interface{})
 	if debugOutput {
-		output = log.Debugln
+		output = logger.Debugln
 	} else {
-		output = log.Infoln
+		output = logger.Infoln
 	}
 
 	output("正在获取登录状态")
@@ -88,10 +91,10 @@ func Login(eth *tools.Eth, debugOutput bool) error {
 	var loginIp string
 
 	if config.Meta.DoubleStack {
-		log.Debugln("使用双栈网络时认证 ip 为空")
+		logger.Debugln("使用双栈网络时认证 ip 为空")
 	} else {
 		loginIp = ip
-		log.Debugln("认证客户端 ip: ", ip)
+		logger.Debugln("认证客户端 ip: ", ip)
 	}
 
 	// 登录执行
@@ -107,13 +110,13 @@ func Login(eth *tools.Eth, debugOutput bool) error {
 
 		return nil
 	} else {
-		log.Infoln("检测到用户未登录，开始尝试登录...")
+		logger.Infoln("检测到用户未登录，开始尝试登录...")
 
 		if err = srunClient.DoLogin(loginIp); err != nil {
 			return err
 		}
 
-		log.Infoln("登录成功~")
+		logger.Infoln("登录成功~")
 
 		if config.Settings.DDNS.Enable {
 			_ = ddns(ip, httpClient)
@@ -127,6 +130,7 @@ var ipLast string
 
 func ddns(ip string, httpClient *http.Client) error {
 	return dns.Run(&dns.Config{
+		Logger:   config.Logger,
 		Provider: config.Settings.DDNS.Provider,
 		IP:       ip,
 		Domain:   config.Settings.DDNS.Domain,

internal/pkg/dns/dns.go

@@ -10,12 +10,15 @@ import (
 )
 
 func Run(c *Config) error {
-	log.Infof("开始 %s DDNS 流程", c.Provider)
-
+	if c.Logger == nil {
+		c.Logger = log.New()
+	}
 	if c.TTL == 0 {
 		c.TTL = 600
 	}
 
+	c.Logger.Infof("开始 %s DDNS 流程", c.Provider)
+
 	var dns Provider
 	var err error
 	switch c.Provider {
@@ -32,22 +35,22 @@ func Run(c *Config) error {
 		} else {
 			msg = fmt.Sprintf("DDNS 模块 dns 运营商 %s 不支持", c.Provider)
 		}
-		log.Warnln(msg)
+		c.Logger.Warnln(msg)
 		return errors.New(msg)
 	}
 	if err != nil {
-		log.Warnf("解析 DDNS config 失败：%v", err)
+		c.Logger.Warnf("解析 DDNS config 失败：%v", err)
 		return err
 	}
 
 	// 修改 dns 记录
 
 	if err = dns.SetDomainRecord(c.Domain, c.IP); err != nil {
-		log.Warnf("设置 dns 解析记录失败：%v", err)
+		c.Logger.Warnf("设置 dns 解析记录失败：%v", err)
 		return err
 	}
 
-	log.Infof("DDNS 配置应用成功: %s | %s", c.Domain, c.IP)
+	c.Logger.Infof("DDNS 配置应用成功: %s | %s", c.Domain, c.IP)
 
 	return nil
 }

internal/pkg/dns/models.go

@@ -2,6 +2,7 @@ package dns
 
 import (
 	"github.com/Mmx233/BitSrunLoginGo/internal/config"
+	log "github.com/sirupsen/logrus"
 	"net/http"
 )
 
@@ -16,4 +17,5 @@ type Config struct {
 	TTL      uint
 	Conf     config.DdnsProviderConfigSum
 	Http     *http.Client
+	Logger   *log.Logger
 }

internal/pkg/http_client/http.go

@@ -0,0 +1,56 @@
+package http_client
+
+import (
+	"github.com/Mmx233/BitSrunLoginGo/internal/config"
+	"github.com/Mmx233/BitSrunLoginGo/internal/config/flags"
+	"github.com/Mmx233/BitSrunLoginGo/tools"
+	"net"
+	"net/http"
+)
+
+type Http struct {
+	Client *http.Client
+}
+
+var HttpPack *Http
+
+var httpTools map[string]*Http
+
+func init() {
+	logger := config.Logger
+	if config.Settings.Basic.Interfaces == "" {
+		var eth *tools.Eth
+		if flags.Interface != "" {
+			netEth, err := net.InterfaceByName(flags.Interface)
+			if err != nil {
+				logger.Warnf("获取指定网卡 %s 失败，使用默认网卡: %v", flags.Interface, err)
+			} else {
+				eth, err = tools.ConvertInterface(logger, *netEth)
+				if err != nil {
+					logger.Warnf("获取指定网卡 %s ip 地址失败，使用默认网卡: %v", flags.Interface, err)
+				} else if eth == nil {
+					logger.Warnf("指定网卡 %s 无可用 ip 地址，使用默认网卡", flags.Interface)
+				} else {
+					logger.Debugf("使用指定网卡 %s ip: %s", eth.Name, eth.Addr.String())
+				}
+			}
+		}
+
+		HttpPack = genHttpPack(eth)
+	} else {
+		httpTools = make(map[string]*Http)
+	}
+}
+
+func HttpPackSelect(eth *tools.Eth) *Http {
+	if HttpPack != nil {
+		return HttpPack
+	}
+	if addrHttp, ok := httpTools[eth.Name]; ok {
+		return addrHttp
+	} else {
+		addrHttp = genHttpPack(eth)
+		httpTools[eth.Name] = addrHttp
+		return addrHttp
+	}
+}

internal/pkg/http_client/http_default.go

@@ -0,0 +1,35 @@
+//go:build !linux
+
+package http_client
+
+import (
+	"crypto/tls"
+	"github.com/Mmx233/BitSrunLoginGo/internal/config"
+	"github.com/Mmx233/BitSrunLoginGo/tools"
+	"github.com/Mmx233/tool"
+	"net"
+	"net/http"
+)
+
+func genHttpPack(eth *tools.Eth) *Http {
+	var addr net.Addr
+	if eth != nil {
+		addr = eth.Addr
+	}
+	tr := &http.Transport{
+		DialContext: (&net.Dialer{
+			Timeout:   config.Timeout,
+			LocalAddr: addr,
+		}).DialContext,
+		TLSClientConfig: &tls.Config{
+			InsecureSkipVerify: config.Settings.Basic.SkipCertVerify,
+		},
+		Proxy: http.ProxyFromEnvironment,
+	}
+	return &Http{
+		Client: tool.GenHttpClient(&tool.HttpClientOptions{
+			Transport: tr,
+			Timeout:   config.Timeout,
+		}),
+	}
+}

internal/pkg/http_client/http_linux.go

@@ -0,0 +1,48 @@
+package http_client
+
+import (
+	"crypto/tls"
+	"github.com/Mmx233/BitSrunLoginGo/internal/config"
+	"github.com/Mmx233/BitSrunLoginGo/tools"
+	"github.com/Mmx233/tool"
+	"net"
+	"net/http"
+	"syscall"
+)
+
+func genHttpPack(eth *tools.Eth) *Http {
+	dialer := net.Dialer{
+		Timeout: config.Timeout,
+	}
+	if eth != nil {
+		dialer.LocalAddr = eth.Addr
+		ethName := eth.Name
+		dialer.Control = func(network string, address string, c syscall.RawConn) error {
+			var operr error
+			fn := func(fd uintptr) {
+				operr = syscall.SetsockoptString(int(fd), syscall.SOL_SOCKET, syscall.SO_BINDTODEVICE, ethName)
+			}
+			if err := c.Control(fn); err != nil {
+				return err
+			}
+			if operr != nil {
+				return operr
+			}
+			return nil
+		}
+	}
+
+	tr := &http.Transport{
+		DialContext:         dialer.DialContext,
+		TLSHandshakeTimeout: config.Timeout,
+		IdleConnTimeout:     config.Timeout,
+		TLSClientConfig:     &tls.Config{InsecureSkipVerify: config.Settings.Basic.SkipCertVerify},
+	}
+	tr.Proxy = http.ProxyFromEnvironment
+	return &Http{
+		Client: tool.GenHttpClient(&tool.HttpClientOptions{
+			Transport: tr,
+			Timeout:   config.Timeout,
+		}),
+	}
+}