2019-06-30 17:07:58 -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.
|
|
|
|
|
2019-03-31 21:41:29 -05:00
|
|
|
package caddyhttp
|
|
|
|
|
|
|
|
import (
|
2019-06-04 14:42:54 -05:00
|
|
|
"encoding/json"
|
2019-05-10 22:07:02 -05:00
|
|
|
"fmt"
|
2019-04-03 10:47:27 -05:00
|
|
|
"log"
|
2019-06-04 14:42:54 -05:00
|
|
|
"net"
|
2019-03-31 21:41:29 -05:00
|
|
|
"net/http"
|
2019-05-10 22:07:02 -05:00
|
|
|
"net/textproto"
|
|
|
|
"net/url"
|
2019-05-20 11:59:20 -05:00
|
|
|
"path/filepath"
|
2019-05-10 22:07:02 -05:00
|
|
|
"regexp"
|
2019-03-31 21:41:29 -05:00
|
|
|
"strings"
|
|
|
|
|
2019-07-02 13:37:06 -05:00
|
|
|
"github.com/caddyserver/caddy/v2"
|
2019-08-09 13:05:47 -05:00
|
|
|
"github.com/caddyserver/caddy/v2/caddyconfig/caddyfile"
|
2019-04-03 10:47:27 -05:00
|
|
|
)
|
|
|
|
|
|
|
|
type (
|
2019-11-15 14:47:06 -05:00
|
|
|
// MatchHost matches requests by the Host value (case-insensitive).
|
2019-12-31 18:57:54 -05:00
|
|
|
//
|
2020-01-17 12:57:57 -05:00
|
|
|
// When used in a top-level HTTP route,
|
2019-12-31 18:57:54 -05:00
|
|
|
// [qualifying domain names](/docs/automatic-https#hostname-requirements)
|
|
|
|
// may trigger [automatic HTTPS](/docs/automatic-https), which automatically
|
|
|
|
// provisions and renews certificates for you. Before doing this, you
|
|
|
|
// should ensure that DNS records for these domains are properly configured,
|
|
|
|
// especially A/AAAA pointed at your server.
|
|
|
|
//
|
|
|
|
// Automatic HTTPS can be
|
|
|
|
// [customized or disabled](/docs/json/apps/http/servers/automatic_https/).
|
2019-05-22 14:13:39 -05:00
|
|
|
MatchHost []string
|
|
|
|
|
2020-01-09 16:00:32 -05:00
|
|
|
// MatchPath matches requests by the URI's path (case-insensitive). Path
|
|
|
|
// matches are exact, but wildcards may be used:
|
|
|
|
//
|
|
|
|
// - At the end, for a prefix match (`/prefix/*`)
|
|
|
|
// - At the beginning, for a suffix match (`*.suffix`)
|
|
|
|
// - On both sides, for a substring match (`*/contains/*`)
|
|
|
|
// - In the middle, for a globular match (`/accounts/*/info`)
|
|
|
|
//
|
|
|
|
// This matcher is fast, so it does not support regular expressions or
|
2020-01-17 12:57:57 -05:00
|
|
|
// capture groups. For slower but more powerful matching, use the
|
|
|
|
// path_regexp matcher.
|
2019-05-22 14:13:39 -05:00
|
|
|
MatchPath []string
|
|
|
|
|
|
|
|
// MatchPathRE matches requests by a regular expression on the URI's path.
|
2019-12-29 15:16:34 -05:00
|
|
|
//
|
|
|
|
// Upon a match, it adds placeholders to the request: `{http.regexp.name.capture_group}`
|
|
|
|
// where `name` is the regular expression's name, and `capture_group` is either
|
|
|
|
// the named or positional capture group from the expression itself. If no name
|
|
|
|
// is given, then the placeholder omits the name: `{http.regexp.capture_group}`
|
|
|
|
// (potentially leading to collisions).
|
2019-05-22 14:13:39 -05:00
|
|
|
MatchPathRE struct{ MatchRegexp }
|
|
|
|
|
|
|
|
// MatchMethod matches requests by the method.
|
|
|
|
MatchMethod []string
|
|
|
|
|
|
|
|
// MatchQuery matches requests by URI's query string.
|
|
|
|
MatchQuery url.Values
|
|
|
|
|
2020-02-14 13:00:46 -05:00
|
|
|
// MatchHeader matches requests by header fields. It performs fast,
|
|
|
|
// exact string comparisons of the field values. Fast prefix, suffix,
|
|
|
|
// and substring matches can also be done by suffixing, prefixing, or
|
|
|
|
// surrounding the value with the wildcard `*` character, respectively.
|
|
|
|
// If a list is null, the header must not exist. If the list is empty,
|
|
|
|
// the field must simply exist, regardless of its value.
|
2019-05-22 14:13:39 -05:00
|
|
|
MatchHeader http.Header
|
|
|
|
|
|
|
|
// MatchHeaderRE matches requests by a regular expression on header fields.
|
2019-12-29 15:16:34 -05:00
|
|
|
//
|
|
|
|
// Upon a match, it adds placeholders to the request: `{http.regexp.name.capture_group}`
|
|
|
|
// where `name` is the regular expression's name, and `capture_group` is either
|
|
|
|
// the named or positional capture group from the expression itself. If no name
|
|
|
|
// is given, then the placeholder omits the name: `{http.regexp.capture_group}`
|
|
|
|
// (potentially leading to collisions).
|
2019-05-22 14:13:39 -05:00
|
|
|
MatchHeaderRE map[string]*MatchRegexp
|
|
|
|
|
|
|
|
// MatchProtocol matches requests by protocol.
|
|
|
|
MatchProtocol string
|
|
|
|
|
2019-06-04 14:42:54 -05:00
|
|
|
// MatchRemoteIP matches requests by client IP (or CIDR range).
|
|
|
|
MatchRemoteIP struct {
|
|
|
|
Ranges []string `json:"ranges,omitempty"`
|
|
|
|
|
|
|
|
cidrs []*net.IPNet
|
|
|
|
}
|
|
|
|
|
|
|
|
// MatchNegate matches requests by negating its matchers' results.
|
2019-12-29 15:16:34 -05:00
|
|
|
// To use, simply specify a set of matchers like you normally would;
|
|
|
|
// the only difference is that their result will be negated.
|
2019-06-04 14:42:54 -05:00
|
|
|
MatchNegate struct {
|
2019-12-10 15:36:46 -05:00
|
|
|
MatchersRaw caddy.ModuleMap `json:"-" caddy:"namespace=http.matchers"`
|
2019-06-04 14:42:54 -05:00
|
|
|
|
2019-09-17 16:16:17 -05:00
|
|
|
Matchers MatcherSet `json:"-"`
|
2019-06-04 14:42:54 -05:00
|
|
|
}
|
|
|
|
|
2019-05-22 14:13:39 -05:00
|
|
|
// MatchTable matches requests by values in the table.
|
|
|
|
MatchTable string // TODO: finish implementing
|
2019-03-31 21:41:29 -05:00
|
|
|
)
|
|
|
|
|
|
|
|
func init() {
|
2019-08-21 11:46:35 -05:00
|
|
|
caddy.RegisterModule(MatchHost{})
|
|
|
|
caddy.RegisterModule(MatchPath{})
|
|
|
|
caddy.RegisterModule(MatchPathRE{})
|
|
|
|
caddy.RegisterModule(MatchMethod{})
|
|
|
|
caddy.RegisterModule(MatchQuery{})
|
|
|
|
caddy.RegisterModule(MatchHeader{})
|
|
|
|
caddy.RegisterModule(MatchHeaderRE{})
|
|
|
|
caddy.RegisterModule(new(MatchProtocol))
|
|
|
|
caddy.RegisterModule(MatchRemoteIP{})
|
|
|
|
caddy.RegisterModule(MatchNegate{})
|
|
|
|
}
|
|
|
|
|
|
|
|
// CaddyModule returns the Caddy module information.
|
|
|
|
func (MatchHost) CaddyModule() caddy.ModuleInfo {
|
|
|
|
return caddy.ModuleInfo{
|
2019-12-10 15:36:46 -05:00
|
|
|
ID: "http.matchers.host",
|
|
|
|
New: func() caddy.Module { return new(MatchHost) },
|
2019-08-21 11:46:35 -05:00
|
|
|
}
|
2019-03-31 21:41:29 -05:00
|
|
|
}
|
|
|
|
|
2019-08-09 13:05:47 -05:00
|
|
|
// UnmarshalCaddyfile implements caddyfile.Unmarshaler.
|
|
|
|
func (m *MatchHost) UnmarshalCaddyfile(d *caddyfile.Dispenser) error {
|
|
|
|
*m = d.RemainingArgs()
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-05-22 14:13:39 -05:00
|
|
|
// Match returns true if r matches m.
|
2019-05-22 13:32:36 -05:00
|
|
|
func (m MatchHost) Match(r *http.Request) bool {
|
2019-06-20 21:24:46 -05:00
|
|
|
reqHost, _, err := net.SplitHostPort(r.Host)
|
|
|
|
if err != nil {
|
|
|
|
// OK; probably didn't have a port
|
|
|
|
reqHost = r.Host
|
2019-09-18 10:45:21 -05:00
|
|
|
|
|
|
|
// make sure we strip the brackets from IPv6 addresses
|
|
|
|
reqHost = strings.TrimPrefix(reqHost, "[")
|
|
|
|
reqHost = strings.TrimSuffix(reqHost, "]")
|
2019-06-20 21:24:46 -05:00
|
|
|
}
|
|
|
|
|
2019-12-29 15:12:52 -05:00
|
|
|
repl := r.Context().Value(caddy.ReplacerCtxKey).(*caddy.Replacer)
|
2019-10-14 12:29:36 -05:00
|
|
|
|
2019-05-10 22:07:02 -05:00
|
|
|
outer:
|
2019-03-31 21:41:29 -05:00
|
|
|
for _, host := range m {
|
2019-10-14 12:29:36 -05:00
|
|
|
host = repl.ReplaceAll(host, "")
|
2019-05-10 22:07:02 -05:00
|
|
|
if strings.Contains(host, "*") {
|
|
|
|
patternParts := strings.Split(host, ".")
|
2019-06-20 21:24:46 -05:00
|
|
|
incomingParts := strings.Split(reqHost, ".")
|
2019-05-10 22:07:02 -05:00
|
|
|
if len(patternParts) != len(incomingParts) {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
for i := range patternParts {
|
|
|
|
if patternParts[i] == "*" {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
if !strings.EqualFold(patternParts[i], incomingParts[i]) {
|
|
|
|
continue outer
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true
|
2019-06-20 21:24:46 -05:00
|
|
|
} else if strings.EqualFold(reqHost, host) {
|
2019-03-31 21:41:29 -05:00
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
2019-06-20 21:24:46 -05:00
|
|
|
|
2019-03-31 21:41:29 -05:00
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2019-08-21 11:46:35 -05:00
|
|
|
// CaddyModule returns the Caddy module information.
|
|
|
|
func (MatchPath) CaddyModule() caddy.ModuleInfo {
|
|
|
|
return caddy.ModuleInfo{
|
2019-12-10 15:36:46 -05:00
|
|
|
ID: "http.matchers.path",
|
|
|
|
New: func() caddy.Module { return new(MatchPath) },
|
2019-08-21 11:46:35 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-11-15 14:47:06 -05:00
|
|
|
// Provision lower-cases the paths in m to ensure case-insensitive matching.
|
|
|
|
func (m MatchPath) Provision(_ caddy.Context) error {
|
|
|
|
for i := range m {
|
|
|
|
m[i] = strings.ToLower(m[i])
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-05-22 14:13:39 -05:00
|
|
|
// Match returns true if r matches m.
|
2019-05-22 13:32:36 -05:00
|
|
|
func (m MatchPath) Match(r *http.Request) bool {
|
2019-11-15 14:47:06 -05:00
|
|
|
lowerPath := strings.ToLower(r.URL.Path)
|
2019-12-17 12:14:04 -05:00
|
|
|
|
|
|
|
// see #2917; Windows ignores trailing dots and spaces
|
|
|
|
// when accessing files (sigh), potentially causing a
|
|
|
|
// security risk (cry) if PHP files end up being served
|
|
|
|
// as static files, exposing the source code, instead of
|
|
|
|
// being matched by *.php to be treated as PHP scripts
|
|
|
|
lowerPath = strings.TrimRight(lowerPath, ". ")
|
|
|
|
|
2020-01-09 16:00:32 -05:00
|
|
|
repl := r.Context().Value(caddy.ReplacerCtxKey).(*caddy.Replacer)
|
|
|
|
|
2019-05-20 11:59:20 -05:00
|
|
|
for _, matchPath := range m {
|
2020-01-09 16:00:32 -05:00
|
|
|
matchPath = repl.ReplaceAll(matchPath, "")
|
|
|
|
|
|
|
|
// special case: first and last characters are wildcard,
|
|
|
|
// treat it as a fast substring match
|
|
|
|
if strings.HasPrefix(matchPath, "*") && strings.HasSuffix(matchPath, "*") {
|
|
|
|
if strings.Contains(lowerPath, matchPath[1:len(matchPath)-1]) {
|
2019-11-28 23:11:45 -05:00
|
|
|
return true
|
|
|
|
}
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
// special case: first character is a wildcard,
|
|
|
|
// treat it as a fast suffix match
|
2019-05-20 11:59:20 -05:00
|
|
|
if strings.HasPrefix(matchPath, "*") {
|
2019-11-28 23:11:45 -05:00
|
|
|
if strings.HasSuffix(lowerPath, matchPath[1:]) {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
continue
|
2019-05-20 11:59:20 -05:00
|
|
|
}
|
2019-11-28 23:11:45 -05:00
|
|
|
|
2020-01-09 16:00:32 -05:00
|
|
|
// special case: last character is a wildcard,
|
|
|
|
// treat it as a fast prefix match
|
|
|
|
if strings.HasSuffix(matchPath, "*") {
|
|
|
|
if strings.HasPrefix(lowerPath, matchPath[:len(matchPath)-1]) {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
// for everything else, try globular matching, which also
|
|
|
|
// is exact matching if there are no glob/wildcard chars;
|
2019-05-20 11:59:20 -05:00
|
|
|
// can ignore error here because we can't handle it anyway
|
2019-11-15 14:47:06 -05:00
|
|
|
matches, _ := filepath.Match(matchPath, lowerPath)
|
2019-05-20 11:59:20 -05:00
|
|
|
if matches {
|
|
|
|
return true
|
|
|
|
}
|
2019-03-31 21:41:29 -05:00
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2019-08-09 13:05:47 -05:00
|
|
|
// UnmarshalCaddyfile implements caddyfile.Unmarshaler.
|
|
|
|
func (m *MatchPath) UnmarshalCaddyfile(d *caddyfile.Dispenser) error {
|
2019-08-21 11:46:35 -05:00
|
|
|
for d.Next() {
|
|
|
|
*m = d.RemainingArgs()
|
|
|
|
}
|
2019-08-09 13:05:47 -05:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-08-21 11:46:35 -05:00
|
|
|
// CaddyModule returns the Caddy module information.
|
|
|
|
func (MatchPathRE) CaddyModule() caddy.ModuleInfo {
|
|
|
|
return caddy.ModuleInfo{
|
2019-12-10 15:36:46 -05:00
|
|
|
ID: "http.matchers.path_regexp",
|
|
|
|
New: func() caddy.Module { return new(MatchPathRE) },
|
2019-08-21 11:46:35 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-05-22 14:13:39 -05:00
|
|
|
// Match returns true if r matches m.
|
2019-05-22 13:32:36 -05:00
|
|
|
func (m MatchPathRE) Match(r *http.Request) bool {
|
2019-12-29 15:12:52 -05:00
|
|
|
repl := r.Context().Value(caddy.ReplacerCtxKey).(*caddy.Replacer)
|
2019-11-29 13:23:49 -05:00
|
|
|
return m.MatchRegexp.Match(r.URL.Path, repl)
|
2019-05-10 22:07:02 -05:00
|
|
|
}
|
|
|
|
|
2019-08-21 11:46:35 -05:00
|
|
|
// CaddyModule returns the Caddy module information.
|
|
|
|
func (MatchMethod) CaddyModule() caddy.ModuleInfo {
|
|
|
|
return caddy.ModuleInfo{
|
2019-12-10 15:36:46 -05:00
|
|
|
ID: "http.matchers.method",
|
|
|
|
New: func() caddy.Module { return new(MatchMethod) },
|
2019-08-21 11:46:35 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-08-09 13:05:47 -05:00
|
|
|
// UnmarshalCaddyfile implements caddyfile.Unmarshaler.
|
|
|
|
func (m *MatchMethod) UnmarshalCaddyfile(d *caddyfile.Dispenser) error {
|
2019-08-21 11:46:35 -05:00
|
|
|
for d.Next() {
|
|
|
|
*m = d.RemainingArgs()
|
|
|
|
}
|
2019-08-09 13:05:47 -05:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-05-22 14:13:39 -05:00
|
|
|
// Match returns true if r matches m.
|
2019-05-22 13:32:36 -05:00
|
|
|
func (m MatchMethod) Match(r *http.Request) bool {
|
2019-03-31 21:41:29 -05:00
|
|
|
for _, method := range m {
|
|
|
|
if r.Method == method {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2019-08-21 11:46:35 -05:00
|
|
|
// CaddyModule returns the Caddy module information.
|
|
|
|
func (MatchQuery) CaddyModule() caddy.ModuleInfo {
|
|
|
|
return caddy.ModuleInfo{
|
2019-12-10 15:36:46 -05:00
|
|
|
ID: "http.matchers.query",
|
|
|
|
New: func() caddy.Module { return new(MatchQuery) },
|
2019-08-21 11:46:35 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-08-09 13:05:47 -05:00
|
|
|
// UnmarshalCaddyfile implements caddyfile.Unmarshaler.
|
|
|
|
func (m *MatchQuery) UnmarshalCaddyfile(d *caddyfile.Dispenser) error {
|
2019-11-29 15:05:22 -05:00
|
|
|
if *m == nil {
|
|
|
|
*m = make(map[string][]string)
|
|
|
|
}
|
|
|
|
|
2019-08-09 13:05:47 -05:00
|
|
|
for d.Next() {
|
2019-11-29 15:05:22 -05:00
|
|
|
var query string
|
|
|
|
if !d.Args(&query) {
|
|
|
|
return d.ArgErr()
|
|
|
|
}
|
|
|
|
parts := strings.SplitN(query, "=", 2)
|
2019-08-09 13:05:47 -05:00
|
|
|
if len(parts) != 2 {
|
|
|
|
return d.Errf("malformed query matcher token: %s; must be in param=val format", d.Val())
|
|
|
|
}
|
|
|
|
url.Values(*m).Set(parts[0], parts[1])
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-05-22 14:13:39 -05:00
|
|
|
// Match returns true if r matches m.
|
2019-05-22 13:32:36 -05:00
|
|
|
func (m MatchQuery) Match(r *http.Request) bool {
|
2019-03-31 21:41:29 -05:00
|
|
|
for param, vals := range m {
|
2019-11-29 15:05:22 -05:00
|
|
|
paramVal, found := r.URL.Query()[param]
|
|
|
|
if found {
|
|
|
|
for _, v := range vals {
|
|
|
|
if paramVal[0] == v || v == "*" {
|
|
|
|
return true
|
|
|
|
}
|
2019-03-31 21:41:29 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2019-08-21 11:46:35 -05:00
|
|
|
// CaddyModule returns the Caddy module information.
|
|
|
|
func (MatchHeader) CaddyModule() caddy.ModuleInfo {
|
|
|
|
return caddy.ModuleInfo{
|
2019-12-10 15:36:46 -05:00
|
|
|
ID: "http.matchers.header",
|
|
|
|
New: func() caddy.Module { return new(MatchHeader) },
|
2019-08-21 11:46:35 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-08-09 13:05:47 -05:00
|
|
|
// UnmarshalCaddyfile implements caddyfile.Unmarshaler.
|
|
|
|
func (m *MatchHeader) UnmarshalCaddyfile(d *caddyfile.Dispenser) error {
|
2019-09-10 20:21:52 -05:00
|
|
|
if *m == nil {
|
|
|
|
*m = make(map[string][]string)
|
|
|
|
}
|
2019-08-09 13:05:47 -05:00
|
|
|
for d.Next() {
|
|
|
|
var field, val string
|
|
|
|
if !d.Args(&field, &val) {
|
|
|
|
return d.Errf("expected both field and value")
|
|
|
|
}
|
|
|
|
http.Header(*m).Set(field, val)
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-02-20 12:55:47 -05:00
|
|
|
// Like req.Header.Get(), but that works with Host header.
|
|
|
|
// go's http module swallows "Host" header.
|
|
|
|
func getHeader(r *http.Request, field string) []string {
|
|
|
|
field = textproto.CanonicalMIMEHeaderKey(field)
|
|
|
|
|
|
|
|
if field == "Host" {
|
|
|
|
return []string{r.Host}
|
|
|
|
}
|
|
|
|
|
|
|
|
return r.Header[field]
|
|
|
|
}
|
|
|
|
|
2019-05-22 14:13:39 -05:00
|
|
|
// Match returns true if r matches m.
|
2019-05-22 13:32:36 -05:00
|
|
|
func (m MatchHeader) Match(r *http.Request) bool {
|
2019-05-10 22:07:02 -05:00
|
|
|
for field, allowedFieldVals := range m {
|
2020-02-20 12:55:47 -05:00
|
|
|
actualFieldVals := getHeader(r, field)
|
|
|
|
|
|
|
|
if allowedFieldVals != nil && len(allowedFieldVals) == 0 && actualFieldVals != nil {
|
2019-09-06 15:25:16 -05:00
|
|
|
// a non-nil but empty list of allowed values means
|
|
|
|
// match if the header field exists at all
|
|
|
|
continue
|
|
|
|
}
|
2019-05-10 22:07:02 -05:00
|
|
|
var match bool
|
|
|
|
fieldVals:
|
|
|
|
for _, actualFieldVal := range actualFieldVals {
|
|
|
|
for _, allowedFieldVal := range allowedFieldVals {
|
2019-11-27 13:52:31 -05:00
|
|
|
switch {
|
2020-02-20 12:55:47 -05:00
|
|
|
case allowedFieldVal == "*":
|
|
|
|
match = true
|
2019-11-27 13:52:31 -05:00
|
|
|
case strings.HasPrefix(allowedFieldVal, "*") && strings.HasSuffix(allowedFieldVal, "*"):
|
|
|
|
match = strings.Contains(actualFieldVal, allowedFieldVal[1:len(allowedFieldVal)-1])
|
|
|
|
case strings.HasPrefix(allowedFieldVal, "*"):
|
|
|
|
match = strings.HasSuffix(actualFieldVal, allowedFieldVal[1:])
|
|
|
|
case strings.HasSuffix(allowedFieldVal, "*"):
|
|
|
|
match = strings.HasPrefix(actualFieldVal, allowedFieldVal[:len(allowedFieldVal)-1])
|
|
|
|
default:
|
|
|
|
match = actualFieldVal == allowedFieldVal
|
|
|
|
}
|
|
|
|
if match {
|
2019-05-10 22:07:02 -05:00
|
|
|
break fieldVals
|
2019-03-31 21:41:29 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2019-05-10 22:07:02 -05:00
|
|
|
if !match {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
2019-08-21 11:46:35 -05:00
|
|
|
// CaddyModule returns the Caddy module information.
|
|
|
|
func (MatchHeaderRE) CaddyModule() caddy.ModuleInfo {
|
|
|
|
return caddy.ModuleInfo{
|
2019-12-10 15:36:46 -05:00
|
|
|
ID: "http.matchers.header_regexp",
|
|
|
|
New: func() caddy.Module { return new(MatchHeaderRE) },
|
2019-08-21 11:46:35 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-08-09 13:05:47 -05:00
|
|
|
// UnmarshalCaddyfile implements caddyfile.Unmarshaler.
|
|
|
|
func (m *MatchHeaderRE) UnmarshalCaddyfile(d *caddyfile.Dispenser) error {
|
|
|
|
if *m == nil {
|
|
|
|
*m = make(map[string]*MatchRegexp)
|
|
|
|
}
|
|
|
|
for d.Next() {
|
2020-02-20 12:55:47 -05:00
|
|
|
var first, second, third string
|
|
|
|
if !d.Args(&first, &second) {
|
2019-08-09 13:05:47 -05:00
|
|
|
return d.ArgErr()
|
|
|
|
}
|
2020-02-20 12:55:47 -05:00
|
|
|
|
|
|
|
var name, field, val string
|
|
|
|
if d.Args(&third) {
|
|
|
|
name = first
|
|
|
|
field = second
|
|
|
|
val = third
|
|
|
|
} else {
|
|
|
|
field = first
|
|
|
|
val = second
|
|
|
|
}
|
|
|
|
|
|
|
|
(*m)[field] = &MatchRegexp{Pattern: val, Name: name}
|
2019-08-09 13:05:47 -05:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-05-22 14:13:39 -05:00
|
|
|
// Match returns true if r matches m.
|
2019-05-22 13:32:36 -05:00
|
|
|
func (m MatchHeaderRE) Match(r *http.Request) bool {
|
2019-05-10 22:07:02 -05:00
|
|
|
for field, rm := range m {
|
2020-02-20 12:55:47 -05:00
|
|
|
actualFieldVals := getHeader(r, field)
|
|
|
|
|
|
|
|
match := false
|
|
|
|
fieldVal:
|
|
|
|
for _, actualFieldVal := range actualFieldVals {
|
|
|
|
repl := r.Context().Value(caddy.ReplacerCtxKey).(*caddy.Replacer)
|
|
|
|
if rm.Match(actualFieldVal, repl) {
|
|
|
|
match = true
|
|
|
|
break fieldVal
|
|
|
|
}
|
|
|
|
}
|
2019-05-10 22:07:02 -05:00
|
|
|
if !match {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
2019-05-22 14:13:39 -05:00
|
|
|
// Provision compiles m's regular expressions.
|
2019-06-21 15:36:26 -05:00
|
|
|
func (m MatchHeaderRE) Provision(ctx caddy.Context) error {
|
2019-05-10 22:07:02 -05:00
|
|
|
for _, rm := range m {
|
2019-06-21 15:36:26 -05:00
|
|
|
err := rm.Provision(ctx)
|
2019-05-10 22:07:02 -05:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-05-22 14:13:39 -05:00
|
|
|
// Validate validates m's regular expressions.
|
2019-05-22 13:32:36 -05:00
|
|
|
func (m MatchHeaderRE) Validate() error {
|
2019-05-10 22:07:02 -05:00
|
|
|
for _, rm := range m {
|
|
|
|
err := rm.Validate()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-08-21 11:46:35 -05:00
|
|
|
// CaddyModule returns the Caddy module information.
|
|
|
|
func (MatchProtocol) CaddyModule() caddy.ModuleInfo {
|
|
|
|
return caddy.ModuleInfo{
|
2019-12-10 15:36:46 -05:00
|
|
|
ID: "http.matchers.protocol",
|
|
|
|
New: func() caddy.Module { return new(MatchProtocol) },
|
2019-08-21 11:46:35 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-05-22 14:13:39 -05:00
|
|
|
// Match returns true if r matches m.
|
2019-05-22 13:32:36 -05:00
|
|
|
func (m MatchProtocol) Match(r *http.Request) bool {
|
2019-05-10 22:07:02 -05:00
|
|
|
switch string(m) {
|
|
|
|
case "grpc":
|
|
|
|
return r.Header.Get("content-type") == "application/grpc"
|
|
|
|
case "https":
|
|
|
|
return r.TLS != nil
|
|
|
|
case "http":
|
|
|
|
return r.TLS == nil
|
2019-03-31 21:41:29 -05:00
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2019-08-09 13:05:47 -05:00
|
|
|
// UnmarshalCaddyfile implements caddyfile.Unmarshaler.
|
|
|
|
func (m *MatchProtocol) UnmarshalCaddyfile(d *caddyfile.Dispenser) error {
|
2019-08-21 11:46:35 -05:00
|
|
|
for d.Next() {
|
|
|
|
var proto string
|
|
|
|
if !d.Args(&proto) {
|
|
|
|
return d.Err("expected exactly one protocol")
|
|
|
|
}
|
|
|
|
*m = MatchProtocol(proto)
|
2019-08-09 13:05:47 -05:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-08-21 11:46:35 -05:00
|
|
|
// CaddyModule returns the Caddy module information.
|
|
|
|
func (MatchNegate) CaddyModule() caddy.ModuleInfo {
|
|
|
|
return caddy.ModuleInfo{
|
2019-12-10 15:36:46 -05:00
|
|
|
ID: "http.matchers.not",
|
|
|
|
New: func() caddy.Module { return new(MatchNegate) },
|
2019-08-21 11:46:35 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-04 14:42:54 -05:00
|
|
|
// UnmarshalJSON unmarshals data into m's unexported map field.
|
|
|
|
// This is done because we cannot embed the map directly into
|
|
|
|
// the struct, but we need a struct because we need another
|
|
|
|
// field just for the provisioned modules.
|
|
|
|
func (m *MatchNegate) UnmarshalJSON(data []byte) error {
|
2019-09-17 16:16:17 -05:00
|
|
|
return json.Unmarshal(data, &m.MatchersRaw)
|
|
|
|
}
|
|
|
|
|
|
|
|
// MarshalJSON marshals m's matchers.
|
|
|
|
func (m MatchNegate) MarshalJSON() ([]byte, error) {
|
|
|
|
return json.Marshal(m.MatchersRaw)
|
2019-06-04 14:42:54 -05:00
|
|
|
}
|
|
|
|
|
2019-08-09 13:05:47 -05:00
|
|
|
// UnmarshalCaddyfile implements caddyfile.Unmarshaler.
|
|
|
|
func (m *MatchNegate) UnmarshalCaddyfile(d *caddyfile.Dispenser) error {
|
2019-09-30 10:09:57 -05:00
|
|
|
// first, unmarshal each matcher in the set from its tokens
|
|
|
|
|
|
|
|
matcherMap := make(map[string]RequestMatcher)
|
|
|
|
for d.Next() {
|
|
|
|
for d.NextBlock(0) {
|
|
|
|
matcherName := d.Val()
|
|
|
|
mod, err := caddy.GetModule("http.matchers." + matcherName)
|
|
|
|
if err != nil {
|
|
|
|
return d.Errf("getting matcher module '%s': %v", matcherName, err)
|
|
|
|
}
|
|
|
|
unm, ok := mod.New().(caddyfile.Unmarshaler)
|
|
|
|
if !ok {
|
|
|
|
return d.Errf("matcher module '%s' is not a Caddyfile unmarshaler", matcherName)
|
|
|
|
}
|
2020-02-14 13:00:16 -05:00
|
|
|
err = unm.UnmarshalCaddyfile(d.NewFromNextSegment())
|
2019-09-30 10:09:57 -05:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
rm := unm.(RequestMatcher)
|
|
|
|
m.Matchers = append(m.Matchers, rm)
|
|
|
|
matcherMap[matcherName] = rm
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// we should now be functional, but we also need
|
|
|
|
// to be able to marshal as JSON, otherwise config
|
|
|
|
// adaptation won't work properly
|
2019-12-10 15:36:46 -05:00
|
|
|
m.MatchersRaw = make(caddy.ModuleMap)
|
2019-09-30 10:09:57 -05:00
|
|
|
for name, matchers := range matcherMap {
|
|
|
|
jsonBytes, err := json.Marshal(matchers)
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("marshaling matcher %s: %v", name, err)
|
|
|
|
}
|
|
|
|
m.MatchersRaw[name] = jsonBytes
|
|
|
|
}
|
|
|
|
|
2019-08-09 13:05:47 -05:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-06-04 14:42:54 -05:00
|
|
|
// Provision loads the matcher modules to be negated.
|
2019-06-14 12:58:28 -05:00
|
|
|
func (m *MatchNegate) Provision(ctx caddy.Context) error {
|
2019-12-10 15:36:46 -05:00
|
|
|
mods, err := ctx.LoadModule(m, "MatchersRaw")
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("loading matchers: %v", err)
|
|
|
|
}
|
|
|
|
for _, modIface := range mods.(map[string]interface{}) {
|
|
|
|
m.Matchers = append(m.Matchers, modIface.(RequestMatcher))
|
2019-06-04 14:42:54 -05:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Match returns true if r matches m. Since this matcher negates the
|
|
|
|
// embedded matchers, false is returned if any of its matchers match.
|
|
|
|
func (m MatchNegate) Match(r *http.Request) bool {
|
2019-09-17 16:16:17 -05:00
|
|
|
return !m.Matchers.Match(r)
|
2019-06-04 14:42:54 -05:00
|
|
|
}
|
|
|
|
|
2019-08-21 11:46:35 -05:00
|
|
|
// CaddyModule returns the Caddy module information.
|
|
|
|
func (MatchRemoteIP) CaddyModule() caddy.ModuleInfo {
|
|
|
|
return caddy.ModuleInfo{
|
2019-12-10 15:36:46 -05:00
|
|
|
ID: "http.matchers.remote_ip",
|
|
|
|
New: func() caddy.Module { return new(MatchRemoteIP) },
|
2019-08-21 11:46:35 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-08-09 13:05:47 -05:00
|
|
|
// UnmarshalCaddyfile implements caddyfile.Unmarshaler.
|
|
|
|
func (m *MatchRemoteIP) UnmarshalCaddyfile(d *caddyfile.Dispenser) error {
|
2019-08-21 11:46:35 -05:00
|
|
|
for d.Next() {
|
|
|
|
m.Ranges = d.RemainingArgs()
|
|
|
|
}
|
2019-08-09 13:05:47 -05:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-06-04 14:42:54 -05:00
|
|
|
// Provision parses m's IP ranges, either from IP or CIDR expressions.
|
2019-06-14 12:58:28 -05:00
|
|
|
func (m *MatchRemoteIP) Provision(ctx caddy.Context) error {
|
2019-06-04 14:42:54 -05:00
|
|
|
for _, str := range m.Ranges {
|
|
|
|
if strings.Contains(str, "/") {
|
|
|
|
_, ipNet, err := net.ParseCIDR(str)
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("parsing CIDR expression: %v", err)
|
|
|
|
}
|
|
|
|
m.cidrs = append(m.cidrs, ipNet)
|
|
|
|
} else {
|
|
|
|
ip := net.ParseIP(str)
|
|
|
|
if ip == nil {
|
|
|
|
return fmt.Errorf("invalid IP address: %s", str)
|
|
|
|
}
|
|
|
|
mask := len(ip) * 8
|
|
|
|
m.cidrs = append(m.cidrs, &net.IPNet{
|
|
|
|
IP: ip,
|
|
|
|
Mask: net.CIDRMask(mask, mask),
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (m MatchRemoteIP) getClientIP(r *http.Request) (net.IP, error) {
|
|
|
|
var remote string
|
|
|
|
if fwdFor := r.Header.Get("X-Forwarded-For"); fwdFor != "" {
|
|
|
|
remote = strings.TrimSpace(strings.Split(fwdFor, ",")[0])
|
|
|
|
}
|
|
|
|
if remote == "" {
|
|
|
|
remote = r.RemoteAddr
|
|
|
|
}
|
|
|
|
|
|
|
|
ipStr, _, err := net.SplitHostPort(remote)
|
|
|
|
if err != nil {
|
|
|
|
ipStr = remote // OK; probably didn't have a port
|
|
|
|
}
|
|
|
|
|
|
|
|
ip := net.ParseIP(ipStr)
|
|
|
|
if ip == nil {
|
|
|
|
return nil, fmt.Errorf("invalid client IP address: %s", ipStr)
|
|
|
|
}
|
|
|
|
|
|
|
|
return ip, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Match returns true if r matches m.
|
|
|
|
func (m MatchRemoteIP) Match(r *http.Request) bool {
|
|
|
|
clientIP, err := m.getClientIP(r)
|
|
|
|
if err != nil {
|
|
|
|
log.Printf("[ERROR] remote_ip matcher: %v", err)
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
for _, ipRange := range m.cidrs {
|
|
|
|
if ipRange.Contains(clientIP) {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2020-02-27 21:30:48 -05:00
|
|
|
// MatchRegexp is an embedable type for matching
|
2019-12-29 15:16:34 -05:00
|
|
|
// using regular expressions. It adds placeholders
|
|
|
|
// to the request's replacer.
|
2019-05-22 14:13:39 -05:00
|
|
|
type MatchRegexp struct {
|
2019-12-29 15:16:34 -05:00
|
|
|
// A unique name for this regular expression. Optional,
|
|
|
|
// but useful to prevent overwriting captures from other
|
|
|
|
// regexp matchers.
|
|
|
|
Name string `json:"name,omitempty"`
|
|
|
|
|
|
|
|
// The regular expression to evaluate, in RE2 syntax,
|
|
|
|
// which is the same general syntax used by Go, Perl,
|
|
|
|
// and Python. For details, see
|
|
|
|
// [Go's regexp package](https://golang.org/pkg/regexp/).
|
|
|
|
// Captures are accessible via placeholders. Unnamed
|
|
|
|
// capture groups are exposed as their numeric, 1-based
|
|
|
|
// index, while named capture groups are available by
|
|
|
|
// the capture group name.
|
|
|
|
Pattern string `json:"pattern"`
|
|
|
|
|
2019-05-10 22:07:02 -05:00
|
|
|
compiled *regexp.Regexp
|
2019-12-29 15:16:34 -05:00
|
|
|
phPrefix string
|
2019-05-10 22:07:02 -05:00
|
|
|
}
|
|
|
|
|
2019-05-22 14:13:39 -05:00
|
|
|
// Provision compiles the regular expression.
|
2019-06-21 15:36:26 -05:00
|
|
|
func (mre *MatchRegexp) Provision(caddy.Context) error {
|
2019-05-10 22:07:02 -05:00
|
|
|
re, err := regexp.Compile(mre.Pattern)
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("compiling matcher regexp %s: %v", mre.Pattern, err)
|
|
|
|
}
|
|
|
|
mre.compiled = re
|
2019-12-29 15:16:34 -05:00
|
|
|
mre.phPrefix = regexpPlaceholderPrefix
|
|
|
|
if mre.Name != "" {
|
|
|
|
mre.phPrefix += "." + mre.Name
|
|
|
|
}
|
2019-05-10 22:07:02 -05:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-05-22 14:13:39 -05:00
|
|
|
// Validate ensures mre is set up correctly.
|
|
|
|
func (mre *MatchRegexp) Validate() error {
|
2019-05-10 22:07:02 -05:00
|
|
|
if mre.Name != "" && !wordRE.MatchString(mre.Name) {
|
|
|
|
return fmt.Errorf("invalid regexp name (must contain only word characters): %s", mre.Name)
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-05-22 14:13:39 -05:00
|
|
|
// Match returns true if input matches the compiled regular
|
|
|
|
// expression in mre. It sets values on the replacer repl
|
|
|
|
// associated with capture groups, using the given scope
|
2019-12-29 15:12:52 -05:00
|
|
|
// (namespace).
|
|
|
|
func (mre *MatchRegexp) Match(input string, repl *caddy.Replacer) bool {
|
2019-05-10 22:07:02 -05:00
|
|
|
matches := mre.compiled.FindStringSubmatch(input)
|
|
|
|
if matches == nil {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
// save all capture groups, first by index
|
|
|
|
for i, match := range matches {
|
2019-12-29 15:16:34 -05:00
|
|
|
key := fmt.Sprintf("%s.%d", mre.phPrefix, i)
|
2019-05-20 11:59:20 -05:00
|
|
|
repl.Set(key, match)
|
2019-05-10 22:07:02 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// then by name
|
|
|
|
for i, name := range mre.compiled.SubexpNames() {
|
|
|
|
if i != 0 && name != "" {
|
2019-12-29 15:16:34 -05:00
|
|
|
key := fmt.Sprintf("%s.%s", mre.phPrefix, name)
|
2019-05-20 11:59:20 -05:00
|
|
|
repl.Set(key, matches[i])
|
2019-05-10 22:07:02 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
2019-08-09 13:05:47 -05:00
|
|
|
// UnmarshalCaddyfile implements caddyfile.Unmarshaler.
|
|
|
|
func (mre *MatchRegexp) UnmarshalCaddyfile(d *caddyfile.Dispenser) error {
|
2019-08-21 11:46:35 -05:00
|
|
|
for d.Next() {
|
|
|
|
args := d.RemainingArgs()
|
|
|
|
switch len(args) {
|
|
|
|
case 1:
|
|
|
|
mre.Pattern = args[0]
|
|
|
|
case 2:
|
|
|
|
mre.Name = args[0]
|
|
|
|
mre.Pattern = args[1]
|
|
|
|
default:
|
|
|
|
return d.ArgErr()
|
|
|
|
}
|
2019-08-09 13:05:47 -05:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-12-23 14:45:35 -05:00
|
|
|
// ResponseMatcher is a type which can determine if an
|
|
|
|
// HTTP response matches some criteria.
|
2019-05-28 19:53:08 -05:00
|
|
|
type ResponseMatcher struct {
|
|
|
|
// If set, one of these status codes would be required.
|
|
|
|
// A one-digit status can be used to represent all codes
|
|
|
|
// in that class (e.g. 3 for all 3xx codes).
|
|
|
|
StatusCode []int `json:"status_code,omitempty"`
|
|
|
|
|
|
|
|
// If set, each header specified must be one of the specified values.
|
|
|
|
Headers http.Header `json:"headers,omitempty"`
|
|
|
|
}
|
|
|
|
|
|
|
|
// Match returns true if the given statusCode and hdr match rm.
|
|
|
|
func (rm ResponseMatcher) Match(statusCode int, hdr http.Header) bool {
|
|
|
|
if !rm.matchStatusCode(statusCode) {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
return rm.matchHeaders(hdr)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (rm ResponseMatcher) matchStatusCode(statusCode int) bool {
|
|
|
|
if rm.StatusCode == nil {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
for _, code := range rm.StatusCode {
|
2019-09-02 23:01:02 -05:00
|
|
|
if StatusCodeMatches(statusCode, code) {
|
2019-05-28 19:53:08 -05:00
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (rm ResponseMatcher) matchHeaders(hdr http.Header) bool {
|
|
|
|
for field, allowedFieldVals := range rm.Headers {
|
2019-09-06 15:25:16 -05:00
|
|
|
actualFieldVals, fieldExists := hdr[textproto.CanonicalMIMEHeaderKey(field)]
|
|
|
|
if allowedFieldVals != nil && len(allowedFieldVals) == 0 && fieldExists {
|
|
|
|
// a non-nil but empty list of allowed values means
|
|
|
|
// match if the header field exists at all
|
|
|
|
continue
|
|
|
|
}
|
2019-05-28 19:53:08 -05:00
|
|
|
var match bool
|
|
|
|
fieldVals:
|
|
|
|
for _, actualFieldVal := range actualFieldVals {
|
|
|
|
for _, allowedFieldVal := range allowedFieldVals {
|
|
|
|
if actualFieldVal == allowedFieldVal {
|
|
|
|
match = true
|
|
|
|
break fieldVals
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if !match {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
2019-05-10 22:07:02 -05:00
|
|
|
var wordRE = regexp.MustCompile(`\w+`)
|
|
|
|
|
2019-12-29 15:16:34 -05:00
|
|
|
const regexpPlaceholderPrefix = "http.regexp"
|
|
|
|
|
2019-04-11 21:42:55 -05:00
|
|
|
// Interface guards
|
2019-03-31 21:41:29 -05:00
|
|
|
var (
|
2019-06-20 21:24:46 -05:00
|
|
|
_ RequestMatcher = (*MatchHost)(nil)
|
|
|
|
_ RequestMatcher = (*MatchPath)(nil)
|
|
|
|
_ RequestMatcher = (*MatchPathRE)(nil)
|
2019-06-21 15:36:26 -05:00
|
|
|
_ caddy.Provisioner = (*MatchPathRE)(nil)
|
2019-06-20 21:24:46 -05:00
|
|
|
_ RequestMatcher = (*MatchMethod)(nil)
|
|
|
|
_ RequestMatcher = (*MatchQuery)(nil)
|
|
|
|
_ RequestMatcher = (*MatchHeader)(nil)
|
|
|
|
_ RequestMatcher = (*MatchHeaderRE)(nil)
|
2019-06-21 15:36:26 -05:00
|
|
|
_ caddy.Provisioner = (*MatchHeaderRE)(nil)
|
2019-06-20 21:24:46 -05:00
|
|
|
_ RequestMatcher = (*MatchProtocol)(nil)
|
|
|
|
_ RequestMatcher = (*MatchRemoteIP)(nil)
|
2019-06-14 12:58:28 -05:00
|
|
|
_ caddy.Provisioner = (*MatchRemoteIP)(nil)
|
2019-06-20 21:24:46 -05:00
|
|
|
_ RequestMatcher = (*MatchNegate)(nil)
|
2019-06-14 12:58:28 -05:00
|
|
|
_ caddy.Provisioner = (*MatchNegate)(nil)
|
2019-06-21 15:36:26 -05:00
|
|
|
_ caddy.Provisioner = (*MatchRegexp)(nil)
|
2019-08-09 13:05:47 -05:00
|
|
|
|
|
|
|
_ caddyfile.Unmarshaler = (*MatchHost)(nil)
|
|
|
|
_ caddyfile.Unmarshaler = (*MatchPath)(nil)
|
|
|
|
_ caddyfile.Unmarshaler = (*MatchPathRE)(nil)
|
|
|
|
_ caddyfile.Unmarshaler = (*MatchMethod)(nil)
|
|
|
|
_ caddyfile.Unmarshaler = (*MatchQuery)(nil)
|
|
|
|
_ caddyfile.Unmarshaler = (*MatchHeader)(nil)
|
|
|
|
_ caddyfile.Unmarshaler = (*MatchHeaderRE)(nil)
|
|
|
|
_ caddyfile.Unmarshaler = (*MatchProtocol)(nil)
|
|
|
|
_ caddyfile.Unmarshaler = (*MatchRemoteIP)(nil)
|
2019-09-17 16:16:17 -05:00
|
|
|
|
|
|
|
_ json.Marshaler = (*MatchNegate)(nil)
|
|
|
|
_ json.Unmarshaler = (*MatchNegate)(nil)
|
2019-03-31 21:41:29 -05:00
|
|
|
)
|