From 2b8d966909c5a8bd2de52b3666eada5c0bfc46ed Mon Sep 17 00:00:00 2001
From: hahahrfool <75717694+hahahrfool@users.noreply.github.com>
Date: Sun, 3 Apr 2022 17:10:25 +0800
Subject: [PATCH] =?UTF-8?q?=E4=BF=AE=E8=AE=A2=E4=BB=A3=E7=A0=81?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 Makefile_release         |  6 +++---
 httpLayer/fallback.go    |  9 +++++---
 main.go                  |  9 ++++----
 netLayer/geoip.go        | 17 ++++++++++++---
 netLayer/netlayer.go     | 38 +++++++++++++++++++++++++++++++--
 proxy/config_standard.go | 15 +++++++++++--
 proxy/creator.go         | 31 +++++++++++++++++++++++----
 proxy/proxy.go           | 46 +++++++++++++++++++++++++++++++++++-----
 tlsLayer/tlsLayer.go     | 14 ++++++++++--
 9 files changed, 156 insertions(+), 29 deletions(-)

diff --git a/Makefile_release b/Makefile_release
index 0abba3d..47f0683 100644
--- a/Makefile_release
+++ b/Makefile_release
@@ -21,7 +21,7 @@ endef
 endif
 
 
-all: linux_amd64 linux_arm64 linux_arm32_v7 linux_mips64 linux_mips android_arm64 macos macm1 win10 win10_arm win32
+all: linux_amd64 linux_arm64 linux_arm32_v7 linux_mips64 linux_mips macos macm1 win10 win10_arm win32
 
 # 注意调用参数时，逗号前后不能留空格
 # 关于arm版本号 https://github.com/goreleaser/goreleaser/issues/36
@@ -41,8 +41,8 @@ linux_mips64:
 linux_mips:
 	$(call compile, ${prefix}_linux_mips,linux,mips)
 
-android_arm64:
-	$(call compile, ${prefix}_android_arm64,android,arm64)
+#android_arm64:
+#	$(call compile, ${prefix}_android_arm64,android,arm64)
 
 macos:
 	$(call compile, ${prefix}_macOS_intel,darwin,amd64)
diff --git a/httpLayer/fallback.go b/httpLayer/fallback.go
index 2eaff6a..147ff13 100644
--- a/httpLayer/fallback.go
+++ b/httpLayer/fallback.go
@@ -6,6 +6,7 @@ import (
 
 	"github.com/hahahrfool/v2ray_simple/netLayer"
 	"github.com/hahahrfool/v2ray_simple/utils"
+	"go.uber.org/zap"
 	"gonum.org/v1/gonum/stat/combin"
 )
 
