package main

import (

"bufio"

"bytes"

"context"

cryptorand "crypto/rand"

"crypto/rsa"

"crypto/tls"

"crypto/x509"

"crypto/x509/pkix"

"embed"

"encoding/base64"

"encoding/json"

"encoding/pem"

"encoding/xml"

"errors"

"flag"

"fmt"

"io"

"log/slog"

"math/big"

"math/rand"

"mime"

"mime/multipart"

"net"

"net/http"

"net/http/httputil"

"net/url"

"os"

"os/exec"

"os/signal"

"path/filepath"

"reflect"

"runtime"

"strconv"

"strings"

"sync"

"syscall"

"time"

)

// Header 定义HTTP请求头结构体，用于JSON序列化和反序列化

type Header struct {

Name string `json:"name"` // 请求头名称

Value string `json:"value"` // 请求头值

}

// FileInfo 定义文件信息结构体，用于文件上传功能

type FileInfo struct {

FieldName string `json:"field_name"` // 表单字段名

FileName string `json:"file_name"` // 文件名

}

// ForwardParams 定义转发参数结构体，用于存储WebSocket和SSE连接的参数

type ForwardParams struct {

URL string // 目标URL地址

Headers string // 请求头JSON字符串

VerifySSL string // SSL验证选项 (Y/N)

FollowRedirect string // 重定向跟随选项 (Y/N)

Timeout int // 超时时间（秒）

RetryCount int // 重试次数

RetryDelay int // 重试延迟（秒）

}

// wsConnParams 存储WebSocket连接的参数映射表

// 键为connect_id，值为ForwardParams

var wsConnParams sync.Map

// sseConnParams 存储SSE连接的参数映射表

// 键为connect_id，值为ForwardParams

var sseConnParams sync.Map

// DetachedProcess Windows系统进程标志，用于后台运行

var DetachedProcess uint32 = 0

// CreateNewProcessGroup Windows系统进程组标志，用于后台运行

var CreateNewProcessGroup uint32 = 0

// controlParams 定义控制参数白名单，用于过滤不需要转发的参数

// 这些参数是WebCurl内部使用的，不应该转发到目标服务器

var controlParams = map[string]bool{

"url": true, // 目标URL

"time_out": true, // 超时时间

"retry_count": true, // 重试次数

"retry_delay": true, // 重试延迟

"method": true, // 请求方法

"body_type": true, // 请求体类型

"headers": true, // 请求头

"body": true, // 请求体

"file_info": true, // 文件信息

"files": true, // 文件数据

"follow_redirect": true, // 重定向跟随

"verify_ssl": true, // SSL验证

}

// webroot 静态文件根目录路径，为空时使用内嵌的index.html

var webroot = ""

// form-data上传文件目录

var uploadDir = ""

// embeddedFS 内嵌的前端文件系统，包含index.html和favicon.ico

//

//go:embed index.html mock.html tool.html favicon.ico README.md

var embeddedFS embed.FS

// logger 全局日志记录器

var logger *slog.Logger

// server 全局HTTP服务器实例，用于优雅退出

var server *http.Server

// shutdownWg 等待组，用于等待所有goroutine完成

var shutdownWg sync.WaitGroup

// ParseMultipartForm 16G

var maxMemory int64 = 16 << 30

// genConnectID 生成32位随机连接ID

// 用于WebSocket和SSE连接的唯一标识

func genConnectID() string {

const letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"

const length = 32

b := make([]byte, length)

for i := range b {

b[i] = letters[rand.Intn(len(letters))]

}

return string(b)

}

/*

字段 含义 示例

/C 国家 CN

/ST 省/州 Guangdong

/L 城市 Shenzhen

/O 组织 MyCompany

/OU 部门 Tech

/CN 域名或名称 *.test.com

*/

// parseCertInfo 解析 --cert-info 参数，格式如 "/C=CN/ST=Shanghai/L=Pudong/O=Test/OU=Ops/CN=app.example.net"

func parseCertInfo(certInfo string) pkix.Name {

name := pkix.Name{}

if certInfo == "" {

return name

}

fields := strings.Split(certInfo, "/")

for _, field := range fields {

if field == "" {

continue

}

kv := strings.SplitN(field, "=", 2)

if len(kv) != 2 {

continue

}

key, value := kv[0], kv[1]

switch key {

case "C":

name.Country = []string{value}

case "ST":

name.Province = []string{value}

case "L":

name.Locality = []string{value}

case "O":

name.Organization = []string{value}

case "OU":

name.OrganizationalUnit = []string{value}

case "CN":

name.CommonName = value

}

}

return name

}

