226 lines
5.8 KiB
Go
226 lines
5.8 KiB
Go
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"crypto/tls"
|
|
"encoding/base64"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"log/slog"
|
|
"mime/multipart"
|
|
"net/http"
|
|
"net/url"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
var httpClient = &http.Client{
|
|
Timeout: 200 * time.Second,
|
|
Transport: &http.Transport{
|
|
TLSClientConfig: &tls.Config{InsecureSkipVerify: true}, // Allow self-signed
|
|
},
|
|
}
|
|
|
|
func proxyRequestHandler(w http.ResponseWriter, r *http.Request) {
|
|
if err := r.ParseMultipartForm(512 << 20); err != nil { // 512MB
|
|
if err == http.ErrNotMultipart {
|
|
if err2 := r.ParseForm(); err2 != nil {
|
|
writeJSON(w, http.StatusBadRequest, map[string]any{"status_code": 400, "content": "Failed to parse form: " + err2.Error()})
|
|
return
|
|
}
|
|
} else {
|
|
writeJSON(w, http.StatusBadRequest, map[string]any{"status_code": 400, "content": "Failed to parse form: " + err.Error()})
|
|
return
|
|
}
|
|
}
|
|
|
|
targetURL := r.FormValue("url")
|
|
method := r.FormValue("method")
|
|
if method == "" {
|
|
method = "POST"
|
|
}
|
|
|
|
// Parse headers
|
|
headersStr := r.FormValue("headers")
|
|
var headers map[string]string
|
|
if err := json.Unmarshal([]byte(headersStr), &headers); err != nil {
|
|
headers = make(map[string]string)
|
|
}
|
|
|
|
// Parse auth
|
|
authStr := r.FormValue("auth")
|
|
var auth map[string]string
|
|
if err := json.Unmarshal([]byte(authStr), &auth); err != nil {
|
|
auth = map[string]string{"type": "none"}
|
|
}
|
|
|
|
// Construct request body
|
|
var reqBody io.Reader
|
|
var reqContentType string
|
|
hasFiles := r.MultipartForm != nil && len(r.MultipartForm.File) > 0
|
|
|
|
if hasFiles {
|
|
// Multipart request
|
|
bodyBuf := &bytes.Buffer{}
|
|
writer := multipart.NewWriter(bodyBuf)
|
|
|
|
// Form fields
|
|
for key, values := range r.MultipartForm.Value {
|
|
if isInternalKey(key) {
|
|
continue
|
|
}
|
|
for _, val := range values {
|
|
writer.WriteField(key, val)
|
|
}
|
|
}
|
|
|
|
// Files
|
|
for key, files := range r.MultipartForm.File {
|
|
for _, fileHeader := range files {
|
|
part, err := writer.CreateFormFile(key, fileHeader.Filename)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
file, err := fileHeader.Open()
|
|
if err != nil {
|
|
continue
|
|
}
|
|
io.Copy(part, file)
|
|
file.Close()
|
|
}
|
|
}
|
|
writer.Close()
|
|
reqBody = bodyBuf
|
|
reqContentType = writer.FormDataContentType()
|
|
} else if r.FormValue("body_type") == "json" {
|
|
bodyField := r.FormValue("body")
|
|
if bodyField == "" {
|
|
bodyField = r.FormValue("_json_body")
|
|
}
|
|
reqBody = bytes.NewBufferString(bodyField)
|
|
if _, ok := headers["Content-Type"]; !ok {
|
|
headers["Content-Type"] = "application/json"
|
|
}
|
|
} else {
|
|
// URL encoded form
|
|
form := url.Values{}
|
|
srcMap := r.Form
|
|
if r.MultipartForm != nil {
|
|
srcMap = r.MultipartForm.Value
|
|
}
|
|
for key, values := range srcMap {
|
|
if !isInternalKey(key) {
|
|
for _, val := range values {
|
|
form.Add(key, val)
|
|
}
|
|
}
|
|
}
|
|
encoded := form.Encode()
|
|
if encoded != "" {
|
|
reqBody = bytes.NewBufferString(encoded)
|
|
if _, ok := headers["Content-Type"]; !ok {
|
|
headers["Content-Type"] = "application/x-www-form-urlencoded"
|
|
}
|
|
}
|
|
}
|
|
|
|
// Create Request
|
|
outReq, err := http.NewRequest(method, targetURL, reqBody)
|
|
if err != nil {
|
|
writeJSON(w, http.StatusInternalServerError, map[string]any{"status_code": 500, "content": err.Error()})
|
|
return
|
|
}
|
|
|
|
// Auth
|
|
authType := auth["type"]
|
|
if authType == "bearer" {
|
|
outReq.Header.Set("Authorization", "Bearer "+auth["token"])
|
|
} else if authType == "basic" {
|
|
outReq.SetBasicAuth(auth["username"], auth["password"])
|
|
} else if authType == "apikey" {
|
|
if key, ok := auth["key"]; ok && key != "" {
|
|
outReq.Header.Set(key, auth["value"])
|
|
}
|
|
}
|
|
|
|
// Set headers
|
|
for k, v := range headers {
|
|
if hasFiles && strings.ToLower(k) == "content-type" {
|
|
continue // skip custom content-type if multipart
|
|
}
|
|
outReq.Header.Set(k, v)
|
|
}
|
|
|
|
if hasFiles {
|
|
outReq.Header.Set("Content-Type", reqContentType)
|
|
}
|
|
|
|
startTime := time.Now()
|
|
slog.Info("proxying request", "method", method, "url", targetURL, "has_files", hasFiles)
|
|
|
|
// Execute
|
|
resp, err := httpClient.Do(outReq)
|
|
duration := time.Since(startTime).Milliseconds()
|
|
if err != nil {
|
|
// Timeout or connection error
|
|
statusCode := 500
|
|
content := "Internal Proxy Error: " + err.Error()
|
|
if urlErr, ok := err.(*url.Error); ok && urlErr.Timeout() {
|
|
statusCode = 408
|
|
content = "Request Timeout"
|
|
}
|
|
slog.Error("proxy request failed", "url", targetURL, "status", statusCode, "duration_ms", duration, "error", err)
|
|
writeJSON(w, http.StatusOK, map[string]any{
|
|
"status_code": statusCode,
|
|
"content": content,
|
|
"headers": map[string]string{},
|
|
}) // Python returns 200 wrapper
|
|
return
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
slog.Info("proxy request completed", "url", targetURL, "status", resp.StatusCode, "duration_ms", duration)
|
|
|
|
// Parse Response
|
|
respData := map[string]any{
|
|
"status_code": resp.StatusCode,
|
|
"headers": make(map[string]string),
|
|
"content": nil,
|
|
"binary_data": nil,
|
|
"content_type": resp.Header.Get("Content-Type"),
|
|
}
|
|
|
|
for k, v := range resp.Header {
|
|
if len(v) > 0 {
|
|
respData["headers"].(map[string]string)[k] = v[0]
|
|
}
|
|
}
|
|
|
|
bodyBytes, _ := io.ReadAll(resp.Body)
|
|
contentType := strings.ToLower(resp.Header.Get("Content-Type"))
|
|
|
|
isBinary := strings.Contains(contentType, "image") || strings.Contains(contentType, "pdf") ||
|
|
strings.Contains(contentType, "octet-stream") || strings.Contains(contentType, "audio") ||
|
|
strings.Contains(contentType, "video") || strings.Contains(contentType, "zip")
|
|
|
|
if isBinary {
|
|
respData["binary_data"] = base64.StdEncoding.EncodeToString(bodyBytes)
|
|
respData["content"] = fmt.Sprintf("[Binary Data: %d bytes]", len(bodyBytes))
|
|
} else {
|
|
respData["content"] = string(bodyBytes)
|
|
}
|
|
|
|
writeJSON(w, http.StatusOK, respData)
|
|
}
|
|
|
|
func isInternalKey(key string) bool {
|
|
keys := []string{"url", "method", "headers", "auth", "body_type", "body", "_json_body"}
|
|
for _, k := range keys {
|
|
if k == key {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|