app-init

internal/tunnel/client.go

@@ -0,0 +1,131 @@
+package tunnel
+
+import (
+	"context"
+	"crypto/tls"
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"strings"
+	"time"
+
+	"mysql-tunnel/internal/logger"
+)
+
+// HTTPClient is a generic HTTP client for the tunnel endpoint.
+// Navicat request/response encoding belongs in package navicat (Phase 2).
+type HTTPClient struct {
+	base       *http.Client
+	insecure   bool
+	userAgent  string
+}
+
+type Options struct {
+	Timeout               time.Duration
+	TLSInsecureSkipVerify bool
+}
+
+func NewHTTPClient(opt Options) *HTTPClient {
+	if opt.Timeout <= 0 {
+		opt.Timeout = 30 * time.Second
+	}
+	transport := &http.Transport{
+		Proxy: http.ProxyFromEnvironment,
+		DialContext: (&net.Dialer{
+			Timeout:   10 * time.Second,
+			KeepAlive: 30 * time.Second,
+		}).DialContext,
+		ForceAttemptHTTP2:     true,
+		MaxIdleConns:          8,
+		IdleConnTimeout:       90 * time.Second,
+		TLSHandshakeTimeout:   10 * time.Second,
+		ExpectContinueTimeout: 1 * time.Second,
+		TLSClientConfig:       &tls.Config{MinVersion: tls.VersionTLS12},
+	}
+	if opt.TLSInsecureSkipVerify {
+		transport.TLSClientConfig.InsecureSkipVerify = true
+	}
+	return &HTTPClient{
+		base: &http.Client{
+			Timeout:   opt.Timeout,
+			Transport: transport,
+		},
+		insecure:  opt.TLSInsecureSkipVerify,
+		userAgent: "mysql-tunnel/0.1",
+	}
+}
+
+type Response struct {
+	StatusCode  int
+	ContentType string
+	Body        []byte
+}
+
+func (c *HTTPClient) Do(ctx context.Context, method, rawURL string, contentType string, body io.Reader) (*Response, error) {
+	req, err := http.NewRequestWithContext(ctx, method, rawURL, body)
+	if err != nil {
+		return nil, fmt.Errorf("build request: %w", redactErr(err))
+	}
+	req.Header.Set("User-Agent", c.userAgent)
+	if contentType != "" {
+		req.Header.Set("Content-Type", contentType)
+	}
+	resp, err := c.base.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("http %s %s: %w", method, logger.RedactURL(rawURL), redactErr(err))
+	}
+	defer resp.Body.Close()
+	data, err := io.ReadAll(io.LimitReader(resp.Body, 64<<20))
+	if err != nil {
+		return nil, fmt.Errorf("read response from %s: %w", logger.RedactURL(rawURL), err)
+	}
+	return &Response{
+		StatusCode:  resp.StatusCode,
+		ContentType: resp.Header.Get("Content-Type"),
+		Body:        data,
+	}, nil
+}
+
+func (c *HTTPClient) InsecureTLS() bool {
+	return c.insecure
+}
+
+func redactErr(err error) error {
+	if err == nil {
+		return nil
+	}
+	return fmt.Errorf("%s", logger.RedactError(err))
+}
+
+func LooksLikeNavicatHeader(body []byte) bool {
+	if len(body) < 16 {
+		return false
+	}
+	magic := uint32(body[0])<<24 | uint32(body[1])<<16 | uint32(body[2])<<8 | uint32(body[3])
+	return magic == 1111
+}
+
+func HeaderErrno(body []byte) (uint32, bool) {
+	if len(body) < 10 {
+		return 0, false
+	}
+	errno := uint32(body[6])<<24 | uint32(body[7])<<16 | uint32(body[8])<<8 | uint32(body[9])
+	return errno, true
+}
+
+func IsProbablyHTML(body []byte) bool {
+	s := strings.TrimSpace(string(body))
+	if len(s) < 5 {
+		return false
+	}
+	ls := strings.ToLower(s[:min(64, len(s))])
+	return strings.HasPrefix(ls, "<!doctype") || strings.HasPrefix(ls, "<html")
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}