// generateSSLCertificateToDir 生成自签名SSL证书到指定目录，支持自定义主题

// subject: 证书主题信息（可为空，使用默认）

func generateSSLCertificateToDir(dir string, subject pkix.Name) error {

// 生成2048位RSA私钥

privateKey, err := rsa.GenerateKey(cryptorand.Reader, 2048)

if err != nil {

return fmt.Errorf("生成私钥失败: %v", err)

}

// 创建证书模板，设置有效期和基本信息

notBefore := time.Now()

notAfter := notBefore.Add(10 * 365 * 24 * time.Hour) // 10年有效期

template := x509.Certificate{

SerialNumber: big.NewInt(time.Now().Unix()),

Subject: subject,

NotBefore: notBefore,

NotAfter: notAfter,

KeyUsage: x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature,

ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},

BasicConstraintsValid: true,

DNSNames: []string{"localhost", "127.0.0.1"},

IPAddresses: []net.IP{net.ParseIP("127.0.0.1"), net.ParseIP("::1")},

}

if subject.CommonName != "" {

template.DNSNames = append(template.DNSNames, subject.CommonName)

}

// 确保目标目录存在

if err := os.MkdirAll(dir, 0755); err != nil {

return fmt.Errorf("创建目录失败: %v", err)

}

// 设置证书和私钥文件路径

keyPath := filepath.Join(dir, "ssl_cert.key")

certPath := filepath.Join(dir, "ssl_cert.pem")

// 将私钥编码为PEM格式并保存到文件

privateKeyPEM := &pem.Block{

Type: "RSA PRIVATE KEY",

Bytes: x509.MarshalPKCS1PrivateKey(privateKey),

}

if err := os.WriteFile(keyPath, pem.EncodeToMemory(privateKeyPEM), 0600); err != nil {

return fmt.Errorf("保存私钥失败: %v", err)

}

// 创建X.509证书

derBytes, err := x509.CreateCertificate(cryptorand.Reader, &template, &template, &privateKey.PublicKey, privateKey)

if err != nil {

return fmt.Errorf("创建证书失败: %v", err)

}

// 将证书编码为PEM格式并保存到文件

certPEM := &pem.Block{

Type: "CERTIFICATE",

Bytes: derBytes,

}

if err := os.WriteFile(certPath, pem.EncodeToMemory(certPEM), 0644); err != nil {

return fmt.Errorf("保存证书失败: %v", err)

}

return nil

}

// setupLogger 初始化日志系统

// logLevelStr: 日志级别 (debug/info/warn/error)

// logFilePath: 日志文件路径，为空时使用默认路径

// maxLogSize: 日志文件最大大小（字节）

// stdoutLog: 是否在控制台打印日志，默认true

func setupLogger(logLevelStr, logFilePath string, maxLogSize int64, stdoutLog bool) {

// 根据字符串设置日志级别

var lvl = slog.LevelWarn

switch strings.ToLower(logLevelStr) {

case "debug":

lvl = slog.LevelDebug

case "info":

lvl = slog.LevelInfo

case "warn":

lvl = slog.LevelWarn

default:

lvl = slog.LevelError

}

// 如果未指定日志文件路径，使用默认路径

if logFilePath == "" {

exe, err := os.Executable()

if err != nil {

logFilePath = "WebCurl.log"

} else {

dir := filepath.Dir(exe)

logFilePath = filepath.Join(dir, "WebCurl.log")

}

}

// 检查日志文件大小，超过限制则清空文件

if info, err := os.Stat(logFilePath); err == nil && info.Size() > maxLogSize {

if f, err := os.OpenFile(logFilePath, os.O_TRUNC|os.O_WRONLY, 0644); err == nil {

_ = f.Close()

}

}

// 创建日志文件或使用控制台输出

logFile, err := os.OpenFile(logFilePath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)

var handler slog.Handler

if err != nil {

handler = slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: lvl})

fmt.Printf("无法打开日志文件: %v,日志输出到控制台\n", err)

} else {

if stdoutLog {

handler = slog.NewTextHandler(io.MultiWriter(logFile, os.Stdout), &slog.HandlerOptions{Level: lvl})

} else {

handler = slog.NewTextHandler(logFile, &slog.HandlerOptions{Level: lvl})

}

}

