2019-09-10 02:23:27 +08: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 fastcgi
|
|
|
|
|
|
2019-09-11 04:16:41 +08:00
|
|
|
|
import (
|
|
|
|
|
"encoding/json"
|
2019-09-18 05:16:17 +08:00
|
|
|
|
"net/http"
|
2020-04-25 11:05:09 +08:00
|
|
|
|
"strconv"
|
2019-09-11 04:16:41 +08:00
|
|
|
|
|
2019-12-11 04:36:46 +08:00
|
|
|
|
"github.com/caddyserver/caddy/v2"
|
2019-09-11 04:16:41 +08:00
|
|
|
|
"github.com/caddyserver/caddy/v2/caddyconfig"
|
|
|
|
|
"github.com/caddyserver/caddy/v2/caddyconfig/caddyfile"
|
|
|
|
|
"github.com/caddyserver/caddy/v2/caddyconfig/httpcaddyfile"
|
|
|
|
|
"github.com/caddyserver/caddy/v2/modules/caddyhttp"
|
|
|
|
|
"github.com/caddyserver/caddy/v2/modules/caddyhttp/fileserver"
|
|
|
|
|
"github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy"
|
|
|
|
|
"github.com/caddyserver/caddy/v2/modules/caddyhttp/rewrite"
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
func init() {
|
|
|
|
|
httpcaddyfile.RegisterDirective("php_fastcgi", parsePHPFastCGI)
|
|
|
|
|
}
|
2019-09-10 02:23:27 +08:00
|
|
|
|
|
|
|
|
|
// UnmarshalCaddyfile deserializes Caddyfile tokens into h.
|
|
|
|
|
//
|
2022-09-02 12:02:48 +08:00
|
|
|
|
// transport fastcgi {
|
|
|
|
|
// root <path>
|
|
|
|
|
// split <at>
|
|
|
|
|
// env <key> <value>
|
|
|
|
|
// resolve_root_symlink
|
|
|
|
|
// dial_timeout <duration>
|
|
|
|
|
// read_timeout <duration>
|
|
|
|
|
// write_timeout <duration>
|
|
|
|
|
// capture_stderr
|
|
|
|
|
// }
|
2019-09-10 02:23:27 +08:00
|
|
|
|
func (t *Transport) UnmarshalCaddyfile(d *caddyfile.Dispenser) error {
|
2019-09-11 09:21:52 +08:00
|
|
|
|
for d.Next() {
|
|
|
|
|
for d.NextBlock(0) {
|
|
|
|
|
switch d.Val() {
|
|
|
|
|
case "root":
|
|
|
|
|
if !d.NextArg() {
|
|
|
|
|
return d.ArgErr()
|
|
|
|
|
}
|
|
|
|
|
t.Root = d.Val()
|
2019-09-10 02:23:27 +08:00
|
|
|
|
|
2019-09-11 09:21:52 +08:00
|
|
|
|
case "split":
|
2020-03-22 21:48:21 +08:00
|
|
|
|
t.SplitPath = d.RemainingArgs()
|
|
|
|
|
if len(t.SplitPath) == 0 {
|
2019-09-11 09:21:52 +08:00
|
|
|
|
return d.ArgErr()
|
|
|
|
|
}
|
2019-09-10 02:23:27 +08:00
|
|
|
|
|
2019-09-11 09:21:52 +08:00
|
|
|
|
case "env":
|
|
|
|
|
args := d.RemainingArgs()
|
|
|
|
|
if len(args) != 2 {
|
|
|
|
|
return d.ArgErr()
|
|
|
|
|
}
|
|
|
|
|
if t.EnvVars == nil {
|
|
|
|
|
t.EnvVars = make(map[string]string)
|
|
|
|
|
}
|
|
|
|
|
t.EnvVars[args[0]] = args[1]
|
2019-09-10 02:23:27 +08:00
|
|
|
|
|
2020-07-21 02:16:13 +08:00
|
|
|
|
case "resolve_root_symlink":
|
2020-11-03 06:11:17 +08:00
|
|
|
|
if d.NextArg() {
|
|
|
|
|
return d.ArgErr()
|
|
|
|
|
}
|
2020-07-21 02:16:13 +08:00
|
|
|
|
t.ResolveRootSymlink = true
|
|
|
|
|
|
2020-11-03 06:11:17 +08: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)
|
|
|
|
|
}
|
|
|
|
|
t.DialTimeout = caddy.Duration(dur)
|
|
|
|
|
|
|
|
|
|
case "read_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)
|
|
|
|
|
}
|
|
|
|
|
t.ReadTimeout = caddy.Duration(dur)
|
|
|
|
|
|
|
|
|
|
case "write_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)
|
|
|
|
|
}
|
|
|
|
|
t.WriteTimeout = caddy.Duration(dur)
|
|
|
|
|
|
2022-09-02 12:02:48 +08:00
|
|
|
|
case "capture_stderr":
|
|
|
|
|
if d.NextArg() {
|
|
|
|
|
return d.ArgErr()
|
|
|
|
|
}
|
|
|
|
|
t.CaptureStderr = true
|
|
|
|
|
|
2019-09-11 09:21:52 +08:00
|
|
|
|
default:
|
|
|
|
|
return d.Errf("unrecognized subdirective %s", d.Val())
|
|
|
|
|
}
|
2019-09-10 02:23:27 +08:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return nil
|
|
|
|
|
}
|
2019-09-11 04:16:41 +08:00
|
|
|
|
|
|
|
|
|
// parsePHPFastCGI parses the php_fastcgi directive, which has the same syntax
|
|
|
|
|
// as the reverse_proxy directive (in fact, the reverse_proxy's directive
|
|
|
|
|
// Unmarshaler is invoked by this function) but the resulting proxy is specially
|
|
|
|
|
// configured for most™️ PHP apps over FastCGI. A line such as this:
|
|
|
|
|
//
|
2022-09-02 12:02:48 +08:00
|
|
|
|
// php_fastcgi localhost:7777
|
2019-09-11 04:16:41 +08:00
|
|
|
|
//
|
2020-01-17 08:08:52 +08:00
|
|
|
|
// is equivalent to a route consisting of:
|
2019-09-11 04:16:41 +08:00
|
|
|
|
//
|
2022-09-02 12:02:48 +08:00
|
|
|
|
// # Add trailing slash for directory requests
|
|
|
|
|
// @canonicalPath {
|
|
|
|
|
// file {path}/index.php
|
|
|
|
|
// not path */
|
|
|
|
|
// }
|
|
|
|
|
// redir @canonicalPath {path}/ 308
|
2019-10-29 05:08:45 +08:00
|
|
|
|
//
|
2022-09-02 12:02:48 +08:00
|
|
|
|
// # If the requested file does not exist, try index files
|
|
|
|
|
// @indexFiles file {
|
|
|
|
|
// try_files {path} {path}/index.php index.php
|
|
|
|
|
// split_path .php
|
|
|
|
|
// }
|
|
|
|
|
// rewrite @indexFiles {http.matchers.file.relative}
|
2021-09-17 22:23:06 +08:00
|
|
|
|
//
|
2022-09-02 12:02:48 +08:00
|
|
|
|
// # Proxy PHP files to the FastCGI responder
|
|
|
|
|
// @phpFiles path *.php
|
|
|
|
|
// reverse_proxy @phpFiles localhost:7777 {
|
|
|
|
|
// transport fastcgi {
|
|
|
|
|
// split .php
|
|
|
|
|
// }
|
|
|
|
|
// }
|
2019-09-11 04:16:41 +08:00
|
|
|
|
//
|
2020-01-17 08:08:52 +08:00
|
|
|
|
// Thus, this directive produces multiple handlers, each with a different
|
2020-02-28 10:30:48 +08:00
|
|
|
|
// matcher because multiple consecutive handlers are necessary to support
|
2019-09-11 04:16:41 +08:00
|
|
|
|
// the common PHP use case. If this "common" config is not compatible
|
2019-10-29 05:08:45 +08:00
|
|
|
|
// with a user's PHP requirements, they can use a manual approach based
|
|
|
|
|
// on the example above to configure it precisely as they need.
|
2019-09-11 04:16:41 +08:00
|
|
|
|
//
|
|
|
|
|
// If a matcher is specified by the user, for example:
|
|
|
|
|
//
|
2022-09-02 12:02:48 +08:00
|
|
|
|
// php_fastcgi /subpath localhost:7777
|
2019-09-11 04:16:41 +08:00
|
|
|
|
//
|
2020-01-17 08:08:52 +08:00
|
|
|
|
// then the resulting handlers are wrapped in a subroute that uses the
|
2019-12-18 01:14:04 +08:00
|
|
|
|
// user's matcher as a prerequisite to enter the subroute. In other
|
|
|
|
|
// words, the directive's matcher is necessary, but not sufficient.
|
2019-09-11 04:16:41 +08:00
|
|
|
|
func parsePHPFastCGI(h httpcaddyfile.Helper) ([]httpcaddyfile.ConfigValue, error) {
|
|
|
|
|
if !h.Next() {
|
|
|
|
|
return nil, h.ArgErr()
|
|
|
|
|
}
|
|
|
|
|
|
2020-05-19 02:15:38 +08:00
|
|
|
|
// set up the transport for FastCGI, and specifically PHP
|
|
|
|
|
fcgiTransport := Transport{}
|
2019-09-18 05:16:17 +08:00
|
|
|
|
|
2020-05-19 02:15:38 +08:00
|
|
|
|
// set up the set of file extensions allowed to execute PHP code
|
|
|
|
|
extensions := []string{".php"}
|
|
|
|
|
|
|
|
|
|
// set the default index file for the try_files rewrites
|
|
|
|
|
indexFile := "index.php"
|
|
|
|
|
|
2021-09-17 22:23:06 +08:00
|
|
|
|
// set up for explicitly overriding try_files
|
|
|
|
|
tryFiles := []string{}
|
|
|
|
|
|
2020-06-23 01:45:18 +08:00
|
|
|
|
// if the user specified a matcher token, use that
|
|
|
|
|
// matcher in a route that wraps both of our routes;
|
|
|
|
|
// either way, strip the matcher token and pass
|
|
|
|
|
// the remaining tokens to the unmarshaler so that
|
|
|
|
|
// we can gain the rest of the reverse_proxy syntax
|
|
|
|
|
userMatcherSet, err := h.ExtractMatcherSet()
|
|
|
|
|
if err != nil {
|
|
|
|
|
return nil, err
|
|
|
|
|
}
|
|
|
|
|
|
2020-05-19 02:15:38 +08:00
|
|
|
|
// make a new dispenser from the remaining tokens so that we
|
|
|
|
|
// can reset the dispenser back to this point for the
|
|
|
|
|
// reverse_proxy unmarshaler to read from it as well
|
|
|
|
|
dispenser := h.NewFromNextSegment()
|
|
|
|
|
|
|
|
|
|
// read the subdirectives that we allow as overrides to
|
|
|
|
|
// the php_fastcgi shortcut
|
|
|
|
|
// NOTE: we delete the tokens as we go so that the reverse_proxy
|
|
|
|
|
// unmarshal doesn't see these subdirectives which it cannot handle
|
|
|
|
|
for dispenser.Next() {
|
2022-05-06 22:50:26 +08:00
|
|
|
|
for dispenser.NextBlock(0) {
|
|
|
|
|
// ignore any sub-subdirectives that might
|
|
|
|
|
// have the same name somewhere within
|
|
|
|
|
// the reverse_proxy passthrough tokens
|
|
|
|
|
if dispenser.Nesting() != 1 {
|
|
|
|
|
continue
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// parse the php_fastcgi subdirectives
|
2020-05-19 02:15:38 +08:00
|
|
|
|
switch dispenser.Val() {
|
|
|
|
|
case "root":
|
|
|
|
|
if !dispenser.NextArg() {
|
|
|
|
|
return nil, dispenser.ArgErr()
|
|
|
|
|
}
|
|
|
|
|
fcgiTransport.Root = dispenser.Val()
|
2023-02-26 08:34:27 +08:00
|
|
|
|
dispenser.DeleteN(2)
|
2020-05-19 02:15:38 +08:00
|
|
|
|
|
|
|
|
|
case "split":
|
|
|
|
|
extensions = dispenser.RemainingArgs()
|
2023-02-26 08:34:27 +08:00
|
|
|
|
dispenser.DeleteN(len(extensions) + 1)
|
2020-05-19 02:15:38 +08:00
|
|
|
|
if len(extensions) == 0 {
|
|
|
|
|
return nil, dispenser.ArgErr()
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
case "env":
|
|
|
|
|
args := dispenser.RemainingArgs()
|
2023-02-26 08:34:27 +08:00
|
|
|
|
dispenser.DeleteN(len(args) + 1)
|
2020-05-19 02:15:38 +08:00
|
|
|
|
if len(args) != 2 {
|
|
|
|
|
return nil, dispenser.ArgErr()
|
|
|
|
|
}
|
|
|
|
|
if fcgiTransport.EnvVars == nil {
|
|
|
|
|
fcgiTransport.EnvVars = make(map[string]string)
|
|
|
|
|
}
|
|
|
|
|
fcgiTransport.EnvVars[args[0]] = args[1]
|
|
|
|
|
|
|
|
|
|
case "index":
|
|
|
|
|
args := dispenser.RemainingArgs()
|
2023-02-26 08:34:27 +08:00
|
|
|
|
dispenser.DeleteN(len(args) + 1)
|
2020-05-19 02:15:38 +08:00
|
|
|
|
if len(args) != 1 {
|
|
|
|
|
return nil, dispenser.ArgErr()
|
|
|
|
|
}
|
|
|
|
|
indexFile = args[0]
|
2020-07-21 02:16:13 +08:00
|
|
|
|
|
2021-09-17 22:23:06 +08:00
|
|
|
|
case "try_files":
|
|
|
|
|
args := dispenser.RemainingArgs()
|
2023-02-26 08:34:27 +08:00
|
|
|
|
dispenser.DeleteN(len(args) + 1)
|
2021-09-17 22:23:06 +08:00
|
|
|
|
if len(args) < 1 {
|
|
|
|
|
return nil, dispenser.ArgErr()
|
|
|
|
|
}
|
|
|
|
|
tryFiles = args
|
|
|
|
|
|
2020-07-21 02:16:13 +08:00
|
|
|
|
case "resolve_root_symlink":
|
|
|
|
|
args := dispenser.RemainingArgs()
|
2023-02-26 08:34:27 +08:00
|
|
|
|
dispenser.DeleteN(len(args) + 1)
|
2020-07-21 02:16:13 +08:00
|
|
|
|
fcgiTransport.ResolveRootSymlink = true
|
2020-11-03 06:11:17 +08:00
|
|
|
|
|
|
|
|
|
case "dial_timeout":
|
|
|
|
|
if !dispenser.NextArg() {
|
|
|
|
|
return nil, dispenser.ArgErr()
|
|
|
|
|
}
|
|
|
|
|
dur, err := caddy.ParseDuration(dispenser.Val())
|
|
|
|
|
if err != nil {
|
|
|
|
|
return nil, dispenser.Errf("bad timeout value %s: %v", dispenser.Val(), err)
|
|
|
|
|
}
|
|
|
|
|
fcgiTransport.DialTimeout = caddy.Duration(dur)
|
2023-02-26 08:34:27 +08:00
|
|
|
|
dispenser.DeleteN(2)
|
2020-11-03 06:11:17 +08:00
|
|
|
|
|
|
|
|
|
case "read_timeout":
|
|
|
|
|
if !dispenser.NextArg() {
|
|
|
|
|
return nil, dispenser.ArgErr()
|
|
|
|
|
}
|
|
|
|
|
dur, err := caddy.ParseDuration(dispenser.Val())
|
|
|
|
|
if err != nil {
|
|
|
|
|
return nil, dispenser.Errf("bad timeout value %s: %v", dispenser.Val(), err)
|
|
|
|
|
}
|
|
|
|
|
fcgiTransport.ReadTimeout = caddy.Duration(dur)
|
2023-02-26 08:34:27 +08:00
|
|
|
|
dispenser.DeleteN(2)
|
2020-11-03 06:11:17 +08:00
|
|
|
|
|
|
|
|
|
case "write_timeout":
|
|
|
|
|
if !dispenser.NextArg() {
|
|
|
|
|
return nil, dispenser.ArgErr()
|
|
|
|
|
}
|
|
|
|
|
dur, err := caddy.ParseDuration(dispenser.Val())
|
|
|
|
|
if err != nil {
|
|
|
|
|
return nil, dispenser.Errf("bad timeout value %s: %v", dispenser.Val(), err)
|
|
|
|
|
}
|
|
|
|
|
fcgiTransport.WriteTimeout = caddy.Duration(dur)
|
2023-02-26 08:34:27 +08:00
|
|
|
|
dispenser.DeleteN(2)
|
2022-09-02 12:02:48 +08:00
|
|
|
|
|
|
|
|
|
case "capture_stderr":
|
|
|
|
|
args := dispenser.RemainingArgs()
|
2023-02-26 08:34:27 +08:00
|
|
|
|
dispenser.DeleteN(len(args) + 1)
|
2022-09-02 12:02:48 +08:00
|
|
|
|
fcgiTransport.CaptureStderr = true
|
2020-05-19 02:15:38 +08:00
|
|
|
|
}
|
|
|
|
|
}
|
2019-09-11 04:16:41 +08:00
|
|
|
|
}
|
2020-05-19 02:15:38 +08:00
|
|
|
|
|
|
|
|
|
// reset the dispenser after we're done so that the reverse_proxy
|
|
|
|
|
// unmarshaler can read it from the start
|
|
|
|
|
dispenser.Reset()
|
|
|
|
|
|
|
|
|
|
// set up a route list that we'll append to
|
|
|
|
|
routes := caddyhttp.RouteList{}
|
|
|
|
|
|
|
|
|
|
// set the list of allowed path segments on which to split
|
|
|
|
|
fcgiTransport.SplitPath = extensions
|
|
|
|
|
|
|
|
|
|
// if the index is turned off, we skip the redirect and try_files
|
|
|
|
|
if indexFile != "off" {
|
|
|
|
|
// route to redirect to canonical path if index PHP file
|
|
|
|
|
redirMatcherSet := caddy.ModuleMap{
|
|
|
|
|
"file": h.JSON(fileserver.MatchFile{
|
|
|
|
|
TryFiles: []string{"{http.request.uri.path}/" + indexFile},
|
|
|
|
|
}),
|
|
|
|
|
"not": h.JSON(caddyhttp.MatchNot{
|
|
|
|
|
MatcherSetsRaw: []caddy.ModuleMap{
|
|
|
|
|
{
|
|
|
|
|
"path": h.JSON(caddyhttp.MatchPath{"*/"}),
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
}),
|
|
|
|
|
}
|
|
|
|
|
redirHandler := caddyhttp.StaticResponse{
|
|
|
|
|
StatusCode: caddyhttp.WeakString(strconv.Itoa(http.StatusPermanentRedirect)),
|
2022-09-24 04:36:38 +08:00
|
|
|
|
Headers: http.Header{"Location": []string{"{http.request.orig_uri.path}/"}},
|
2020-05-19 02:15:38 +08:00
|
|
|
|
}
|
|
|
|
|
redirRoute := caddyhttp.Route{
|
|
|
|
|
MatcherSetsRaw: []caddy.ModuleMap{redirMatcherSet},
|
|
|
|
|
HandlersRaw: []json.RawMessage{caddyconfig.JSONModuleObject(redirHandler, "handler", "static_response", nil)},
|
|
|
|
|
}
|
|
|
|
|
|
2021-09-17 22:23:06 +08:00
|
|
|
|
// if tryFiles wasn't overridden, use a reasonable default
|
|
|
|
|
if len(tryFiles) == 0 {
|
|
|
|
|
tryFiles = []string{"{http.request.uri.path}", "{http.request.uri.path}/" + indexFile, indexFile}
|
|
|
|
|
}
|
|
|
|
|
|
2020-05-19 02:15:38 +08:00
|
|
|
|
// route to rewrite to PHP index file
|
|
|
|
|
rewriteMatcherSet := caddy.ModuleMap{
|
|
|
|
|
"file": h.JSON(fileserver.MatchFile{
|
2021-09-17 22:23:06 +08:00
|
|
|
|
TryFiles: tryFiles,
|
2020-05-19 02:15:38 +08:00
|
|
|
|
SplitPath: extensions,
|
|
|
|
|
}),
|
|
|
|
|
}
|
|
|
|
|
rewriteHandler := rewrite.Rewrite{
|
|
|
|
|
URI: "{http.matchers.file.relative}",
|
|
|
|
|
}
|
|
|
|
|
rewriteRoute := caddyhttp.Route{
|
|
|
|
|
MatcherSetsRaw: []caddy.ModuleMap{rewriteMatcherSet},
|
|
|
|
|
HandlersRaw: []json.RawMessage{caddyconfig.JSONModuleObject(rewriteHandler, "handler", "rewrite", nil)},
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
routes = append(routes, redirRoute, rewriteRoute)
|
2019-09-11 04:16:41 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// route to actually reverse proxy requests to PHP files;
|
|
|
|
|
// match only requests that are for PHP files
|
2020-05-19 02:15:38 +08:00
|
|
|
|
pathList := []string{}
|
|
|
|
|
for _, ext := range extensions {
|
|
|
|
|
pathList = append(pathList, "*"+ext)
|
|
|
|
|
}
|
2019-12-11 04:36:46 +08:00
|
|
|
|
rpMatcherSet := caddy.ModuleMap{
|
2020-05-19 02:15:38 +08:00
|
|
|
|
"path": h.JSON(pathList),
|
2019-09-11 04:16:41 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// create the reverse proxy handler which uses our FastCGI transport
|
|
|
|
|
rpHandler := &reverseproxy.Handler{
|
|
|
|
|
TransportRaw: caddyconfig.JSONModuleObject(fcgiTransport, "protocol", "fastcgi", nil),
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// the rest of the config is specified by the user
|
|
|
|
|
// using the reverse_proxy directive syntax
|
2020-05-19 02:15:38 +08:00
|
|
|
|
err = rpHandler.UnmarshalCaddyfile(dispenser)
|
2019-09-11 04:16:41 +08:00
|
|
|
|
if err != nil {
|
|
|
|
|
return nil, err
|
|
|
|
|
}
|
2021-05-03 02:39:06 +08:00
|
|
|
|
err = rpHandler.FinalizeUnmarshalCaddyfile(h)
|
|
|
|
|
if err != nil {
|
|
|
|
|
return nil, err
|
|
|
|
|
}
|
2019-09-11 04:16:41 +08:00
|
|
|
|
|
|
|
|
|
// create the final reverse proxy route which is
|
|
|
|
|
// conditional on matching PHP files
|
|
|
|
|
rpRoute := caddyhttp.Route{
|
2019-12-11 04:36:46 +08:00
|
|
|
|
MatcherSetsRaw: []caddy.ModuleMap{rpMatcherSet},
|
2019-09-11 04:16:41 +08:00
|
|
|
|
HandlersRaw: []json.RawMessage{caddyconfig.JSONModuleObject(rpHandler, "handler", "reverse_proxy", nil)},
|
|
|
|
|
}
|
|
|
|
|
|
2020-01-17 08:08:52 +08:00
|
|
|
|
subroute := caddyhttp.Subroute{
|
2020-05-19 02:15:38 +08:00
|
|
|
|
Routes: append(routes, rpRoute),
|
2020-01-17 08:08:52 +08:00
|
|
|
|
}
|
|
|
|
|
|
2019-09-11 04:16:41 +08:00
|
|
|
|
// the user's matcher is a prerequisite for ours, so
|
|
|
|
|
// wrap ours in a subroute and return that
|
2020-02-28 12:03:45 +08:00
|
|
|
|
if userMatcherSet != nil {
|
2019-09-11 04:16:41 +08:00
|
|
|
|
return []httpcaddyfile.ConfigValue{
|
|
|
|
|
{
|
|
|
|
|
Class: "route",
|
|
|
|
|
Value: caddyhttp.Route{
|
2019-12-11 04:36:46 +08:00
|
|
|
|
MatcherSetsRaw: []caddy.ModuleMap{userMatcherSet},
|
2019-09-11 04:16:41 +08:00
|
|
|
|
HandlersRaw: []json.RawMessage{caddyconfig.JSONModuleObject(subroute, "handler", "subroute", nil)},
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
}, nil
|
|
|
|
|
}
|
|
|
|
|
|
2020-01-17 08:08:52 +08:00
|
|
|
|
// otherwise, return the literal subroute instead of
|
|
|
|
|
// individual routes, to ensure they stay together and
|
|
|
|
|
// are treated as a single unit, without necessarily
|
|
|
|
|
// creating an actual subroute in the output
|
2019-09-11 04:16:41 +08:00
|
|
|
|
return []httpcaddyfile.ConfigValue{
|
2019-09-18 05:16:17 +08:00
|
|
|
|
{
|
|
|
|
|
Class: "route",
|
2020-01-17 08:08:52 +08:00
|
|
|
|
Value: subroute,
|
2019-09-11 04:16:41 +08:00
|
|
|
|
},
|
|
|
|
|
}, nil
|
|
|
|
|
}
|