Merge pull request #67 from WJQSERVER-STUDIO/dev

2.5.0
update changelog
2025-03-17 14:01:33 +08:00 · 2025-03-17 13:53:37 +08:00 · 2025-03-17 13:48:53 +08:00 · 2025-03-17 13:45:36 +08:00 · 2025-03-16 21:03:28 +08:00 · 2025-03-16 12:28:00 +08:00
19 changed files with 678 additions and 275 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,41 @@
 # 更新日志

+2.5.0 - 2025-03-17
+---
+- ADD: 加入脚本嵌套加速功能
+- CHANGE: 改进Auth模块
+
+25w19a - 2025-03-16
+---
+- PRE-RELEASE: 此版本是v2.5.0的预发布版本,请勿在生产环境中使用;
+- ADD: 加入脚本嵌套加速功能
+- CHANGE: 改进Auth模块
+- CHANGE: 将handler模块化改进
+
+2.4.2 - 2025-03-14
+---
+- CHANGE: 在GitClone Cache模式下, 相关请求会使用独立httpc client
+- CHANGE: 为GitClone Cache的独立httpc client增加ForceH2C选项
+- FIX: 修正GitClone Cache模式下的Url生成问题
+
+25w18a - 2025-03-14
+---
+- PRE-RELEASE: 此版本是v2.4.2的预发布版本,请勿在生产环境中使用;
+- CHANGE: 在GitClone Cache模式下, 相关请求会使用独立httpc client
+- CHANGE: 为GitClone Cache的独立httpc client增加ForceH2C选项
+- FIX: 修正GitClone Cache模式下的Url生成问题
+
+2.4.1 - 2025-03-13
+---
+- CHANGE: 重构路由匹配
+- CHANGE: 更新相关依赖以修复错误
+
+25w17a - 2025-03-13
+---
+- PRE-RELEASE: 此版本是v2.4.1的预发布版本,请勿在生产环境中使用;
+- CHANGE: 重构路由匹配
+- CHANGE: 更新相关依赖以修复错误
+
 2.4.0 - 2025-03-12
 ---
 - ADD: 支持通过[Smart-Git](https://github.com/WJQSERVER-STUDIO/smart-git)实现Git Clone缓存
--- a/2
+++ b/2
@@ -1 +1 @@
-25w16d
+25w19a
--- a/README.md
+++ b/README.md
@@ -20,6 +20,7 @@
 - 使用[Gin](https://github.com/gin-gonic/gin)作为Web框架
 - 使用[Touka-HTTPC](https://github.com/satomitouka/touka-httpc)作为HTTP客户端
 - 支持Git clone,raw,realeases等文件拉取
+- 支持Git Clone缓存(配合组件)
 - 支持Docker部署
 - 支持速率限制
 - 支持用户鉴权
@@ -31,8 +32,9 @@
 **本项目是[WJQSERVER-STUDIO/ghproxy-go](https://github.com/WJQSERVER-STUDIO/ghproxy-go)的重构版本,实现了原项目原定功能的同时,进一步优化了性能**
 关于此项目的详细开发过程,请参看Commit记录与[CHANGELOG.md](https://github.com/WJQSERVER-STUDIO/ghproxy/blob/main/CHANGELOG.md)

- V2.0.0 对`proxy`核心模块进行了重构,大幅优化内存占用
- V1.0.0 迁移至本仓库,并再次重构内容实现
+- v2.4.1 对路径匹配进行优化
+- v2.0.0 对`proxy`核心模块进行了重构,大幅优化内存占用
+- v1.0.0 迁移至本仓库,并再次重构内容实现
 - v0.2.0 重构项目实现

 ### LICENSE
@@ -48,9 +50,11 @@
 ```
 # 下载文件
 https://ghproxy.1888866.xyz/raw.githubusercontent.com/WJQSERVER-STUDIO/tools-stable/main/tools-stable-ghproxy.sh
+https://ghproxy.1888866.xyz/https://raw.githubusercontent.com/WJQSERVER-STUDIO/tools-stable/main/tools-stable-ghproxy.sh

 # 克隆仓库
 git clone https://ghproxy.1888866.xyz/github.com/WJQSERVER-STUDIO/ghproxy.git
+git clone https://ghproxy.1888866.xyz/https://github.com/WJQSERVER-STUDIO/ghproxy.git
 ```

 ## 部署说明
@@ -105,6 +109,10 @@ maxConnsPerHost = 0 # only for advanced mode 仅用于高级模式
 [gitclone]
 mode = "bypass" # bypass / cache 运行模式, cache模式依赖smart-git
 smartGitAddr = "http://127.0.0.1:8080" # smart-git组件地址
+ForceH2C = false # 强制使用H2C连接
+
+[shell]
+editor = false # 脚本嵌套加速

 [pages]
 mode = "internal" # "internal" or "external" 内部/外部 前端 默认内部
@@ -120,6 +128,7 @@ level = "info"  # 日志级别 dump, debug, info, warn, error, none
 authMethod = "parameters" # 鉴权方式,支持parameters,header
 authToken = "token"  # 用户鉴权Token
 enabled = false  # 是否开启用户鉴权
+ForceAllowApi = false # 在不开启Header鉴权的情况下允许api代理

 [blacklist]
 blacklistFile = "/data/ghproxy/config/blacklist.json"  # 黑名单文件路径
@@ -170,19 +179,16 @@ url = "socks5://127.0.0.1:1080" # "http://127.0.0.1:7890" 支持Socks5/HTTP(S)
  }
 ```

-### Caddy反代配置
-
-```Caddyfile
-example.com {
-    reverse_proxy * 127.0.0.1:7210
-}
-```
-
 ### 前端页面

+#### Bootstrap主题
 ![ghproxy-demo.png](https://webp.wjqserver.com/ghproxy/1.8.1-light.png)
 ![ghproxy-demo-dark.png](https://webp.wjqserver.com/ghproxy/1.8.1-dark.png)

+#### Nebula主题
+![nebula-dark-v2.3.0.png](https://webp.wjqserver.com/ghproxy/nebula-dark.png)
+![nebula-light-v2.3.0.png](https://webp.wjqserver.com/ghproxy/nebula-light.png)
+
 ## 赞助

 如果您觉得本项目对您有帮助,欢迎赞助支持,您的赞助将用于Demo服务器开支及开发者时间成本支出,感谢您的支持!
@@ -191,6 +197,8 @@ example.com {

 爱发电: https://afdian.com/a/wjqserver

+USDT(TRC20): `TNfSYG6F2vkiibd6J6mhhHNWDgWgNdF5hN`
+
 ### 捐赠列表

 虚位以待...
--- a/2
+++ b/2
@@ -1 +1 @@
-2.4.0
+2.5.0
--- a/auth/auth-header.go
+++ b/auth/auth-header.go
@@ -7,23 +7,21 @@ import (
 	"github.com/gin-gonic/gin"
 )

-func AuthHeaderHandler(c *gin.Context, cfg *config.Config) (isValid bool, err string) {
+func AuthHeaderHandler(c *gin.Context, cfg *config.Config) (isValid bool, err error) {
 	if !cfg.Auth.Enabled {
-		return true, ""
+		return true, nil
 	}
 	// 获取"GH-Auth"的值
 	authToken := c.GetHeader("GH-Auth")
 	logDebug("%s %s %s %s %s AUTH_TOKEN: %s", c.Request.Method, c.Request.Host, c.Request.URL.Path, c.Request.Proto, c.Request.RemoteAddr, authToken)
 	if authToken == "" {
-		err := "Auth Header == nil"
-		return false, err
+		return false, fmt.Errorf("Auth token not found")
 	}

 	isValid = authToken == cfg.Auth.AuthToken
 	if !isValid {
-		err := fmt.Sprintf("Auth token incorrect: %s", authToken)
-		return false, err
+		return false, fmt.Errorf("Auth token incorrect")
 	}

-	return isValid, ""
+	return isValid, nil
 }
--- a/auth/auth-parameters.go
+++ b/auth/auth-parameters.go
@@ -7,24 +7,22 @@ import (
 	"github.com/gin-gonic/gin"
 )

-func AuthParametersHandler(c *gin.Context, cfg *config.Config) (isValid bool, err string) {
+func AuthParametersHandler(c *gin.Context, cfg *config.Config) (isValid bool, err error) {
 	if !cfg.Auth.Enabled {
-		return true, ""
+		return true, nil
 	}

 	authToken := c.Query("auth_token")
 	logDebug("%s %s %s %s %s AUTH_TOKEN: %s", c.ClientIP(), c.Request.Method, c.Request.URL.Path, c.Request.UserAgent(), c.Request.Proto, authToken)

 	if authToken == "" {
-		err := "Auth token == nil"
-		return false, err
+		return false, fmt.Errorf("Auth token not found")
 	}

 	isValid = authToken == cfg.Auth.AuthToken
 	if !isValid {
-		err := fmt.Sprintf("Auth token incorrect: %s", authToken)
-		return false, err
+		return false, fmt.Errorf("Auth token invalid")
 	}

-	return isValid, ""
+	return isValid, nil
 }
--- a/auth/auth.go
+++ b/auth/auth.go
@@ -1,6 +1,7 @@
 package auth

 import (
+	"fmt"
 	"ghproxy/config"

 	"github.com/WJQSERVER-STUDIO/go-utils/logger"
@@ -34,7 +35,7 @@ func Init(cfg *config.Config) {
 	logDebug("Auth Init")
 }

-func AuthHandler(c *gin.Context, cfg *config.Config) (isValid bool, err string) {
+func AuthHandler(c *gin.Context, cfg *config.Config) (isValid bool, err error) {
 	if cfg.Auth.AuthMethod == "parameters" {
 		isValid, err = AuthParametersHandler(c, cfg)
 		return isValid, err
@@ -43,9 +44,9 @@ func AuthHandler(c *gin.Context, cfg *config.Config) (isValid bool, err string)
 		return isValid, err
 	} else if cfg.Auth.AuthMethod == "" {
 		logError("Auth method not set")
-		return true, ""
+		return true, nil
 	} else {
 		logError("Auth method not supported")
-		return false, "Auth method not supported"
+		return false, fmt.Errorf(fmt.Sprintf("Auth method %s not supported", cfg.Auth.AuthMethod))
 	}
 }
--- a/config/config.go
+++ b/config/config.go
@@ -8,6 +8,7 @@ type Config struct {
 	Server    ServerConfig
 	Httpc     HttpcConfig
 	GitClone  GitCloneConfig
+	Shell     ShellConfig
 	Pages     PagesConfig
 	Log       LogConfig
 	Auth      AuthConfig
@@ -54,10 +55,20 @@ type HttpcConfig struct {
 [gitclone]
 mode = "bypass" # bypass / cache
 smartGitAddr = ":8080"
+ForceH2C = true
 */
 type GitCloneConfig struct {
 	Mode         string `toml:"mode"`
 	SmartGitAddr string `toml:"smartGitAddr"`
+	ForceH2C     bool   `toml:"ForceH2C"`
+}
+
+/*
+[shell]
+editor = true
+*/
+type ShellConfig struct {
+	Editor bool `toml:"editor"`
 }

 /*
@@ -80,11 +91,20 @@ type LogConfig struct {
 	Level       string `toml:"level"`
 }

+/*
+[auth]
+authMethod = "parameters" # "header" or "parameters"
+authToken = "token"
+enabled = false
+passThrough = false
+ForceAllowApi = true
+*/
 type AuthConfig struct {
-	Enabled     bool   `toml:"enabled"`
-	AuthMethod  string `toml:"authMethod"`
-	AuthToken   string `toml:"authToken"`
-	PassThrough bool   `toml:"passThrough"`
+	Enabled       bool   `toml:"enabled"`
+	AuthMethod    string `toml:"authMethod"`
+	AuthToken     string `toml:"authToken"`
+	PassThrough   bool   `toml:"passThrough"`
+	ForceAllowApi bool   `toml:"ForceAllowApi"`
 }

 type BlacklistConfig struct {
--- a/config/config.toml
+++ b/config/config.toml
@@ -15,6 +15,10 @@ maxConnsPerHost = 0 # only for advanced mode
 [gitclone]
 mode = "bypass" # bypass / cache
 smartGitAddr = "http://127.0.0.1:8080"
+ForceH2C = false
+
+[shell]
+editor = false

 [pages]
 mode = "internal" # "internal" or "external"
@@ -31,6 +35,7 @@ authMethod = "parameters" # "header" or "parameters"
 authToken = "token"
 enabled = false
 passThrough = false
+ForceAllowApi = false

 [blacklist]
 blacklistFile = "/data/ghproxy/config/blacklist.json"
--- a/deploy/config.toml
+++ b/deploy/config.toml
@@ -15,6 +15,10 @@ maxConnsPerHost = 0 # only for advanced mode
 [gitclone]
 mode = "bypass" # bypass / cache
 smartGitAddr = "http://127.0.0.1:8080"
+ForceH2C = false
+
+[shell]
+editor = false

 [pages]
 mode = "internal" # "internal" or "external"
@@ -31,6 +35,7 @@ authMethod = "parameters" # "header" or "parameters"
 authToken = "token"
 enabled = false
 passThrough = false
+ForceAllowApi = false

 [blacklist]
 blacklistFile = "/usr/local/ghproxy/config/blacklist.json"
--- a/go.mod
+++ b/go.mod
@@ -4,12 +4,12 @@ go 1.24.1

 require (
 	github.com/BurntSushi/toml v1.4.0
-	github.com/WJQSERVER-STUDIO/go-utils/copyb v0.0.3
+	github.com/WJQSERVER-STUDIO/go-utils/copyb v0.0.4
 	github.com/WJQSERVER-STUDIO/go-utils/logger v1.5.0
 	github.com/gin-gonic/gin v1.10.0
 	github.com/go-git/go-git/v5 v5.14.0
 	github.com/pierrec/lz4 v2.6.1+incompatible
-	github.com/satomitouka/touka-httpc v0.3.1
+	github.com/satomitouka/touka-httpc v0.3.3
 	golang.org/x/net v0.37.0
 	golang.org/x/time v0.11.0
 )
--- a/go.sum
+++ b/go.sum
@@ -7,8 +7,8 @@ github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERo
 github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU=
 github.com/ProtonMail/go-crypto v1.1.6 h1:ZcV+Ropw6Qn0AX9brlQLAUXfqLBc7Bl+f/DmNxpLfdw=
 github.com/ProtonMail/go-crypto v1.1.6/go.mod h1:rA3QumHc/FZ8pAHreoekgiAbzpNsfQAosU5td4SnOrE=
-github.com/WJQSERVER-STUDIO/go-utils/copyb v0.0.3 h1:S1tFRwMZkrAswOJxF1X2yTvL6Tz+6IeOBuqmycDnydw=
-github.com/WJQSERVER-STUDIO/go-utils/copyb v0.0.3/go.mod h1:FZ6XE+4TKy4MOfX1xWKe6Rwsg0ucYFCdNh1KLvyKTfc=
+github.com/WJQSERVER-STUDIO/go-utils/copyb v0.0.4 h1:JLtFd00AdFg/TP+dtvIzLkdHwKUGPOAijN1sMtEYoFg=
+github.com/WJQSERVER-STUDIO/go-utils/copyb v0.0.4/go.mod h1:FZ6XE+4TKy4MOfX1xWKe6Rwsg0ucYFCdNh1KLvyKTfc=
 github.com/WJQSERVER-STUDIO/go-utils/log v0.0.1 h1:gJEQspQPB527Vp2FPcdOrynQEj3YYtrg1ixVSB/JvZM=
 github.com/WJQSERVER-STUDIO/go-utils/log v0.0.1/go.mod h1:j9Q+xnwpOfve7/uJnZ2izRQw6NNoXjvJHz7vUQAaLZE=
 github.com/WJQSERVER-STUDIO/go-utils/logger v1.5.0 h1:Uk4N7Sh4OPth3am3xVv17JlAm7tsna97ZLQRpQj7r5c=
@@ -113,8 +113,8 @@ github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZN
 github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
 github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
 github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
-github.com/satomitouka/touka-httpc v0.3.1 h1:UnKFHgK0diEZeSxRW5Q7ibCO2EyAyK1lgXvGEbUmz6I=
-github.com/satomitouka/touka-httpc v0.3.1/go.mod h1:b5b+/0x4/uodWQSYCerbQyH8GrpNg92q+GcCBPhFjhI=
+github.com/satomitouka/touka-httpc v0.3.3 h1:Th0uJ5do3oqqZgdUDtqD1SH11x8TcJmrwHMJQlEIKCg=
+github.com/satomitouka/touka-httpc v0.3.3/go.mod h1:sNXyW5XBufkwB9ZJ+PIlgN/6xiJ7aZV1fWGrXR0u3bA=
 github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 h1:n661drycOFuPLCN3Uc8sB6B/s6Z4t2xvBgU1htSHuq8=
 github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3/go.mod h1:A0bzQcvG0E7Rwjx0REVgAGH58e96+X0MeOfepqsbeW4=
 github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=
--- a/proxy/chunkreq.go
+++ b/proxy/chunkreq.go
@@ -12,7 +12,7 @@ import (
 	"github.com/gin-gonic/gin"
 )

-func ChunkedProxyRequest(c *gin.Context, u string, cfg *config.Config, mode string, runMode string) {
+func ChunkedProxyRequest(c *gin.Context, u string, cfg *config.Config, matcher string) {
 	method := c.Request.Method

 	// 发送HEAD请求, 预获取Content-Length
@@ -23,6 +23,7 @@ func ChunkedProxyRequest(c *gin.Context, u string, cfg *config.Config, mode stri
 	}
 	setRequestHeaders(c, headReq)
 	removeWSHeader(headReq) // 删除Conection Upgrade头, 避免与HTTP/2冲突(检查是否存在Upgrade头)
+	reWriteEncodeHeader(headReq)
 	AuthPassThrough(c, cfg, headReq)

 	headResp, err := client.Do(headReq)
@@ -64,6 +65,7 @@ func ChunkedProxyRequest(c *gin.Context, u string, cfg *config.Config, mode stri
 	}
 	setRequestHeaders(c, req)
 	removeWSHeader(req) // 删除Conection Upgrade头, 避免与HTTP/2冲突(检查是否存在Upgrade头)
+	reWriteEncodeHeader(req)
 	AuthPassThrough(c, cfg, req)

 	resp, err := client.Do(req)
@@ -106,6 +108,9 @@ func ChunkedProxyRequest(c *gin.Context, u string, cfg *config.Config, mode stri
 		resp.Header.Del(header)
 	}

+	//c.Header("Accept-Encoding", "gzip")
+	//c.Header("Content-Encoding", "gzip")
+
 	/*
 		if cfg.CORS.Enabled {
 			c.Header("Access-Control-Allow-Origin", "*")
@@ -127,12 +132,30 @@ func ChunkedProxyRequest(c *gin.Context, u string, cfg *config.Config, mode stri

 	c.Status(resp.StatusCode)

-	//_, err = io.CopyBuffer(c.Writer, resp.Body, nil)
-	_, err = copyb.CopyBuffer(c.Writer, resp.Body, nil)
-	if err != nil {
-		logError("%s %s %s %s %s Failed to copy response body: %v", c.ClientIP(), method, u, c.Request.Header.Get("User-Agent"), c.Request.Proto, err)
-		return
+	if MatcherShell(u) && matchString(matcher, matchedMatchers) && cfg.Shell.Editor {
+		// 判断body是不是gzip
+		var compress string
+		if resp.Header.Get("Content-Encoding") == "gzip" {
+			compress = "gzip"
+		}
+
+		logInfo("Is Shell: %s %s %s %s %s", c.ClientIP(), method, u, c.Request.Header.Get("User-Agent"), c.Request.Proto)
+		c.Header("Content-Length", "")
+		_, err = processLinks(resp.Body, c.Writer, compress, c.Request.Host, cfg)
+		if err != nil {
+			logError("%s %s %s %s %s Failed to copy response body: %v", c.ClientIP(), method, u, c.Request.Header.Get("User-Agent"), c.Request.Proto, err)
+			return
+		} else {
+			c.Writer.Flush() // 确保刷入
+		}
 	} else {
-		c.Writer.Flush() // 确保刷入
+		//_, err = io.CopyBuffer(c.Writer, resp.Body, nil)
+		_, err = copyb.CopyBuffer(c.Writer, resp.Body, nil)
+		if err != nil {
+			logError("%s %s %s %s %s Failed to copy response body: %v", c.ClientIP(), method, u, c.Request.Header.Get("User-Agent"), c.Request.Proto, err)
+			return
+		} else {
+			c.Writer.Flush() // 确保刷入
+		}
 	}
 }
--- a/proxy/gitreq.go
+++ b/proxy/gitreq.go
@@ -18,17 +18,23 @@ func GitReq(c *gin.Context, u string, cfg *config.Config, mode string, runMode s
 	method := c.Request.Method
 	logInfo("%s %s %s %s %s", c.ClientIP(), method, u, c.Request.Header.Get("User-Agent"), c.Request.Proto)

-	logInfo("U:%s", u)
+	logDump("Url Before FMT:%s", u)
 	if cfg.GitClone.Mode == "cache" {
-		userPath, repoPath, remainingPath, err := extractParts(u)
+		userPath, repoPath, remainingPath, queryParams, err := extractParts(u)
 		if err != nil {
 			HandleError(c, fmt.Sprintf("Failed to extract parts from URL: %v", err))
 			return
 		}
 		// 构建新url
-		u = cfg.GitClone.SmartGitAddr + userPath + repoPath + remainingPath
+		u = cfg.GitClone.SmartGitAddr + userPath + repoPath + remainingPath + "?" + queryParams.Encode()
+		logDump("New Url After FMT:%s", u)
 	}

+	var (
+		resp *http.Response
+		err  error
+	)
+
 	body, err := readRequestBody(c)
 	if err != nil {
 		HandleError(c, err.Error())
@@ -37,18 +43,35 @@ func GitReq(c *gin.Context, u string, cfg *config.Config, mode string, runMode s

 	bodyReader := bytes.NewBuffer(body)
 	// 创建请求
-	req, err := client.NewRequest(method, u, bodyReader)
-	if err != nil {
-		HandleError(c, fmt.Sprintf("Failed to create request: %v", err))
-		return
-	}
-	setRequestHeaders(c, req)
-	AuthPassThrough(c, cfg, req)

-	resp, err := client.Do(req)
-	if err != nil {
-		HandleError(c, fmt.Sprintf("Failed to send request: %v", err))
-		return
+	if cfg.GitClone.Mode == "cache" {
+		req, err := gitclient.NewRequest(method, u, bodyReader)
+		if err != nil {
+			HandleError(c, fmt.Sprintf("Failed to create request: %v", err))
+			return
+		}
+		setRequestHeaders(c, req)
+		AuthPassThrough(c, cfg, req)
+
+		resp, err = gitclient.Do(req)
+		if err != nil {
+			HandleError(c, fmt.Sprintf("Failed to send request: %v", err))
+			return
+		}
+	} else {
+		req, err := client.NewRequest(method, u, bodyReader)
+		if err != nil {
+			HandleError(c, fmt.Sprintf("Failed to create request: %v", err))
+			return
+		}
+		setRequestHeaders(c, req)
+		AuthPassThrough(c, cfg, req)
+
+		resp, err = client.Do(req)
+		if err != nil {
+			HandleError(c, fmt.Sprintf("Failed to send request: %v", err))
+			return
+		}
 	}
 	//defer resp.Body.Close()
 	defer func(Body io.ReadCloser) {
@@ -124,11 +147,11 @@ func GitReq(c *gin.Context, u string, cfg *config.Config, mode string, runMode s
 }

 // extractParts 从给定的 URL 中提取所需的部分
-func extractParts(rawURL string) (string, string, string, error) {
+func extractParts(rawURL string) (string, string, string, url.Values, error) {
 	// 解析 URL
 	parsedURL, err := url.Parse(rawURL)
 	if err != nil {
-		return "", "", "", err
+		return "", "", "", nil, err
 	}

 	// 获取路径部分并分割
@@ -136,7 +159,7 @@ func extractParts(rawURL string) (string, string, string, error) {

 	// 提取所需的部分
 	if len(pathParts) < 3 {
-		return "", "", "", fmt.Errorf("URL path is too short")
+		return "", "", "", nil, fmt.Errorf("URL path is too short")
 	}

 	// 提取 /WJQSERVER-STUDIO 和 /go-utils.git
@@ -149,5 +172,8 @@ func extractParts(rawURL string) (string, string, string, error) {
 		remainingPath = "/" + remainingPath
 	}

-	return repoOwner, repoName, remainingPath, nil
+	// 查询参数
+	queryParams := parsedURL.Query()
+
+	return repoOwner, repoName, remainingPath, queryParams, nil
 }
--- a/proxy/handler.go
+++ b/proxy/handler.go
@@ -1,6 +1,7 @@
 package proxy

 import (
+	"errors"
 	"fmt"
 	"ghproxy/auth"
 	"ghproxy/config"
@@ -12,6 +13,8 @@ import (
 	"github.com/gin-gonic/gin"
 )

+var re = regexp.MustCompile(`^(http:|https:)?/?/?(.*)`) // 匹配http://或https://开头的路径
+/*
 var exps = []*regexp.Regexp{
 	regexp.MustCompile(`^(?:https?://)?github\.com/([^/]+)/([^/]+)/(?:releases|archive)/.*`),     // 匹配 GitHub Releases 或 Archive 链接
 	regexp.MustCompile(`^(?:https?://)?github\.com/([^/]+)/([^/]+)/(?:blob|raw)/.*`),             // 匹配 GitHub Blob 或 Raw 链接
@@ -20,151 +23,144 @@ var exps = []*regexp.Regexp{
 	regexp.MustCompile(`^(?:https?://)?gist\.github(?:usercontent|)\.com/([^/]+)/.+?/.+`),        // 匹配 gist.githubusercontent.com 链接
 	regexp.MustCompile(`^(?:https?://)?api\.github\.com/repos/([^/]+)/([^/]+)/.*`),               // 匹配 api.github.com/repos 链接 (GitHub API)
 }
+*/

-// NoRouteHandler 是 Gin 框架的 NoRoute 处理器函数，用于处理所有未匹配到预定义路由的请求
-// 此函数实现了请求的频率限制、URL 路径解析、白名单/黑名单检查、URL 类型匹配和最终的代理请求处理
 func NoRouteHandler(cfg *config.Config, limiter *rate.RateLimiter, iplimiter *rate.IPRateLimiter, runMode string) gin.HandlerFunc {
 	return func(c *gin.Context) {

-		// **频率限制处理**
-		if cfg.RateLimit.Enabled { // 检查是否启用频率限制
+		// 限制访问频率
+		if cfg.RateLimit.Enabled {

-			var allowed bool // 用于标记是否允许请求
+			var allowed bool

-			switch cfg.RateLimit.RateMethod { // 根据配置的频率限制方法选择
-			case "ip": // 基于 IP 地址的频率限制
-				allowed = iplimiter.Allow(c.ClientIP()) // 使用 IPRateLimiter 检查客户端 IP 是否允许请求
-			case "total": // 基于总请求量的频率限制
-				allowed = limiter.Allow() // 使用 RateLimiter 检查总请求量是否允许请求
-			default: // 无效的频率限制方法
-				logWarning("Invalid RateLimit Method") // 记录警告日志
-				return                                 // 中断请求处理
+			switch cfg.RateLimit.RateMethod {
+			case "ip":
+				allowed = iplimiter.Allow(c.ClientIP())
+			case "total":
+				allowed = limiter.Allow()
+			default:
+				logWarning("Invalid RateLimit Method")
+				return
 			}

-			if !allowed { // 如果请求被频率限制阻止
-				c.JSON(http.StatusTooManyRequests, gin.H{"error": "Too Many Requests"})                                                                                           // 返回 429 状态码和错误信息
-				logWarning("%s %s %s %s %s 429-TooManyRequests", c.ClientIP(), c.Request.Method, c.Request.URL.RequestURI(), c.Request.Header.Get("User-Agent"), c.Request.Proto) // 记录警告日志
-				return                                                                                                                                                            // 中断请求处理
+			if !allowed {
+				c.JSON(http.StatusTooManyRequests, gin.H{"error": "Too Many Requests"})
+				logWarning("%s %s %s %s %s 429-TooManyRequests", c.ClientIP(), c.Request.Method, c.Request.URL.RequestURI(), c.Request.Header.Get("User-Agent"), c.Request.Proto)
+				return
 			}
 		}

-		rawPath := strings.TrimPrefix(c.Request.URL.RequestURI(), "/") // 去掉 URL 前缀的斜杠 '/', 获取原始路径 (例如: /https://github.com/user/repo -> https://github.com/user/repo)
-		re := regexp.MustCompile(`^(http:|https:)?/?/?(.*)`)           // 定义正则表达式，匹配以 http:// 或 https:// 开头的路径，并捕获协议和剩余部分
-		matches := re.FindStringSubmatch(rawPath)                      // 使用正则表达式匹配原始路径
+		//rawPath := strings.TrimPrefix(c.Request.URL.Path, "/") // 去掉前缀/
+		rawPath := strings.TrimPrefix(c.Request.URL.RequestURI(), "/") // 去掉前缀/
+		matches := re.FindStringSubmatch(rawPath)                      // 匹配路径
+		logInfo("Matches: %v", matches)

-		// **路径匹配错误处理**
-		if len(matches) < 3 { // 如果匹配结果少于 3 个子串 (完整匹配 + 协议 + 剩余部分)，则说明 URL 格式无效
-			errMsg := fmt.Sprintf("%s %s %s %s %s Invalid URL", c.ClientIP(), c.Request.Method, rawPath, c.Request.Header.Get("User-Agent"), c.Request.Proto) // 构建错误日志信息
-			logWarning(errMsg)                                                                                                                                // 记录警告日志
-			c.String(http.StatusForbidden, "Invalid URL Format. Path: %s", rawPath)                                                                           // 返回 403 状态码和错误信息，提示 URL 格式无效
-			return                                                                                                                                            // 中断请求处理
-		}
-
-		// **构建完整的 URL**
-		rawPath = "https://" + matches[2] // 从匹配结果中提取 URL 的剩余部分，并添加 https:// 协议头，构建完整的 URL
-
-		username, repo := MatchUserRepo(rawPath, cfg, c, matches) // 调用 MatchUserRepo 函数，从 URL 中提取用户名和仓库名
-
-		logInfo("%s %s %s %s %s Matched-Username: %s, Matched-Repo: %s", c.ClientIP(), c.Request.Method, rawPath, c.Request.Header.Get("User-Agent"), c.Request.Proto, username, repo) // 记录 info 日志，包含匹配到的用户名和仓库名
-		// dump log 记录详细信息 c.ClientIP(), c.Request.Method, rawPath, c.Request.Header.Get("User-Agent"), c.Request.Proto, full Header
-		LogDump("%s %s %s %s %s %s", c.ClientIP(), c.Request.Method, rawPath, c.Request.Header.Get("User-Agent"), c.Request.Proto, c.Request.Header) // 记录 dump 日志，包含更详细的请求头信息
-		repouser := fmt.Sprintf("%s/%s", username, repo)                                                                                             // 构建 "用户名/仓库名" 格式的字符串
-
-		// **白名单检查**
-		if cfg.Whitelist.Enabled { // 检查是否启用白名单
-			whitelist := auth.CheckWhitelist(username, repo) // 调用 CheckWhitelist 函数检查当前仓库是否在白名单中
-			if !whitelist {                                  // 如果仓库不在白名单中
-				logErrMsg := fmt.Sprintf("%s %s %s %s %s Whitelist Blocked repo: %s", c.ClientIP(), c.Request.Method, rawPath, c.Request.Header.Get("User-Agent"), c.Request.Proto, repouser) // 构建错误日志信息
-				errMsg := fmt.Sprintf("Whitelist Blocked repo: %s", repouser)                                                                                                                 // 构建返回给客户端的错误信息
-				c.JSON(http.StatusForbidden, gin.H{"error": errMsg})                                                                                                                          // 返回 403 状态码和 JSON 错误信息
-				logWarning(logErrMsg)                                                                                                                                                         // 记录警告日志
-				return                                                                                                                                                                        // 中断请求处理
-			}
-		}
-
-		// **黑名单检查**
-		if cfg.Blacklist.Enabled { // 检查是否启用黑名单
-			blacklist := auth.CheckBlacklist(username, repo) // 调用 CheckBlacklist 函数检查当前仓库是否在黑名单中
-			if blacklist {                                   // 如果仓库在黑名单中
-				logErrMsg := fmt.Sprintf("%s %s %s %s %s Blacklist Blocked repo: %s", c.ClientIP(), c.Request.Method, rawPath, c.Request.Header.Get("User-Agent"), c.Request.Proto, repouser) // 构建错误日志信息
-				errMsg := fmt.Sprintf("Blacklist Blocked repo: %s", repouser)                                                                                                                 // 构建返回给客户端的错误信息
-				c.JSON(http.StatusForbidden, gin.H{"error": errMsg})                                                                                                                          // 返回 403 状态码和 JSON 错误信息
-				logWarning(logErrMsg)                                                                                                                                                         // 记录警告日志
-				return                                                                                                                                                                        // 中断请求处理
-			}
-		}
-
-		var matchedIndex = -1 // 用于存储匹配到的正则表达式索引，初始化为 -1 表示未匹配
-
-		// **优化的 URL 匹配逻辑：基于关键词分类匹配**
-		switch {
-		case strings.Contains(rawPath, "/releases/") || strings.Contains(rawPath, "/archive/"): // 检查 URL 中是否包含 "/releases/" 或 "/archive/" 关键词
-			matchedIndex = 0 // 如果包含，则匹配 exps[0] (GitHub Releases/Archive 链接)
-		case strings.Contains(rawPath, "/blob/") || strings.Contains(rawPath, "/raw/"): // 检查 URL 中是否包含 "/blob/" 或 "/raw/" 关键词
-			matchedIndex = 1 // 如果包含，则匹配 exps[1] (GitHub Blob/Raw 链接)
-		case strings.Contains(rawPath, "/info/") || strings.Contains(rawPath, "/git-"): // 检查 URL 中是否包含 "/info/" 或 "/git-" 关键词
-			matchedIndex = 2 // 如果包含，则匹配 exps[2] (GitHub Info/Git 相关链接)
-		case strings.Contains(rawPath, "raw.githubusercontent.com"): // 检查 URL 中是否包含 "raw.githubusercontent.com" 域名
-			matchedIndex = 3 // 如果包含，则匹配 exps[3] (raw.githubusercontent.com 链接)
-		case strings.Contains(rawPath, "gist.githubusercontent.com"): // 检查 URL 中是否包含 "gist.githubusercontent.com" 域名
-			matchedIndex = 4 // 如果包含，则匹配 exps[4] (gist.githubusercontent.com 链接)
-		case strings.Contains(rawPath, "api.github.com/repos/"): // 检查 URL 中是否包含 "api.github.com/repos/" 路径前缀
-			matchedIndex = 5 // 如果包含，则匹配 exps[5] (api.github.com/repos 链接)
-		}
-
-		if matchedIndex == -1 { // 如果没有任何关键词匹配到，则说明 URL 类型无法识别
-			c.AbortWithStatus(http.StatusNotFound)                                                                                                 // 返回 404 状态码
-			logWarning("%s %s %s %s %s 404-NOMATCH", c.ClientIP(), c.Request.Method, rawPath, c.Request.Header.Get("User-Agent"), c.Request.Proto) // 记录警告日志
-			return                                                                                                                                 // 中断请求处理
-		}
-
-		// **使用分类匹配到的正则表达式进行精确匹配**
-		exp := exps[matchedIndex]
-		matches = exp.FindStringSubmatch(rawPath)
-		if len(matches) == 0 {
-			// 如果精确匹配失败 (例如，关键词匹配到 releases，但实际 URL 格式不符合 releases 的正则)
-			c.AbortWithStatus(http.StatusNotFound)
-			logWarning("%s %s %s %s %s 404-NOMATCH-ExpSpecific", c.ClientIP(), c.Request.Method, rawPath, c.Request.Header.Get("User-Agent"), c.Request.Proto) // 记录警告日志，表明是特定正则匹配失败
+		// 匹配路径错误处理
+		if len(matches) < 3 {
+			errMsg := fmt.Sprintf("%s %s %s %s %s Invalid URL", c.ClientIP(), c.Request.Method, rawPath, c.Request.Header.Get("User-Agent"), c.Request.Proto)
+			logWarning(errMsg)
+			c.String(http.StatusForbidden, "Invalid URL Format. Path: %s", rawPath)
 			return
 		}

-		// **HeaderAuth 鉴权检查 (仅针对 api.github.com/repos 链接)**
-		if matchedIndex == 5 { // 如果匹配的是 api.github.com/repos 链接 (对应 exps[5])
-			if cfg.Auth.AuthMethod != "header" || !cfg.Auth.Enabled { // 检查是否启用了 HeaderAuth 并且 AuthMethod 配置为 "header"
-				c.JSON(http.StatusForbidden, gin.H{"error": "HeaderAuth is not enabled."})                                                                                            // 返回 403 状态码和错误信息，提示 HeaderAuth 未启用
-				logError("%s %s %s %s %s HeaderAuth-Error: HeaderAuth is not enabled.", c.ClientIP(), c.Request.Method, rawPath, c.Request.Header.Get("User-Agent"), c.Request.Proto) // 记录错误日志
-				return                                                                                                                                                                // 中断请求处理
+		// 制作url
+		rawPath = "https://" + matches[2]
+
+		user, repo, matcher, err := Matcher(rawPath, cfg)
+		if err != nil {
+			if errors.Is(err, ErrInvalidURL) {
+				c.String(http.StatusForbidden, "Invalid URL Format. Path: %s", rawPath)
+				logWarning(err.Error())
+				return
+			}
+			if errors.Is(err, ErrAuthHeaderUnavailable) {
+				c.String(http.StatusForbidden, "AuthHeader Unavailable")
+				logWarning(err.Error())
+				return
+			}
+		}
+		username := user
+
+		logInfo("%s %s %s %s %s Matched-Username: %s, Matched-Repo: %s", c.ClientIP(), c.Request.Method, rawPath, c.Request.Header.Get("User-Agent"), c.Request.Proto, username, repo)
+		// dump log 记录详细信息 c.ClientIP(), c.Request.Method, rawPath, c.Request.Header.Get("User-Agent"), c.Request.Proto, full Header
+		logDump("%s %s %s %s %s %s", c.ClientIP(), c.Request.Method, rawPath, c.Request.Header.Get("User-Agent"), c.Request.Proto, c.Request.Header)
+		repouser := fmt.Sprintf("%s/%s", username, repo)
+
+		// 白名单检查
+		if cfg.Whitelist.Enabled {
+			whitelist := auth.CheckWhitelist(username, repo)
+			if !whitelist {
+				logErrMsg := fmt.Sprintf("%s %s %s %s %s Whitelist Blocked repo: %s", c.ClientIP(), c.Request.Method, rawPath, c.Request.Header.Get("User-Agent"), c.Request.Proto, repouser)
+				errMsg := fmt.Sprintf("Whitelist Blocked repo: %s", repouser)
+				c.JSON(http.StatusForbidden, gin.H{"error": errMsg})
+				logWarning(logErrMsg)
+				return
 			}
 		}

-		// **处理 blob/raw 路径**
-		if matchedIndex == 1 { // 如果匹配的是 GitHub Blob/Raw 链接 (对应 exps[1])
-			rawPath = strings.Replace(rawPath, "/blob/", "/raw/", 1) // 将 URL 中的 "/blob/" 替换为 "/raw/"，获取 raw 链接 (用于下载原始文件内容)
+		// 黑名单检查
+		if cfg.Blacklist.Enabled {
+			blacklist := auth.CheckBlacklist(username, repo)
+			if blacklist {
+				logErrMsg := fmt.Sprintf("%s %s %s %s %s Blacklist Blocked repo: %s", c.ClientIP(), c.Request.Method, rawPath, c.Request.Header.Get("User-Agent"), c.Request.Proto, repouser)
+				errMsg := fmt.Sprintf("Blacklist Blocked repo: %s", repouser)
+				c.JSON(http.StatusForbidden, gin.H{"error": errMsg})
+				logWarning(logErrMsg)
+				return
+			}
 		}

-		// **通用鉴权处理**
-		authcheck, err := auth.AuthHandler(c, cfg) // 调用 AuthHandler 函数进行通用鉴权检查 (例如，基于 Cookie 或 Header 的鉴权)
-		if !authcheck {                            // 如果鉴权失败
-			c.AbortWithStatusJSON(401, gin.H{"error": "Unauthorized"})                                                                                     // 返回 401 状态码和 JSON 错误信息，提示未授权
-			logWarning("%s %s %s %s %s Auth-Error: %v", c.ClientIP(), c.Request.Method, rawPath, c.Request.Header.Get("User-Agent"), c.Request.Proto, err) // 记录警告日志，包含鉴权错误信息
-			return                                                                                                                                         // 中断请求处理
+		/*
+			matches = CheckURL(rawPath, c)
+			if matches == nil {
+				c.AbortWithStatus(http.StatusNotFound)
+				logWarning("%s %s %s %s %s 404-NOMATCH", c.ClientIP(), c.Request.Method, rawPath, c.Request.Header.Get("User-Agent"), c.Request.Proto)
+				return
+			}
+		*/
+
+		// 若匹配api.github.com/repos/用户名/仓库名/路径, 则检查是否开启HeaderAuth
+
+		// 处理blob/raw路径
+		if matcher == "blob" {
+			rawPath = strings.Replace(rawPath, "/blob/", "/raw/", 1)
 		}

-		// **Debug 日志记录匹配结果**
-		logDebug("%s %s %s %s %s Matches: %v", c.ClientIP(), c.Request.Method, rawPath, c.Request.Header.Get("User-Agent"), c.Request.Proto, matches) // 记录 debug 日志，包含匹配结果信息
+		// 鉴权
+		var authcheck bool
+		authcheck, err = auth.AuthHandler(c, cfg)
+		if !authcheck {
+			c.AbortWithStatusJSON(401, gin.H{"error": "Unauthorized"})
+			logWarning("%s %s %s %s %s Auth-Error: %v", c.ClientIP(), c.Request.Method, rawPath, c.Request.Header.Get("User-Agent"), c.Request.Proto, err)
+			return
+		}

-		// **根据匹配到的 URL 类型，进行不同的代理请求处理**
-		switch matchedIndex {
-		case 0, 1, 3, 4: // 如果匹配的是 Releases/Archive, Blob/Raw, raw.githubusercontent.com 或 gist.githubusercontent.com 链接 (对应 exps[0], exps[1], exps[3], exps[4])
-			//ProxyRequest(c, rawPath, cfg, "chrome", runMode) // 原始的 ProxyRequest 函数 (可能一次性读取全部响应)
-			ChunkedProxyRequest(c, rawPath, cfg, "chrome", runMode) // 使用 ChunkedProxyRequest 函数进行分块代理 (更高效，特别是对于大文件)
-		case 2: // 如果匹配的是 Info/Git 相关链接 (对应 exps[2])
-			//ProxyRequest(c, rawPath, cfg, "git", runMode) // 原始的 ProxyRequest 函数
-			GitReq(c, rawPath, cfg, "git", runMode) // 使用 GitReq 函数处理 Git 相关请求 (针对 .gitattributes, .gitignore 等)
-		default: // 如果匹配到其他类型 (理论上不应该发生，因为前面的 matchedIndex == -1 已经处理了未识别类型)
-			c.String(http.StatusForbidden, "Invalid input.") // 返回 403 状态码和错误信息，提示无效输入
-			fmt.Println("Invalid input.")                    // 打印错误信息到控制台
-			return                                           // 中断请求处理
+		// IP METHOD URL USERAGENT PROTO MATCHES
+		logDebug("%s %s %s %s %s Matches: %v", c.ClientIP(), c.Request.Method, rawPath, c.Request.Header.Get("User-Agent"), c.Request.Proto, matches)
+
+		switch matcher {
+		case "releases", "blob", "raw", "gist", "api":
+			ChunkedProxyRequest(c, rawPath, cfg, matcher)
+		case "clone":
+			//ProxyRequest(c, rawPath, cfg, "git", runMode)
+			GitReq(c, rawPath, cfg, "git", runMode)
+		default:
+			c.String(http.StatusForbidden, "Invalid input.")
+			fmt.Println("Invalid input.")
+			return
 		}
 	}
 }
+
+/*
+func CheckURL(u string, c *gin.Context) []string {
+	for _, exp := range exps {
+		if matches := exp.FindStringSubmatch(u); matches != nil {
+			return matches[1:]
+		}
+	}
+	errMsg := fmt.Sprintf("%s %s %s %s %s Invalid URL", c.ClientIP(), c.Request.Method, u, c.Request.Header.Get("User-Agent"), c.Request.Proto)
+	logError(errMsg)
+	return nil
+}
+*/
--- a/proxy/httpc.go
+++ b/proxy/httpc.go
@@ -14,12 +14,17 @@ var BufferSize int = 32 * 1024 // 32KB

 var (
 	tr         *http.Transport
+	gittr      *http.Transport
 	BufferPool *sync.Pool
 	client     *httpc.Client
+	gitclient  *httpc.Client
 )

 func InitReq(cfg *config.Config) {
 	initHTTPClient(cfg)
+	if cfg.GitClone.Mode == "cache" {
+		initGitHTTPClient(cfg)
+	}

 	// 初始化固定大小的缓存池
 	BufferPool = &sync.Pool{
@@ -30,26 +35,18 @@ func InitReq(cfg *config.Config) {
 }

 func initHTTPClient(cfg *config.Config) {
-	/*
-		ctr = &http.Transport{
-			MaxIdleConns:          100,
-			MaxConnsPerHost:       60,
-			IdleConnTimeout:       20 * time.Second,
-			TLSHandshakeTimeout:   10 * time.Second,
-			ExpectContinueTimeout: 1 * time.Second,
-			ResponseHeaderTimeout: 10 * time.Second,
-			DialContext: (&net.Dialer{
-				Timeout:   30 * time.Second,
-				KeepAlive: 30 * time.Second,
-			}).DialContext,
-		}
-	*/
+	var proTolcols = new(http.Protocols)
+	proTolcols.SetHTTP1(true)
+	proTolcols.SetHTTP2(true)
+	proTolcols.SetUnencryptedHTTP2(true)
 	if cfg.Httpc.Mode == "auto" {
+
 		tr = &http.Transport{
 			//MaxIdleConns:    160,
 			IdleConnTimeout: 30 * time.Second,
 			WriteBufferSize: 32 * 1024, // 32KB
 			ReadBufferSize:  32 * 1024, // 32KB
+			Protocols:       proTolcols,
 		}
 	} else if cfg.Httpc.Mode == "advanced" {
 		tr = &http.Transport{
@@ -58,6 +55,7 @@ func initHTTPClient(cfg *config.Config) {
 			MaxIdleConnsPerHost: cfg.Httpc.MaxIdleConnsPerHost,
 			WriteBufferSize:     32 * 1024, // 32KB
 			ReadBufferSize:      32 * 1024, // 32KB
+			Protocols:           proTolcols,
 		}
 	} else {
 		// 错误的模式
@@ -86,3 +84,60 @@ func initHTTPClient(cfg *config.Config) {
 		)
 	}
 }
+
+func initGitHTTPClient(cfg *config.Config) {
+
+	var proTolcols = new(http.Protocols)
+	proTolcols.SetHTTP1(true)
+	proTolcols.SetHTTP2(true)
+	proTolcols.SetUnencryptedHTTP2(true)
+	if cfg.GitClone.ForceH2C {
+		proTolcols.SetHTTP1(false)
+		proTolcols.SetHTTP2(false)
+		proTolcols.SetUnencryptedHTTP2(true)
+	}
+	if cfg.Httpc.Mode == "auto" {
+
+		gittr = &http.Transport{
+			//MaxIdleConns:    160,
+			IdleConnTimeout: 30 * time.Second,
+			WriteBufferSize: 32 * 1024, // 32KB
+			ReadBufferSize:  32 * 1024, // 32KB
+			Protocols:       proTolcols,
+		}
+	} else if cfg.Httpc.Mode == "advanced" {
+		gittr = &http.Transport{
+			MaxIdleConns:        cfg.Httpc.MaxIdleConns,
+			MaxConnsPerHost:     cfg.Httpc.MaxConnsPerHost,
+			MaxIdleConnsPerHost: cfg.Httpc.MaxIdleConnsPerHost,
+			WriteBufferSize:     32 * 1024, // 32KB
+			ReadBufferSize:      32 * 1024, // 32KB
+			Protocols:           proTolcols,
+		}
+	} else {
+		// 错误的模式
+		logError("unknown httpc mode: %s", cfg.Httpc.Mode)
+		fmt.Println("unknown httpc mode: ", cfg.Httpc.Mode)
+		logWarning("use Auto to Run HTTP Client")
+		fmt.Println("use Auto to Run HTTP Client")
+		gittr = &http.Transport{
+			//MaxIdleConns:    160,
+			IdleConnTimeout: 30 * time.Second,
+			WriteBufferSize: 32 * 1024, // 32KB
+			ReadBufferSize:  32 * 1024, // 32KB
+		}
+	}
+	if cfg.Outbound.Enabled {
+		initTransport(cfg, gittr)
+	}
+	if cfg.Server.Debug {
+		gitclient = httpc.New(
+			httpc.WithTransport(gittr),
+			httpc.WithDumpLog(),
+		)
+	} else {
+		gitclient = httpc.New(
+			httpc.WithTransport(gittr),
+		)
+	}
+}
--- a/proxy/matchrepo.go
+++ b/proxy/matchrepo.go
@@ -1,34 +1,286 @@
 package proxy

 import (
+	"bufio"
+	"compress/gzip"
 	"fmt"
 	"ghproxy/config"
-	"net/http"
+	"io"
 	"regexp"
-
-	"github.com/gin-gonic/gin"
+	"strings"
 )

-// 预定义regex
-var (
-	pathRegex = regexp.MustCompile(`^([^/]+)/([^/]+)/([^/]+)/.*`)                                         // 匹配路径
-	gistRegex = regexp.MustCompile(`^(?:https?://)?gist\.github(?:usercontent|)\.com/([^/]+)/([^/]+)/.*`) // 匹配gist路径
-)
-
-// 提取用户名和仓库名
-func MatchUserRepo(rawPath string, cfg *config.Config, c *gin.Context, matches []string) (string, string) {
-	if gistMatches := gistRegex.FindStringSubmatch(rawPath); len(gistMatches) == 3 {
-		LogDump("%s %s %s %s %s Matched-Username: %s", c.ClientIP(), c.Request.Method, rawPath, c.Request.Header.Get("User-Agent"), c.Request.Proto, gistMatches[1])
-		return gistMatches[1], ""
-	}
-	// 定义路径
-	if pathMatches := pathRegex.FindStringSubmatch(matches[2]); len(pathMatches) >= 4 {
-		return pathMatches[2], pathMatches[3]
-	}
-
-	// 返回错误信息
-	errMsg := fmt.Sprintf("%s %s %s %s %s Invalid URL", c.ClientIP(), c.Request.Method, rawPath, c.Request.Header.Get("User-Agent"), c.Request.Proto)
-	logWarning(errMsg)
-	c.String(http.StatusForbidden, "Invalid path; expected username/repo, Path: %s", rawPath)
-	return "", ""
+// 定义错误类型, error承载描述, 便于处理
+type MatcherErrors struct {
+	Code int
+	Msg  string
+	Err  error
+}
+
+var (
+	ErrInvalidURL = &MatcherErrors{
+		Code: 403,
+		Msg:  "Invalid URL Format",
+	}
+	ErrAuthHeaderUnavailable = &MatcherErrors{
+		Code: 403,
+		Msg:  "AuthHeader Unavailable",
+	}
+)
+
+func (e *MatcherErrors) Error() string {
+	if e.Err != nil {
+		return fmt.Sprintf("Code: %d, Msg: %s, Err: %s", e.Code, e.Msg, e.Err.Error())
+	}
+	return fmt.Sprintf("Code: %d, Msg: %s", e.Code, e.Msg)
+}
+
+func (e *MatcherErrors) Unwrap() error {
+	return e.Err
+}
+
+func Matcher(rawPath string, cfg *config.Config) (string, string, string, error) {
+	var (
+		user    string
+		repo    string
+		matcher string
+	)
+	// 匹配 "https://github.com"开头的链接
+	if strings.HasPrefix(rawPath, "https://github.com") {
+		remainingPath := strings.TrimPrefix(rawPath, "https://github.com")
+		if strings.HasPrefix(remainingPath, "/") {
+			remainingPath = strings.TrimPrefix(remainingPath, "/")
+		}
+		// 预期格式/user/repo/more...
+		// 取出user和repo和最后部分
+		parts := strings.Split(remainingPath, "/")
+		if len(parts) <= 2 {
+			return "", "", "", ErrInvalidURL
+		}
+		user = parts[0]
+		repo = parts[1]
+		// 匹配 "https://github.com"开头的链接
+		if len(parts) >= 3 {
+			switch parts[2] {
+			case "releases", "archive":
+				matcher = "releases"
+			case "blob", "raw":
+				matcher = "blob"
+			case "info", "git-upload-pack":
+				matcher = "clone"
+			default:
+				return "", "", "", ErrInvalidURL
+			}
+		}
+		return user, repo, matcher, nil
+	}
+	// 匹配 "https://raw"开头的链接
+	if strings.HasPrefix(rawPath, "https://raw") {
+		remainingPath := strings.TrimPrefix(rawPath, "https://")
+		parts := strings.Split(remainingPath, "/")
+		if len(parts) <= 3 {
+			return "", "", "", ErrInvalidURL
+		}
+		user = parts[1]
+		repo = parts[2]
+		matcher = "raw"
+
+		return user, repo, matcher, nil
+	}
+	// 匹配 "https://gist"开头的链接
+	if strings.HasPrefix(rawPath, "https://gist") {
+		remainingPath := strings.TrimPrefix(rawPath, "https://")
+		parts := strings.Split(remainingPath, "/")
+		if len(parts) <= 3 {
+			return "", "", "", ErrInvalidURL
+		}
+		user = parts[1]
+		repo = ""
+		matcher = "gist"
+		return user, repo, matcher, nil
+	}
+	// 匹配 "https://api.github.com/"开头的链接
+	if strings.HasPrefix(rawPath, "https://api.github.com/") {
+		matcher = "api"
+		remainingPath := strings.TrimPrefix(rawPath, "https://api.github.com/")
+
+		parts := strings.Split(remainingPath, "/")
+		if parts[0] == "repos" {
+			user = parts[1]
+			repo = parts[2]
+		}
+		if parts[0] == "users" {
+			user = parts[1]
+		}
+		if !cfg.Auth.ForceAllowApi {
+			if cfg.Auth.AuthMethod != "header" || !cfg.Auth.Enabled {
+				return "", "", "", ErrAuthHeaderUnavailable
+			}
+		}
+		return user, repo, matcher, nil
+	}
+	return "", "", "", ErrInvalidURL
+}
+
+func EditorMatcher(rawPath string, cfg *config.Config) (bool, string, error) {
+	var (
+		matcher string
+	)
+	// 匹配 "https://github.com"开头的链接
+	if strings.HasPrefix(rawPath, "https://github.com") {
+		remainingPath := strings.TrimPrefix(rawPath, "https://github.com")
+		if strings.HasPrefix(remainingPath, "/") {
+			remainingPath = strings.TrimPrefix(remainingPath, "/")
+		}
+		return true, "", nil
+	}
+	// 匹配 "https://raw.githubusercontent.com"开头的链接
+	if strings.HasPrefix(rawPath, "https://raw.githubusercontent.com") {
+		return true, matcher, nil
+	}
+	// 匹配 "https://raw.github.com"开头的链接
+	if strings.HasPrefix(rawPath, "https://raw.github.com") {
+		return true, matcher, nil
+	}
+	// 匹配 "https://gist.githubusercontent.com"开头的链接
+	if strings.HasPrefix(rawPath, "https://gist.githubusercontent.com") {
+		return true, matcher, nil
+	}
+	// 匹配 "https://gist.github.com"开头的链接
+	if strings.HasPrefix(rawPath, "https://gist.github.com") {
+		return true, matcher, nil
+	}
+	// 匹配 "https://api.github.com/"开头的链接
+	if strings.HasPrefix(rawPath, "https://api.github.com") {
+		matcher = "api"
+		return true, matcher, nil
+	}
+	return false, "", ErrInvalidURL
+}
+
+// 匹配文件扩展名是sh的rawPath
+func MatcherShell(rawPath string) bool {
+	if strings.HasSuffix(rawPath, ".sh") {
+		return true
+	}
+	return false
+}
+
+// LinkProcessor 是一个函数类型，用于处理提取到的链接。
+type LinkProcessor func(string) string
+
+// 自定义 URL 修改函数
+func modifyURL(url string, host string, cfg *config.Config) string {
+	// 去除url内的https://或http://
+	matched, _, err := EditorMatcher(url, cfg)
+	if err != nil {
+		logDump("Invalid URL: %s", url)
+		return url
+	}
+	if matched {
+
+		u := strings.TrimPrefix(url, "https://")
+		u = strings.TrimPrefix(url, "http://")
+		logDump("Modified URL: %s", "https://"+host+"/"+u)
+		return "https://" + host + "/" + u
+	}
+	return url
+}
+
+var (
+	matchedMatchers = []string{
+		"blob",
+		"raw",
+		"gist",
+	}
+)
+
+// matchString 检查目标字符串是否在给定的字符串集合中
+func matchString(target string, stringsToMatch []string) bool {
+	matchMap := make(map[string]struct{}, len(stringsToMatch))
+	for _, str := range stringsToMatch {
+		matchMap[str] = struct{}{}
+	}
+	_, exists := matchMap[target]
+	return exists
+}
+
+// processLinks 处理链接并将结果写入输出流
+func processLinks(input io.Reader, output io.Writer, compress string, host string, cfg *config.Config) (written int64, err error) {
+	var reader *bufio.Reader
+
+	if compress == "gzip" {
+		// 解压gzip
+		gzipReader, err := gzip.NewReader(input)
+		if err != nil {
+			return 0, fmt.Errorf("gzip解压错误: %v", err)
+		}
+		defer gzipReader.Close()
+		reader = bufio.NewReader(gzipReader)
+	} else {
+		reader = bufio.NewReader(input)
+	}
+
+	var writer *bufio.Writer
+	var gzipWriter *gzip.Writer
+
+	// 根据是否gzip确定 writer 的创建
+	if compress == "gzip" {
+		gzipWriter = gzip.NewWriter(output)
+		writer = bufio.NewWriterSize(gzipWriter, 4096) //设置缓冲区大小
+	} else {
+		writer = bufio.NewWriterSize(output, 4096)
+	}
+
+	//确保writer关闭
+	defer func() {
+		var closeErr error // 局部变量，用于保存defer中可能发生的错误
+
+		if gzipWriter != nil {
+			if closeErr = gzipWriter.Close(); closeErr != nil {
+				logError("gzipWriter close failed %v", closeErr)
+				// 如果已经存在错误，则保留。否则，记录此错误。
+				if err == nil {
+					err = closeErr
+				}
+			}
+		}
+		if flushErr := writer.Flush(); flushErr != nil {
+			logError("writer flush failed %v", flushErr)
+			// 如果已经存在错误，则保留。否则，记录此错误。
+			if err == nil {
+				err = flushErr
+			}
+		}
+	}()
+
+	// 使用正则表达式匹配 http 和 https 链接
+	urlPattern := regexp.MustCompile(`https?://[^\s'"]+`)
+	for {
+		line, err := reader.ReadString('\n')
+		if err != nil {
+			if err == io.EOF {
+				break // 文件结束
+			}
+			return written, fmt.Errorf("读取行错误: %v", err) // 传递错误
+		}
+
+		// 替换所有匹配的 URL
+		modifiedLine := urlPattern.ReplaceAllStringFunc(line, func(originalURL string) string {
+			return modifyURL(originalURL, host, cfg)
+		})
+
+		n, werr := writer.WriteString(modifiedLine)
+		written += int64(n) // 更新写入的字节数
+		if werr != nil {
+			return written, fmt.Errorf("写入文件错误: %v", werr) // 传递错误
+		}
+	}
+
+	// 在返回之前，再刷新一次
+	if fErr := writer.Flush(); fErr != nil {
+		return written, fErr
+	}
+
+	return written, nil
 }
--- a/proxy/proxy.go
+++ b/proxy/proxy.go
@@ -12,7 +12,7 @@ import (
 // 日志模块
 var (
 	logw       = logger.Logw
-	LogDump    = logger.LogDump
+	logDump    = logger.LogDump
 	logDebug   = logger.LogDebug
 	logInfo    = logger.LogInfo
 	logWarning = logger.LogWarning
@@ -30,56 +30,7 @@ func readRequestBody(c *gin.Context) ([]byte, error) {
 	return body, nil
 }

-/*
-func SendRequest(c *gin.Context, req *req.Request, method, url string) (*req.Response, error) {
-	switch method {
-	case "GET":
-		return req.Get(url)
-	case "POST":
-		return req.Post(url)
-	case "PUT":
-		return req.Put(url)
-	case "DELETE":
-		return req.Delete(url)
-	default:
-		// IP METHOD URL USERAGENT PROTO UNSUPPORTED-METHOD
-		errmsg := fmt.Sprintf("%s %s %s %s %s Unsupported method", c.ClientIP(), method, url, c.Request.Header.Get("User-Agent"), c.Request.Proto)
-		logWarning(errmsg)
-		return nil, fmt.Errorf(errmsg)
-	}
-}
-*/
-
 func HandleError(c *gin.Context, message string) {
 	c.String(http.StatusInternalServerError, fmt.Sprintf("server error %v", message))
 	logError(message)
 }
-
-func CheckURL(u string, c *gin.Context) []string {
-	for _, exp := range exps {
-		if matches := exp.FindStringSubmatch(u); matches != nil {
-			return matches[1:]
-		}
-	}
-	errMsg := fmt.Sprintf("%s %s %s %s %s Invalid URL", c.ClientIP(), c.Request.Method, u, c.Request.Header.Get("User-Agent"), c.Request.Proto)
-	logError(errMsg)
-	return nil
-}
-
-/*
-// 处理响应大小
-func HandleResponseSize(resp *http.Response, cfg *config.Config, c *gin.Context) error {
-	contentLength := resp.Header.Get("Content-Length")
-	sizelimit := cfg.Server.SizeLimit * 1024 * 1024
-	if contentLength != "" {
-		size, err := strconv.Atoi(contentLength)
-		if err == nil && size > sizelimit {
-			finalURL := resp.Request.URL.String()
-			c.Redirect(http.StatusMovedPermanently, finalURL)
-			logWarning("%s %s %s %s %s Final-URL: %s Size-Limit-Exceeded: %d", c.ClientIP(), c.Request.Method, c.Request.URL.String(), c.Request.Header.Get("User-Agent"), c.Request.Proto, finalURL, size)
-			return fmt.Errorf("Path: %s size limit exceeded: %d", finalURL, size)
-		}
-	}
-	return nil
-}
-*/
--- a/proxy/reqheader.go
+++ b/proxy/reqheader.go
@@ -2,6 +2,7 @@ package proxy

 import (
 	"net/http"
+	"strings"

 	"github.com/gin-gonic/gin"
 )
@@ -19,3 +20,31 @@ func removeWSHeader(req *http.Request) {
 	req.Header.Del("Upgrade")
 	req.Header.Del("Connection")
 }
+
+func reWriteEncodeHeader(req *http.Request) {
+
+	if isGzipAccepted(req.Header) {
+		req.Header.Set("Content-Encoding", "gzip")
+		req.Header.Set("Accept-Encoding", "gzip")
+	} else {
+		req.Header.Del("Content-Encoding")
+		req.Header.Del("Accept-Encoding")
+	}
+
+}
+
+// isGzipAccepted 检查 Accept-Encoding 头部中是否包含 gzip
+func isGzipAccepted(header http.Header) bool {
+	// 获取 Accept-Encoding 的值
+	encodings := header["Accept-Encoding"]
+	for _, encoding := range encodings {
+		// 将 encoding 字符串拆分为多个编码
+		for _, enc := range strings.Split(encoding, ",") {
+			// 去除空格并检查是否为 gzip
+			if strings.TrimSpace(enc) == "gzip" {
+				return true
+			}
+		}
+	}
+	return false
+}
Author	SHA1	Message	Date
WJQSERVER	3e40146281	Merge pull request #67 from WJQSERVER-STUDIO/dev 2.5.0	2025-03-17 14:01:33 +08:00
wjqserver	ac7e1e43b5	update changelog	2025-03-17 13:53:37 +08:00
wjqserver	f134d22540	2.5.0	2025-03-17 13:48:53 +08:00
wjqserver	79153c0f7d	update readme.md	2025-03-17 13:45:36 +08:00
wjqserver	4fd47812f7	25w19a	2025-03-16 21:03:28 +08:00
wjqserver	17c49d534b	update readme.md	2025-03-16 12:28:00 +08:00
WJQSERVER	284b38bab4	Merge pull request #66 from WJQSERVER-STUDIO/dev v2.4.2	2025-03-14 21:56:18 +08:00
wjqserver	d73dfe7db5	2.4.2	2025-03-14 21:48:25 +08:00
wjqserver	dc286e002c	25w18a	2025-03-14 21:40:21 +08:00
WJQSERVER	5c54ae788c	Merge pull request #65 from WJQSERVER-STUDIO/dev Rewrite path matcher (v2.4.1)	2025-03-13 22:48:27 +08:00
wjqserver	bfcb1c9901	2.4.1	2025-03-13 22:41:13 +08:00
wjqserver	9bfe8517cb	rewrite path matcher	2025-03-13 18:16:17 +08:00
@@ -1 +1 @@
 w16d
 w19a
@@ -1 +1 @@
 .4.0
 .5.0