logger = slog.New(handler)

logger.Info("日志初始化", "level", lvl, "file", logFilePath, "stdout", stdoutLog)

}

// daemonizeIfNeeded 跨平台后台运行功能

// daemon: 是否启用后台运行

func daemonizeIfNeeded(daemon bool) {

if !daemon {

return

}

// 检查是否已经是子进程

if os.Getenv("GO_DAEMON_MODE_WEB_CURL") == "1" {

// 已经是子进程

return

}

// 获取可执行文件路径和参数

exe, _ := os.Executable()

args := os.Args[1:]

cmd := exec.Command(exe, args...)

cmd.Env = append(os.Environ(), "GO_DAEMON_MODE_WEB_CURL=1")

cmd.Stdout = nil

cmd.Stderr = nil

cmd.Stdin = nil

// 设置进程属性，实现跨平台后台运行

attr := &syscall.SysProcAttr{}

rv := reflect.ValueOf(attr).Elem()

if runtime.GOOS == "windows" {

// Windows系统：使用反射设置CreationFlags

if flags := rv.FieldByName("CreationFlags"); flags.IsValid() && flags.CanSet() {

flags.SetUint(uint64(CreateNewProcessGroup | DetachedProcess))

}

} else {

// Unix系统：使用反射设置SetSid

if setsid := rv.FieldByName("Setsid"); setsid.IsValid() && setsid.CanSet() {

setsid.SetBool(true)

}

}

cmd.SysProcAttr = attr

// 启动后台进程并退出当前进程

_ = cmd.Start()

fmt.Println("已切换到后台运行,PID:", cmd.Process.Pid)

os.Exit(0)

}

// printAndLogConfig 打印并记录服务启动配置信息

func printAndLogConfig(host, port, webroot string, daemon, echoServer bool, logLevel, logFile, logSize, sslCert, sslCertKey, uploadDir string, stdoutLog bool) {

// 获取默认日志文件路径

defaultLogFile := "WebCurl.log"

exe, err := os.Executable()

if err == nil {

dir := filepath.Dir(exe)

defaultLogFile = filepath.Join(dir, "WebCurl.log")

}

// 构建配置映射表

config := map[string]any{

"--host": host,

"--port": port,

"--webroot": webroot,

"--daemon": daemon,

"--echo-server": echoServer,

"--log-level": logLevel,

"--log-file": logFile,

"--log-size": logSize,

"--ssl-cert": sslCert,

"--ssl-cert-key": sslCertKey,

"--upload-dir": uploadDir,

"--stdout-log": stdoutLog,

}

// 打印配置信息到控制台

fmt.Println("服务启动配置：")

for k, v := range config {

// 对于空字符串，显示默认值

if str, ok := v.(string); ok && str == "" {

if k == "--log-file" {

fmt.Printf(" %-25s: %s (默认)\n", k, defaultLogFile)

} else if k == "--webroot" {

fmt.Printf(" %-25s: 使用内嵌index.html (默认)\n", k)

} else if k == "--ssl-cert" {

fmt.Printf(" %-25s: ssl_cert.pem (默认)\n", k)

} else if k == "--ssl-cert-key" {

fmt.Printf(" %-25s: ssl_cert.key (默认)\n", k)

} else if k == "--upload-dir" {

fmt.Printf(" %-25s: <空> (仅透传)\n", k)

} else {

fmt.Printf(" %-25s: <空>\n", k)

}

} else {

fmt.Printf(" %-25s: %v\n", k, v)

}

}

// 记录配置信息到日志

logger.Info("服务启动配置", "config", config)

}

// handleRoot 处理根路径请求，提供静态文件服务

// 优先使用webroot目录，如果为空则使用内嵌的index.html

