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 fastcgi
|
|
|
|
|
|
2019-09-10 15:16:41 -05:00
|
|
|
|
import (
|
|
|
|
|
"encoding/json"
|
2019-09-17 16:16:17 -05:00
|
|
|
|
"net/http"
|
2020-04-24 22:05:09 -05:00
|
|
|
|
"strconv"
|
2019-09-10 15:16:41 -05:00
|
|
|
|
|
2019-12-10 15:36:46 -05:00
|
|
|
|
"github.com/caddyserver/caddy/v2"
|
2019-09-10 15:16:41 -05: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-09 13:23:27 -05:00
|
|
|
|
|
|
|
|
|
// UnmarshalCaddyfile deserializes Caddyfile tokens into h.
|
|
|
|
|
//
|
|
|
|
|
// transport fastcgi {
|
|
|
|
|
// root <path>
|
|
|
|
|
// split <at>
|
|
|
|
|
// env <key> <value>
|
|
|
|
|
// }
|
|
|
|
|
//
|
|
|
|
|
func (t *Transport) UnmarshalCaddyfile(d *caddyfile.Dispenser) error {
|
2019-09-10 20:21:52 -05: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-09 13:23:27 -05:00
|
|
|
|
|
2019-09-10 20:21:52 -05:00
|
|
|
|
case "split":
|
2020-03-22 08:48:21 -05:00
|
|
|
|
t.SplitPath = d.RemainingArgs()
|
|
|
|
|
if len(t.SplitPath) == 0 {
|
2019-09-10 20:21:52 -05:00
|
|
|
|
return d.ArgErr()
|
|
|
|
|
}
|
2019-09-09 13:23:27 -05:00
|
|
|
|
|
2019-09-10 20:21:52 -05: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-09 13:23:27 -05:00
|
|
|
|
|
2019-09-10 20:21:52 -05:00
|
|
|
|
default:
|
|
|
|
|
return d.Errf("unrecognized subdirective %s", d.Val())
|
|
|
|
|
}
|
2019-09-09 13:23:27 -05:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return nil
|
|
|
|
|
}
|
2019-09-10 15:16:41 -05: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:
|
|
|
|
|
//
|
|
|
|
|
// php_fastcgi localhost:7777
|
|
|
|
|
//
|
2020-01-16 19:08:52 -05:00
|
|
|
|
// is equivalent to a route consisting of:
|
2019-09-10 15:16:41 -05:00
|
|
|
|
//
|
2020-01-09 16:38:59 -05:00
|
|
|
|
// @canonicalPath {
|
2019-09-10 15:16:41 -05:00
|
|
|
|
// file {
|
2019-10-28 16:08:45 -05:00
|
|
|
|
// try_files {path}/index.php
|
|
|
|
|
// }
|
|
|
|
|
// not {
|
|
|
|
|
// path */
|
2019-09-10 15:16:41 -05:00
|
|
|
|
// }
|
|
|
|
|
// }
|
2020-01-09 16:38:59 -05:00
|
|
|
|
// redir @canonicalPath {path}/ 308
|
2019-10-28 16:08:45 -05:00
|
|
|
|
//
|
|
|
|
|
// try_files {path} {path}/index.php index.php
|
2019-09-10 15:16:41 -05:00
|
|
|
|
//
|
2020-01-09 16:38:59 -05:00
|
|
|
|
// @phpFiles {
|
2019-09-10 15:16:41 -05:00
|
|
|
|
// path *.php
|
|
|
|
|
// }
|
2020-01-09 16:38:59 -05:00
|
|
|
|
// reverse_proxy @phpFiles localhost:7777 {
|
2019-09-10 15:16:41 -05:00
|
|
|
|
// transport fastcgi {
|
|
|
|
|
// split .php
|
|
|
|
|
// }
|
|
|
|
|
// }
|
|
|
|
|
//
|
2020-01-16 19:08:52 -05:00
|
|
|
|
// Thus, this directive produces multiple handlers, each with a different
|
2020-02-27 21:30:48 -05:00
|
|
|
|
// matcher because multiple consecutive handlers are necessary to support
|
2019-09-10 15:16:41 -05:00
|
|
|
|
// the common PHP use case. If this "common" config is not compatible
|
2019-10-28 16:08:45 -05: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-10 15:16:41 -05:00
|
|
|
|
//
|
|
|
|
|
// If a matcher is specified by the user, for example:
|
|
|
|
|
//
|
|
|
|
|
// php_fastcgi /subpath localhost:7777
|
|
|
|
|
//
|
2020-01-16 19:08:52 -05:00
|
|
|
|
// then the resulting handlers are wrapped in a subroute that uses the
|
2019-12-17 12:14:04 -05: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-10 15:16:41 -05:00
|
|
|
|
func parsePHPFastCGI(h httpcaddyfile.Helper) ([]httpcaddyfile.ConfigValue, error) {
|
|
|
|
|
if !h.Next() {
|
|
|
|
|
return nil, h.ArgErr()
|
|
|
|
|
}
|
|
|
|
|
|
2020-05-18 13:15:38 -05:00
|
|
|
|
// set up the transport for FastCGI, and specifically PHP
|
|
|
|
|
fcgiTransport := Transport{}
|
2019-09-17 16:16:17 -05:00
|
|
|
|
|
2020-05-18 13:15:38 -05: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"
|
|
|
|
|
|
2020-06-22 12:45:18 -05: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-18 13:15:38 -05: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() {
|
|
|
|
|
for dispenser.NextBlock(0) {
|
|
|
|
|
switch dispenser.Val() {
|
|
|
|
|
case "root":
|
|
|
|
|
if !dispenser.NextArg() {
|
|
|
|
|
return nil, dispenser.ArgErr()
|
|
|
|
|
}
|
|
|
|
|
fcgiTransport.Root = dispenser.Val()
|
|
|
|
|
dispenser.Delete()
|
|
|
|
|
dispenser.Delete()
|
|
|
|
|
|
|
|
|
|
case "split":
|
|
|
|
|
extensions = dispenser.RemainingArgs()
|
|
|
|
|
dispenser.Delete()
|
|
|
|
|
for range extensions {
|
|
|
|
|
dispenser.Delete()
|
|
|
|
|
}
|
|
|
|
|
if len(extensions) == 0 {
|
|
|
|
|
return nil, dispenser.ArgErr()
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
case "env":
|
|
|
|
|
args := dispenser.RemainingArgs()
|
|
|
|
|
dispenser.Delete()
|
|
|
|
|
for range args {
|
|
|
|
|
dispenser.Delete()
|
|
|
|
|
}
|
|
|
|
|
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()
|
|
|
|
|
dispenser.Delete()
|
|
|
|
|
for range args {
|
|
|
|
|
dispenser.Delete()
|
|
|
|
|
}
|
|
|
|
|
if len(args) != 1 {
|
|
|
|
|
return nil, dispenser.ArgErr()
|
|
|
|
|
}
|
|
|
|
|
indexFile = args[0]
|
|
|
|
|
}
|
|
|
|
|
}
|
2019-09-10 15:16:41 -05:00
|
|
|
|
}
|
2020-05-18 13:15:38 -05: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)),
|
|
|
|
|
Headers: http.Header{"Location": []string{"{http.request.uri.path}/"}},
|
|
|
|
|
}
|
|
|
|
|
redirRoute := caddyhttp.Route{
|
|
|
|
|
MatcherSetsRaw: []caddy.ModuleMap{redirMatcherSet},
|
|
|
|
|
HandlersRaw: []json.RawMessage{caddyconfig.JSONModuleObject(redirHandler, "handler", "static_response", nil)},
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// route to rewrite to PHP index file
|
|
|
|
|
rewriteMatcherSet := caddy.ModuleMap{
|
|
|
|
|
"file": h.JSON(fileserver.MatchFile{
|
|
|
|
|
TryFiles: []string{"{http.request.uri.path}", "{http.request.uri.path}/" + indexFile, indexFile},
|
|
|
|
|
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-10 15:16:41 -05:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// route to actually reverse proxy requests to PHP files;
|
|
|
|
|
// match only requests that are for PHP files
|
2020-05-18 13:15:38 -05:00
|
|
|
|
pathList := []string{}
|
|
|
|
|
for _, ext := range extensions {
|
|
|
|
|
pathList = append(pathList, "*"+ext)
|
|
|
|
|
}
|
2019-12-10 15:36:46 -05:00
|
|
|
|
rpMatcherSet := caddy.ModuleMap{
|
2020-05-18 13:15:38 -05:00
|
|
|
|
"path": h.JSON(pathList),
|
2019-09-10 15:16:41 -05: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-02-27 23:03:45 -05:00
|
|
|
|
// TODO: this can overwrite our fcgiTransport that we encoded and
|
|
|
|
|
// set on the rpHandler... even with a non-fastcgi transport!
|
2020-05-18 13:15:38 -05:00
|
|
|
|
err = rpHandler.UnmarshalCaddyfile(dispenser)
|
2019-09-10 15:16:41 -05:00
|
|
|
|
if err != nil {
|
|
|
|
|
return nil, err
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// create the final reverse proxy route which is
|
|
|
|
|
// conditional on matching PHP files
|
|
|
|
|
rpRoute := caddyhttp.Route{
|
2019-12-10 15:36:46 -05:00
|
|
|
|
MatcherSetsRaw: []caddy.ModuleMap{rpMatcherSet},
|
2019-09-10 15:16:41 -05:00
|
|
|
|
HandlersRaw: []json.RawMessage{caddyconfig.JSONModuleObject(rpHandler, "handler", "reverse_proxy", nil)},
|
|
|
|
|
}
|
|
|
|
|
|
2020-01-16 19:08:52 -05:00
|
|
|
|
subroute := caddyhttp.Subroute{
|
2020-05-18 13:15:38 -05:00
|
|
|
|
Routes: append(routes, rpRoute),
|
2020-01-16 19:08:52 -05:00
|
|
|
|
}
|
|
|
|
|
|
2019-09-10 15:16:41 -05:00
|
|
|
|
// the user's matcher is a prerequisite for ours, so
|
|
|
|
|
// wrap ours in a subroute and return that
|
2020-02-27 23:03:45 -05:00
|
|
|
|
if userMatcherSet != nil {
|
2019-09-10 15:16:41 -05:00
|
|
|
|
return []httpcaddyfile.ConfigValue{
|
|
|
|
|
{
|
|
|
|
|
Class: "route",
|
|
|
|
|
Value: caddyhttp.Route{
|
2019-12-10 15:36:46 -05:00
|
|
|
|
MatcherSetsRaw: []caddy.ModuleMap{userMatcherSet},
|
2019-09-10 15:16:41 -05:00
|
|
|
|
HandlersRaw: []json.RawMessage{caddyconfig.JSONModuleObject(subroute, "handler", "subroute", nil)},
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
}, nil
|
|
|
|
|
}
|
|
|
|
|
|
2020-01-16 19:08:52 -05: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-10 15:16:41 -05:00
|
|
|
|
return []httpcaddyfile.ConfigValue{
|
2019-09-17 16:16:17 -05:00
|
|
|
|
{
|
|
|
|
|
Class: "route",
|
2020-01-16 19:08:52 -05:00
|
|
|
|
Value: subroute,
|
2019-09-10 15:16:41 -05:00
|
|
|
|
},
|
|
|
|
|
}, nil
|
|
|
|
|
}
|