@@ -301,11 +302,13 @@ type FallbackConf struct {
 func NewClassicFallbackFromConfList(fcl []*FallbackConf) *ClassicFallback {
 	cfb := NewClassicFallback()
 	for _, fc := range fcl {
-		//log.Println("NewClassicFallbackFromConfList called", reflect.TypeOf(v.Dest))
-
 		addr, err := netLayer.NewAddrFromAny(fc.Dest)
 		if err != nil {
-			log.Fatal(err)
+			if utils.ZapLogger != nil {
+				utils.ZapLogger.Fatal("NewClassicFallbackFromConfList, netLayer.NewAddrFromAny err", zap.Error(err))
+			} else {
+				log.Fatalln("NewClassicFallbackFromConfList, netLayer.NewAddrFromAny err", err)
+			}
 		}
 		var aMask byte
 		if len(fc.Alpn) > 2 {
diff --git a/main.go b/main.go
index 4aa51d8..50e773e 100644
--- a/main.go
+++ b/main.go
@@ -328,7 +328,7 @@ func listenSer(inServer proxy.Server, defaultOutClientForThis proxy.Client) {
 
 		handleFunc := inServer.HandleInitialLayersFunc()
 		if handleFunc == nil {
-			log.Fatalf("inServer.IsHandleInitialLayers but inServer.HandleInitialLayersFunc() returns nil\n")
+			utils.ZapLogger.Fatal("inServer.IsHandleInitialLayers but inServer.HandleInitialLayersFunc() returns nil")
 		}
 
 		newConnChan, baseConn := handleFunc()
@@ -398,7 +398,8 @@ func listenSer(inServer proxy.Server, defaultOutClientForThis proxy.Client) {
 
 	} else {
 		if err != nil {
-			log.Fatalf("can not listen inServer on %s %s\n", inServer.AddrStr(), err)
+			utils.ZapLogger.Fatal(
+				"can not listen inServer on %s %s\n", zap.String("addr", inServer.AddrStr()), zap.Error(err))
 
 		}
 	}
@@ -694,9 +695,7 @@ func handshakeInserver_and_passToOutClient(iics incomingInserverConnState) {
 		if iics.theFallbackFirstBuffer == nil {
 			//不应该，至少能读到1字节的。
 
-			if ce := utils.CanLogFatal("No FirstBuffer"); ce != nil {
-				ce.Write()
-			}
+			utils.ZapLogger.Fatal("No FirstBuffer")
 
 			log.Fatalf("No FirstBuffer\n")
 		}
diff --git a/netLayer/geoip.go b/netLayer/geoip.go
index c514ead..076156c 100644
--- a/netLayer/geoip.go
+++ b/netLayer/geoip.go
@@ -7,7 +7,9 @@ import (
 	"net"
 	"os"
 
+	"github.com/hahahrfool/v2ray_simple/utils"
 	"github.com/oschwald/maxminddb-golang"
+	"go.uber.org/zap"
 )
 
 var (
@@ -29,7 +31,8 @@ func HasEmbedGeoip() bool {
 func loadMaxmindGeoipBytes(bs []byte) {
 	db, err := maxminddb.FromBytes(bs)
 	if err != nil {
-		log.Fatalln("err when loadMaxmindGeoipBytes", err)
+		log.Println("loadMaxmindGeoipBytes err,", err)
+		return
 	}
 	the_geoipdb = db
 }
@@ -44,7 +47,8 @@ func LoadMaxmindGeoipFile(fn string) {
 	}
 	bs, e := os.ReadFile(fn)
 	if e != nil {
-		log.Fatalln("loadMaxmindGeoipBytes", e)
+		log.Println("LoadMaxmindGeoipFile err", e)
+		return
 	}
 	loadMaxmindGeoipBytes(bs)
 
@@ -69,7 +73,14 @@ func GetIP_ISO_byReader(db *maxminddb.Reader, ip net.IP) string {
 
 	err := db.Lookup(ip, &record)
 	if err != nil {
-		log.Fatal(err) //不应该发生
+
+		if utils.ZapLogger != nil {
+			if ce := utils.CanLogErr("GetIP_ISO_byReader db.Lookup err"); ce != nil {
+				ce.Write(zap.Error(err))
+			}
+		}
+
+		return ""
 	}
 	return record.Country.ISOCode
 }
diff --git a/netLayer/netlayer.go b/netLayer/netlayer.go
index a19b119..0a031ef 100644
--- a/netLayer/netlayer.go
+++ b/netLayer/netlayer.go
@@ -10,6 +10,7 @@ package netLayer
 
 import (
 	"io"
+	"log"
 	"net"
 	"syscall"
 
@@ -31,13 +32,46 @@ func Prepare() {
 }
 
 func HasIpv6Interface() bool {
+
+	if utils.LogLevel == utils.Log_debug {
+		log.Println("HasIpv6Interface called")
+	}
+
 	addrs, err := net.InterfaceAddrs()
 	if err != nil {
-		if ce := utils.CanLogErr("call net.InterfaceAddrs failed"); ce != nil {
-			ce.Write(zap.Error(err))
+		if utils.ZapLogger != nil {
+			if ce := utils.CanLogErr("call net.InterfaceAddrs failed"); ce != nil {
+				ce.Write(zap.Error(err))
+			}
+		} else {
+			log.Println("call net.InterfaceAddrs failed", err)
 		}
+
 		return false
 	}
+
+	if utils.LogLevel == utils.Log_debug {
+
+		log.Println("interfaces", len(addrs), addrs)
+
+		for _, address := range addrs {
+
+			if ipnet, ok := address.(*net.IPNet); ok {
+
+				isipv6 := false
+
+				if !ipnet.IP.IsLoopback() && !ipnet.IP.IsPrivate() && !ipnet.IP.IsLinkLocalUnicast() {
+					if ipnet.IP.To4() == nil {
+						isipv6 = true
+					}
+				}
+				log.Println(ipnet.IP.String(), isipv6)
+
+			}
+
+		}
+	}
+
 	for _, address := range addrs {
 		if ipnet, ok := address.(*net.IPNet); ok && !ipnet.IP.IsLoopback() && !ipnet.IP.IsPrivate() && !ipnet.IP.IsLinkLocalUnicast() {
 			// IsLinkLocalUnicast: something starts with fe80:
diff --git a/proxy/config_standard.go b/proxy/config_standard.go
index 77c4c54..e88493d 100644
--- a/proxy/config_standard.go
+++ b/proxy/config_standard.go
@@ -14,6 +14,7 @@ import (
 	"github.com/hahahrfool/v2ray_simple/netLayer"
 	"github.com/hahahrfool/v2ray_simple/utils"
 	"github.com/yl2chen/cidranger"
+	"go.uber.org/zap"
 )
 
 // CommonConf 是标准配置中 Listen和Dial 都有的部分
@@ -224,7 +225,12 @@ func LoadDnsMachine(conf *DnsConf) *netLayer.DNSMachine {
 		case string:
 			ad, e := netLayer.NewAddrByURL(value)
 			if e != nil {
-				log.Fatalf("LoadDnsMachine loading server err %s\n", e)
+				if utils.ZapLogger != nil {
+					utils.ZapLogger.Fatal("LoadDnsMachine loading server err", zap.Error(e))
+				} else {
+					log.Fatalf("LoadDnsMachine loading server err %s\n", e)
+
+				}
 
 			}
 			dm = netLayer.NewDnsMachine(&ad)
@@ -267,7 +273,12 @@ func LoadDnsMachine(conf *DnsConf) *netLayer.DNSMachine {
 				for _, str := range value {
 					ad, err := netLayer.NewAddrFromAny(str)
 					if err != nil {
-						log.Fatalf("LoadDnsMachine loading host err %s\n", err)
+						if utils.ZapLogger != nil {
+							utils.ZapLogger.Fatal("LoadDnsMachine loading host err", zap.Error(err))
+						} else {
+							log.Fatalf("LoadDnsMachine loading host err %s\n", err)
+
+						}
 					}
 
 					dm.SpecialIPPollicy[thishost] = append(dm.SpecialIPPollicy[thishost], ad.GetHashable().Addr())
diff --git a/proxy/creator.go b/proxy/creator.go
index e7a3741..2caeb34 100644
--- a/proxy/creator.go
+++ b/proxy/creator.go
@@ -7,6 +7,7 @@ import (
 
 	"github.com/hahahrfool/v2ray_simple/netLayer"
 	"github.com/hahahrfool/v2ray_simple/utils"
+	"go.uber.org/zap"
 )
 
 type ClientCreator interface {
@@ -130,7 +131,12 @@ func NewServer(lc *ListenConf) (Server, error) {
 			ser.SetUseTLS()
 			err = prepareTLS_forServer(ser, lc)
 			if err != nil {
-				log.Fatalf("prepareTLS error %s\n", err)
+				if utils.ZapLogger != nil {
+					utils.ZapLogger.Fatal("prepareTLS failed", zap.Error(err))
+				} else {
+					log.Fatalf("prepareTLS error %s\n", err)
+
+				}
 			}
 			return ser, nil
 		}
@@ -149,7 +155,14 @@ func NewServer(lc *ListenConf) (Server, error) {
 			ser.SetUseTLS()
 			err = prepareTLS_forServer(ser, lc)
 			if err != nil {
-				log.Fatalf("prepareTLS error %s\n", err)
+
+				if utils.ZapLogger != nil {
+					utils.ZapLogger.Fatal("prepareTLS failed", zap.Error(err))
+				} else {
+					log.Fatalf("prepareTLS error %s\n", err)
+
+				}
+
 			}
 			return ser, nil
 
@@ -228,7 +241,12 @@ func configCommonURLQueryForServer(ser ProxyCommon, u *url.URL) {
 		fa, err := netLayer.NewAddr(fallbackStr)
 
 		if err != nil {
-			log.Fatalf("invalid fallback %s\n", fallbackStr)
+			if utils.ZapLogger != nil {
+				utils.ZapLogger.Fatal("configCommonURLQueryForServer failed", zap.String("invalid fallback", fallbackStr))
+			} else {
+				log.Fatalf("invalid fallback %s\n", fallbackStr)
+
+			}
 		}
 
 		ser.setFallback(fa)
@@ -313,7 +331,12 @@ func configCommonForServer(ser ProxyCommon, lc *ListenConf) {
 		fa, err := netLayer.NewAddrFromAny(fallbackThing)
 
 		if err != nil {
-			log.Fatalln("invalid fallback", fallbackThing)
+			if utils.ZapLogger != nil {
+				utils.ZapLogger.Fatal("configCommonURLQueryForServer failed", zap.Any("invalid fallback", fallbackThing))
+			} else {
+				log.Fatalln("invalid fallback", fallbackThing)
+
+			}
 		}
 
 		ser.setFallback(fa)
diff --git a/proxy/proxy.go b/proxy/proxy.go
index e32ad4f..8549679 100644
--- a/proxy/proxy.go
+++ b/proxy/proxy.go
@@ -13,7 +13,9 @@ import (
 	"github.com/hahahrfool/v2ray_simple/netLayer"
 	"github.com/hahahrfool/v2ray_simple/quic"
 	"github.com/hahahrfool/v2ray_simple/tlsLayer"
+	"github.com/hahahrfool/v2ray_simple/utils"
 	"github.com/hahahrfool/v2ray_simple/ws"
+	"go.uber.org/zap"
 )
 
 func PrintAllServerNames() {
@@ -557,7 +559,13 @@ func (s *ProxyCommonStruct) GetGRPC_Server() *grpc.Server {
 //for outClient
 func (s *ProxyCommonStruct) initWS_client() {
 	if s.dialConf == nil {
-		log.Fatal("initWS_client failed when no dialConf assigned")
+		const eStr = "initWS_client failed when no dialConf assigned"
+		if utils.ZapLogger != nil {
+			utils.ZapLogger.Fatal(eStr)
+		} else {
+			log.Fatal(eStr)
+
+		}
 	}
 	path := s.dialConf.Path
 	if path == "" { // 至少Path需要为 "/"
@@ -575,7 +583,15 @@ func (s *ProxyCommonStruct) initWS_client() {
 
 	c, e := ws.NewClient(s.dialConf.GetAddrStr(), path)
 	if e != nil {
-		log.Fatal("initWS_client failed", e)
+
+		const eStr2 = "initWS_client failed"
+		if utils.ZapLogger != nil {
+			utils.ZapLogger.Fatal(eStr2, zap.Error(e))
+		} else {
+			log.Fatal(eStr2, e)
+
+		}
+
 	}
 	c.UseEarlyData = useEarlyData
 	s.ws_c = c
@@ -584,7 +600,14 @@ func (s *ProxyCommonStruct) initWS_client() {
 
 func (s *ProxyCommonStruct) initWS_server() {
 	if s.listenConf == nil {
-		log.Fatal("initWS_server failed when no listenConf assigned")
+
+		const eStr3 = "initWS_server failed when no listenConf assigned"
+		if utils.ZapLogger != nil {
+			utils.ZapLogger.Fatal(eStr3)
+		} else {
+			log.Fatal(eStr3)
+		}
+
 	}
 	path := s.listenConf.Path
 	if path == "" { // 至少Path需要为 "/"
@@ -607,12 +630,25 @@ func (s *ProxyCommonStruct) initWS_server() {
 
 func (s *ProxyCommonStruct) initGRPC_server() {
 	if s.listenConf == nil {
-		log.Fatal("initGRPC_server failed when no listenConf assigned")
+
+		const eStr1 = "initGRPC_server failed when no listenConf assigned"
+		if utils.ZapLogger != nil {
+			utils.ZapLogger.Fatal(eStr1)
+		} else {
+			log.Fatal(eStr1)
+		}
+
 	}
 
 	serviceName := s.listenConf.Path
 	if serviceName == "" { //不能为空
-		log.Fatal("initGRPC_server failed, path must be specified")
+
+		const eStr2 = "initGRPC_server failed, path must be specified"
+		if utils.ZapLogger != nil {
+			utils.ZapLogger.Fatal(eStr2)
+		} else {
+			log.Fatal(eStr2)
+		}
 	}
 
 	s.grpc_s = grpc.NewServer(serviceName)
diff --git a/tlsLayer/tlsLayer.go b/tlsLayer/tlsLayer.go
index 669884e..27f7a47 100644
--- a/tlsLayer/tlsLayer.go
+++ b/tlsLayer/tlsLayer.go
@@ -18,6 +18,7 @@ import (
 	"time"
 
 	"github.com/hahahrfool/v2ray_simple/utils"
+	"go.uber.org/zap"
 )
 
 func GenerateRandomeCert_Key() ([]byte, []byte) {
@@ -86,14 +87,23 @@ func GenerateRandomCertKeyFiles(cfn, kfn string) {
 
 	certOut, err := os.Create(cfn)
 	if err != nil {
-		log.Fatalf("failed to open file %s", err)
+		if utils.ZapLogger != nil {
+			utils.ZapLogger.Fatal("failed to open file", zap.Error(err))
+		} else {
+			log.Fatalf("failed to open file %s", err)
+
+		}
 	}
 
 	certOut.Write(cb)
 
 	kOut, err := os.Create(kfn)
 	if err != nil {
-		log.Fatalf("failed to open file %s", err)
+		if utils.ZapLogger != nil {
+			utils.ZapLogger.Fatal("failed to open file", zap.Error(err))
+		} else {
+			log.Fatalf("failed to open file %s", err)
+		}
 	}
 
 	kOut.Write(kb)