func handleRoot(w http.ResponseWriter, r *http.Request) {

if webroot != "" {

// 优先使用webroot目录

path := filepath.Join(webroot, r.URL.Path)

info, err := os.Stat(path)

if err == nil {

if info.IsDir() {

// 如果是目录，尝试查找 index.html

indexPath := filepath.Join(path, "index.html")

if _, err := os.Stat(indexPath); err == nil {

http.ServeFile(w, r, indexPath)

return

}

// 如果没有 index.html，返回 404

w.WriteHeader(http.StatusNotFound)

_, _ = w.Write([]byte("404 not found"))

return

}

// 如果是文件，直接提供

http.ServeFile(w, r, path)

return

}

// 如果文件不存在，返回 404

w.WriteHeader(http.StatusNotFound)

_, _ = w.Write([]byte("404 not found"))

return

}

// 如果没有指定 webroot，使用内嵌的 index.html

if r.URL.Path == "/" {

data, err := embeddedFS.ReadFile("index.html")

if err != nil {

w.WriteHeader(http.StatusNotFound)

_, _ = w.Write([]byte("index.html not found"))

return

}

w.Header().Set("Content-Type", "text/html; charset=utf-8")

w.WriteHeader(http.StatusOK)

_, _ = w.Write(data)

return

}

w.WriteHeader(http.StatusNotFound)

_, _ = w.Write([]byte("404 not found"))

}

// handleMode 处理模式检测请求，返回当前服务模式

func handleMode(w http.ResponseWriter, _ *http.Request) {

w.Header().Set("Content-Type", "application/json")

w.WriteHeader(http.StatusOK)

_, _ = w.Write([]byte(`{"mode": "proxy"}`))

}

// handleDoc 处理文档下载请求，返回README.md文件

func handleDoc(w http.ResponseWriter, _ *http.Request) {

data, err := embeddedFS.ReadFile("README.md")

if err != nil {

w.WriteHeader(http.StatusNotFound)

_, _ = w.Write([]byte("README.md not found"))

return

}

w.Header().Set("Content-Type", "text/markdown; charset=utf-8")

w.Header().Set("Content-Disposition", "attachment; filename=README.md")

w.Header().Set("Cache-Control", "public, max-age=3600")

w.WriteHeader(http.StatusOK)

_, _ = w.Write(data)

}

// handleFavicon 处理favicon.ico请求

func handleFavicon(w http.ResponseWriter, r *http.Request) {

data, err := embeddedFS.ReadFile("favicon.ico")

if err != nil {

w.WriteHeader(http.StatusNotFound)

return

}

w.Header().Set("Content-Type", "image/x-icon")

w.Header().Set("Cache-Control", "public, max-age=86400")

w.WriteHeader(http.StatusOK)

_, _ = w.Write(data)

}

// handleForward 处理HTTP请求转发，支持多种请求体格式和文件上传

