2019-09-09 13:23:27 -05:00
// Copyright 2015 Matthew Holt and The Caddy Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package reverseproxy
import (
2023-05-15 13:14:50 -05:00
"fmt"
2024-07-15 12:00:12 -05:00
"net"
2019-09-09 13:23:27 -05:00
"net/http"
2020-02-27 22:56:24 -05:00
"reflect"
2019-09-09 13:23:27 -05:00
"strconv"
"strings"
2023-08-14 10:41:15 -05:00
"github.com/dustin/go-humanize"
2019-09-09 13:23:27 -05:00
"github.com/caddyserver/caddy/v2"
"github.com/caddyserver/caddy/v2/caddyconfig"
"github.com/caddyserver/caddy/v2/caddyconfig/caddyfile"
"github.com/caddyserver/caddy/v2/caddyconfig/httpcaddyfile"
2024-08-07 12:02:23 -05:00
"github.com/caddyserver/caddy/v2/internal"
2019-09-09 13:23:27 -05:00
"github.com/caddyserver/caddy/v2/modules/caddyhttp"
2019-09-20 14:13:49 -05:00
"github.com/caddyserver/caddy/v2/modules/caddyhttp/headers"
2022-05-06 09:50:26 -05:00
"github.com/caddyserver/caddy/v2/modules/caddyhttp/rewrite"
2024-04-12 08:19:14 -05:00
"github.com/caddyserver/caddy/v2/modules/caddytls"
2019-09-09 13:23:27 -05:00
)
func init ( ) {
httpcaddyfile . RegisterHandlerDirective ( "reverse_proxy" , parseCaddyfile )
reverseproxy: copy_response and copy_response_headers for handle_response routes (#4391)
* reverseproxy: New `copy_response` handler for `handle_response` routes
Followup to #4298 and #4388.
This adds a new `copy_response` handler which may only be used in `reverse_proxy`'s `handle_response` routes, which can be used to actually copy the proxy response downstream.
Previously, if `handle_response` was used (with routes, not the status code mode), it was impossible to use the upstream's response body at all, because we would always close the body, expecting the routes to write a new body from scratch.
To implement this, I had to refactor `h.reverseProxy()` to move all the code that came after the `HandleResponse` loop into a new function. This new function `h.finalizeResponse()` takes care of preparing the response by removing extra headers, dealing with trailers, then copying the headers and body downstream.
Since basically what we want `copy_response` to do is invoke `h.finalizeResponse()` at a configurable point in time, we need to pass down the proxy handler, the response, and some other state via a new `req.WithContext(ctx)`. Wrapping a new context is pretty much the only way we have to jump a few layers in the HTTP middleware chain and let a handler pick up this information. Feels a bit dirty, but it works.
Also fixed a bug with the `http.reverse_proxy.upstream.duration` placeholder, it always had the same duration as `http.reverse_proxy.upstream.latency`, but the former was meant to be the time taken for the roundtrip _plus_ copying/writing the response.
* Delete the "Content-Length" header if we aren't copying
Fixes a bug where the Content-Length will mismatch the actual bytes written if we skipped copying the response, so we get a message like this when using curl:
```
curl: (18) transfer closed with 18 bytes remaining to read
```
To replicate:
```
{
admin off
debug
}
:8881 {
reverse_proxy 127.0.0.1:8882 {
@200 status 200
handle_response @200 {
header Foo bar
}
}
}
:8882 {
header Content-Type application/json
respond `{"hello": "world"}` 200
}
```
* Implement `copy_response_headers`, with include/exclude list support
* Apply suggestions from code review
Co-authored-by: Matt Holt <mholt@users.noreply.github.com>
2022-03-09 13:00:51 -05:00
httpcaddyfile . RegisterHandlerDirective ( "copy_response" , parseCopyResponseCaddyfile )
httpcaddyfile . RegisterHandlerDirective ( "copy_response_headers" , parseCopyResponseHeadersCaddyfile )
2019-09-09 13:23:27 -05:00
}
func parseCaddyfile ( h httpcaddyfile . Helper ) ( caddyhttp . MiddlewareHandler , error ) {
rp := new ( Handler )
err := rp . UnmarshalCaddyfile ( h . Dispenser )
if err != nil {
return nil , err
}
2021-05-02 13:39:06 -05:00
err = rp . FinalizeUnmarshalCaddyfile ( h )
if err != nil {
return nil , err
}
2019-09-09 13:23:27 -05:00
return rp , nil
}
// UnmarshalCaddyfile sets up the handler from Caddyfile tokens. Syntax:
//
2022-08-25 22:42:48 -05:00
// reverse_proxy [<matcher>] [<upstreams...>] {
// # backends
// to <upstreams...>
// dynamic <name> [...]
2019-09-09 13:23:27 -05:00
//
2022-08-25 22:42:48 -05:00
// # load balancing
// lb_policy <name> [<options...>]
// lb_retries <retries>
// lb_try_duration <duration>
// lb_try_interval <interval>
// lb_retry_match <request-matcher>
2019-09-09 13:23:27 -05:00
//
2022-08-25 22:42:48 -05:00
// # active health checking
2024-08-19 11:55:55 -05:00
// health_uri <uri>
// health_port <port>
// health_interval <interval>
// health_passes <num>
// health_fails <num>
// health_timeout <duration>
// health_status <status>
// health_body <regexp>
// health_method <value>
// health_request_body <value>
2024-05-07 09:40:15 -05:00
// health_follow_redirects
2022-08-25 22:42:48 -05:00
// health_headers {
// <field> [<values...>]
// }
2019-09-09 13:23:27 -05:00
//
2022-08-25 22:42:48 -05:00
// # passive health checking
// fail_duration <duration>
// max_fails <num>
// unhealthy_status <status>
// unhealthy_latency <duration>
// unhealthy_request_count <num>
2019-09-09 13:23:27 -05:00
//
2022-08-25 22:42:48 -05:00
// # streaming
2023-06-19 16:54:43 -05:00
// flush_interval <duration>
2022-08-25 22:42:48 -05:00
// buffer_requests
// buffer_responses
2023-06-19 16:54:43 -05:00
// max_buffer_size <size>
// stream_timeout <duration>
// stream_close_delay <duration>
2023-10-11 14:36:20 -05:00
// trace_logs
2019-11-27 13:51:32 -05:00
//
2022-08-25 22:42:48 -05:00
// # request manipulation
// trusted_proxies [private_ranges] <ranges...>
// header_up [+|-]<field> [<value|regexp> [<replacement>]]
// header_down [+|-]<field> [<value|regexp> [<replacement>]]
// method <method>
// rewrite <to>
2019-09-20 14:13:49 -05:00
//
2022-08-25 22:42:48 -05:00
// # round trip
// transport <name> {
// ...
// }
2021-05-02 13:39:06 -05:00
//
2022-08-25 22:42:48 -05:00
// # optionally intercept responses from upstream
// @name {
// status <code...>
// header <field> [<value>]
// }
// replace_status [<matcher>] <status_code>
// handle_response [<matcher>] {
// <directives...>
2022-03-13 01:38:11 -05:00
//
2022-08-25 22:42:48 -05:00
// # special directives only available in handle_response
// copy_response [<matcher>] [<status>] {
// status <status>
// }
// copy_response_headers [<matcher>] {
// include <fields...>
// exclude <fields...>
// }
// }
// }
2019-09-09 13:23:27 -05:00
//
2020-02-27 22:56:24 -05:00
// Proxy upstream addresses should be network dial addresses such
// as `host:port`, or a URL such as `scheme://host:port`. Scheme
// and port may be inferred from other parts of the address/URL; if
// either are missing, defaults to HTTP.
2021-05-02 13:39:06 -05:00
//
// The FinalizeUnmarshalCaddyfile method should be called after this
// to finalize parsing of "handle_response" blocks, if possible.
2019-09-09 13:23:27 -05:00
func ( h * Handler ) UnmarshalCaddyfile ( d * caddyfile . Dispenser ) error {
2020-02-27 22:56:24 -05:00
// currently, all backends must use the same scheme/protocol (the
// underlying JSON does not yet support per-backend transports)
var commonScheme string
// we'll wait until the very end of parsing before
// validating and encoding the transport
var transport http . RoundTripper
var transportModuleName string
2021-05-02 13:39:06 -05:00
// collect the response matchers defined as subdirectives
// prefixed with "@" for use with "handle_response" blocks
h . responseMatchers = make ( map [ string ] caddyhttp . ResponseMatcher )
2020-03-24 11:53:53 -05:00
// appendUpstream creates an upstream for address and adds
2023-04-10 15:08:40 -05:00
// it to the list.
2020-03-24 11:53:53 -05:00
appendUpstream := func ( address string ) error {
2023-08-05 16:30:02 -05:00
pa , err := parseUpstreamDialAddress ( address )
2020-03-24 11:53:53 -05:00
if err != nil {
2022-03-05 18:34:19 -05:00
return d . WrapErr ( err )
}
// the underlying JSON does not yet support different
// transports (protocols or schemes) to each backend,
// so we remember the last one we see and compare them
2023-08-19 06:28:25 -05:00
switch pa . scheme {
case "wss" :
return d . Errf ( "the scheme wss:// is only supported in browsers; use https:// instead" )
case "ws" :
return d . Errf ( "the scheme ws:// is only supported in browsers; use http:// instead" )
case "https" , "http" , "h2c" , "" :
// Do nothing or handle the valid schemes
default :
return d . Errf ( "unsupported URL scheme %s://" , pa . scheme )
}
2023-08-05 16:30:02 -05:00
if commonScheme != "" && pa . scheme != commonScheme {
2022-03-05 18:34:19 -05:00
return d . Errf ( "for now, all proxy upstreams must use the same scheme (transport protocol); expecting '%s://' but got '%s://'" ,
2023-08-05 16:30:02 -05:00
commonScheme , pa . scheme )
2020-03-24 11:53:53 -05:00
}
2023-08-05 16:30:02 -05:00
commonScheme = pa . scheme
2022-03-05 18:34:19 -05:00
2023-08-05 16:30:02 -05:00
// if the port of upstream address contains a placeholder, only wrap it with the `Upstream` struct,
// delaying actual resolution of the address until request time.
if pa . replaceablePort ( ) {
h . Upstreams = append ( h . Upstreams , & Upstream { Dial : pa . dialAddr ( ) } )
return nil
}
parsedAddr , err := caddy . ParseNetworkAddress ( pa . dialAddr ( ) )
2023-05-15 13:14:50 -05:00
if err != nil {
return d . WrapErr ( err )
}
2023-08-05 16:30:02 -05:00
if pa . isUnix ( ) || ! pa . rangedPort ( ) {
2023-05-15 13:14:50 -05:00
// unix networks don't have ports
h . Upstreams = append ( h . Upstreams , & Upstream {
2023-08-05 16:30:02 -05:00
Dial : pa . dialAddr ( ) ,
2023-05-15 13:14:50 -05:00
} )
} else {
// expand a port range into multiple upstreams
for i := parsedAddr . StartPort ; i <= parsedAddr . EndPort ; i ++ {
h . Upstreams = append ( h . Upstreams , & Upstream {
Dial : caddy . JoinNetworkAddress ( "" , parsedAddr . Host , fmt . Sprint ( i ) ) ,
} )
}
}
2020-03-24 11:53:53 -05:00
return nil
}
2023-04-20 13:43:51 -05:00
d . Next ( ) // consume the directive name
for _ , up := range d . RemainingArgs ( ) {
err := appendUpstream ( up )
if err != nil {
2023-08-19 06:28:25 -05:00
return fmt . Errorf ( "parsing upstream '%s': %w" , up , err )
2023-04-20 13:43:51 -05:00
}
}
2024-01-23 19:36:59 -05:00
for d . NextBlock ( 0 ) {
2023-04-20 13:43:51 -05:00
// if the subdirective has an "@" prefix then we
// parse it as a response matcher for use with "handle_response"
if strings . HasPrefix ( d . Val ( ) , matcherPrefix ) {
err := caddyhttp . ParseNamedResponseMatcher ( d . NewFromNextSegment ( ) , h . responseMatchers )
2020-02-27 22:56:24 -05:00
if err != nil {
return err
}
2023-04-20 13:43:51 -05:00
continue
2019-09-09 13:23:27 -05:00
}
2023-04-20 13:43:51 -05:00
switch d . Val ( ) {
case "to" :
args := d . RemainingArgs ( )
if len ( args ) == 0 {
return d . ArgErr ( )
}
for _ , up := range args {
err := appendUpstream ( up )
2021-05-02 13:39:06 -05:00
if err != nil {
2023-08-19 06:28:25 -05:00
return fmt . Errorf ( "parsing upstream '%s': %w" , up , err )
2021-05-02 13:39:06 -05:00
}
}
2023-04-20 13:43:51 -05:00
case "dynamic" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
if h . DynamicUpstreams != nil {
return d . Err ( "dynamic upstreams already specified" )
}
dynModule := d . Val ( )
modID := "http.reverse_proxy.upstreams." + dynModule
unm , err := caddyfile . UnmarshalModule ( d , modID )
if err != nil {
return err
}
source , ok := unm . ( UpstreamSource )
if ! ok {
return d . Errf ( "module %s (%T) is not an UpstreamSource" , modID , unm )
}
h . DynamicUpstreamsRaw = caddyconfig . JSONModuleObject ( source , "source" , dynModule , nil )
2019-09-09 13:23:27 -05:00
2023-04-20 13:43:51 -05:00
case "lb_policy" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
if h . LoadBalancing != nil && h . LoadBalancing . SelectionPolicyRaw != nil {
return d . Err ( "load balancing selection policy already specified" )
}
name := d . Val ( )
modID := "http.reverse_proxy.selection_policies." + name
unm , err := caddyfile . UnmarshalModule ( d , modID )
if err != nil {
return err
}
sel , ok := unm . ( Selector )
if ! ok {
return d . Errf ( "module %s (%T) is not a reverseproxy.Selector" , modID , unm )
}
if h . LoadBalancing == nil {
h . LoadBalancing = new ( LoadBalancing )
}
h . LoadBalancing . SelectionPolicyRaw = caddyconfig . JSONModuleObject ( sel , "policy" , name , nil )
2022-03-06 19:43:39 -05:00
2023-04-20 13:43:51 -05:00
case "lb_retries" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
tries , err := strconv . Atoi ( d . Val ( ) )
if err != nil {
return d . Errf ( "bad lb_retries number '%s': %v" , d . Val ( ) , err )
}
if h . LoadBalancing == nil {
h . LoadBalancing = new ( LoadBalancing )
}
h . LoadBalancing . Retries = tries
2019-09-09 13:23:27 -05:00
2023-04-20 13:43:51 -05:00
case "lb_try_duration" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
if h . LoadBalancing == nil {
h . LoadBalancing = new ( LoadBalancing )
}
dur , err := caddy . ParseDuration ( d . Val ( ) )
if err != nil {
return d . Errf ( "bad duration value %s: %v" , d . Val ( ) , err )
}
h . LoadBalancing . TryDuration = caddy . Duration ( dur )
2022-07-13 15:15:00 -05:00
2023-04-20 13:43:51 -05:00
case "lb_try_interval" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
if h . LoadBalancing == nil {
h . LoadBalancing = new ( LoadBalancing )
}
dur , err := caddy . ParseDuration ( d . Val ( ) )
if err != nil {
return d . Errf ( "bad interval value '%s': %v" , d . Val ( ) , err )
}
h . LoadBalancing . TryInterval = caddy . Duration ( dur )
2019-09-09 13:23:27 -05:00
2023-04-20 13:43:51 -05:00
case "lb_retry_match" :
matcherSet , err := caddyhttp . ParseCaddyfileNestedMatcherSet ( d )
if err != nil {
return d . Errf ( "failed to parse lb_retry_match: %v" , err )
}
if h . LoadBalancing == nil {
h . LoadBalancing = new ( LoadBalancing )
}
h . LoadBalancing . RetryMatchRaw = append ( h . LoadBalancing . RetryMatchRaw , matcherSet )
2019-09-09 13:23:27 -05:00
2023-04-20 13:43:51 -05:00
case "health_uri" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
if h . HealthChecks == nil {
h . HealthChecks = new ( HealthChecks )
}
if h . HealthChecks . Active == nil {
h . HealthChecks . Active = new ( ActiveHealthChecks )
}
h . HealthChecks . Active . URI = d . Val ( )
2022-07-13 15:15:00 -05:00
2023-04-20 13:43:51 -05:00
case "health_path" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
if h . HealthChecks == nil {
h . HealthChecks = new ( HealthChecks )
}
if h . HealthChecks . Active == nil {
h . HealthChecks . Active = new ( ActiveHealthChecks )
}
h . HealthChecks . Active . Path = d . Val ( )
caddy . Log ( ) . Named ( "config.adapter.caddyfile" ) . Warn ( "the 'health_path' subdirective is deprecated, please use 'health_uri' instead!" )
2021-03-29 19:36:40 -05:00
2024-07-15 12:00:12 -05:00
case "health_upstream" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
if h . HealthChecks == nil {
h . HealthChecks = new ( HealthChecks )
}
if h . HealthChecks . Active == nil {
h . HealthChecks . Active = new ( ActiveHealthChecks )
}
_ , port , err := net . SplitHostPort ( d . Val ( ) )
if err != nil {
return d . Errf ( "health_upstream is malformed '%s': %v" , d . Val ( ) , err )
}
_ , err = strconv . Atoi ( port )
if err != nil {
return d . Errf ( "bad port number '%s': %v" , d . Val ( ) , err )
}
h . HealthChecks . Active . Upstream = d . Val ( )
2023-04-20 13:43:51 -05:00
case "health_port" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
if h . HealthChecks == nil {
h . HealthChecks = new ( HealthChecks )
}
if h . HealthChecks . Active == nil {
h . HealthChecks . Active = new ( ActiveHealthChecks )
}
2024-07-15 12:00:12 -05:00
if h . HealthChecks . Active . Upstream != "" {
return d . Errf ( "the 'health_port' subdirective is ignored if 'health_upstream' is used!" )
}
2023-04-20 13:43:51 -05:00
portNum , err := strconv . Atoi ( d . Val ( ) )
if err != nil {
return d . Errf ( "bad port number '%s': %v" , d . Val ( ) , err )
}
h . HealthChecks . Active . Port = portNum
2019-09-09 13:23:27 -05:00
2023-04-20 13:43:51 -05:00
case "health_headers" :
healthHeaders := make ( http . Header )
for nesting := d . Nesting ( ) ; d . NextBlock ( nesting ) ; {
key := d . Val ( )
values := d . RemainingArgs ( )
if len ( values ) == 0 {
values = append ( values , "" )
2021-01-04 13:26:18 -05:00
}
2023-10-11 10:50:28 -05:00
healthHeaders [ key ] = append ( healthHeaders [ key ] , values ... )
2023-04-20 13:43:51 -05:00
}
if h . HealthChecks == nil {
h . HealthChecks = new ( HealthChecks )
}
if h . HealthChecks . Active == nil {
h . HealthChecks . Active = new ( ActiveHealthChecks )
}
h . HealthChecks . Active . Headers = healthHeaders
2021-01-04 13:26:18 -05:00
2024-07-12 16:01:58 -05:00
case "health_method" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
if h . HealthChecks == nil {
h . HealthChecks = new ( HealthChecks )
}
if h . HealthChecks . Active == nil {
h . HealthChecks . Active = new ( ActiveHealthChecks )
}
h . HealthChecks . Active . Method = d . Val ( )
2024-08-19 11:55:55 -05:00
case "health_request_body" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
if h . HealthChecks == nil {
h . HealthChecks = new ( HealthChecks )
}
if h . HealthChecks . Active == nil {
h . HealthChecks . Active = new ( ActiveHealthChecks )
}
h . HealthChecks . Active . Body = d . Val ( )
2023-04-20 13:43:51 -05:00
case "health_interval" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
if h . HealthChecks == nil {
h . HealthChecks = new ( HealthChecks )
}
if h . HealthChecks . Active == nil {
h . HealthChecks . Active = new ( ActiveHealthChecks )
}
dur , err := caddy . ParseDuration ( d . Val ( ) )
if err != nil {
return d . Errf ( "bad interval value %s: %v" , d . Val ( ) , err )
}
h . HealthChecks . Active . Interval = caddy . Duration ( dur )
2019-09-09 13:23:27 -05:00
2023-04-20 13:43:51 -05:00
case "health_timeout" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
if h . HealthChecks == nil {
h . HealthChecks = new ( HealthChecks )
}
if h . HealthChecks . Active == nil {
h . HealthChecks . Active = new ( ActiveHealthChecks )
}
dur , err := caddy . ParseDuration ( d . Val ( ) )
if err != nil {
return d . Errf ( "bad timeout value %s: %v" , d . Val ( ) , err )
}
h . HealthChecks . Active . Timeout = caddy . Duration ( dur )
2019-09-09 13:23:27 -05:00
2023-04-20 13:43:51 -05:00
case "health_status" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
if h . HealthChecks == nil {
h . HealthChecks = new ( HealthChecks )
}
if h . HealthChecks . Active == nil {
h . HealthChecks . Active = new ( ActiveHealthChecks )
}
val := d . Val ( )
if len ( val ) == 3 && strings . HasSuffix ( val , "xx" ) {
val = val [ : 1 ]
}
statusNum , err := strconv . Atoi ( val )
if err != nil {
return d . Errf ( "bad status value '%s': %v" , d . Val ( ) , err )
}
h . HealthChecks . Active . ExpectStatus = statusNum
2019-09-09 13:23:27 -05:00
2023-04-20 13:43:51 -05:00
case "health_body" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
if h . HealthChecks == nil {
h . HealthChecks = new ( HealthChecks )
}
if h . HealthChecks . Active == nil {
h . HealthChecks . Active = new ( ActiveHealthChecks )
}
h . HealthChecks . Active . ExpectBody = d . Val ( )
2019-09-09 13:23:27 -05:00
2024-05-07 09:40:15 -05:00
case "health_follow_redirects" :
if d . NextArg ( ) {
return d . ArgErr ( )
}
if h . HealthChecks == nil {
h . HealthChecks = new ( HealthChecks )
}
if h . HealthChecks . Active == nil {
h . HealthChecks . Active = new ( ActiveHealthChecks )
}
h . HealthChecks . Active . FollowRedirects = true
2024-03-20 12:13:35 -05:00
case "health_passes" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
if h . HealthChecks == nil {
h . HealthChecks = new ( HealthChecks )
}
if h . HealthChecks . Active == nil {
h . HealthChecks . Active = new ( ActiveHealthChecks )
}
passes , err := strconv . Atoi ( d . Val ( ) )
if err != nil {
return d . Errf ( "invalid passes count '%s': %v" , d . Val ( ) , err )
}
h . HealthChecks . Active . Passes = passes
case "health_fails" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
if h . HealthChecks == nil {
h . HealthChecks = new ( HealthChecks )
}
if h . HealthChecks . Active == nil {
h . HealthChecks . Active = new ( ActiveHealthChecks )
}
fails , err := strconv . Atoi ( d . Val ( ) )
if err != nil {
return d . Errf ( "invalid fails count '%s': %v" , d . Val ( ) , err )
}
h . HealthChecks . Active . Fails = fails
2023-04-20 13:43:51 -05:00
case "max_fails" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
if h . HealthChecks == nil {
h . HealthChecks = new ( HealthChecks )
}
if h . HealthChecks . Passive == nil {
h . HealthChecks . Passive = new ( PassiveHealthChecks )
}
maxFails , err := strconv . Atoi ( d . Val ( ) )
if err != nil {
return d . Errf ( "invalid maximum fail count '%s': %v" , d . Val ( ) , err )
}
h . HealthChecks . Passive . MaxFails = maxFails
2019-09-09 13:23:27 -05:00
2023-04-20 13:43:51 -05:00
case "fail_duration" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
if h . HealthChecks == nil {
h . HealthChecks = new ( HealthChecks )
}
if h . HealthChecks . Passive == nil {
h . HealthChecks . Passive = new ( PassiveHealthChecks )
}
dur , err := caddy . ParseDuration ( d . Val ( ) )
if err != nil {
return d . Errf ( "bad duration value '%s': %v" , d . Val ( ) , err )
}
h . HealthChecks . Passive . FailDuration = caddy . Duration ( dur )
2019-09-09 13:23:27 -05:00
2023-04-20 13:43:51 -05:00
case "unhealthy_request_count" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
if h . HealthChecks == nil {
h . HealthChecks = new ( HealthChecks )
}
if h . HealthChecks . Passive == nil {
h . HealthChecks . Passive = new ( PassiveHealthChecks )
}
maxConns , err := strconv . Atoi ( d . Val ( ) )
if err != nil {
return d . Errf ( "invalid maximum connection count '%s': %v" , d . Val ( ) , err )
}
h . HealthChecks . Passive . UnhealthyRequestCount = maxConns
case "unhealthy_status" :
args := d . RemainingArgs ( )
if len ( args ) == 0 {
return d . ArgErr ( )
}
if h . HealthChecks == nil {
h . HealthChecks = new ( HealthChecks )
}
if h . HealthChecks . Passive == nil {
h . HealthChecks . Passive = new ( PassiveHealthChecks )
}
for _ , arg := range args {
if len ( arg ) == 3 && strings . HasSuffix ( arg , "xx" ) {
arg = arg [ : 1 ]
2019-09-09 13:23:27 -05:00
}
2023-04-20 13:43:51 -05:00
statusNum , err := strconv . Atoi ( arg )
2019-09-09 13:23:27 -05:00
if err != nil {
2023-04-20 13:43:51 -05:00
return d . Errf ( "bad status value '%s': %v" , d . Val ( ) , err )
2019-09-09 13:23:27 -05:00
}
2023-04-20 13:43:51 -05:00
h . HealthChecks . Passive . UnhealthyStatus = append ( h . HealthChecks . Passive . UnhealthyStatus , statusNum )
}
2019-09-09 13:23:27 -05:00
2023-04-20 13:43:51 -05:00
case "unhealthy_latency" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
if h . HealthChecks == nil {
h . HealthChecks = new ( HealthChecks )
}
if h . HealthChecks . Passive == nil {
h . HealthChecks . Passive = new ( PassiveHealthChecks )
}
dur , err := caddy . ParseDuration ( d . Val ( ) )
if err != nil {
return d . Errf ( "bad duration value '%s': %v" , d . Val ( ) , err )
}
h . HealthChecks . Passive . UnhealthyLatency = caddy . Duration ( dur )
2019-09-09 13:23:27 -05:00
2023-04-20 13:43:51 -05:00
case "flush_interval" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
if fi , err := strconv . Atoi ( d . Val ( ) ) ; err == nil {
h . FlushInterval = caddy . Duration ( fi )
} else {
2020-05-11 17:41:11 -05:00
dur , err := caddy . ParseDuration ( d . Val ( ) )
2019-09-09 13:23:27 -05:00
if err != nil {
return d . Errf ( "bad duration value '%s': %v" , d . Val ( ) , err )
}
2023-04-20 13:43:51 -05:00
h . FlushInterval = caddy . Duration ( dur )
}
2019-09-09 13:23:27 -05:00
2023-04-20 13:43:51 -05:00
case "request_buffers" , "response_buffers" :
subdir := d . Val ( )
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
2023-10-11 03:42:40 -05:00
val := d . Val ( )
var size int64
if val == "unlimited" {
size = - 1
} else {
usize , err := humanize . ParseBytes ( val )
if err != nil {
return d . Errf ( "invalid byte size '%s': %v" , val , err )
}
size = int64 ( usize )
2023-04-20 13:43:51 -05:00
}
if d . NextArg ( ) {
return d . ArgErr ( )
}
if subdir == "request_buffers" {
2023-10-11 03:42:40 -05:00
h . RequestBuffers = size
2023-04-20 13:43:51 -05:00
} else if subdir == "response_buffers" {
2023-10-11 03:42:40 -05:00
h . ResponseBuffers = size
2023-04-20 13:43:51 -05:00
}
2020-09-08 11:37:46 -05:00
2023-06-19 16:54:43 -05:00
case "stream_timeout" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
if fi , err := strconv . Atoi ( d . Val ( ) ) ; err == nil {
h . StreamTimeout = caddy . Duration ( fi )
} else {
dur , err := caddy . ParseDuration ( d . Val ( ) )
if err != nil {
return d . Errf ( "bad duration value '%s': %v" , d . Val ( ) , err )
}
h . StreamTimeout = caddy . Duration ( dur )
}
case "stream_close_delay" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
if fi , err := strconv . Atoi ( d . Val ( ) ) ; err == nil {
h . StreamCloseDelay = caddy . Duration ( fi )
} else {
dur , err := caddy . ParseDuration ( d . Val ( ) )
if err != nil {
return d . Errf ( "bad duration value '%s': %v" , d . Val ( ) , err )
}
h . StreamCloseDelay = caddy . Duration ( dur )
}
2023-04-20 13:43:51 -05:00
case "trusted_proxies" :
for d . NextArg ( ) {
if d . Val ( ) == "private_ranges" {
2024-08-07 12:02:23 -05:00
h . TrustedProxies = append ( h . TrustedProxies , internal . PrivateRangesCIDR ( ) ... )
2023-04-20 13:43:51 -05:00
continue
2021-02-09 16:15:04 -05:00
}
2023-04-20 13:43:51 -05:00
h . TrustedProxies = append ( h . TrustedProxies , d . Val ( ) )
}
case "header_up" :
var err error
if h . Headers == nil {
h . Headers = new ( headers . Handler )
}
if h . Headers . Request == nil {
h . Headers . Request = new ( headers . HeaderOps )
}
args := d . RemainingArgs ( )
switch len ( args ) {
case 1 :
2024-03-21 12:29:32 -05:00
err = headers . CaddyfileHeaderOp ( h . Headers . Request , args [ 0 ] , "" , nil )
2023-04-20 13:43:51 -05:00
case 2 :
// some lint checks, I guess
if strings . EqualFold ( args [ 0 ] , "host" ) && ( args [ 1 ] == "{hostport}" || args [ 1 ] == "{http.request.hostport}" ) {
caddy . Log ( ) . Named ( "caddyfile" ) . Warn ( "Unnecessary header_up Host: the reverse proxy's default behavior is to pass headers to the upstream" )
2021-02-09 16:15:04 -05:00
}
2023-04-20 13:43:51 -05:00
if strings . EqualFold ( args [ 0 ] , "x-forwarded-for" ) && ( args [ 1 ] == "{remote}" || args [ 1 ] == "{http.request.remote}" || args [ 1 ] == "{remote_host}" || args [ 1 ] == "{http.request.remote.host}" ) {
caddy . Log ( ) . Named ( "caddyfile" ) . Warn ( "Unnecessary header_up X-Forwarded-For: the reverse proxy's default behavior is to pass headers to the upstream" )
2021-02-09 16:15:04 -05:00
}
2023-04-20 13:43:51 -05:00
if strings . EqualFold ( args [ 0 ] , "x-forwarded-proto" ) && ( args [ 1 ] == "{scheme}" || args [ 1 ] == "{http.request.scheme}" ) {
caddy . Log ( ) . Named ( "caddyfile" ) . Warn ( "Unnecessary header_up X-Forwarded-Proto: the reverse proxy's default behavior is to pass headers to the upstream" )
2021-02-09 16:15:04 -05:00
}
2023-04-20 13:43:51 -05:00
if strings . EqualFold ( args [ 0 ] , "x-forwarded-host" ) && ( args [ 1 ] == "{host}" || args [ 1 ] == "{http.request.host}" || args [ 1 ] == "{hostport}" || args [ 1 ] == "{http.request.hostport}" ) {
caddy . Log ( ) . Named ( "caddyfile" ) . Warn ( "Unnecessary header_up X-Forwarded-Host: the reverse proxy's default behavior is to pass headers to the upstream" )
2022-03-06 18:51:55 -05:00
}
2024-03-21 12:29:32 -05:00
err = headers . CaddyfileHeaderOp ( h . Headers . Request , args [ 0 ] , args [ 1 ] , nil )
2023-04-20 13:43:51 -05:00
case 3 :
2024-03-21 12:29:32 -05:00
err = headers . CaddyfileHeaderOp ( h . Headers . Request , args [ 0 ] , args [ 1 ] , & args [ 2 ] )
2023-04-20 13:43:51 -05:00
default :
return d . ArgErr ( )
}
2022-03-06 18:51:55 -05:00
2023-04-20 13:43:51 -05:00
if err != nil {
return d . Err ( err . Error ( ) )
}
2020-11-20 14:38:16 -05:00
2023-04-20 13:43:51 -05:00
case "header_down" :
var err error
2019-09-20 14:13:49 -05:00
2023-04-20 13:43:51 -05:00
if h . Headers == nil {
h . Headers = new ( headers . Handler )
}
if h . Headers . Response == nil {
h . Headers . Response = & headers . RespHeaderOps {
HeaderOps : new ( headers . HeaderOps ) ,
2020-11-20 14:38:16 -05:00
}
2023-04-20 13:43:51 -05:00
}
args := d . RemainingArgs ( )
2024-03-21 12:29:32 -05:00
2023-04-20 13:43:51 -05:00
switch len ( args ) {
case 1 :
2024-03-21 12:29:32 -05:00
err = headers . CaddyfileHeaderOp ( h . Headers . Response . HeaderOps , args [ 0 ] , "" , nil )
2023-04-20 13:43:51 -05:00
case 2 :
2024-03-21 12:29:32 -05:00
err = headers . CaddyfileHeaderOp ( h . Headers . Response . HeaderOps , args [ 0 ] , args [ 1 ] , nil )
2023-04-20 13:43:51 -05:00
case 3 :
2024-03-21 12:29:32 -05:00
err = headers . CaddyfileHeaderOp ( h . Headers . Response . HeaderOps , args [ 0 ] , args [ 1 ] , & args [ 2 ] )
2023-04-20 13:43:51 -05:00
default :
return d . ArgErr ( )
}
2020-11-20 14:38:16 -05:00
2023-04-20 13:43:51 -05:00
if err != nil {
return d . Err ( err . Error ( ) )
}
2020-11-20 14:38:16 -05:00
2023-04-20 13:43:51 -05:00
case "method" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
if h . Rewrite == nil {
h . Rewrite = & rewrite . Rewrite { }
}
h . Rewrite . Method = d . Val ( )
if d . NextArg ( ) {
return d . ArgErr ( )
}
2019-09-20 14:13:49 -05:00
2023-04-20 13:43:51 -05:00
case "rewrite" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
if h . Rewrite == nil {
h . Rewrite = & rewrite . Rewrite { }
}
h . Rewrite . URI = d . Val ( )
if d . NextArg ( ) {
return d . ArgErr ( )
}
2020-11-20 14:38:16 -05:00
2023-04-20 13:43:51 -05:00
case "transport" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
if h . TransportRaw != nil {
return d . Err ( "transport already specified" )
}
transportModuleName = d . Val ( )
modID := "http.reverse_proxy.transport." + transportModuleName
unm , err := caddyfile . UnmarshalModule ( d , modID )
if err != nil {
return err
}
rt , ok := unm . ( http . RoundTripper )
if ! ok {
return d . Errf ( "module %s (%T) is not a RoundTripper" , modID , unm )
}
transport = rt
case "handle_response" :
// delegate the parsing of handle_response to the caller,
// since we need the httpcaddyfile.Helper to parse subroutes.
// See h.FinalizeUnmarshalCaddyfile
h . handleResponseSegments = append ( h . handleResponseSegments , d . NewFromNextSegment ( ) )
case "replace_status" :
args := d . RemainingArgs ( )
if len ( args ) != 1 && len ( args ) != 2 {
return d . Errf ( "must have one or two arguments: an optional response matcher, and a status code" )
}
2022-05-06 09:50:26 -05:00
2023-04-20 13:43:51 -05:00
responseHandler := caddyhttp . ResponseHandler { }
2022-05-06 09:50:26 -05:00
2023-04-20 13:43:51 -05:00
if len ( args ) == 2 {
if ! strings . HasPrefix ( args [ 0 ] , matcherPrefix ) {
return d . Errf ( "must use a named response matcher, starting with '@'" )
2019-09-09 13:23:27 -05:00
}
2023-04-20 13:43:51 -05:00
foundMatcher , ok := h . responseMatchers [ args [ 0 ] ]
2019-09-09 13:23:27 -05:00
if ! ok {
2023-04-20 13:43:51 -05:00
return d . Errf ( "no named response matcher defined with name '%s'" , args [ 0 ] [ 1 : ] )
2022-03-01 16:12:43 -05:00
}
2023-04-20 13:43:51 -05:00
responseHandler . Match = & foundMatcher
responseHandler . StatusCode = caddyhttp . WeakString ( args [ 1 ] )
} else if len ( args ) == 1 {
responseHandler . StatusCode = caddyhttp . WeakString ( args [ 0 ] )
}
2022-03-01 16:12:43 -05:00
2023-04-20 13:43:51 -05:00
// make sure there's no block, cause it doesn't make sense
2024-01-23 19:36:59 -05:00
if nesting := d . Nesting ( ) ; d . NextBlock ( nesting ) {
2023-04-20 13:43:51 -05:00
return d . Errf ( "cannot define routes for 'replace_status', use 'handle_response' instead." )
}
2022-03-01 16:12:43 -05:00
2023-04-20 13:43:51 -05:00
h . HandleResponse = append (
h . HandleResponse ,
responseHandler ,
)
2022-03-01 16:12:43 -05:00
2023-10-11 14:36:20 -05:00
case "verbose_logs" :
if h . VerboseLogs {
return d . Err ( "verbose_logs already specified" )
}
h . VerboseLogs = true
2023-04-20 13:43:51 -05:00
default :
return d . Errf ( "unrecognized subdirective %s" , d . Val ( ) )
2019-09-09 13:23:27 -05:00
}
}
2020-02-27 22:56:24 -05:00
// if the scheme inferred from the backends' addresses is
2020-11-23 14:18:26 -05:00
// HTTPS, we will need a non-nil transport to enable TLS,
// or if H2C, to set the transport versions.
if ( commonScheme == "https" || commonScheme == "h2c" ) && transport == nil {
2020-02-27 22:56:24 -05:00
transport = new ( HTTPTransport )
transportModuleName = "http"
}
// verify transport configuration, and finally encode it
if transport != nil {
2020-04-07 09:31:52 -05:00
if te , ok := transport . ( TLSTransport ) ; ok {
if commonScheme == "https" && ! te . TLSEnabled ( ) {
err := te . EnableTLS ( new ( TLSConfig ) )
if err != nil {
return err
}
2020-02-27 22:56:24 -05:00
}
2020-04-07 09:31:52 -05:00
if commonScheme == "http" && te . TLSEnabled ( ) {
2020-02-27 22:56:24 -05:00
return d . Errf ( "upstream address scheme is HTTP but transport is configured for HTTP+TLS (HTTPS)" )
}
2020-11-23 14:18:26 -05:00
if te , ok := transport . ( * HTTPTransport ) ; ok && commonScheme == "h2c" {
te . Versions = [ ] string { "h2c" , "2" }
}
2020-04-07 09:31:52 -05:00
} else if commonScheme == "https" {
return d . Errf ( "upstreams are configured for HTTPS but transport module does not support TLS: %T" , transport )
2020-02-27 22:56:24 -05:00
}
2020-07-17 14:18:32 -05:00
// no need to encode empty default transport
if ! reflect . DeepEqual ( transport , new ( HTTPTransport ) ) {
2020-02-27 22:56:24 -05:00
h . TransportRaw = caddyconfig . JSONModuleObject ( transport , "protocol" , transportModuleName , nil )
}
}
2019-09-09 13:23:27 -05:00
return nil
}
2021-05-02 13:39:06 -05:00
// FinalizeUnmarshalCaddyfile finalizes the Caddyfile parsing which
// requires having an httpcaddyfile.Helper to function, to parse subroutes.
func ( h * Handler ) FinalizeUnmarshalCaddyfile ( helper httpcaddyfile . Helper ) error {
for _ , d := range h . handleResponseSegments {
// consume the "handle_response" token
d . Next ( )
args := d . RemainingArgs ( )
2022-03-01 16:12:43 -05:00
// TODO: Remove this check at some point in the future
if len ( args ) == 2 {
return d . Errf ( "configuring 'handle_response' for status code replacement is no longer supported. Use 'replace_status' instead." )
}
if len ( args ) > 1 {
2021-05-02 13:39:06 -05:00
return d . Errf ( "too many arguments for 'handle_response': %s" , args )
}
2022-03-01 16:12:43 -05:00
var matcher * caddyhttp . ResponseMatcher
if len ( args ) == 1 {
// the first arg should always be a matcher.
2021-05-02 13:39:06 -05:00
if ! strings . HasPrefix ( args [ 0 ] , matcherPrefix ) {
return d . Errf ( "must use a named response matcher, starting with '@'" )
}
foundMatcher , ok := h . responseMatchers [ args [ 0 ] ]
if ! ok {
return d . Errf ( "no named response matcher defined with name '%s'" , args [ 0 ] [ 1 : ] )
}
matcher = & foundMatcher
}
// parse the block as routes
handler , err := httpcaddyfile . ParseSegmentAsSubroute ( helper . WithDispenser ( d . NewFromNextSegment ( ) ) )
if err != nil {
return err
}
subroute , ok := handler . ( * caddyhttp . Subroute )
if ! ok {
return helper . Errf ( "segment was not parsed as a subroute" )
}
h . HandleResponse = append (
h . HandleResponse ,
caddyhttp . ResponseHandler {
Match : matcher ,
Routes : subroute . Routes ,
} ,
)
}
// move the handle_response entries without a matcher to the end.
// we can't use sort.SliceStable because it will reorder the rest of the
// entries which may be undesirable because we don't have a good
// heuristic to use for sorting.
withoutMatchers := [ ] caddyhttp . ResponseHandler { }
withMatchers := [ ] caddyhttp . ResponseHandler { }
for _ , hr := range h . HandleResponse {
if hr . Match == nil {
withoutMatchers = append ( withoutMatchers , hr )
} else {
withMatchers = append ( withMatchers , hr )
}
}
h . HandleResponse = append ( withMatchers , withoutMatchers ... )
// clean up the bits we only needed for adapting
h . handleResponseSegments = nil
h . responseMatchers = nil
return nil
}
2019-09-09 13:23:27 -05:00
// UnmarshalCaddyfile deserializes Caddyfile tokens into h.
//
2022-08-25 22:42:48 -05:00
// transport http {
// read_buffer <size>
// write_buffer <size>
// max_response_header <size>
2024-03-17 23:07:25 -05:00
// forward_proxy_url <url>
2022-08-25 22:42:48 -05:00
// dial_timeout <duration>
// dial_fallback_delay <duration>
// response_header_timeout <duration>
// expect_continue_timeout <duration>
// resolvers <resolvers...>
// tls
// tls_client_auth <automate_name> | <cert_file> <key_file>
// tls_insecure_skip_verify
// tls_timeout <duration>
// tls_trusted_ca_certs <cert_files...>
// tls_server_name <sni>
// tls_renegotiation <level>
// tls_except_ports <ports...>
// keepalive [off|<duration>]
// keepalive_interval <interval>
// keepalive_idle_conns <max_count>
// keepalive_idle_conns_per_host <count>
// versions <versions...>
// compression off
// max_conns_per_host <count>
// max_idle_conns_per_host <count>
// }
2019-09-09 13:23:27 -05:00
func ( h * HTTPTransport ) UnmarshalCaddyfile ( d * caddyfile . Dispenser ) error {
2024-01-23 19:36:59 -05:00
d . Next ( ) // consume transport name
for d . NextBlock ( 0 ) {
switch d . Val ( ) {
case "read_buffer" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
size , err := humanize . ParseBytes ( d . Val ( ) )
if err != nil {
return d . Errf ( "invalid read buffer size '%s': %v" , d . Val ( ) , err )
}
h . ReadBufferSize = int ( size )
2019-09-09 13:23:27 -05:00
2024-01-23 19:36:59 -05:00
case "write_buffer" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
size , err := humanize . ParseBytes ( d . Val ( ) )
if err != nil {
return d . Errf ( "invalid write buffer size '%s': %v" , d . Val ( ) , err )
}
h . WriteBufferSize = int ( size )
2022-07-23 23:38:41 -05:00
2024-01-23 19:36:59 -05:00
case "read_timeout" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
timeout , err := caddy . ParseDuration ( d . Val ( ) )
if err != nil {
return d . Errf ( "invalid read timeout duration '%s': %v" , d . Val ( ) , err )
}
h . ReadTimeout = caddy . Duration ( timeout )
2022-07-23 23:38:41 -05:00
2024-01-23 19:36:59 -05:00
case "write_timeout" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
timeout , err := caddy . ParseDuration ( d . Val ( ) )
if err != nil {
return d . Errf ( "invalid write timeout duration '%s': %v" , d . Val ( ) , err )
}
h . WriteTimeout = caddy . Duration ( timeout )
2020-11-02 16:59:02 -05:00
2024-01-23 19:36:59 -05:00
case "max_response_header" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
size , err := humanize . ParseBytes ( d . Val ( ) )
if err != nil {
return d . Errf ( "invalid max response header size '%s': %v" , d . Val ( ) , err )
}
h . MaxResponseHeaderSize = int64 ( size )
2023-03-31 16:44:53 -05:00
2024-01-23 19:36:59 -05:00
case "proxy_protocol" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
switch proxyProtocol := d . Val ( ) ; proxyProtocol {
case "v1" , "v2" :
h . ProxyProtocol = proxyProtocol
default :
return d . Errf ( "invalid proxy protocol version '%s'" , proxyProtocol )
}
2019-09-09 13:23:27 -05:00
2024-03-17 23:07:25 -05:00
case "forward_proxy_url" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
h . ForwardProxyURL = d . Val ( )
2024-01-23 19:36:59 -05:00
case "dial_timeout" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
dur , err := caddy . ParseDuration ( d . Val ( ) )
if err != nil {
return d . Errf ( "bad timeout value '%s': %v" , d . Val ( ) , err )
}
h . DialTimeout = caddy . Duration ( dur )
2020-11-02 16:59:02 -05:00
2024-01-23 19:36:59 -05:00
case "dial_fallback_delay" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
dur , err := caddy . ParseDuration ( d . Val ( ) )
if err != nil {
return d . Errf ( "bad fallback delay value '%s': %v" , d . Val ( ) , err )
}
h . FallbackDelay = caddy . Duration ( dur )
2020-11-02 16:59:02 -05:00
2024-01-23 19:36:59 -05:00
case "response_header_timeout" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
dur , err := caddy . ParseDuration ( d . Val ( ) )
if err != nil {
return d . Errf ( "bad timeout value '%s': %v" , d . Val ( ) , err )
}
h . ResponseHeaderTimeout = caddy . Duration ( dur )
2020-11-02 16:59:02 -05:00
2024-01-23 19:36:59 -05:00
case "expect_continue_timeout" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
dur , err := caddy . ParseDuration ( d . Val ( ) )
if err != nil {
return d . Errf ( "bad timeout value '%s': %v" , d . Val ( ) , err )
}
h . ExpectContinueTimeout = caddy . Duration ( dur )
2022-03-06 19:43:39 -05:00
2024-01-23 19:36:59 -05:00
case "resolvers" :
if h . Resolver == nil {
h . Resolver = new ( UpstreamResolver )
}
h . Resolver . Addresses = d . RemainingArgs ( )
if len ( h . Resolver . Addresses ) == 0 {
return d . Errf ( "must specify at least one resolver address" )
}
2022-07-08 12:04:22 -05:00
2024-01-23 19:36:59 -05:00
case "tls" :
if h . TLS == nil {
h . TLS = new ( TLSConfig )
}
2019-09-09 13:23:27 -05:00
2024-01-23 19:36:59 -05:00
case "tls_client_auth" :
if h . TLS == nil {
h . TLS = new ( TLSConfig )
}
args := d . RemainingArgs ( )
switch len ( args ) {
case 1 :
h . TLS . ClientCertificateAutomate = args [ 0 ]
case 2 :
h . TLS . ClientCertificateFile = args [ 0 ]
h . TLS . ClientCertificateKeyFile = args [ 1 ]
default :
return d . ArgErr ( )
}
2019-09-09 13:23:27 -05:00
2024-01-23 19:36:59 -05:00
case "tls_insecure_skip_verify" :
if d . NextArg ( ) {
return d . ArgErr ( )
}
if h . TLS == nil {
h . TLS = new ( TLSConfig )
}
h . TLS . InsecureSkipVerify = true
2024-01-13 15:56:23 -05:00
2024-01-23 19:36:59 -05:00
case "tls_curves" :
args := d . RemainingArgs ( )
if len ( args ) == 0 {
return d . ArgErr ( )
}
if h . TLS == nil {
h . TLS = new ( TLSConfig )
}
h . TLS . Curves = args
2019-09-09 13:23:27 -05:00
2024-01-23 19:36:59 -05:00
case "tls_timeout" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
dur , err := caddy . ParseDuration ( d . Val ( ) )
if err != nil {
return d . Errf ( "bad timeout value '%s': %v" , d . Val ( ) , err )
}
if h . TLS == nil {
h . TLS = new ( TLSConfig )
}
h . TLS . HandshakeTimeout = caddy . Duration ( dur )
2020-01-07 14:07:42 -05:00
2024-01-23 19:36:59 -05:00
case "tls_trusted_ca_certs" :
2024-04-27 14:51:00 -05:00
caddy . Log ( ) . Warn ( "The 'tls_trusted_ca_certs' field is deprecated. Use the 'tls_trust_pool' field instead." )
2024-01-23 19:36:59 -05:00
args := d . RemainingArgs ( )
if len ( args ) == 0 {
return d . ArgErr ( )
}
if h . TLS == nil {
h . TLS = new ( TLSConfig )
}
2024-04-12 08:19:14 -05:00
if len ( h . TLS . CARaw ) != 0 {
return d . Err ( "cannot specify both 'tls_trust_pool' and 'tls_trusted_ca_certs" )
}
2024-01-23 19:36:59 -05:00
h . TLS . RootCAPEMFiles = args
2020-05-05 13:39:39 -05:00
2024-01-23 19:36:59 -05:00
case "tls_server_name" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
if h . TLS == nil {
h . TLS = new ( TLSConfig )
}
h . TLS . ServerName = d . Val ( )
2022-07-08 12:04:22 -05:00
2024-01-23 19:36:59 -05:00
case "tls_renegotiation" :
if h . TLS == nil {
h . TLS = new ( TLSConfig )
}
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
switch renegotiation := d . Val ( ) ; renegotiation {
case "never" , "once" , "freely" :
h . TLS . Renegotiation = renegotiation
default :
return d . ArgErr ( )
}
2022-07-08 12:04:22 -05:00
2024-01-23 19:36:59 -05:00
case "tls_except_ports" :
if h . TLS == nil {
h . TLS = new ( TLSConfig )
}
h . TLS . ExceptPorts = d . RemainingArgs ( )
if len ( h . TLS . ExceptPorts ) == 0 {
return d . ArgErr ( )
}
2019-09-09 13:23:27 -05:00
2024-01-23 19:36:59 -05:00
case "keepalive" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
if h . KeepAlive == nil {
h . KeepAlive = new ( KeepAlive )
}
if d . Val ( ) == "off" {
var disable bool
h . KeepAlive . Enabled = & disable
break
}
dur , err := caddy . ParseDuration ( d . Val ( ) )
if err != nil {
return d . Errf ( "bad duration value '%s': %v" , d . Val ( ) , err )
}
h . KeepAlive . IdleConnTimeout = caddy . Duration ( dur )
2021-11-24 01:32:25 -05:00
2024-01-23 19:36:59 -05:00
case "keepalive_interval" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
dur , err := caddy . ParseDuration ( d . Val ( ) )
if err != nil {
return d . Errf ( "bad interval value '%s': %v" , d . Val ( ) , err )
}
if h . KeepAlive == nil {
h . KeepAlive = new ( KeepAlive )
}
h . KeepAlive . ProbeInterval = caddy . Duration ( dur )
2021-06-15 15:54:48 -05:00
2024-01-23 19:36:59 -05:00
case "keepalive_idle_conns" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
num , err := strconv . Atoi ( d . Val ( ) )
if err != nil {
return d . Errf ( "bad integer value '%s': %v" , d . Val ( ) , err )
}
if h . KeepAlive == nil {
h . KeepAlive = new ( KeepAlive )
}
h . KeepAlive . MaxIdleConns = num
2019-09-09 13:23:27 -05:00
2024-01-23 19:36:59 -05:00
case "keepalive_idle_conns_per_host" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
num , err := strconv . Atoi ( d . Val ( ) )
if err != nil {
return d . Errf ( "bad integer value '%s': %v" , d . Val ( ) , err )
}
if h . KeepAlive == nil {
h . KeepAlive = new ( KeepAlive )
}
h . KeepAlive . MaxIdleConnsPerHost = num
2020-05-05 13:33:21 -05:00
2024-01-23 19:36:59 -05:00
case "versions" :
h . Versions = d . RemainingArgs ( )
if len ( h . Versions ) == 0 {
return d . ArgErr ( )
}
2020-07-31 12:30:20 -05:00
2024-01-23 19:36:59 -05:00
case "compression" :
if d . NextArg ( ) {
if d . Val ( ) == "off" {
var disable bool
h . Compression = & disable
2020-10-30 13:05:21 -05:00
}
2024-01-23 19:36:59 -05:00
}
2020-10-30 13:05:21 -05:00
2024-01-23 19:36:59 -05:00
case "max_conns_per_host" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
num , err := strconv . Atoi ( d . Val ( ) )
if err != nil {
return d . Errf ( "bad integer value '%s': %v" , d . Val ( ) , err )
2019-09-11 19:53:44 -05:00
}
2024-01-23 19:36:59 -05:00
h . MaxConnsPerHost = num
2024-04-12 08:19:14 -05:00
case "tls_trust_pool" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
modStem := d . Val ( )
modID := "tls.ca_pool.source." + modStem
unm , err := caddyfile . UnmarshalModule ( d , modID )
if err != nil {
return err
}
ca , ok := unm . ( caddytls . CA )
if ! ok {
return d . Errf ( "module %s is not a caddytls.CA" , modID )
}
if h . TLS == nil {
h . TLS = new ( TLSConfig )
}
if len ( h . TLS . RootCAPEMFiles ) != 0 {
return d . Err ( "cannot specify both 'tls_trust_pool' and 'tls_trusted_ca_certs'" )
}
if h . TLS . CARaw != nil {
return d . Err ( "cannot specify \"tls_trust_pool\" twice in caddyfile" )
}
h . TLS . CARaw = caddyconfig . JSONModuleObject ( ca , "provider" , modStem , nil )
2024-01-23 19:36:59 -05:00
default :
return d . Errf ( "unrecognized subdirective %s" , d . Val ( ) )
2019-09-09 13:23:27 -05:00
}
}
return nil
}
reverseproxy: copy_response and copy_response_headers for handle_response routes (#4391)
* reverseproxy: New `copy_response` handler for `handle_response` routes
Followup to #4298 and #4388.
This adds a new `copy_response` handler which may only be used in `reverse_proxy`'s `handle_response` routes, which can be used to actually copy the proxy response downstream.
Previously, if `handle_response` was used (with routes, not the status code mode), it was impossible to use the upstream's response body at all, because we would always close the body, expecting the routes to write a new body from scratch.
To implement this, I had to refactor `h.reverseProxy()` to move all the code that came after the `HandleResponse` loop into a new function. This new function `h.finalizeResponse()` takes care of preparing the response by removing extra headers, dealing with trailers, then copying the headers and body downstream.
Since basically what we want `copy_response` to do is invoke `h.finalizeResponse()` at a configurable point in time, we need to pass down the proxy handler, the response, and some other state via a new `req.WithContext(ctx)`. Wrapping a new context is pretty much the only way we have to jump a few layers in the HTTP middleware chain and let a handler pick up this information. Feels a bit dirty, but it works.
Also fixed a bug with the `http.reverse_proxy.upstream.duration` placeholder, it always had the same duration as `http.reverse_proxy.upstream.latency`, but the former was meant to be the time taken for the roundtrip _plus_ copying/writing the response.
* Delete the "Content-Length" header if we aren't copying
Fixes a bug where the Content-Length will mismatch the actual bytes written if we skipped copying the response, so we get a message like this when using curl:
```
curl: (18) transfer closed with 18 bytes remaining to read
```
To replicate:
```
{
admin off
debug
}
:8881 {
reverse_proxy 127.0.0.1:8882 {
@200 status 200
handle_response @200 {
header Foo bar
}
}
}
:8882 {
header Content-Type application/json
respond `{"hello": "world"}` 200
}
```
* Implement `copy_response_headers`, with include/exclude list support
* Apply suggestions from code review
Co-authored-by: Matt Holt <mholt@users.noreply.github.com>
2022-03-09 13:00:51 -05:00
func parseCopyResponseCaddyfile ( h httpcaddyfile . Helper ) ( caddyhttp . MiddlewareHandler , error ) {
crh := new ( CopyResponseHandler )
err := crh . UnmarshalCaddyfile ( h . Dispenser )
if err != nil {
return nil , err
}
return crh , nil
}
// UnmarshalCaddyfile sets up the handler from Caddyfile tokens. Syntax:
//
2022-08-25 22:42:48 -05:00
// copy_response [<matcher>] [<status>] {
// status <status>
// }
reverseproxy: copy_response and copy_response_headers for handle_response routes (#4391)
* reverseproxy: New `copy_response` handler for `handle_response` routes
Followup to #4298 and #4388.
This adds a new `copy_response` handler which may only be used in `reverse_proxy`'s `handle_response` routes, which can be used to actually copy the proxy response downstream.
Previously, if `handle_response` was used (with routes, not the status code mode), it was impossible to use the upstream's response body at all, because we would always close the body, expecting the routes to write a new body from scratch.
To implement this, I had to refactor `h.reverseProxy()` to move all the code that came after the `HandleResponse` loop into a new function. This new function `h.finalizeResponse()` takes care of preparing the response by removing extra headers, dealing with trailers, then copying the headers and body downstream.
Since basically what we want `copy_response` to do is invoke `h.finalizeResponse()` at a configurable point in time, we need to pass down the proxy handler, the response, and some other state via a new `req.WithContext(ctx)`. Wrapping a new context is pretty much the only way we have to jump a few layers in the HTTP middleware chain and let a handler pick up this information. Feels a bit dirty, but it works.
Also fixed a bug with the `http.reverse_proxy.upstream.duration` placeholder, it always had the same duration as `http.reverse_proxy.upstream.latency`, but the former was meant to be the time taken for the roundtrip _plus_ copying/writing the response.
* Delete the "Content-Length" header if we aren't copying
Fixes a bug where the Content-Length will mismatch the actual bytes written if we skipped copying the response, so we get a message like this when using curl:
```
curl: (18) transfer closed with 18 bytes remaining to read
```
To replicate:
```
{
admin off
debug
}
:8881 {
reverse_proxy 127.0.0.1:8882 {
@200 status 200
handle_response @200 {
header Foo bar
}
}
}
:8882 {
header Content-Type application/json
respond `{"hello": "world"}` 200
}
```
* Implement `copy_response_headers`, with include/exclude list support
* Apply suggestions from code review
Co-authored-by: Matt Holt <mholt@users.noreply.github.com>
2022-03-09 13:00:51 -05:00
func ( h * CopyResponseHandler ) UnmarshalCaddyfile ( d * caddyfile . Dispenser ) error {
2024-01-23 19:36:59 -05:00
d . Next ( ) // consume directive name
args := d . RemainingArgs ( )
if len ( args ) == 1 {
if num , err := strconv . Atoi ( args [ 0 ] ) ; err == nil && num > 0 {
h . StatusCode = caddyhttp . WeakString ( args [ 0 ] )
return nil
reverseproxy: copy_response and copy_response_headers for handle_response routes (#4391)
* reverseproxy: New `copy_response` handler for `handle_response` routes
Followup to #4298 and #4388.
This adds a new `copy_response` handler which may only be used in `reverse_proxy`'s `handle_response` routes, which can be used to actually copy the proxy response downstream.
Previously, if `handle_response` was used (with routes, not the status code mode), it was impossible to use the upstream's response body at all, because we would always close the body, expecting the routes to write a new body from scratch.
To implement this, I had to refactor `h.reverseProxy()` to move all the code that came after the `HandleResponse` loop into a new function. This new function `h.finalizeResponse()` takes care of preparing the response by removing extra headers, dealing with trailers, then copying the headers and body downstream.
Since basically what we want `copy_response` to do is invoke `h.finalizeResponse()` at a configurable point in time, we need to pass down the proxy handler, the response, and some other state via a new `req.WithContext(ctx)`. Wrapping a new context is pretty much the only way we have to jump a few layers in the HTTP middleware chain and let a handler pick up this information. Feels a bit dirty, but it works.
Also fixed a bug with the `http.reverse_proxy.upstream.duration` placeholder, it always had the same duration as `http.reverse_proxy.upstream.latency`, but the former was meant to be the time taken for the roundtrip _plus_ copying/writing the response.
* Delete the "Content-Length" header if we aren't copying
Fixes a bug where the Content-Length will mismatch the actual bytes written if we skipped copying the response, so we get a message like this when using curl:
```
curl: (18) transfer closed with 18 bytes remaining to read
```
To replicate:
```
{
admin off
debug
}
:8881 {
reverse_proxy 127.0.0.1:8882 {
@200 status 200
handle_response @200 {
header Foo bar
}
}
}
:8882 {
header Content-Type application/json
respond `{"hello": "world"}` 200
}
```
* Implement `copy_response_headers`, with include/exclude list support
* Apply suggestions from code review
Co-authored-by: Matt Holt <mholt@users.noreply.github.com>
2022-03-09 13:00:51 -05:00
}
2024-01-23 19:36:59 -05:00
}
reverseproxy: copy_response and copy_response_headers for handle_response routes (#4391)
* reverseproxy: New `copy_response` handler for `handle_response` routes
Followup to #4298 and #4388.
This adds a new `copy_response` handler which may only be used in `reverse_proxy`'s `handle_response` routes, which can be used to actually copy the proxy response downstream.
Previously, if `handle_response` was used (with routes, not the status code mode), it was impossible to use the upstream's response body at all, because we would always close the body, expecting the routes to write a new body from scratch.
To implement this, I had to refactor `h.reverseProxy()` to move all the code that came after the `HandleResponse` loop into a new function. This new function `h.finalizeResponse()` takes care of preparing the response by removing extra headers, dealing with trailers, then copying the headers and body downstream.
Since basically what we want `copy_response` to do is invoke `h.finalizeResponse()` at a configurable point in time, we need to pass down the proxy handler, the response, and some other state via a new `req.WithContext(ctx)`. Wrapping a new context is pretty much the only way we have to jump a few layers in the HTTP middleware chain and let a handler pick up this information. Feels a bit dirty, but it works.
Also fixed a bug with the `http.reverse_proxy.upstream.duration` placeholder, it always had the same duration as `http.reverse_proxy.upstream.latency`, but the former was meant to be the time taken for the roundtrip _plus_ copying/writing the response.
* Delete the "Content-Length" header if we aren't copying
Fixes a bug where the Content-Length will mismatch the actual bytes written if we skipped copying the response, so we get a message like this when using curl:
```
curl: (18) transfer closed with 18 bytes remaining to read
```
To replicate:
```
{
admin off
debug
}
:8881 {
reverse_proxy 127.0.0.1:8882 {
@200 status 200
handle_response @200 {
header Foo bar
}
}
}
:8882 {
header Content-Type application/json
respond `{"hello": "world"}` 200
}
```
* Implement `copy_response_headers`, with include/exclude list support
* Apply suggestions from code review
Co-authored-by: Matt Holt <mholt@users.noreply.github.com>
2022-03-09 13:00:51 -05:00
2024-01-23 19:36:59 -05:00
for d . NextBlock ( 0 ) {
switch d . Val ( ) {
case "status" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
reverseproxy: copy_response and copy_response_headers for handle_response routes (#4391)
* reverseproxy: New `copy_response` handler for `handle_response` routes
Followup to #4298 and #4388.
This adds a new `copy_response` handler which may only be used in `reverse_proxy`'s `handle_response` routes, which can be used to actually copy the proxy response downstream.
Previously, if `handle_response` was used (with routes, not the status code mode), it was impossible to use the upstream's response body at all, because we would always close the body, expecting the routes to write a new body from scratch.
To implement this, I had to refactor `h.reverseProxy()` to move all the code that came after the `HandleResponse` loop into a new function. This new function `h.finalizeResponse()` takes care of preparing the response by removing extra headers, dealing with trailers, then copying the headers and body downstream.
Since basically what we want `copy_response` to do is invoke `h.finalizeResponse()` at a configurable point in time, we need to pass down the proxy handler, the response, and some other state via a new `req.WithContext(ctx)`. Wrapping a new context is pretty much the only way we have to jump a few layers in the HTTP middleware chain and let a handler pick up this information. Feels a bit dirty, but it works.
Also fixed a bug with the `http.reverse_proxy.upstream.duration` placeholder, it always had the same duration as `http.reverse_proxy.upstream.latency`, but the former was meant to be the time taken for the roundtrip _plus_ copying/writing the response.
* Delete the "Content-Length" header if we aren't copying
Fixes a bug where the Content-Length will mismatch the actual bytes written if we skipped copying the response, so we get a message like this when using curl:
```
curl: (18) transfer closed with 18 bytes remaining to read
```
To replicate:
```
{
admin off
debug
}
:8881 {
reverse_proxy 127.0.0.1:8882 {
@200 status 200
handle_response @200 {
header Foo bar
}
}
}
:8882 {
header Content-Type application/json
respond `{"hello": "world"}` 200
}
```
* Implement `copy_response_headers`, with include/exclude list support
* Apply suggestions from code review
Co-authored-by: Matt Holt <mholt@users.noreply.github.com>
2022-03-09 13:00:51 -05:00
}
2024-01-23 19:36:59 -05:00
h . StatusCode = caddyhttp . WeakString ( d . Val ( ) )
default :
return d . Errf ( "unrecognized subdirective '%s'" , d . Val ( ) )
reverseproxy: copy_response and copy_response_headers for handle_response routes (#4391)
* reverseproxy: New `copy_response` handler for `handle_response` routes
Followup to #4298 and #4388.
This adds a new `copy_response` handler which may only be used in `reverse_proxy`'s `handle_response` routes, which can be used to actually copy the proxy response downstream.
Previously, if `handle_response` was used (with routes, not the status code mode), it was impossible to use the upstream's response body at all, because we would always close the body, expecting the routes to write a new body from scratch.
To implement this, I had to refactor `h.reverseProxy()` to move all the code that came after the `HandleResponse` loop into a new function. This new function `h.finalizeResponse()` takes care of preparing the response by removing extra headers, dealing with trailers, then copying the headers and body downstream.
Since basically what we want `copy_response` to do is invoke `h.finalizeResponse()` at a configurable point in time, we need to pass down the proxy handler, the response, and some other state via a new `req.WithContext(ctx)`. Wrapping a new context is pretty much the only way we have to jump a few layers in the HTTP middleware chain and let a handler pick up this information. Feels a bit dirty, but it works.
Also fixed a bug with the `http.reverse_proxy.upstream.duration` placeholder, it always had the same duration as `http.reverse_proxy.upstream.latency`, but the former was meant to be the time taken for the roundtrip _plus_ copying/writing the response.
* Delete the "Content-Length" header if we aren't copying
Fixes a bug where the Content-Length will mismatch the actual bytes written if we skipped copying the response, so we get a message like this when using curl:
```
curl: (18) transfer closed with 18 bytes remaining to read
```
To replicate:
```
{
admin off
debug
}
:8881 {
reverse_proxy 127.0.0.1:8882 {
@200 status 200
handle_response @200 {
header Foo bar
}
}
}
:8882 {
header Content-Type application/json
respond `{"hello": "world"}` 200
}
```
* Implement `copy_response_headers`, with include/exclude list support
* Apply suggestions from code review
Co-authored-by: Matt Holt <mholt@users.noreply.github.com>
2022-03-09 13:00:51 -05:00
}
}
return nil
}
func parseCopyResponseHeadersCaddyfile ( h httpcaddyfile . Helper ) ( caddyhttp . MiddlewareHandler , error ) {
crh := new ( CopyResponseHeadersHandler )
err := crh . UnmarshalCaddyfile ( h . Dispenser )
if err != nil {
return nil , err
}
return crh , nil
}
// UnmarshalCaddyfile sets up the handler from Caddyfile tokens. Syntax:
//
2022-08-25 22:42:48 -05:00
// copy_response_headers [<matcher>] {
// include <fields...>
// exclude <fields...>
// }
reverseproxy: copy_response and copy_response_headers for handle_response routes (#4391)
* reverseproxy: New `copy_response` handler for `handle_response` routes
Followup to #4298 and #4388.
This adds a new `copy_response` handler which may only be used in `reverse_proxy`'s `handle_response` routes, which can be used to actually copy the proxy response downstream.
Previously, if `handle_response` was used (with routes, not the status code mode), it was impossible to use the upstream's response body at all, because we would always close the body, expecting the routes to write a new body from scratch.
To implement this, I had to refactor `h.reverseProxy()` to move all the code that came after the `HandleResponse` loop into a new function. This new function `h.finalizeResponse()` takes care of preparing the response by removing extra headers, dealing with trailers, then copying the headers and body downstream.
Since basically what we want `copy_response` to do is invoke `h.finalizeResponse()` at a configurable point in time, we need to pass down the proxy handler, the response, and some other state via a new `req.WithContext(ctx)`. Wrapping a new context is pretty much the only way we have to jump a few layers in the HTTP middleware chain and let a handler pick up this information. Feels a bit dirty, but it works.
Also fixed a bug with the `http.reverse_proxy.upstream.duration` placeholder, it always had the same duration as `http.reverse_proxy.upstream.latency`, but the former was meant to be the time taken for the roundtrip _plus_ copying/writing the response.
* Delete the "Content-Length" header if we aren't copying
Fixes a bug where the Content-Length will mismatch the actual bytes written if we skipped copying the response, so we get a message like this when using curl:
```
curl: (18) transfer closed with 18 bytes remaining to read
```
To replicate:
```
{
admin off
debug
}
:8881 {
reverse_proxy 127.0.0.1:8882 {
@200 status 200
handle_response @200 {
header Foo bar
}
}
}
:8882 {
header Content-Type application/json
respond `{"hello": "world"}` 200
}
```
* Implement `copy_response_headers`, with include/exclude list support
* Apply suggestions from code review
Co-authored-by: Matt Holt <mholt@users.noreply.github.com>
2022-03-09 13:00:51 -05:00
func ( h * CopyResponseHeadersHandler ) UnmarshalCaddyfile ( d * caddyfile . Dispenser ) error {
2024-01-23 19:36:59 -05:00
d . Next ( ) // consume directive name
reverseproxy: copy_response and copy_response_headers for handle_response routes (#4391)
* reverseproxy: New `copy_response` handler for `handle_response` routes
Followup to #4298 and #4388.
This adds a new `copy_response` handler which may only be used in `reverse_proxy`'s `handle_response` routes, which can be used to actually copy the proxy response downstream.
Previously, if `handle_response` was used (with routes, not the status code mode), it was impossible to use the upstream's response body at all, because we would always close the body, expecting the routes to write a new body from scratch.
To implement this, I had to refactor `h.reverseProxy()` to move all the code that came after the `HandleResponse` loop into a new function. This new function `h.finalizeResponse()` takes care of preparing the response by removing extra headers, dealing with trailers, then copying the headers and body downstream.
Since basically what we want `copy_response` to do is invoke `h.finalizeResponse()` at a configurable point in time, we need to pass down the proxy handler, the response, and some other state via a new `req.WithContext(ctx)`. Wrapping a new context is pretty much the only way we have to jump a few layers in the HTTP middleware chain and let a handler pick up this information. Feels a bit dirty, but it works.
Also fixed a bug with the `http.reverse_proxy.upstream.duration` placeholder, it always had the same duration as `http.reverse_proxy.upstream.latency`, but the former was meant to be the time taken for the roundtrip _plus_ copying/writing the response.
* Delete the "Content-Length" header if we aren't copying
Fixes a bug where the Content-Length will mismatch the actual bytes written if we skipped copying the response, so we get a message like this when using curl:
```
curl: (18) transfer closed with 18 bytes remaining to read
```
To replicate:
```
{
admin off
debug
}
:8881 {
reverse_proxy 127.0.0.1:8882 {
@200 status 200
handle_response @200 {
header Foo bar
}
}
}
:8882 {
header Content-Type application/json
respond `{"hello": "world"}` 200
}
```
* Implement `copy_response_headers`, with include/exclude list support
* Apply suggestions from code review
Co-authored-by: Matt Holt <mholt@users.noreply.github.com>
2022-03-09 13:00:51 -05:00
2024-01-23 19:36:59 -05:00
args := d . RemainingArgs ( )
if len ( args ) > 0 {
return d . ArgErr ( )
}
reverseproxy: copy_response and copy_response_headers for handle_response routes (#4391)
* reverseproxy: New `copy_response` handler for `handle_response` routes
Followup to #4298 and #4388.
This adds a new `copy_response` handler which may only be used in `reverse_proxy`'s `handle_response` routes, which can be used to actually copy the proxy response downstream.
Previously, if `handle_response` was used (with routes, not the status code mode), it was impossible to use the upstream's response body at all, because we would always close the body, expecting the routes to write a new body from scratch.
To implement this, I had to refactor `h.reverseProxy()` to move all the code that came after the `HandleResponse` loop into a new function. This new function `h.finalizeResponse()` takes care of preparing the response by removing extra headers, dealing with trailers, then copying the headers and body downstream.
Since basically what we want `copy_response` to do is invoke `h.finalizeResponse()` at a configurable point in time, we need to pass down the proxy handler, the response, and some other state via a new `req.WithContext(ctx)`. Wrapping a new context is pretty much the only way we have to jump a few layers in the HTTP middleware chain and let a handler pick up this information. Feels a bit dirty, but it works.
Also fixed a bug with the `http.reverse_proxy.upstream.duration` placeholder, it always had the same duration as `http.reverse_proxy.upstream.latency`, but the former was meant to be the time taken for the roundtrip _plus_ copying/writing the response.
* Delete the "Content-Length" header if we aren't copying
Fixes a bug where the Content-Length will mismatch the actual bytes written if we skipped copying the response, so we get a message like this when using curl:
```
curl: (18) transfer closed with 18 bytes remaining to read
```
To replicate:
```
{
admin off
debug
}
:8881 {
reverse_proxy 127.0.0.1:8882 {
@200 status 200
handle_response @200 {
header Foo bar
}
}
}
:8882 {
header Content-Type application/json
respond `{"hello": "world"}` 200
}
```
* Implement `copy_response_headers`, with include/exclude list support
* Apply suggestions from code review
Co-authored-by: Matt Holt <mholt@users.noreply.github.com>
2022-03-09 13:00:51 -05:00
2024-01-23 19:36:59 -05:00
for d . NextBlock ( 0 ) {
switch d . Val ( ) {
case "include" :
h . Include = append ( h . Include , d . RemainingArgs ( ) ... )
reverseproxy: copy_response and copy_response_headers for handle_response routes (#4391)
* reverseproxy: New `copy_response` handler for `handle_response` routes
Followup to #4298 and #4388.
This adds a new `copy_response` handler which may only be used in `reverse_proxy`'s `handle_response` routes, which can be used to actually copy the proxy response downstream.
Previously, if `handle_response` was used (with routes, not the status code mode), it was impossible to use the upstream's response body at all, because we would always close the body, expecting the routes to write a new body from scratch.
To implement this, I had to refactor `h.reverseProxy()` to move all the code that came after the `HandleResponse` loop into a new function. This new function `h.finalizeResponse()` takes care of preparing the response by removing extra headers, dealing with trailers, then copying the headers and body downstream.
Since basically what we want `copy_response` to do is invoke `h.finalizeResponse()` at a configurable point in time, we need to pass down the proxy handler, the response, and some other state via a new `req.WithContext(ctx)`. Wrapping a new context is pretty much the only way we have to jump a few layers in the HTTP middleware chain and let a handler pick up this information. Feels a bit dirty, but it works.
Also fixed a bug with the `http.reverse_proxy.upstream.duration` placeholder, it always had the same duration as `http.reverse_proxy.upstream.latency`, but the former was meant to be the time taken for the roundtrip _plus_ copying/writing the response.
* Delete the "Content-Length" header if we aren't copying
Fixes a bug where the Content-Length will mismatch the actual bytes written if we skipped copying the response, so we get a message like this when using curl:
```
curl: (18) transfer closed with 18 bytes remaining to read
```
To replicate:
```
{
admin off
debug
}
:8881 {
reverse_proxy 127.0.0.1:8882 {
@200 status 200
handle_response @200 {
header Foo bar
}
}
}
:8882 {
header Content-Type application/json
respond `{"hello": "world"}` 200
}
```
* Implement `copy_response_headers`, with include/exclude list support
* Apply suggestions from code review
Co-authored-by: Matt Holt <mholt@users.noreply.github.com>
2022-03-09 13:00:51 -05:00
2024-01-23 19:36:59 -05:00
case "exclude" :
h . Exclude = append ( h . Exclude , d . RemainingArgs ( ) ... )
default :
return d . Errf ( "unrecognized subdirective '%s'" , d . Val ( ) )
reverseproxy: copy_response and copy_response_headers for handle_response routes (#4391)
* reverseproxy: New `copy_response` handler for `handle_response` routes
Followup to #4298 and #4388.
This adds a new `copy_response` handler which may only be used in `reverse_proxy`'s `handle_response` routes, which can be used to actually copy the proxy response downstream.
Previously, if `handle_response` was used (with routes, not the status code mode), it was impossible to use the upstream's response body at all, because we would always close the body, expecting the routes to write a new body from scratch.
To implement this, I had to refactor `h.reverseProxy()` to move all the code that came after the `HandleResponse` loop into a new function. This new function `h.finalizeResponse()` takes care of preparing the response by removing extra headers, dealing with trailers, then copying the headers and body downstream.
Since basically what we want `copy_response` to do is invoke `h.finalizeResponse()` at a configurable point in time, we need to pass down the proxy handler, the response, and some other state via a new `req.WithContext(ctx)`. Wrapping a new context is pretty much the only way we have to jump a few layers in the HTTP middleware chain and let a handler pick up this information. Feels a bit dirty, but it works.
Also fixed a bug with the `http.reverse_proxy.upstream.duration` placeholder, it always had the same duration as `http.reverse_proxy.upstream.latency`, but the former was meant to be the time taken for the roundtrip _plus_ copying/writing the response.
* Delete the "Content-Length" header if we aren't copying
Fixes a bug where the Content-Length will mismatch the actual bytes written if we skipped copying the response, so we get a message like this when using curl:
```
curl: (18) transfer closed with 18 bytes remaining to read
```
To replicate:
```
{
admin off
debug
}
:8881 {
reverse_proxy 127.0.0.1:8882 {
@200 status 200
handle_response @200 {
header Foo bar
}
}
}
:8882 {
header Content-Type application/json
respond `{"hello": "world"}` 200
}
```
* Implement `copy_response_headers`, with include/exclude list support
* Apply suggestions from code review
Co-authored-by: Matt Holt <mholt@users.noreply.github.com>
2022-03-09 13:00:51 -05:00
}
}
return nil
}
2022-03-06 19:43:39 -05:00
// UnmarshalCaddyfile deserializes Caddyfile tokens into h.
//
2022-08-25 22:42:48 -05:00
// dynamic srv [<name>] {
// service <service>
// proto <proto>
// name <name>
// refresh <interval>
// resolvers <resolvers...>
// dial_timeout <timeout>
// dial_fallback_delay <timeout>
2024-04-23 08:12:57 -05:00
// grace_period <duration>
2022-08-25 22:42:48 -05:00
// }
2022-03-06 19:43:39 -05:00
func ( u * SRVUpstreams ) UnmarshalCaddyfile ( d * caddyfile . Dispenser ) error {
2024-01-23 19:36:59 -05:00
d . Next ( ) // consume upstream source name
2022-03-06 19:43:39 -05:00
2024-01-23 19:36:59 -05:00
args := d . RemainingArgs ( )
if len ( args ) > 1 {
return d . ArgErr ( )
}
if len ( args ) > 0 {
u . Name = args [ 0 ]
}
2022-03-06 19:43:39 -05:00
2024-01-23 19:36:59 -05:00
for d . NextBlock ( 0 ) {
switch d . Val ( ) {
case "service" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
if u . Service != "" {
return d . Errf ( "srv service has already been specified" )
}
u . Service = d . Val ( )
2022-03-06 19:43:39 -05:00
2024-01-23 19:36:59 -05:00
case "proto" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
if u . Proto != "" {
return d . Errf ( "srv proto has already been specified" )
}
u . Proto = d . Val ( )
2022-03-06 19:43:39 -05:00
2024-01-23 19:36:59 -05:00
case "name" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
if u . Name != "" {
return d . Errf ( "srv name has already been specified" )
}
u . Name = d . Val ( )
2022-03-06 19:43:39 -05:00
2024-01-23 19:36:59 -05:00
case "refresh" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
dur , err := caddy . ParseDuration ( d . Val ( ) )
if err != nil {
return d . Errf ( "parsing refresh interval duration: %v" , err )
}
u . Refresh = caddy . Duration ( dur )
2022-03-06 19:43:39 -05:00
2024-01-23 19:36:59 -05:00
case "resolvers" :
if u . Resolver == nil {
u . Resolver = new ( UpstreamResolver )
}
u . Resolver . Addresses = d . RemainingArgs ( )
if len ( u . Resolver . Addresses ) == 0 {
return d . Errf ( "must specify at least one resolver address" )
}
2022-03-06 19:43:39 -05:00
2024-01-23 19:36:59 -05:00
case "dial_timeout" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
dur , err := caddy . ParseDuration ( d . Val ( ) )
if err != nil {
return d . Errf ( "bad timeout value '%s': %v" , d . Val ( ) , err )
}
u . DialTimeout = caddy . Duration ( dur )
2022-03-06 19:43:39 -05:00
2024-01-23 19:36:59 -05:00
case "dial_fallback_delay" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
dur , err := caddy . ParseDuration ( d . Val ( ) )
if err != nil {
return d . Errf ( "bad delay value '%s': %v" , d . Val ( ) , err )
2022-03-06 19:43:39 -05:00
}
2024-01-23 19:36:59 -05:00
u . FallbackDelay = caddy . Duration ( dur )
2024-04-23 08:12:57 -05:00
case "grace_period" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
dur , err := caddy . ParseDuration ( d . Val ( ) )
if err != nil {
return d . Errf ( "bad grace period value '%s': %v" , d . Val ( ) , err )
}
u . GracePeriod = caddy . Duration ( dur )
2024-01-23 19:36:59 -05:00
default :
return d . Errf ( "unrecognized srv option '%s'" , d . Val ( ) )
2022-03-06 19:43:39 -05:00
}
}
return nil
}
// UnmarshalCaddyfile deserializes Caddyfile tokens into h.
//
2022-08-25 22:42:48 -05:00
// dynamic a [<name> <port] {
// name <name>
// port <port>
// refresh <interval>
// resolvers <resolvers...>
// dial_timeout <timeout>
// dial_fallback_delay <timeout>
2023-02-27 12:23:09 -05:00
// versions ipv4|ipv6
2022-08-25 22:42:48 -05:00
// }
2022-03-06 19:43:39 -05:00
func ( u * AUpstreams ) UnmarshalCaddyfile ( d * caddyfile . Dispenser ) error {
2024-01-23 19:36:59 -05:00
d . Next ( ) // consume upstream source name
args := d . RemainingArgs ( )
if len ( args ) > 2 {
return d . ArgErr ( )
}
if len ( args ) > 0 {
u . Name = args [ 0 ]
if len ( args ) == 2 {
u . Port = args [ 1 ]
2022-03-06 19:43:39 -05:00
}
2024-01-23 19:36:59 -05:00
}
2022-03-06 19:43:39 -05:00
2024-01-23 19:36:59 -05:00
for d . NextBlock ( 0 ) {
switch d . Val ( ) {
case "name" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
if u . Name != "" {
return d . Errf ( "a name has already been specified" )
}
u . Name = d . Val ( )
2022-03-06 19:43:39 -05:00
2024-01-23 19:36:59 -05:00
case "port" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
if u . Port != "" {
return d . Errf ( "a port has already been specified" )
}
u . Port = d . Val ( )
2022-03-06 19:43:39 -05:00
2024-01-23 19:36:59 -05:00
case "refresh" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
dur , err := caddy . ParseDuration ( d . Val ( ) )
if err != nil {
return d . Errf ( "parsing refresh interval duration: %v" , err )
}
u . Refresh = caddy . Duration ( dur )
2022-03-06 19:43:39 -05:00
2024-01-23 19:36:59 -05:00
case "resolvers" :
if u . Resolver == nil {
u . Resolver = new ( UpstreamResolver )
}
u . Resolver . Addresses = d . RemainingArgs ( )
if len ( u . Resolver . Addresses ) == 0 {
return d . Errf ( "must specify at least one resolver address" )
}
2022-03-06 19:43:39 -05:00
2024-01-23 19:36:59 -05:00
case "dial_timeout" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
dur , err := caddy . ParseDuration ( d . Val ( ) )
if err != nil {
return d . Errf ( "bad timeout value '%s': %v" , d . Val ( ) , err )
}
u . DialTimeout = caddy . Duration ( dur )
2022-03-06 19:43:39 -05:00
2024-01-23 19:36:59 -05:00
case "dial_fallback_delay" :
if ! d . NextArg ( ) {
return d . ArgErr ( )
}
dur , err := caddy . ParseDuration ( d . Val ( ) )
if err != nil {
return d . Errf ( "bad delay value '%s': %v" , d . Val ( ) , err )
}
u . FallbackDelay = caddy . Duration ( dur )
2022-03-06 19:43:39 -05:00
2024-01-23 19:36:59 -05:00
case "versions" :
args := d . RemainingArgs ( )
if len ( args ) == 0 {
return d . Errf ( "must specify at least one version" )
}
2023-02-27 12:23:09 -05:00
2024-01-23 19:36:59 -05:00
if u . Versions == nil {
u . Versions = & IPVersions { }
}
2023-02-27 12:23:09 -05:00
2024-01-23 19:36:59 -05:00
trueBool := true
for _ , arg := range args {
switch arg {
case "ipv4" :
u . Versions . IPv4 = & trueBool
case "ipv6" :
u . Versions . IPv6 = & trueBool
default :
return d . Errf ( "unsupported version: '%s'" , arg )
2023-02-27 12:23:09 -05:00
}
2022-03-06 19:43:39 -05:00
}
2024-01-23 19:36:59 -05:00
default :
return d . Errf ( "unrecognized a option '%s'" , d . Val ( ) )
2022-03-06 19:43:39 -05:00
}
}
return nil
}
2022-08-25 22:42:48 -05:00
// UnmarshalCaddyfile deserializes Caddyfile tokens into h.
//
// dynamic multi {
// <source> [...]
// }
func ( u * MultiUpstreams ) UnmarshalCaddyfile ( d * caddyfile . Dispenser ) error {
2024-01-23 19:36:59 -05:00
d . Next ( ) // consume upstream source name
2022-08-25 22:42:48 -05:00
2024-01-23 19:36:59 -05:00
if d . NextArg ( ) {
return d . ArgErr ( )
2022-08-25 22:42:48 -05:00
}
2024-01-23 19:36:59 -05:00
for d . NextBlock ( 0 ) {
dynModule := d . Val ( )
modID := "http.reverse_proxy.upstreams." + dynModule
unm , err := caddyfile . UnmarshalModule ( d , modID )
if err != nil {
return err
}
source , ok := unm . ( UpstreamSource )
if ! ok {
return d . Errf ( "module %s (%T) is not an UpstreamSource" , modID , unm )
}
u . SourcesRaw = append ( u . SourcesRaw , caddyconfig . JSONModuleObject ( source , "source" , dynModule , nil ) )
}
2022-08-25 22:42:48 -05:00
return nil
}
2021-05-02 13:39:06 -05:00
const matcherPrefix = "@"
2019-09-09 13:23:27 -05:00
// Interface guards
var (
_ caddyfile . Unmarshaler = ( * Handler ) ( nil )
_ caddyfile . Unmarshaler = ( * HTTPTransport ) ( nil )
2022-03-06 19:43:39 -05:00
_ caddyfile . Unmarshaler = ( * SRVUpstreams ) ( nil )
_ caddyfile . Unmarshaler = ( * AUpstreams ) ( nil )
2022-08-25 22:42:48 -05:00
_ caddyfile . Unmarshaler = ( * MultiUpstreams ) ( nil )
2019-09-09 13:23:27 -05:00
)