Method ServeHTTP

modules/caddyhttp/reverseproxy/reverseproxy.go:485–597

(w http.ResponseWriter, r *http.Request, next caddyhttp.Handler)

}

func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request, next caddyhttp.Handler) error {
	repl := r.Context().Value(caddy.ReplacerCtxKey).(*caddy.Replacer)

	// prepare the request for proxying; this is needed only once
	clonedReq, err := h.prepareRequest(r, repl)
	if err != nil {
		return caddyhttp.Error(http.StatusInternalServerError,
			fmt.Errorf("preparing request for upstream round-trip: %v", err))
	}

	// websocket over http2 or http3 if extended connect is enabled, assuming backend doesn't support this, the request will be modified to http1.1 upgrade
	// Both use the same upgrade mechanism: server advertizes extended connect support, and client sends the pseudo header :protocol in a CONNECT request
	// The quic-go http3 implementation also puts :protocol in r.Proto for CONNECT requests (quic-go/http3/headers.go@70-72,185,203)
	// TODO: once we can reliably detect backend support this, it can be removed for those backends
	if (r.ProtoMajor == 2 && r.Method == http.MethodConnect && r.Header.Get(":protocol") == "websocket") ||
		(r.ProtoMajor == 3 && r.Method == http.MethodConnect && r.Proto == "websocket") {
		clonedReq.Header.Del(":protocol")
		// keep the body for later use. http1.1 upgrade uses http.NoBody
		caddyhttp.SetVar(clonedReq.Context(), "extended_connect_websocket_body", clonedReq.Body)
		clonedReq.Body = http.NoBody
		clonedReq.Method = http.MethodGet
		clonedReq.Header.Set("Upgrade", "websocket")
		clonedReq.Header.Set("Connection", "Upgrade")
		key := make([]byte, 16)
		_, randErr := rand.Read(key)
		if randErr != nil {
			return randErr
		}
		clonedReq.Header["Sec-WebSocket-Key"] = []string{base64.StdEncoding.EncodeToString(key)}
	}

	// we will need the original headers and Host value if
	// header operations are configured; this is so that each
	// retry can apply the modifications, because placeholders
	// may be used which depend on the selected upstream for
	// their values
	reqHost := clonedReq.Host
	reqHeader := clonedReq.Header

	// If the request contained a body, wrap it in io.NopCloser
	// to prevent Go's transport from closing it on dial errors.
	// cloneRequest does a shallow copy, so clonedReq.Body and
	// r.Body share the same io.ReadCloser — a dial-failure Close()
	// would kill the original body for all subsequent retry
	// attempts or subsequent handlers. The real body is closed by
	// the HTTP server when the handler returns.
	//
	// If the body was already fully buffered (via request_buffers),
	// we also extract the buffer so the retry loop can replay it
	// from the beginning on each attempt. (see #6259, #7546, #7713)
	var bufferedReqBody *bytes.Buffer
	if clonedReq.Body != nil {
		if reqBodyBuf, ok := clonedReq.Body.(bodyReadCloser); ok && reqBodyBuf.body == nil && reqBodyBuf.buf != nil {
			bufferedReqBody = reqBodyBuf.buf
			reqBodyBuf.buf = nil
			clonedReq.Body = io.NopCloser(bytes.NewReader(bufferedReqBody.Bytes()))
			defer func() {
				bufferedReqBody.Reset()