func handleForward(w http.ResponseWriter, r *http.Request) {

// 只允许POST方法

if r.Method != http.MethodPost {

http.Error(w, "只支持POST方法", http.StatusMethodNotAllowed)

logger.Error("拒绝非POST请求", "method", r.Method, "url", r.URL.String())

return

}

logger.Info("收到请求", "method", r.Method, "url", r.URL.String())

logger.Debug("请求Header", "header", r.Header)

// 解析multipart/form-data请求，支持最大16GB

err := r.ParseMultipartForm(maxMemory)

if err != nil {

http.Error(w, "解析请求失败: "+err.Error(), http.StatusBadRequest)

logger.Error("解析请求失败", "err", err)

return

}

// 获取并验证目标URL

forwardURL := r.FormValue("url")

if forwardURL == "" {

http.Error(w, "缺少目标URL", http.StatusBadRequest)

logger.Error("缺少目标URL参数")

return

}

logger.Debug("转发目标URL", "url", forwardURL)

logger.Debug("Form参数", "form", r.Form)

// 获取SSL验证参数，默认启用

verifySSL := r.FormValue("verify_ssl")

if verifySSL == "" {

verifySSL = "Y"

}

// 获取重定向跟随参数，默认启用

followRedirect := r.FormValue("follow_redirect")

if followRedirect == "" {

followRedirect = "Y"

}

// 解析超时时间参数

timeOut := 0

if timeoutStr := r.FormValue("time_out"); timeoutStr != "" {

timeOut, err = strconv.Atoi(timeoutStr)

if err != nil {

http.Error(w, "无效的超时时间", http.StatusBadRequest)

return

}

}

// 解析重试次数参数

retryCount := 0

if retryStr := r.FormValue("retry_count"); retryStr != "" {

retryCount, err = strconv.Atoi(retryStr)

if err != nil {

http.Error(w, "无效的重试次数", http.StatusBadRequest)

return

}

}

// 解析重试延迟参数

retryDelay := 0

if delayStr := r.FormValue("retry_delay"); delayStr != "" {

retryDelay, err = strconv.Atoi(delayStr)

if err != nil {

http.Error(w, "无效的重试延迟", http.StatusBadRequest)

return

}

}

// 获取请求方法，默认为GET

method := r.FormValue("method")

if method == "" {

method = http.MethodGet

}

// 获取请求体类型，默认为none

bodyType := r.FormValue("body_type")

if bodyType == "" {

bodyType = "none"

}

// 解析请求头JSON

var headers []Header

if headersStr := r.FormValue("headers"); headersStr != "" {

if err := json.Unmarshal([]byte(headersStr), &headers); err != nil {

http.Error(w, "解析请求头失败: "+err.Error(), http.StatusBadRequest)

return

}

}

// 解析文件信息JSON

var filesInfo []FileInfo

if filesInfoStr := r.FormValue("file_info"); filesInfoStr != "" {

if err := json.Unmarshal([]byte(filesInfoStr), &filesInfo); err != nil {

http.Error(w, "解析文件信息失败: "+err.Error(), http.StatusBadRequest)

return

}

}

// 处理WebSocket连接请求

if method == "WS" {

params := ForwardParams{

URL: forwardURL,

Headers: r.FormValue("headers"),

VerifySSL: verifySSL,

FollowRedirect: followRedirect,

Timeout: timeOut,

RetryCount: retryCount,

RetryDelay: retryDelay,

}

connectID := genConnectID()

wsConnParams.Store(connectID, params)

w.Header().Set("Content-Type", "application/json")

w.WriteHeader(http.StatusOK)

_, _ = w.Write([]byte(fmt.Sprintf(`{"connect_id":"%s","code":0,"msg":"OK"}`, connectID)))

return

}

// 处理SSE连接请求

if method == "SSE" {

params := ForwardParams{

URL: forwardURL,

Headers: r.FormValue("headers"),

VerifySSL: verifySSL,

FollowRedirect: followRedirect,

Timeout: timeOut,

RetryCount: retryCount,

RetryDelay: retryDelay,

}

connectID := genConnectID()

sseConnParams.Store(connectID, params)

w.Header().Set("Content-Type", "application/json")

w.WriteHeader(http.StatusOK)

_, _ = w.Write([]byte(fmt.Sprintf(`{"connect_id":"%s","code":0,"msg":"OK"}`, connectID)))

return

}

// 准备请求体数据

var requestBodyBytes []byte

var contentType string

// 创建文件映射：字段名 -> 文件信息列表

fieldToFiles := make(map[string][]FileInfo)

for _, fi := range filesInfo {

fieldToFiles[fi.FieldName] = append(fieldToFiles[fi.FieldName], fi)

}

// 根据请求体类型处理数据

switch strings.ToLower(bodyType) {

case "form-data":

// 处理multipart/form-data格式

bodyBuf := &bytes.Buffer{}

bodyWriter := multipart.NewWriter(bodyBuf)

// 添加普通表单字段

for key, values := range r.MultipartForm.Value {

if !controlParams[key] {

for _, value := range values {

_ = bodyWriter.WriteField(key, value)

}

}

}

// 处理文件上传

for fieldName, files := range fieldToFiles {

for _, fileInfo := range files {

// 在原始请求中查找匹配的文件

var foundFile *multipart.FileHeader

for _, fileHeaders := range r.MultipartForm.File {

for _, fh := range fileHeaders {

if fh.Filename == fileInfo.FileName {

foundFile = fh

break

}

}

if foundFile != nil {

break

}

}

if foundFile == nil {

http.Error(w, "文件未上传: "+fileInfo.FileName, http.StatusBadRequest)

return

}

file, err := foundFile.Open()

if err != nil {

http.Error(w, "打开文件失败: "+err.Error(), http.StatusInternalServerError)

return

}

// 使用流式处理避免大文件内存占用

filePart, err := bodyWriter.CreateFormFile(fieldName, fileInfo.FileName)

if err != nil {

_ = file.Close()

http.Error(w, "创建表单文件失败: "+err.Error(), http.StatusInternalServerError)

return

}

if _, err := io.Copy(filePart, file); err != nil {

_ = file.Close()

http.Error(w, "写入文件数据失败: "+err.Error(), http.StatusInternalServerError)

return

}

// 立即关闭文件，避免在循环中累积文件句柄

_ = file.Close()

}

}

// 完成multipart写入

if err := bodyWriter.Close(); err != nil {

http.Error(w, "关闭multipart写入器失败: "+err.Error(), http.StatusInternalServerError)

return

}

contentType = bodyWriter.FormDataContentType()

requestBodyBytes = bodyBuf.Bytes()

case "x-www-form-urlencoded":

// 处理application/x-www-form-urlencoded格式

data := url.Values{}

for key, values := range r.MultipartForm.Value {

if !controlParams[key] {

for _, value := range values {

data.Add(key, value)

}

}

}

contentType = "application/x-www-form-urlencoded"

requestBodyBytes = []byte(data.Encode())

case "json":

// 处理application/json格式

jsonBody := r.FormValue("body")

contentType = "application/json"

requestBodyBytes = []byte(jsonBody)

case "text":

// 处理text/plain格式

textBody := r.FormValue("body")

contentType = "text/plain"

requestBodyBytes = []byte(textBody)

case "xml":

// 处理application/xml格式

xmlBody := r.FormValue("body")

contentType = "application/xml"

requestBodyBytes = []byte(xmlBody)

case "binary":

// 处理二进制文件上传

if files := r.MultipartForm.File["files"]; len(files) > 0 {

file, err := files[0].Open()

if err != nil {

http.Error(w, "打开文件失败: "+err.Error(), http.StatusBadRequest)

return

}

defer file.Close()

fileData, err := io.ReadAll(file)

if err != nil {

http.Error(w, "读取文件失败: "+err.Error(), http.StatusBadRequest)

return

}

contentType = "application/octet-stream"

requestBodyBytes = fileData

}

case "none", "":

// 无请求体

requestBodyBytes = nil

default:

http.Error(w, "不支持的请求体类型: "+bodyType, http.StatusBadRequest)

return

}

// 创建目标URL

targetURL, err := url.Parse(forwardURL)

if err != nil {

http.Error(w, "无效的目标URL: "+err.Error(), http.StatusBadRequest)

return

}

// 设置HTTP客户端

client := &http.Client{}

if timeOut > 0 {

client.Timeout = time.Duration(timeOut) * time.Second

}

// 如果 verify_ssl == "N",跳过 SSL 验证

if verifySSL == "N" {

tr := &http.Transport{

TLSClientConfig: &tls.Config{InsecureSkipVerify: true},

}

client.Transport = tr

}

// 如果 follow_redirect == "N",不跟随 3XX 跳转

if followRedirect == "N" {

client.CheckRedirect = func(req *http.Request, via []*http.Request) error {

return http.ErrUseLastResponse

}

}

// 执行请求重试逻辑

var resp *http.Response

for i := 0; i <= retryCount; i++ {

if i > 0 && retryDelay > 0 {

time.Sleep(time.Duration(retryDelay) * time.Second)

}

// 准备请求体读取器

var bodyReader io.Reader

if requestBodyBytes != nil {

bodyReader = bytes.NewReader(requestBodyBytes)

} else {

bodyReader = nil

}

// 创建HTTP请求

httpReq, err := http.NewRequest(method, targetURL.String(), bodyReader)

if err != nil {

if i == retryCount {

http.Error(w, "创建HTTP请求失败: "+err.Error(), http.StatusInternalServerError)

return

}

continue

}

// 设置请求头

if contentType != "" {

httpReq.Header.Set("Content-Type", contentType)

}

// 添加用户自定义的请求头

for _, header := range headers {

httpReq.Header.Set(header.Name, header.Value)

}

// 发送请求

resp, err = client.Do(httpReq)

if err == nil && resp.StatusCode < 500 {

logger.Info("转发成功", "method", method, "target", targetURL.String(), "status", resp.StatusCode)

logger.Debug("响应Header", "header", resp.Header)

break

}

if err != nil && i == retryCount {

http.Error(w, "转发请求失败: "+err.Error(), http.StatusInternalServerError)

logger.Error("转发请求失败", "err", err)

return

}

}

// 确保resp不为nil

if resp == nil {

http.Error(w, "转发请求失败: 没有有效的响应", http.StatusInternalServerError)

logger.Error("转发请求失败: 没有有效的响应")

return

}

defer resp.Body.Close()

// 将响应头复制到响应写入器

// 创建一个映射来存储所有响应头

responseHeaders := make(map[string][]string)

for key, values := range resp.Header {

// 将每个响应头添加到响应中

for _, value := range values {

w.Header().Add(key, value)

}

// 同时将响应头存储在映射中

responseHeaders[key] = values

}

// 添加一个特殊的响应头来传递所有头信息

if headersJSON, err := json.Marshal(responseHeaders); err == nil {

w.Header().Set("X-Response-Headers", string(headersJSON))

}

// 检查是否启用流式转发

stream := r.FormValue("stream")

if stream == "true" {

// 流式转发：实时读取并发送数据

streamResponse(w, resp)

return

}

// 默认：阻塞式复制整个响应体

w.WriteHeader(resp.StatusCode)

if _, err := io.Copy(w, resp.Body); err != nil {

http.Error(w, "复制响应体失败: "+err.Error(), http.StatusInternalServerError)

}

}

