mirror of
https://github.com/caddyserver/caddy.git
synced 2025-10-28 01:02:49 -04:00
Merge pull request #1 from thomas4019/master
adding support for php including clean urls and wordpress permalinks
This commit is contained in:
Matt Holt
commit
cd53ec9bcc
@ -4,10 +4,14 @@
|
||||
package fastcgi
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"io/ioutil"
|
||||
"net/http"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
"github.com/mholt/caddy/middleware"
|
||||
@ -15,7 +19,10 @@ import (
|
||||
|
||||
// New generates a new FastCGI middleware.
|
||||
func New(c middleware.Controller) (middleware.Middleware, error) {
|
||||
root := c.Root()
|
||||
root, err := filepath.Abs(c.Root())
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
rules, err := parse(c)
|
||||
if err != nil {
|
||||
@ -23,91 +30,180 @@ func New(c middleware.Controller) (middleware.Middleware, error) {
|
||||
}
|
||||
|
||||
return func(next middleware.Handler) middleware.Handler {
|
||||
return Handler{Next: next, Rules: rules, Root: root}
|
||||
return Handler{
|
||||
Next: next,
|
||||
Rules: rules,
|
||||
Root: root,
|
||||
SoftwareName: "Caddy", // TODO: Once generators are not in the same pkg as handler, obtain this from some global const
|
||||
SoftwareVersion: "", // TODO: Get this from some global const too
|
||||
// TODO: Set ServerName and ServerPort to correct values... (as user defined in config)
|
||||
}
|
||||
}, nil
|
||||
}
|
||||
|
||||
// Handler is a middleware type that can handle requests as a FastCGI client.
|
||||
type Handler struct {
|
||||
Next middleware.Handler
|
||||
Root string
|
||||
Root string // must be absolute path to site root
|
||||
Rules []Rule
|
||||
|
||||
// These are sent to CGI scripts in env variables
|
||||
SoftwareName string
|
||||
SoftwareVersion string
|
||||
ServerName string
|
||||
ServerPort string
|
||||
}
|
||||
|
||||
// ServeHTTP satisfies the middleware.Handler interface.
|
||||
func (h Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error) {
|
||||
servedFcgi := false
|
||||
for _, rule := range h.Rules {
|
||||
if middleware.Path(r.URL.Path).Matches(rule.Path) {
|
||||
servedFcgi = true
|
||||
// In addition to matching the path, a request must meet some
|
||||
// other criteria before being proxied as FastCGI. For example,
|
||||
// we probably want to exclude static assets (CSS, JS, images...)
|
||||
// but we also want to be flexible for the script we proxy to.
|
||||
|
||||
// Get absolute file paths
|
||||
absPath, err := filepath.Abs(h.Root + r.URL.Path)
|
||||
// These criteria work well in this order for PHP sites
|
||||
if middleware.Path(r.URL.Path).Matches(rule.Path) &&
|
||||
(r.URL.Path[len(r.URL.Path)-1] == '/' ||
|
||||
strings.HasSuffix(r.URL.Path, rule.Ext) ||
|
||||
!h.exists(r.URL.Path)) {
|
||||
|
||||
// Create environment for CGI script
|
||||
env, err := h.buildEnv(r, rule)
|
||||
if err != nil {
|
||||
return http.StatusInternalServerError, err
|
||||
}
|
||||
|
||||
// Get absolute file path to website root
|
||||
absRootPath, err := filepath.Abs(h.Root)
|
||||
if err != nil {
|
||||
return http.StatusInternalServerError, err
|
||||
}
|
||||
|
||||
// Separate remote IP and port
|
||||
var ip, port string
|
||||
if idx := strings.Index(r.RemoteAddr, ":"); idx > -1 {
|
||||
ip = r.RemoteAddr[idx:]
|
||||
port = r.RemoteAddr[:idx]
|
||||
} else {
|
||||
ip = r.RemoteAddr
|
||||
}
|
||||
|
||||
// TODO: Do we really have to make this map from scratch for each request?
|
||||
// TODO: We have quite a few more to map, too.
|
||||
env := make(map[string]string)
|
||||
env["SERVER_SOFTWARE"] = "caddy" // TODO: Obtain version info...
|
||||
env["SERVER_PROTOCOL"] = r.Proto
|
||||
env["SCRIPT_FILENAME"] = absPath
|
||||
env["REMOTE_ADDR"] = ip
|
||||
env["REMOTE_PORT"] = port
|
||||
env["REQUEST_METHOD"] = r.Method
|
||||
env["QUERY_STRING"] = r.URL.RawQuery
|
||||
env["DOCUMENT_URI"] = r.URL.Path
|
||||
env["DOCUMENT_ROOT"] = absRootPath
|
||||
|
||||
// Connect to FastCGI gateway
|
||||
fcgi, err := Dial("tcp", rule.Address)
|
||||
if err != nil {
|
||||
return http.StatusBadGateway, err
|
||||
}
|
||||
|
||||
resp, err := fcgi.Get(env)
|
||||
// TODO: Allow more methods (requires refactoring fcgiclient first...)
|
||||
var resp *http.Response
|
||||
switch r.Method {
|
||||
case "GET":
|
||||
resp, err = fcgi.Get(env)
|
||||
case "POST":
|
||||
l, _ := strconv.Atoi(r.Header.Get("Content-Length"))
|
||||
resp, err = fcgi.Post(env, r.Header.Get("Content-Type"), r.Body, l)
|
||||
default:
|
||||
return http.StatusMethodNotAllowed, nil
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
if err != nil && err != io.EOF {
|
||||
return http.StatusBadGateway, err
|
||||
}
|
||||
|
||||
body, err := ioutil.ReadAll(resp.Body)
|
||||
if err != nil {
|
||||
return http.StatusBadGateway, err
|
||||
}
|
||||
|
||||
// Write the response header
|
||||
for key, vals := range resp.Header {
|
||||
for _, val := range vals {
|
||||
w.Header().Add(key, val)
|
||||
}
|
||||
}
|
||||
|
||||
w.WriteHeader(resp.StatusCode)
|
||||
|
||||
body, err := ioutil.ReadAll(resp.Body)
|
||||
fmt.Printf("%s", body)
|
||||
fmt.Printf("%d\n", resp.StatusCode)
|
||||
fmt.Printf("%d\n", len(body))
|
||||
w.Write(body)
|
||||
|
||||
break
|
||||
return resp.StatusCode, nil
|
||||
}
|
||||
}
|
||||
|
||||
if !servedFcgi {
|
||||
return h.Next.ServeHTTP(w, r)
|
||||
return h.Next.ServeHTTP(w, r)
|
||||
}
|
||||
|
||||
func (h Handler) exists(path string) bool {
|
||||
if _, err := os.Stat(h.Root + path); err == nil {
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func (h Handler) buildEnv(r *http.Request, rule Rule) (map[string]string, error) {
|
||||
var env map[string]string
|
||||
|
||||
// Get absolute path of requested resource
|
||||
absPath, err := filepath.Abs(h.Root + r.URL.Path)
|
||||
if err != nil {
|
||||
return env, err
|
||||
}
|
||||
|
||||
return 0, nil
|
||||
// Separate remote IP and port; more lenient than net.SplitHostPort
|
||||
var ip, port string
|
||||
if idx := strings.Index(r.RemoteAddr, ":"); idx > -1 {
|
||||
ip = r.RemoteAddr[:idx]
|
||||
port = r.RemoteAddr[idx+1:]
|
||||
} else {
|
||||
ip = r.RemoteAddr
|
||||
}
|
||||
|
||||
// Split path in preparation for env variables
|
||||
splitPos := strings.Index(r.URL.Path, rule.SplitPath)
|
||||
var docURI, scriptName, scriptFilename, pathInfo string
|
||||
if splitPos == -1 {
|
||||
// Request doesn't have the extension, so assume index file
|
||||
docURI = "/" + rule.IndexFile
|
||||
scriptName = "/" + rule.IndexFile
|
||||
scriptFilename = h.Root + "/" + rule.IndexFile
|
||||
pathInfo = r.URL.Path
|
||||
} else {
|
||||
// Request has the extension; path was split successfully
|
||||
docURI = r.URL.Path[:splitPos+len(rule.SplitPath)]
|
||||
pathInfo = r.URL.Path[splitPos+len(rule.SplitPath):]
|
||||
scriptName = r.URL.Path
|
||||
scriptFilename = absPath
|
||||
}
|
||||
|
||||
// Some variables are unused but cleared explicitly to prevent
|
||||
// the parent environment from interfering.
|
||||
env = map[string]string{
|
||||
|
||||
// Variables defined in CGI 1.1 spec
|
||||
"AUTH_TYPE": "", // Not used
|
||||
"CONTENT_LENGTH": r.Header.Get("Content-Length"),
|
||||
"CONTENT_TYPE": r.Header.Get("Content-Type"),
|
||||
"GATEWAY_INTERFACE": "CGI/1.1",
|
||||
"PATH_INFO": pathInfo,
|
||||
"PATH_TRANSLATED": h.Root + "/" + pathInfo, // Source for path_translated: http://www.oreilly.com/openbook/cgi/ch02_04.html
|
||||
"QUERY_STRING": r.URL.RawQuery,
|
||||
"REMOTE_ADDR": ip,
|
||||
"REMOTE_HOST": ip, // For speed, remote host lookups disabled
|
||||
"REMOTE_PORT": port,
|
||||
"REMOTE_IDENT": "", // Not used
|
||||
"REMOTE_USER": "", // Not used
|
||||
"REQUEST_METHOD": r.Method,
|
||||
"SERVER_NAME": h.ServerName,
|
||||
"SERVER_PORT": h.ServerPort,
|
||||
"SERVER_PROTOCOL": r.Proto,
|
||||
"SERVER_SOFTWARE": h.SoftwareName + "/" + h.SoftwareVersion,
|
||||
|
||||
// Other variables
|
||||
"DOCUMENT_ROOT": h.Root,
|
||||
"DOCUMENT_URI": docURI,
|
||||
"HTTP_HOST": r.Host, // added here, since not always part of headers
|
||||
"REQUEST_URI": r.URL.RequestURI(),
|
||||
"SCRIPT_FILENAME": scriptFilename,
|
||||
"SCRIPT_NAME": scriptName,
|
||||
}
|
||||
|
||||
// Add all HTTP headers to env variables
|
||||
for field, val := range r.Header {
|
||||
header := strings.ToUpper(field)
|
||||
header = headerNameReplacer.Replace(header)
|
||||
// We don't want to pass the encoding header to prevent the fastcgi server from gzipping
|
||||
// TODO: is there a better way.
|
||||
if header != "ACCEPT_ENCODING" {
|
||||
env["HTTP_"+header] = strings.Join(val, ", ")
|
||||
}
|
||||
}
|
||||
|
||||
return env, nil
|
||||
}
|
||||
|
||||
func parse(c middleware.Controller) ([]Rule, error) {
|
||||
@ -115,16 +211,86 @@ func parse(c middleware.Controller) ([]Rule, error) {
|
||||
|
||||
for c.Next() {
|
||||
var rule Rule
|
||||
if !c.Args(&rule.Path, &rule.Address) {
|
||||
|
||||
args := c.RemainingArgs()
|
||||
|
||||
switch len(args) {
|
||||
case 0:
|
||||
return rules, c.ArgErr()
|
||||
case 1:
|
||||
rule.Path = "/"
|
||||
rule.Address = args[0]
|
||||
case 2:
|
||||
rule.Path = args[0]
|
||||
rule.Address = args[1]
|
||||
case 3:
|
||||
rule.Path = args[0]
|
||||
rule.Address = args[1]
|
||||
err := preset(args[2], &rule)
|
||||
if err != nil {
|
||||
return rules, c.Err("Invalid fastcgi rule preset '" + args[2] + "'")
|
||||
}
|
||||
}
|
||||
|
||||
for c.NextBlock() {
|
||||
switch c.Val() {
|
||||
case "ext":
|
||||
if !c.NextArg() {
|
||||
return rules, c.ArgErr()
|
||||
}
|
||||
rule.Ext = c.Val()
|
||||
case "split":
|
||||
if !c.NextArg() {
|
||||
return rules, c.ArgErr()
|
||||
}
|
||||
rule.SplitPath = c.Val()
|
||||
case "index":
|
||||
if !c.NextArg() {
|
||||
return rules, c.ArgErr()
|
||||
}
|
||||
rule.IndexFile = c.Val()
|
||||
}
|
||||
}
|
||||
|
||||
rules = append(rules, rule)
|
||||
}
|
||||
|
||||
return rules, nil
|
||||
}
|
||||
|
||||
// preset configures rule according to name. It returns an error if
|
||||
// name is not a recognized preset name.
|
||||
func preset(name string, rule *Rule) error {
|
||||
switch name {
|
||||
case "php":
|
||||
rule.Ext = ".php"
|
||||
rule.SplitPath = ".php"
|
||||
rule.IndexFile = "index.php"
|
||||
default:
|
||||
return errors.New(name + " is not a valid preset name")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Rule represents a FastCGI handling rule.
|
||||
type Rule struct {
|
||||
Path, Address string
|
||||
// The base path to match. Required.
|
||||
Path string
|
||||
|
||||
// The address of the FastCGI server. Required.
|
||||
Address string
|
||||
|
||||
// Always process files with this extension with fastcgi.
|
||||
Ext string
|
||||
|
||||
// The path in the URL will be split into two, with the first piece ending
|
||||
// with the value of SplitPath. The first piece will be assumed as the
|
||||
// actual resource (CGI script) name, and the second piece will be set to
|
||||
// PATH_INFO for the CGI script to use.
|
||||
SplitPath string
|
||||
|
||||
// If the URL does not indicate a file, an index file with this name will be assumed.
|
||||
IndexFile string
|
||||
}
|
||||
|
||||
var headerNameReplacer = strings.NewReplacer(" ", "_", "-", "_")
|
||||
|
||||
@ -26,6 +26,7 @@ import (
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strconv"
|
||||
"strings"
|
||||
"sync"
|
||||
)
|
||||
|
||||
@ -373,6 +374,17 @@ func (this *FCGIClient) Request(p map[string]string, req io.Reader) (resp *http.
|
||||
}
|
||||
resp.Header = http.Header(mimeHeader)
|
||||
|
||||
if resp.Header.Get("Status") != "" {
|
||||
statusParts := strings.SplitN(resp.Header.Get("Status"), " ", 2)
|
||||
resp.StatusCode, err = strconv.Atoi(statusParts[0])
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
resp.Status = statusParts[1]
|
||||
} else {
|
||||
resp.StatusCode = http.StatusOK
|
||||
}
|
||||
|
||||
// TODO: fixTransferEncoding ?
|
||||
resp.TransferEncoding = resp.Header["Transfer-Encoding"]
|
||||
resp.ContentLength, _ = strconv.ParseInt(resp.Header.Get("Content-Length"), 10, 64)
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user