Fast and extensible multi-platform HTTP/1-2-3 web server with automatic HTTPS
Mirrored from https://github.com/Slazee/caddy.git
Synced Nov 14, 05:15 UTC
headers: Support default header values in Caddyfile with '?' (#3807)
* implement default values for header directive closes #3804 * remove `set_default` header op and rely on "require" handler instead This has the following advantages over the previous attempt: - It does not introduce a new operation for headers, but rather nicely extends over an existing feature in the header handler. - It removes the need to specify the header as "deferred" because it is already implicitely deferred by the use of the require handler. This should be less confusing to the user. * add integration test for header directive in caddyfile * bubble up errors when parsing caddyfile header directive * don't export unnecessarily and don't canonicalize headers unnecessarily * fix response headers not passed in blocks * caddyfile: fix clash when using default header in block Each header is now set in a separate handler so that it doesn't clash with other headers set/added/deleted in the same block. * caddyhttp: New idle_timeout default of 5m * reverseproxy: fix random hangs on http/2 requests with server push (#3875) see https://github.com/golang/go/issues/42534 * Refactor and cleanup with improvements * More specific link Co-authored-by: Matthew Holt <mholt@users.noreply.github.com> Co-authored-by: Денис Телюх <telyukh.denis@gmail.com>
Gilbert Gilb's committed
Nov 20, 2020 at 20:38 UTC
b0d5c2c8ae076393e7a3ad59ce875027f4c29304
6 files changed
+466
-71
caddyconfig/httpcaddyfile/directives.go
+7
-11
@@ -103,20 +103,11 @@ func RegisterHandlerDirective(dir string, setupFunc UnmarshalHandlerFunc) {
103
return nil, h.ArgErr()
104
}
105
106
- matcherSet, ok, err := h.MatcherToken()
106
+ matcherSet, err := h.ExtractMatcherSet()
107
if err != nil {
108
return nil, err
109
}
110
- if ok {
111
- // strip matcher token; we don't need to
112
- // use the return value here because a
113
- // new dispenser should have been made
114
- // solely for this directive's tokens,
115
- // with no other uses of same slice
116
- h.Dispenser.Delete()
117
- }
110
119
- h.Dispenser.Reset() // pretend this lookahead never happened
111
val, err := setupFunc(h)
112
if err != nil {
113
return nil, err
@@ -201,7 +192,12 @@ func (h Helper) ExtractMatcherSet() (caddy.ModuleMap, error) {
192
return nil, err
193
}
194
if hasMatcher {
204
- h.Dispenser.Delete() // strip matcher token
195
+ // strip matcher token; we don't need to
196
+ // use the return value here because a
197
+ // new dispenser should have been made
198
+ // solely for this directive's tokens,
199
+ // with no other uses of same slice
200
+ h.Dispenser.Delete()
201
}
202
h.Dispenser.Reset() // pretend this lookahead never happened
203
return matcherSet, nil
caddytest/integration/caddyfile_adapt/header.txt
new
+107
@@ -0,0 +1,107 @@
1
+:80 {
2
+ header Denis "Ritchie"
3
+ header +Edsger "Dijkstra"
4
+ header ?John "von Neumann"
5
+ header -Wolfram
6
+ header {
7
+ Grace: "Hopper" # some users habitually suffix field names with a colon
8
+ +Ray "Solomonoff"
9
+ ?Tim "Berners-Lee"
10
+ defer
11
+ }
12
+}
13
+----------
14
+{
15
+ "apps": {
16
+ "http": {
17
+ "servers": {
18
+ "srv0": {
19
+ "listen": [
20
+ ":80"
21
+ ],
22
+ "routes": [
23
+ {
24
+ "handle": [
25
+ {
26
+ "handler": "headers",
27
+ "response": {
28
+ "set": {
29
+ "Denis": [
30
+ "Ritchie"
31
+ ]
32
+ }
33
+ }
34
+ },
35
+ {
36
+ "handler": "headers",
37
+ "response": {
38
+ "add": {
39
+ "Edsger": [
40
+ "Dijkstra"
41
+ ]
42
+ }
43
+ }
44
+ },
45
+ {
46
+ "handler": "headers",
47
+ "response": {
48
+ "require": {
49
+ "headers": {
50
+ "John": null
51
+ }
52
+ },
53
+ "set": {
54
+ "John": [
55
+ "von Neumann"
56
+ ]
57
+ }
58
+ }
59
+ },
60
+ {
61
+ "handler": "headers",
62
+ "response": {
63
+ "deferred": true,
64
+ "delete": [
65
+ "Wolfram"
66
+ ]
67
+ }
68
+ },
69
+ {
70
+ "handler": "headers",
71
+ "response": {
72
+ "add": {
73
+ "Ray": [
74
+ "Solomonoff"
75
+ ]
76
+ },
77
+ "deferred": true,
78
+ "set": {
79
+ "Grace": [
80
+ "Hopper"
81
+ ]
82
+ }
83
+ }
84
+ },
85
+ {
86
+ "handler": "headers",
87
+ "response": {
88
+ "require": {
89
+ "headers": {
90
+ "Tim": null
91
+ }
92
+ },
93
+ "set": {
94
+ "Tim": [
95
+ "Berners-Lee"
96
+ ]
97
+ }
98
+ }
99
+ }
100
+ ]
101
+ }
102
+ ]
103
+ }
104
+ }
105
+ }
106
+ }
107
+}
modules/caddyhttp/headers/caddyfile.go
+131
-48
@@ -15,7 +15,9 @@
15
package headers
16
17
import (
18
+ "fmt"
19
"net/http"
20
+ "reflect"
21
"strings"
22
23
"github.com/caddyserver/caddy/v2/caddyconfig/httpcaddyfile"
@@ -23,15 +25,16 @@ import (
25
)
26
27
func init() {
26
- httpcaddyfile.RegisterHandlerDirective("header", parseCaddyfile)
27
- httpcaddyfile.RegisterHandlerDirective("request_header", parseReqHdrCaddyfile)
28
+ httpcaddyfile.RegisterDirective("header", parseCaddyfile)
29
+ httpcaddyfile.RegisterDirective("request_header", parseReqHdrCaddyfile)
30
}
31
32
// parseCaddyfile sets up the handler for response headers from
33
// Caddyfile tokens. Syntax:
34
//
33
-// header [<matcher>] [[+|-]<field> [<value|regexp>] [<replacement>]] {
35
+// header [<matcher>] [[+|-|?]<field> [<value|regexp>] [<replacement>]] {
36
// [+]<field> [<value|regexp> [<replacement>]]
37
+// ?<field> <default_value>
38
// -<field>
39
// [defer]
40
// }
@@ -39,17 +42,23 @@ func init() {
42
// Either a block can be opened or a single header field can be configured
43
// in the first line, but not both in the same directive. Header operations
44
// are deferred to write-time if any headers are being deleted or if the
42
-// 'defer' subdirective is used.
43
-func parseCaddyfile(h httpcaddyfile.Helper) (caddyhttp.MiddlewareHandler, error) {
44
- hdr := new(Handler)
45
-
46
- makeResponseOps := func() {
47
- if hdr.Response == nil {
48
- hdr.Response = &RespHeaderOps{
49
- HeaderOps: new(HeaderOps),
50
- }
45
+// 'defer' subdirective is used. + appends a header value, - deletes a field,
46
+// and ? conditionally sets a value only if the header field is not already
47
+// set.
48
+func parseCaddyfile(h httpcaddyfile.Helper) ([]httpcaddyfile.ConfigValue, error) {
49
+ matcherSet, err := h.ExtractMatcherSet()
50
+ if err != nil {
51
+ return nil, err
52
+ }
53
+
54
+ makeHandler := func() Handler {
55
+ return Handler{
56
+ Response: &RespHeaderOps{
57
+ HeaderOps: &HeaderOps{},
58
+ },
59
}
60
}
61
+ handler, handlerWithRequire := makeHandler(), makeHandler()
62
63
for h.Next() {
64
// first see if headers are in the initial line
@@ -64,10 +73,18 @@ func parseCaddyfile(h httpcaddyfile.Helper) (caddyhttp.MiddlewareHandler, error)
73
if h.NextArg() {
74
replacement = h.Val()
75
}
67
- makeResponseOps()
68
- CaddyfileHeaderOp(hdr.Response.HeaderOps, field, value, replacement)
69
- if len(hdr.Response.HeaderOps.Delete) > 0 {
70
- hdr.Response.Deferred = true
76
+ err := applyHeaderOp(
77
+ handler.Response.HeaderOps,
78
+ handler.Response,
79
+ field,
80
+ value,
81
+ replacement,
82
+ )
83
+ if err != nil {
84
+ return nil, h.Err(err.Error())
85
+ }
86
+ if len(handler.Response.HeaderOps.Delete) > 0 {
87
+ handler.Response.Deferred = true
88
}
89
}
90
@@ -75,12 +92,18 @@ func parseCaddyfile(h httpcaddyfile.Helper) (caddyhttp.MiddlewareHandler, error)
92
for h.NextBlock(0) {
93
field := h.Val()
94
if field == "defer" {
78
- hdr.Response.Deferred = true
95
+ handler.Response.Deferred = true
96
continue
97
}
98
if hasArgs {
82
- return nil, h.Err("cannot specify headers in both arguments and block")
99
+ return nil, h.Err("cannot specify headers in both arguments and block") // because it would be weird
100
}
101
+
102
+ // sometimes it is habitual for users to suffix a field name with a colon,
103
+ // as if they were writing a curl command or something; see
104
+ // https://caddy.community/t/v2-reverse-proxy-please-add-cors-example-to-the-docs/7349/19
105
+ field = strings.TrimSuffix(field, ":")
106
+
107
var value, replacement string
108
if h.NextArg() {
109
value = h.Val()
@@ -88,15 +111,34 @@ func parseCaddyfile(h httpcaddyfile.Helper) (caddyhttp.MiddlewareHandler, error)
111
if h.NextArg() {
112
replacement = h.Val()
113
}
91
- makeResponseOps()
92
- CaddyfileHeaderOp(hdr.Response.HeaderOps, field, value, replacement)
93
- if len(hdr.Response.HeaderOps.Delete) > 0 {
94
- hdr.Response.Deferred = true
114
+
115
+ handlerToUse := handler
116
+ if strings.HasPrefix(field, "?") {
117
+ handlerToUse = handlerWithRequire
118
+ }
119
+
120
+ err := applyHeaderOp(
121
+ handlerToUse.Response.HeaderOps,
122
+ handlerToUse.Response,
123
+ field,
124
+ value,
125
+ replacement,
126
+ )
127
+ if err != nil {
128
+ return nil, h.Err(err.Error())
129
}
130
}
131
}
132
99
- return hdr, nil
133
+ var configValues []httpcaddyfile.ConfigValue
134
+ if !reflect.DeepEqual(handler, makeHandler()) {
135
+ configValues = append(configValues, h.NewRoute(matcherSet, handler)...)
136
+ }
137
+ if !reflect.DeepEqual(handlerWithRequire, makeHandler()) {
138
+ configValues = append(configValues, h.NewRoute(matcherSet, handlerWithRequire)...)
139
+ }
140
+
141
+ return configValues, nil
142
}
143
144
// parseReqHdrCaddyfile sets up the handler for request headers
@@ -104,17 +146,27 @@ func parseCaddyfile(h httpcaddyfile.Helper) (caddyhttp.MiddlewareHandler, error)
146
//
147
// request_header [<matcher>] [[+|-]<field> [<value|regexp>] [<replacement>]]
148
//
107
-func parseReqHdrCaddyfile(h httpcaddyfile.Helper) (caddyhttp.MiddlewareHandler, error) {
108
- hdr := new(Handler)
149
+func parseReqHdrCaddyfile(h httpcaddyfile.Helper) ([]httpcaddyfile.ConfigValue, error) {
150
+ matcherSet, err := h.ExtractMatcherSet()
151
+ if err != nil {
152
+ return nil, err
153
+ }
154
+
155
+ configValues := []httpcaddyfile.ConfigValue{}
156
+
157
for h.Next() {
158
if !h.NextArg() {
159
return nil, h.ArgErr()
160
}
161
field := h.Val()
162
163
+ hdr := Handler{
164
+ Request: &HeaderOps{},
165
+ }
166
+
167
// sometimes it is habitual for users to suffix a field name with a colon,
168
// as if they were writing a curl command or something; see
117
- // https://caddy.community/t/v2-reverse-proxy-please-add-cors-example-to-the-docs/7349
169
+ // https://caddy.community/t/v2-reverse-proxy-please-add-cors-example-to-the-docs/7349/19
170
field = strings.TrimSuffix(field, ":")
171
172
var value, replacement string
@@ -131,13 +183,17 @@ func parseReqHdrCaddyfile(h httpcaddyfile.Helper) (caddyhttp.MiddlewareHandler,
183
if hdr.Request == nil {
184
hdr.Request = new(HeaderOps)
185
}
134
- CaddyfileHeaderOp(hdr.Request, field, value, replacement)
186
+ if err := CaddyfileHeaderOp(hdr.Request, field, value, replacement); err != nil {
187
+ return nil, h.Err(err.Error())
188
+ }
189
+
190
+ configValues = append(configValues, h.NewRoute(matcherSet, hdr)...)
191
192
if h.NextArg() {
193
return nil, h.ArgErr()
194
}
195
}
140
- return hdr, nil
196
+ return configValues, nil
197
}
198
199
// CaddyfileHeaderOp applies a new header operation according to
@@ -148,32 +204,59 @@ func parseReqHdrCaddyfile(h httpcaddyfile.Helper) (caddyhttp.MiddlewareHandler,
204
// will be used to search and then replacement will be used to
205
// complete the substring replacement; in that case, any + or -
206
// prefix to field will be ignored.
151
-func CaddyfileHeaderOp(ops *HeaderOps, field, value, replacement string) {
152
- if strings.HasPrefix(field, "+") {
207
+func CaddyfileHeaderOp(ops *HeaderOps, field, value, replacement string) error {
208
+ return applyHeaderOp(ops, nil, field, value, replacement)
209
+}
210
+
211
+func applyHeaderOp(ops *HeaderOps, respHeaderOps *RespHeaderOps, field, value, replacement string) error {
212
+ switch {
213
+ case strings.HasPrefix(field, "+"): // append
214
if ops.Add == nil {
215
ops.Add = make(http.Header)
216
}
217
ops.Add.Set(field[1:], value)
157
- } else if strings.HasPrefix(field, "-") {
218
+
219
+ case strings.HasPrefix(field, "-"): // delete
220
ops.Delete = append(ops.Delete, field[1:])
159
- } else {
160
- if replacement == "" {
161
- if ops.Set == nil {
162
- ops.Set = make(http.Header)
163
- }
164
- ops.Set.Set(field, value)
165
- } else {
166
- if ops.Replace == nil {
167
- ops.Replace = make(map[string][]Replacement)
221
+ if respHeaderOps != nil {
222
+ respHeaderOps.Deferred = true
223
+ }
224
+
225
+ case strings.HasPrefix(field, "?"): // default (conditional on not existing) - response headers only
226
+ if respHeaderOps == nil {
227
+ return fmt.Errorf("%v: the default header modifier ('?') can only be used on response headers; for conditional manipulation of request headers, use matchers", field)
228
+ }
229
+ if respHeaderOps.Require == nil {
230
+ respHeaderOps.Require = &caddyhttp.ResponseMatcher{
231
+ Headers: make(http.Header),
232
}
169
- field = strings.TrimLeft(field, "+-")
170
- ops.Replace[field] = append(
171
- ops.Replace[field],
172
- Replacement{
173
- SearchRegexp: value,
174
- Replace: replacement,
175
- },
176
- )
233
}
234
+ field = strings.TrimPrefix(field, "?")
235
+ respHeaderOps.Require.Headers[field] = nil
236
+ if respHeaderOps.Set == nil {
237
+ respHeaderOps.Set = make(http.Header)
238
+ }
239
+ respHeaderOps.Set.Set(field, value)
240
+
241
+ case replacement != "": // replace
242
+ if ops.Replace == nil {
243
+ ops.Replace = make(map[string][]Replacement)
244
+ }
245
+ field = strings.TrimLeft(field, "+-?")
246
+ ops.Replace[field] = append(
247
+ ops.Replace[field],
248
+ Replacement{
249
+ SearchRegexp: value,
250
+ Replace: replacement,
251
+ },
252
+ )
253
+
254
+ default: // set (overwrite)
255
+ if ops.Set == nil {
256
+ ops.Set = make(http.Header)
257
+ }
258
+ ops.Set.Set(field, value)
259
}
260
+
261
+ return nil
262
}
modules/caddyhttp/headers/headers_test.go
+192
-3
@@ -14,8 +14,197 @@
14
15
package headers
16
17
-import "testing"
17
+import (
18
+ "context"
19
+ "fmt"
20
+ "net/http"
21
+ "net/http/httptest"
22
+ "reflect"
23
+ "testing"
24
19
-func TestReqHeaders(t *testing.T) {
20
- // TODO: write tests
25
+ "github.com/caddyserver/caddy/v2"
26
+ "github.com/caddyserver/caddy/v2/modules/caddyhttp"
27
+)
28
+
29
+func TestHandler(t *testing.T) {
30
+ for i, tc := range []struct {
31
+ handler Handler
32
+ reqHeader http.Header
33
+ respHeader http.Header
34
+ respStatusCode int
35
+ expectedReqHeader http.Header
36
+ expectedRespHeader http.Header
37
+ }{
38
+ {
39
+ handler: Handler{
40
+ Request: &HeaderOps{
41
+ Add: http.Header{
42
+ "Expose-Secrets": []string{"always"},
43
+ },
44
+ },
45
+ },
46
+ reqHeader: http.Header{
47
+ "Expose-Secrets": []string{"i'm serious"},
48
+ },
49
+ expectedReqHeader: http.Header{
50
+ "Expose-Secrets": []string{"i'm serious", "always"},
51
+ },
52
+ },
53
+ {
54
+ handler: Handler{
55
+ Request: &HeaderOps{
56
+ Set: http.Header{
57
+ "Who-Wins": []string{"batman"},
58
+ },
59
+ },
60
+ },
61
+ reqHeader: http.Header{
62
+ "Who-Wins": []string{"joker"},
63
+ },
64
+ expectedReqHeader: http.Header{
65
+ "Who-Wins": []string{"batman"},
66
+ },
67
+ },
68
+ {
69
+ handler: Handler{
70
+ Request: &HeaderOps{
71
+ Delete: []string{"Kick-Me"},
72
+ },
73
+ },
74
+ reqHeader: http.Header{
75
+ "Kick-Me": []string{"if you can"},
76
+ "Keep-Me": []string{"i swear i'm innocent"},
77
+ },
78
+ expectedReqHeader: http.Header{
79
+ "Keep-Me": []string{"i swear i'm innocent"},
80
+ },
81
+ },
82
+ {
83
+ handler: Handler{
84
+ Request: &HeaderOps{
85
+ Replace: map[string][]Replacement{
86
+ "Best-Server": {
87
+ Replacement{
88
+ Search: "NGINX",
89
+ Replace: "the Caddy web server",
90
+ },
91
+ Replacement{
92
+ SearchRegexp: `Apache(\d+)`,
93
+ Replace: "Caddy",
94
+ },
95
+ },
96
+ },
97
+ },
98
+ },
99
+ reqHeader: http.Header{
100
+ "Best-Server": []string{"it's NGINX, undoubtedly", "I love Apache2"},
101
+ },
102
+ expectedReqHeader: http.Header{
103
+ "Best-Server": []string{"it's the Caddy web server, undoubtedly", "I love Caddy"},
104
+ },
105
+ },
106
+ {
107
+ handler: Handler{
108
+ Response: &RespHeaderOps{
109
+ Require: &caddyhttp.ResponseMatcher{
110
+ Headers: http.Header{
111
+ "Cache-Control": nil,
112
+ },
113
+ },
114
+ HeaderOps: &HeaderOps{
115
+ Add: http.Header{
116
+ "Cache-Control": []string{"no-cache"},
117
+ },
118
+ },
119
+ },
120
+ },
121
+ respHeader: http.Header{},
122
+ expectedRespHeader: http.Header{
123
+ "Cache-Control": []string{"no-cache"},
124
+ },
125
+ },
126
+ {
127
+ handler: Handler{
128
+ Response: &RespHeaderOps{
129
+ Require: &caddyhttp.ResponseMatcher{
130
+ Headers: http.Header{
131
+ "Cache-Control": []string{"no-cache"},
132
+ },
133
+ },
134
+ HeaderOps: &HeaderOps{
135
+ Delete: []string{"Cache-Control"},
136
+ },
137
+ },
138
+ },
139
+ respHeader: http.Header{
140
+ "Cache-Control": []string{"no-cache"},
141
+ },
142
+ expectedRespHeader: http.Header{},
143
+ },
144
+ {
145
+ handler: Handler{
146
+ Response: &RespHeaderOps{
147
+ Require: &caddyhttp.ResponseMatcher{
148
+ StatusCode: []int{5},
149
+ },
150
+ HeaderOps: &HeaderOps{
151
+ Add: http.Header{
152
+ "Fail-5xx": []string{"true"},
153
+ },
154
+ },
155
+ },
156
+ },
157
+ respStatusCode: 503,
158
+ respHeader: http.Header{},
159
+ expectedRespHeader: http.Header{
160
+ "Fail-5xx": []string{"true"},
161
+ },
162
+ },
163
+ } {
164
+ rr := httptest.NewRecorder()
165
+
166
+ req := &http.Request{Header: tc.reqHeader}
167
+ repl := caddy.NewReplacer()
168
+ ctx := context.WithValue(req.Context(), caddy.ReplacerCtxKey, repl)
169
+ req = req.WithContext(ctx)
170
+
171
+ tc.handler.Provision(caddy.Context{})
172
+
173
+ next := nextHandler(func(w http.ResponseWriter, r *http.Request) error {
174
+ for k, hdrs := range tc.respHeader {
175
+ for _, v := range hdrs {
176
+ w.Header().Add(k, v)
177
+ }
178
+ }
179
+
180
+ status := 200
181
+ if tc.respStatusCode != 0 {
182
+ status = tc.respStatusCode
183
+ }
184
+ w.WriteHeader(status)
185
+
186
+ if tc.expectedReqHeader != nil && !reflect.DeepEqual(r.Header, tc.expectedReqHeader) {
187
+ return fmt.Errorf("expected request header %v, got %v", tc.expectedReqHeader, r.Header)
188
+ }
189
+
190
+ return nil
191
+ })
192
+
193
+ if err := tc.handler.ServeHTTP(rr, req, next); err != nil {
194
+ t.Errorf("Test %d: %w", i, err)
195
+ continue
196
+ }
197
+
198
+ actual := rr.Header()
199
+ if tc.expectedRespHeader != nil && !reflect.DeepEqual(actual, tc.expectedRespHeader) {
200
+ t.Errorf("Test %d: expected response header %v, got %v", i, tc.expectedRespHeader, actual)
201
+ continue
202
+ }
203
+ }
204
+}
205
+
206
+type nextHandler func(http.ResponseWriter, *http.Request) error
207
+
208
+func (f nextHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) error {
209
+ return f(w, r)
210
}
modules/caddyhttp/push/caddyfile.go
+10
-3
@@ -59,6 +59,8 @@ func parseCaddyfile(h httpcaddyfile.Helper) (caddyhttp.MiddlewareHandler, error)
59
return nil, h.ArgErr()
60
}
61
for innerNesting := h.Nesting(); h.NextBlock(innerNesting); {
62
+ var err error
63
+
64
// include current token, which we treat as an argument here
65
args := []string{h.Val()}
66
args = append(args, h.RemainingArgs()...)
@@ -66,16 +68,21 @@ func parseCaddyfile(h httpcaddyfile.Helper) (caddyhttp.MiddlewareHandler, error)
68
if handler.Headers == nil {
69
handler.Headers = new(HeaderConfig)
70
}
71
+
72
switch len(args) {
73
case 1:
71
- headers.CaddyfileHeaderOp(&handler.Headers.HeaderOps, args[0], "", "")
74
+ err = headers.CaddyfileHeaderOp(&handler.Headers.HeaderOps, args[0], "", "")
75
case 2:
73
- headers.CaddyfileHeaderOp(&handler.Headers.HeaderOps, args[0], args[1], "")
76
+ err = headers.CaddyfileHeaderOp(&handler.Headers.HeaderOps, args[0], args[1], "")
77
case 3:
75
- headers.CaddyfileHeaderOp(&handler.Headers.HeaderOps, args[0], args[1], args[2])
78
+ err = headers.CaddyfileHeaderOp(&handler.Headers.HeaderOps, args[0], args[1], args[2])
79
default:
80
return nil, h.ArgErr()
81
}
82
+
83
+ if err != nil {
84
+ return nil, h.Err(err.Error())
85
+ }
86
}
87
88
case "GET", "HEAD":
modules/caddyhttp/reverseproxy/caddyfile.go
+19
-6
@@ -480,6 +480,8 @@ func (h *Handler) UnmarshalCaddyfile(d *caddyfile.Dispenser) error {
480
h.BufferRequests = true
481
482
case "header_up":
483
+ var err error
484
+
485
if h.Headers == nil {
486
h.Headers = new(headers.Handler)
487
}
@@ -487,18 +489,25 @@ func (h *Handler) UnmarshalCaddyfile(d *caddyfile.Dispenser) error {
489
h.Headers.Request = new(headers.HeaderOps)
490
}
491
args := d.RemainingArgs()
492
+
493
switch len(args) {
494
case 1:
492
- headers.CaddyfileHeaderOp(h.Headers.Request, args[0], "", "")
495
+ err = headers.CaddyfileHeaderOp(h.Headers.Request, args[0], "", "")
496
case 2:
494
- headers.CaddyfileHeaderOp(h.Headers.Request, args[0], args[1], "")
497
+ err = headers.CaddyfileHeaderOp(h.Headers.Request, args[0], args[1], "")
498
case 3:
496
- headers.CaddyfileHeaderOp(h.Headers.Request, args[0], args[1], args[2])
499
+ err = headers.CaddyfileHeaderOp(h.Headers.Request, args[0], args[1], args[2])
500
default:
501
return d.ArgErr()
502
}
503
504
+ if err != nil {
505
+ return d.Err(err.Error())
506
+ }
507
+
508
case "header_down":
509
+ var err error
510
+
511
if h.Headers == nil {
512
h.Headers = new(headers.Handler)
513
}
@@ -510,15 +519,19 @@ func (h *Handler) UnmarshalCaddyfile(d *caddyfile.Dispenser) error {
519
args := d.RemainingArgs()
520
switch len(args) {
521
case 1:
513
- headers.CaddyfileHeaderOp(h.Headers.Response.HeaderOps, args[0], "", "")
522
+ err = headers.CaddyfileHeaderOp(h.Headers.Response.HeaderOps, args[0], "", "")
523
case 2:
515
- headers.CaddyfileHeaderOp(h.Headers.Response.HeaderOps, args[0], args[1], "")
524
+ err = headers.CaddyfileHeaderOp(h.Headers.Response.HeaderOps, args[0], args[1], "")
525
case 3:
517
- headers.CaddyfileHeaderOp(h.Headers.Response.HeaderOps, args[0], args[1], args[2])
526
+ err = headers.CaddyfileHeaderOp(h.Headers.Response.HeaderOps, args[0], args[1], args[2])
527
default:
528
return d.ArgErr()
529
}
530
531
+ if err != nil {
532
+ return d.Err(err.Error())
533
+ }
534
+
535
case "transport":
536
if !d.NextArg() {
537
return d.ArgErr()