// streamResponse 流式转发响应体，实时将后端数据推送给前端

func streamResponse(w http.ResponseWriter, resp *http.Response) {

// 获取 Flusher 接口，用于实时推送数据

flusher, ok := w.(http.Flusher)

if !ok {

http.Error(w, "Streaming unsupported!", http.StatusInternalServerError)

return

}

// 写入状态码

w.WriteHeader(resp.StatusCode)

// 使用缓冲读取器，每读取一块数据就立即发送给前端

buf := make([]byte, 32*1024) // 32KB 缓冲区

for {

n, err := resp.Body.Read(buf)

if n > 0 {

if _, writeErr := w.Write(buf[:n]); writeErr != nil {

break

}

flusher.Flush() // 立即推送给前端

}

if err != nil {

break

}

}

}

// websocketForward 实现WebSocket双向转发功能

// ws1: 客户端WebSocket连接

// ws2: 目标服务器WebSocket连接

func websocketForward(ws1, ws2 *Conn) {

// 添加到等待组，确保优雅退出时等待所有连接完成

shutdownWg.Add(1)

defer shutdownWg.Done()

var wg sync.WaitGroup

wg.Add(2)

// 定义转发函数，用于双向数据转发

forward := func(dst, src *Conn, name string) {

defer wg.Done()

defer func() { _ = dst.Close(); _ = src.Close() }()

// 设置无超时

_ = src.SetReadDeadline(time.Time{})

_ = dst.SetWriteDeadline(time.Time{})

// 设置ping/pong处理器

src.SetPingHandler(func(data string) error {

return dst.WriteControl(PongMessage, []byte(data), time.Now().Add(10*time.Second))

})

src.SetPongHandler(func(string) error { return nil })

// 持续转发消息

for {

messageType, data, err := src.ReadMessage()

if err != nil {

return

}

if err := dst.WriteMessage(messageType, data); err != nil {

return

}

}

}

// 启动两个goroutine进行双向转发

go forward(ws1, ws2, "ws1<-->ws2")

go forward(ws2, ws1, "ws2<-->ws1")

wg.Wait()

}

