mirror of
https://github.com/yusing/godoxy.git
synced 2025-06-01 01:22:34 +02:00
367 lines
11 KiB
Go
367 lines
11 KiB
Go
// Copyright 2011 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
// License URL: https://cs.opensource.google/go/go/+/master:LICENSE
|
|
|
|
// HTTP reverse proxy handler
|
|
|
|
package reverseproxy
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"log"
|
|
"net/http"
|
|
"net/http/httptrace"
|
|
"net/textproto"
|
|
"strings"
|
|
"sync"
|
|
|
|
"github.com/yusing/go-proxy/internal/utils"
|
|
"golang.org/x/net/http/httpguts"
|
|
)
|
|
|
|
// ReverseProxy is an HTTP Handler that takes an incoming request and
|
|
// sends it to another server, proxying the response back to the
|
|
// client.
|
|
//
|
|
// 1xx responses are forwarded to the client if the underlying
|
|
// transport supports ClientTrace.Got1xxResponse.
|
|
type ReverseProxy struct {
|
|
// Director is a function which modifies
|
|
// the request into a new request to be sent
|
|
// using Transport. Its response is then copied
|
|
// back to the original client unmodified.
|
|
// Director must not access the provided Request
|
|
// after returning.
|
|
//
|
|
// By default, the X-Forwarded-For header is set to the
|
|
// value of the client IP address. If an X-Forwarded-For
|
|
// header already exists, the client IP is appended to the
|
|
// existing values. As a special case, if the header
|
|
// exists in the Request.Header map but has a nil value
|
|
// (such as when set by the Director func), the X-Forwarded-For
|
|
// header is not modified.
|
|
//
|
|
// To prevent IP spoofing, be sure to delete any pre-existing
|
|
// X-Forwarded-For header coming from the client or
|
|
// an untrusted proxy.
|
|
//
|
|
// Hop-by-hop headers are removed from the request after
|
|
// Director returns, which can remove headers added by
|
|
// Director. Use a Rewrite function instead to ensure
|
|
// modifications to the request are preserved.
|
|
//
|
|
// Unparsable query parameters are removed from the outbound
|
|
// request if Request.Form is set after Director returns.
|
|
//
|
|
// At most one of Rewrite or Director may be set.
|
|
Director func(*http.Request)
|
|
|
|
// The transport used to perform proxy requests.
|
|
// If nil, http.DefaultTransport is used.
|
|
Transport http.RoundTripper
|
|
|
|
// ErrorLog specifies an optional logger for errors
|
|
// that occur when attempting to proxy the request.
|
|
// If nil, logging is done via the log package's standard logger.
|
|
ErrorLog *log.Logger
|
|
|
|
// ErrorHandler is an optional function that handles errors
|
|
// reaching the backend or errors from ModifyResponse.
|
|
//
|
|
// If nil, the default is to log the provided error and return
|
|
// a 502 Status Bad Gateway response.
|
|
ErrorHandler func(http.ResponseWriter, *http.Request, error)
|
|
}
|
|
|
|
func copyHeader(dst, src http.Header) {
|
|
for k, vv := range src {
|
|
for _, v := range vv {
|
|
dst.Add(k, v)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Hop-by-hop headers. These are removed when sent to the backend.
|
|
// As of RFC 7230, hop-by-hop headers are required to appear in the
|
|
// Connection header field. These are the headers defined by the
|
|
// obsoleted RFC 2616 (section 13.5.1) and are used for backward
|
|
// compatibility.
|
|
var hopHeaders = []string{
|
|
"Connection",
|
|
"Proxy-Connection", // non-standard but still sent by libcurl and rejected by e.g. google
|
|
"Keep-Alive",
|
|
"Proxy-Authenticate",
|
|
"Proxy-Authorization",
|
|
"Te", // canonicalized version of "TE"
|
|
"Trailer", // not Trailers per URL above; https://www.rfc-editor.org/errata_search.php?eid=4522
|
|
"Transfer-Encoding",
|
|
"Upgrade",
|
|
}
|
|
|
|
func (p *ReverseProxy) defaultErrorHandler(rw http.ResponseWriter, req *http.Request, err error) {
|
|
p.logf("http: proxy error: %v", err)
|
|
rw.WriteHeader(http.StatusBadGateway)
|
|
}
|
|
|
|
func (p *ReverseProxy) getErrorHandler() func(http.ResponseWriter, *http.Request, error) {
|
|
if p.ErrorHandler != nil {
|
|
return p.ErrorHandler
|
|
}
|
|
return p.defaultErrorHandler
|
|
}
|
|
|
|
func (p *ReverseProxy) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
|
|
transport := p.Transport
|
|
ctx := req.Context()
|
|
|
|
outreq := req.Clone(ctx)
|
|
if req.ContentLength == 0 {
|
|
outreq.Body = nil // Issue 16036: nil Body for http.Transport retries
|
|
}
|
|
if outreq.Body != nil {
|
|
// Reading from the request body after returning from a handler is not
|
|
// allowed, and the RoundTrip goroutine that reads the Body can outlive
|
|
// this handler. This can lead to a crash if the handler panics (see
|
|
// Issue 46866). Although calling Close doesn't guarantee there isn't
|
|
// any Read in flight after the handle returns, in practice it's safe to
|
|
// read after closing it.
|
|
defer outreq.Body.Close()
|
|
}
|
|
if outreq.Header == nil {
|
|
outreq.Header = make(http.Header) // Issue 33142: historical behavior was to always allocate
|
|
}
|
|
|
|
p.Director(outreq)
|
|
outreq.Close = false
|
|
|
|
reqUpType := upgradeType(outreq.Header)
|
|
if !IsPrint(reqUpType) {
|
|
p.getErrorHandler()(rw, req, fmt.Errorf("client tried to switch to invalid protocol %q", reqUpType))
|
|
return
|
|
}
|
|
|
|
req.Header.Del("Forwarded")
|
|
removeHopByHopHeaders(outreq.Header)
|
|
|
|
// Issue 21096: tell backend applications that care about trailer support
|
|
// that we support trailers. (We do, but we don't go out of our way to
|
|
// advertise that unless the incoming client request thought it was worth
|
|
// mentioning.) Note that we look at req.Header, not outreq.Header, since
|
|
// the latter has passed through removeHopByHopHeaders.
|
|
if httpguts.HeaderValuesContainsToken(req.Header["Te"], "trailers") {
|
|
outreq.Header.Set("Te", "trailers")
|
|
}
|
|
|
|
if _, ok := outreq.Header["User-Agent"]; !ok {
|
|
// If the outbound request doesn't have a User-Agent header set,
|
|
// don't send the default Go HTTP client User-Agent.
|
|
outreq.Header.Set("User-Agent", "")
|
|
}
|
|
|
|
var (
|
|
roundTripMutex sync.Mutex
|
|
roundTripDone bool
|
|
)
|
|
trace := &httptrace.ClientTrace{
|
|
Got1xxResponse: func(code int, header textproto.MIMEHeader) error {
|
|
roundTripMutex.Lock()
|
|
defer roundTripMutex.Unlock()
|
|
if roundTripDone {
|
|
// If RoundTrip has returned, don't try to further modify
|
|
// the ResponseWriter's header map.
|
|
return nil
|
|
}
|
|
h := rw.Header()
|
|
copyHeader(h, http.Header(header))
|
|
rw.WriteHeader(code)
|
|
|
|
// Clear headers, it's not automatically done by ResponseWriter.WriteHeader() for 1xx responses
|
|
clear(h)
|
|
return nil
|
|
},
|
|
}
|
|
outreq = outreq.WithContext(httptrace.WithClientTrace(outreq.Context(), trace))
|
|
|
|
res, err := transport.RoundTrip(outreq)
|
|
roundTripMutex.Lock()
|
|
roundTripDone = true
|
|
roundTripMutex.Unlock()
|
|
if err != nil {
|
|
p.getErrorHandler()(rw, outreq, err)
|
|
return
|
|
}
|
|
|
|
// Deal with 101 Switching Protocols responses: (WebSocket, h2c, etc)
|
|
if res.StatusCode == http.StatusSwitchingProtocols {
|
|
p.handleUpgradeResponse(rw, outreq, res)
|
|
return
|
|
}
|
|
|
|
removeHopByHopHeaders(res.Header)
|
|
|
|
copyHeader(rw.Header(), res.Header)
|
|
|
|
// The "Trailer" header isn't included in the Transport's response,
|
|
// at least for *http.Transport. Build it up from Trailer.
|
|
announcedTrailers := len(res.Trailer)
|
|
if announcedTrailers > 0 {
|
|
trailerKeys := make([]string, 0, len(res.Trailer))
|
|
for k := range res.Trailer {
|
|
trailerKeys = append(trailerKeys, k)
|
|
}
|
|
rw.Header().Add("Trailer", strings.Join(trailerKeys, ", "))
|
|
}
|
|
|
|
rw.WriteHeader(res.StatusCode)
|
|
|
|
err = utils.CopyCloseWithContext(ctx, rw, res.Body, int(res.ContentLength))
|
|
if err != nil {
|
|
if !errors.Is(err, context.Canceled) {
|
|
p.getErrorHandler()(rw, req, err)
|
|
}
|
|
return
|
|
}
|
|
|
|
if len(res.Trailer) > 0 {
|
|
// Force chunking if we saw a response trailer.
|
|
// This prevents net/http from calculating the length for short
|
|
// bodies and adding a Content-Length.
|
|
http.NewResponseController(rw).Flush()
|
|
}
|
|
|
|
if len(res.Trailer) == announcedTrailers {
|
|
copyHeader(rw.Header(), res.Trailer)
|
|
return
|
|
}
|
|
|
|
for k, vv := range res.Trailer {
|
|
k = http.TrailerPrefix + k
|
|
for _, v := range vv {
|
|
rw.Header().Add(k, v)
|
|
}
|
|
}
|
|
}
|
|
|
|
// removeHopByHopHeaders removes hop-by-hop headers.
|
|
func removeHopByHopHeaders(h http.Header) {
|
|
// RFC 7230, section 6.1: Remove headers listed in the "Connection" header.
|
|
for _, f := range h["Connection"] {
|
|
for sf := range strings.SplitSeq(f, ",") {
|
|
if sf = textproto.TrimString(sf); sf != "" {
|
|
h.Del(sf)
|
|
}
|
|
}
|
|
}
|
|
// RFC 2616, section 13.5.1: Remove a set of known hop-by-hop headers.
|
|
// This behavior is superseded by the RFC 7230 Connection header, but
|
|
// preserve it for backwards compatibility.
|
|
for _, f := range hopHeaders {
|
|
h.Del(f)
|
|
}
|
|
}
|
|
|
|
func (p *ReverseProxy) logf(format string, args ...any) {
|
|
if p.ErrorLog != nil {
|
|
p.ErrorLog.Printf(format, args...)
|
|
} else {
|
|
log.Printf(format, args...)
|
|
}
|
|
}
|
|
|
|
func upgradeType(h http.Header) string {
|
|
if !httpguts.HeaderValuesContainsToken(h["Connection"], "Upgrade") {
|
|
return ""
|
|
}
|
|
return h.Get("Upgrade")
|
|
}
|
|
|
|
func (p *ReverseProxy) handleUpgradeResponse(rw http.ResponseWriter, req *http.Request, res *http.Response) {
|
|
reqUpType := upgradeType(req.Header)
|
|
resUpType := upgradeType(res.Header)
|
|
if !IsPrint(resUpType) { // We know reqUpType is ASCII, it's checked by the caller.
|
|
p.getErrorHandler()(rw, req, fmt.Errorf("backend tried to switch to invalid protocol %q", resUpType))
|
|
return
|
|
}
|
|
if !strings.EqualFold(reqUpType, resUpType) {
|
|
p.getErrorHandler()(rw, req, fmt.Errorf("backend tried to switch protocol %q when %q was requested", resUpType, reqUpType))
|
|
return
|
|
}
|
|
|
|
backConn, ok := res.Body.(io.ReadWriteCloser)
|
|
if !ok {
|
|
p.getErrorHandler()(rw, req, fmt.Errorf("internal error: 101 switching protocols response with non-writable body"))
|
|
return
|
|
}
|
|
|
|
rc := http.NewResponseController(rw)
|
|
conn, brw, hijackErr := rc.Hijack()
|
|
if errors.Is(hijackErr, http.ErrNotSupported) {
|
|
p.getErrorHandler()(rw, req, fmt.Errorf("can't switch protocols using non-Hijacker ResponseWriter type %T", rw))
|
|
return
|
|
}
|
|
|
|
backConnCloseCh := make(chan bool)
|
|
go func() {
|
|
// Ensure that the cancellation of a request closes the backend.
|
|
// See issue https://golang.org/issue/35559.
|
|
select {
|
|
case <-req.Context().Done():
|
|
case <-backConnCloseCh:
|
|
}
|
|
backConn.Close()
|
|
}()
|
|
defer close(backConnCloseCh)
|
|
|
|
if hijackErr != nil {
|
|
p.getErrorHandler()(rw, req, fmt.Errorf("Hijack failed on protocol switch: %v", hijackErr))
|
|
return
|
|
}
|
|
defer conn.Close()
|
|
|
|
copyHeader(rw.Header(), res.Header)
|
|
|
|
res.Header = rw.Header()
|
|
res.Body = nil // so res.Write only writes the headers; we have res.Body in backConn above
|
|
if err := res.Write(brw); err != nil {
|
|
p.getErrorHandler()(rw, req, fmt.Errorf("response write: %v", err))
|
|
return
|
|
}
|
|
if err := brw.Flush(); err != nil {
|
|
p.getErrorHandler()(rw, req, fmt.Errorf("response flush: %v", err))
|
|
return
|
|
}
|
|
errc := make(chan error, 1)
|
|
spc := switchProtocolCopier{user: conn, backend: backConn}
|
|
go spc.copyToBackend(errc)
|
|
go spc.copyFromBackend(errc)
|
|
<-errc
|
|
}
|
|
|
|
// switchProtocolCopier exists so goroutines proxying data back and
|
|
// forth have nice names in stacks.
|
|
type switchProtocolCopier struct {
|
|
user, backend io.ReadWriter
|
|
}
|
|
|
|
func (c switchProtocolCopier) copyFromBackend(errc chan<- error) {
|
|
_, err := io.Copy(c.user, c.backend)
|
|
errc <- err
|
|
}
|
|
|
|
func (c switchProtocolCopier) copyToBackend(errc chan<- error) {
|
|
_, err := io.Copy(c.backend, c.user)
|
|
errc <- err
|
|
}
|
|
|
|
func IsPrint(s string) bool {
|
|
for _, r := range s {
|
|
if r < ' ' || r > '~' {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|