// handleForwardWS 处理WebSocket转发请求

func handleForwardWS(w http.ResponseWriter, r *http.Request) {

// 获取连接ID

connectID := r.URL.Query().Get("connect_id")

if connectID == "" {

http.Error(w, "缺少connect_id", http.StatusBadRequest)

return

}

defer wsConnParams.Delete(connectID)

// 获取连接参数

v, ok := wsConnParams.Load(connectID)

if !ok {

http.Error(w, "无效的connect_id", http.StatusBadRequest)

return

}

params := v.(ForwardParams)

// 升级HTTP连接为WebSocket连接

wsUpgrade := Upgrader{CheckOrigin: func(r *http.Request) bool { return true }}

clientConn, err := wsUpgrade.Upgrade(w, r, nil)

if err != nil {

return

}

defer clientConn.Close()

// 解析请求头

headers := http.Header{}

if params.Headers != "" {

var hs []Header

_ = json.Unmarshal([]byte(params.Headers), &hs)

for _, h := range hs {

headers.Set(h.Name, h.Value)

}

}

// 配置WebSocket拨号器

dialer := Dialer{}

if params.VerifySSL == "N" {

dialer.TLSClientConfig = &tls.Config{InsecureSkipVerify: true}

}

if params.Timeout > 0 {

dialer.HandshakeTimeout = time.Duration(params.Timeout) * time.Second

}

// 重试机制连接目标WebSocket

var targetConn *Conn

var resp *http.Response

var dialErr error

for i := 0; i <= params.RetryCount; i++ {

if i > 0 && params.RetryDelay > 0 {

time.Sleep(time.Duration(params.RetryDelay) * time.Second)

}

targetConn, resp, dialErr = dialer.Dial(params.URL, headers)

if dialErr == nil {

break

}