2019-08-09 13:05:47 -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 httpcaddyfile
|
|
|
|
|
|
|
|
import (
|
|
|
|
"fmt"
|
|
|
|
"net"
|
|
|
|
"reflect"
|
2020-11-23 14:46:50 -05:00
|
|
|
"sort"
|
2019-08-09 13:05:47 -05:00
|
|
|
"strconv"
|
|
|
|
"strings"
|
2020-04-14 17:11:46 -05:00
|
|
|
"unicode"
|
2019-08-09 13:05:47 -05:00
|
|
|
|
2020-03-19 10:43:17 -05:00
|
|
|
"github.com/caddyserver/caddy/v2"
|
2019-08-22 13:26:48 -05:00
|
|
|
"github.com/caddyserver/caddy/v2/caddyconfig/caddyfile"
|
2019-08-09 13:05:47 -05:00
|
|
|
"github.com/caddyserver/caddy/v2/modules/caddyhttp"
|
2020-03-07 01:15:25 -05:00
|
|
|
"github.com/caddyserver/certmagic"
|
2019-08-09 13:05:47 -05:00
|
|
|
)
|
|
|
|
|
|
|
|
// mapAddressToServerBlocks returns a map of listener address to list of server
|
|
|
|
// blocks that will be served on that address. To do this, each server block is
|
|
|
|
// expanded so that each one is considered individually, although keys of a
|
|
|
|
// server block that share the same address stay grouped together so the config
|
|
|
|
// isn't repeated unnecessarily. For example, this Caddyfile:
|
|
|
|
//
|
|
|
|
// example.com {
|
|
|
|
// bind 127.0.0.1
|
|
|
|
// }
|
|
|
|
// www.example.com, example.net/path, localhost:9999 {
|
|
|
|
// bind 127.0.0.1 1.2.3.4
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
// has two server blocks to start with. But expressed in this Caddyfile are
|
|
|
|
// actually 4 listener addresses: 127.0.0.1:443, 1.2.3.4:443, 127.0.0.1:9999,
|
|
|
|
// and 127.0.0.1:9999. This is because the bind directive is applied to each
|
|
|
|
// key of its server block (specifying the host part), and each key may have
|
|
|
|
// a different port. And we definitely need to be sure that a site which is
|
|
|
|
// bound to be served on a specific interface is not served on others just
|
2020-02-27 21:30:48 -05:00
|
|
|
// because that is more convenient: it would be a potential security risk
|
2019-08-09 13:05:47 -05:00
|
|
|
// if the difference between interfaces means private vs. public.
|
|
|
|
//
|
|
|
|
// So what this function does for the example above is iterate each server
|
|
|
|
// block, and for each server block, iterate its keys. For the first, it
|
|
|
|
// finds one key (example.com) and determines its listener address
|
|
|
|
// (127.0.0.1:443 - because of 'bind' and automatic HTTPS). It then adds
|
|
|
|
// the listener address to the map value returned by this function, with
|
|
|
|
// the first server block as one of its associations.
|
|
|
|
//
|
|
|
|
// It then iterates each key on the second server block and associates them
|
|
|
|
// with one or more listener addresses. Indeed, each key in this block has
|
|
|
|
// two listener addresses because of the 'bind' directive. Once we know
|
|
|
|
// which addresses serve which keys, we can create a new server block for
|
|
|
|
// each address containing the contents of the server block and only those
|
|
|
|
// specific keys of the server block which use that address.
|
|
|
|
//
|
|
|
|
// It is possible and even likely that some keys in the returned map have
|
|
|
|
// the exact same list of server blocks (i.e. they are identical). This
|
|
|
|
// happens when multiple hosts are declared with a 'bind' directive and
|
|
|
|
// the resulting listener addresses are not shared by any other server
|
|
|
|
// block (or the other server blocks are exactly identical in their token
|
|
|
|
// contents). This happens with our example above because 1.2.3.4:443
|
|
|
|
// and 1.2.3.4:9999 are used exclusively with the second server block. This
|
|
|
|
// repetition may be undesirable, so call consolidateAddrMappings() to map
|
|
|
|
// multiple addresses to the same lists of server blocks (a many:many mapping).
|
|
|
|
// (Doing this is essentially a map-reduce technique.)
|
2020-01-19 13:51:17 -05:00
|
|
|
func (st *ServerType) mapAddressToServerBlocks(originalServerBlocks []serverBlock,
|
2022-08-02 15:39:09 -05:00
|
|
|
options map[string]any) (map[string][]serverBlock, error) {
|
2019-08-21 11:46:35 -05:00
|
|
|
sbmap := make(map[string][]serverBlock)
|
2019-08-09 13:05:47 -05:00
|
|
|
|
|
|
|
for i, sblock := range originalServerBlocks {
|
|
|
|
// within a server block, we need to map all the listener addresses
|
|
|
|
// implied by the server block to the keys of the server block which
|
|
|
|
// will be served by them; this has the effect of treating each
|
|
|
|
// key of a server block as its own, but without having to repeat its
|
|
|
|
// contents in cases where multiple keys really can be served together
|
|
|
|
addrToKeys := make(map[string][]string)
|
2019-08-21 11:46:35 -05:00
|
|
|
for j, key := range sblock.block.Keys {
|
2019-08-09 13:05:47 -05:00
|
|
|
// a key can have multiple listener addresses if there are multiple
|
|
|
|
// arguments to the 'bind' directive (although they will all have
|
|
|
|
// the same port, since the port is defined by the key or is implicit
|
|
|
|
// through automatic HTTPS)
|
2020-01-19 13:51:17 -05:00
|
|
|
addrs, err := st.listenerAddrsForServerBlockKey(sblock, key, options)
|
2019-08-09 13:05:47 -05:00
|
|
|
if err != nil {
|
|
|
|
return nil, fmt.Errorf("server block %d, key %d (%s): determining listener address: %v", i, j, key, err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// associate this key with each listener address it is served on
|
|
|
|
for _, addr := range addrs {
|
|
|
|
addrToKeys[addr] = append(addrToKeys[addr], key)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-05-08 20:32:10 -05:00
|
|
|
// make a slice of the map keys so we can iterate in sorted order
|
|
|
|
addrs := make([]string, 0, len(addrToKeys))
|
|
|
|
for k := range addrToKeys {
|
|
|
|
addrs = append(addrs, k)
|
|
|
|
}
|
|
|
|
sort.Strings(addrs)
|
|
|
|
|
2019-08-09 13:05:47 -05:00
|
|
|
// now that we know which addresses serve which keys of this
|
|
|
|
// server block, we iterate that mapping and create a list of
|
|
|
|
// new server blocks for each address where the keys of the
|
|
|
|
// server block are only the ones which use the address; but
|
|
|
|
// the contents (tokens) are of course the same
|
2022-05-08 20:32:10 -05:00
|
|
|
for _, addr := range addrs {
|
|
|
|
keys := addrToKeys[addr]
|
2020-04-02 15:20:30 -05:00
|
|
|
// parse keys so that we only have to do it once
|
|
|
|
parsedKeys := make([]Address, 0, len(keys))
|
|
|
|
for _, key := range keys {
|
|
|
|
addr, err := ParseAddress(key)
|
|
|
|
if err != nil {
|
|
|
|
return nil, fmt.Errorf("parsing key '%s': %v", key, err)
|
|
|
|
}
|
|
|
|
parsedKeys = append(parsedKeys, addr.Normalize())
|
|
|
|
}
|
2019-08-21 11:46:35 -05:00
|
|
|
sbmap[addr] = append(sbmap[addr], serverBlock{
|
|
|
|
block: caddyfile.ServerBlock{
|
|
|
|
Keys: keys,
|
|
|
|
Segments: sblock.block.Segments,
|
|
|
|
},
|
|
|
|
pile: sblock.pile,
|
2020-04-02 15:20:30 -05:00
|
|
|
keys: parsedKeys,
|
2019-08-09 13:05:47 -05:00
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return sbmap, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// consolidateAddrMappings eliminates repetition of identical server blocks in a mapping of
|
|
|
|
// single listener addresses to lists of server blocks. Since multiple addresses may serve
|
|
|
|
// identical sites (server block contents), this function turns a 1:many mapping into a
|
|
|
|
// many:many mapping. Server block contents (tokens) must be exactly identical so that
|
|
|
|
// reflect.DeepEqual returns true in order for the addresses to be combined. Identical
|
|
|
|
// entries are deleted from the addrToServerBlocks map. Essentially, each pairing (each
|
|
|
|
// association from multiple addresses to multiple server blocks; i.e. each element of
|
|
|
|
// the returned slice) becomes a server definition in the output JSON.
|
2019-08-21 11:46:35 -05:00
|
|
|
func (st *ServerType) consolidateAddrMappings(addrToServerBlocks map[string][]serverBlock) []sbAddrAssociation {
|
2020-04-08 16:31:51 -05:00
|
|
|
sbaddrs := make([]sbAddrAssociation, 0, len(addrToServerBlocks))
|
2019-08-09 13:05:47 -05:00
|
|
|
for addr, sblocks := range addrToServerBlocks {
|
|
|
|
// we start with knowing that at least this address
|
|
|
|
// maps to these server blocks
|
|
|
|
a := sbAddrAssociation{
|
|
|
|
addresses: []string{addr},
|
|
|
|
serverBlocks: sblocks,
|
|
|
|
}
|
|
|
|
|
|
|
|
// now find other addresses that map to identical
|
|
|
|
// server blocks and add them to our list of
|
|
|
|
// addresses, while removing them from the map
|
|
|
|
for otherAddr, otherSblocks := range addrToServerBlocks {
|
|
|
|
if addr == otherAddr {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
if reflect.DeepEqual(sblocks, otherSblocks) {
|
|
|
|
a.addresses = append(a.addresses, otherAddr)
|
|
|
|
delete(addrToServerBlocks, otherAddr)
|
|
|
|
}
|
|
|
|
}
|
2022-05-08 20:32:10 -05:00
|
|
|
sort.Strings(a.addresses)
|
2019-08-09 13:05:47 -05:00
|
|
|
|
|
|
|
sbaddrs = append(sbaddrs, a)
|
|
|
|
}
|
2020-11-23 14:46:50 -05:00
|
|
|
|
|
|
|
// sort them by their first address (we know there will always be at least one)
|
|
|
|
// to avoid problems with non-deterministic ordering (makes tests flaky)
|
|
|
|
sort.Slice(sbaddrs, func(i, j int) bool {
|
|
|
|
return sbaddrs[i].addresses[0] < sbaddrs[j].addresses[0]
|
|
|
|
})
|
|
|
|
|
2019-08-09 13:05:47 -05:00
|
|
|
return sbaddrs
|
|
|
|
}
|
|
|
|
|
2022-07-25 18:28:20 -05:00
|
|
|
// listenerAddrsForServerBlockKey essentially converts the Caddyfile
|
|
|
|
// site addresses to Caddy listener addresses for each server block.
|
2020-01-19 13:51:17 -05:00
|
|
|
func (st *ServerType) listenerAddrsForServerBlockKey(sblock serverBlock, key string,
|
2022-08-02 15:39:09 -05:00
|
|
|
options map[string]any) ([]string, error) {
|
2019-08-21 11:46:35 -05:00
|
|
|
addr, err := ParseAddress(key)
|
2019-08-09 13:05:47 -05:00
|
|
|
if err != nil {
|
|
|
|
return nil, fmt.Errorf("parsing key: %v", err)
|
|
|
|
}
|
2019-08-21 11:46:35 -05:00
|
|
|
addr = addr.Normalize()
|
2019-08-09 13:05:47 -05:00
|
|
|
|
2020-01-19 13:51:17 -05:00
|
|
|
// figure out the HTTP and HTTPS ports; either
|
|
|
|
// use defaults, or override with user config
|
2020-04-02 15:20:30 -05:00
|
|
|
httpPort, httpsPort := strconv.Itoa(caddyhttp.DefaultHTTPPort), strconv.Itoa(caddyhttp.DefaultHTTPSPort)
|
2020-01-19 13:51:17 -05:00
|
|
|
if hport, ok := options["http_port"]; ok {
|
|
|
|
httpPort = strconv.Itoa(hport.(int))
|
|
|
|
}
|
|
|
|
if hsport, ok := options["https_port"]; ok {
|
|
|
|
httpsPort = strconv.Itoa(hsport.(int))
|
|
|
|
}
|
|
|
|
|
2020-03-13 12:06:08 -05:00
|
|
|
// default port is the HTTPS port
|
|
|
|
lnPort := httpsPort
|
2019-08-09 13:05:47 -05:00
|
|
|
if addr.Port != "" {
|
|
|
|
// port explicitly defined
|
|
|
|
lnPort = addr.Port
|
2020-03-13 12:06:08 -05:00
|
|
|
} else if addr.Scheme == "http" {
|
2020-01-19 13:51:17 -05:00
|
|
|
// port inferred from scheme
|
2020-03-13 12:06:08 -05:00
|
|
|
lnPort = httpPort
|
2020-01-19 13:51:17 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// error if scheme and port combination violate convention
|
|
|
|
if (addr.Scheme == "http" && lnPort == httpsPort) || (addr.Scheme == "https" && lnPort == httpPort) {
|
|
|
|
return nil, fmt.Errorf("[%s] scheme and port violate convention", key)
|
2019-08-09 13:05:47 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// the bind directive specifies hosts, but is optional
|
2022-05-08 20:32:10 -05:00
|
|
|
lnHosts := make([]string, 0, len(sblock.pile["bind"]))
|
2019-08-21 11:46:35 -05:00
|
|
|
for _, cfgVal := range sblock.pile["bind"] {
|
|
|
|
lnHosts = append(lnHosts, cfgVal.Value.([]string)...)
|
2019-08-09 13:05:47 -05:00
|
|
|
}
|
|
|
|
if len(lnHosts) == 0 {
|
2022-05-08 20:32:10 -05:00
|
|
|
if defaultBind, ok := options["default_bind"].([]string); ok {
|
|
|
|
lnHosts = defaultBind
|
2022-01-18 13:29:07 -05:00
|
|
|
} else {
|
|
|
|
lnHosts = []string{""}
|
|
|
|
}
|
2019-08-09 13:05:47 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// use a map to prevent duplication
|
|
|
|
listeners := make(map[string]struct{})
|
|
|
|
for _, host := range lnHosts {
|
2022-07-25 18:28:20 -05:00
|
|
|
// host can have network + host (e.g. "tcp6/localhost") but
|
|
|
|
// will/should not have port information because this usually
|
|
|
|
// comes from the bind directive, so we append the port
|
|
|
|
addr, err := caddy.ParseNetworkAddress(host + ":" + lnPort)
|
|
|
|
if err != nil {
|
|
|
|
return nil, fmt.Errorf("parsing network address: %v", err)
|
2020-03-19 10:43:17 -05:00
|
|
|
}
|
2022-07-25 18:28:20 -05:00
|
|
|
listeners[addr.String()] = struct{}{}
|
2019-08-09 13:05:47 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// now turn map into list
|
2020-04-08 16:31:51 -05:00
|
|
|
listenersList := make([]string, 0, len(listeners))
|
2019-08-09 13:05:47 -05:00
|
|
|
for lnStr := range listeners {
|
|
|
|
listenersList = append(listenersList, lnStr)
|
|
|
|
}
|
2022-05-08 20:32:10 -05:00
|
|
|
sort.Strings(listenersList)
|
2019-08-09 13:05:47 -05:00
|
|
|
|
|
|
|
return listenersList, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Address represents a site address. It contains
|
|
|
|
// the original input value, and the component
|
|
|
|
// parts of an address. The component parts may be
|
|
|
|
// updated to the correct values as setup proceeds,
|
|
|
|
// but the original value should never be changed.
|
|
|
|
//
|
|
|
|
// The Host field must be in a normalized form.
|
|
|
|
type Address struct {
|
|
|
|
Original, Scheme, Host, Port, Path string
|
|
|
|
}
|
|
|
|
|
2019-08-21 11:46:35 -05:00
|
|
|
// ParseAddress parses an address string into a structured format with separate
|
|
|
|
// scheme, host, port, and path portions, as well as the original input string.
|
|
|
|
func ParseAddress(str string) (Address, error) {
|
2020-01-09 14:35:53 -05:00
|
|
|
const maxLen = 4096
|
|
|
|
if len(str) > maxLen {
|
|
|
|
str = str[:maxLen]
|
2019-08-21 11:46:35 -05:00
|
|
|
}
|
2020-01-09 14:35:53 -05:00
|
|
|
remaining := strings.TrimSpace(str)
|
|
|
|
a := Address{Original: remaining}
|
2019-08-21 11:46:35 -05:00
|
|
|
|
2020-01-09 14:35:53 -05:00
|
|
|
// extract scheme
|
|
|
|
splitScheme := strings.SplitN(remaining, "://", 2)
|
|
|
|
switch len(splitScheme) {
|
|
|
|
case 0:
|
|
|
|
return a, nil
|
|
|
|
case 1:
|
|
|
|
remaining = splitScheme[0]
|
|
|
|
case 2:
|
|
|
|
a.Scheme = splitScheme[0]
|
|
|
|
remaining = splitScheme[1]
|
2019-08-21 11:46:35 -05:00
|
|
|
}
|
|
|
|
|
2020-01-09 14:35:53 -05:00
|
|
|
// extract host and port
|
|
|
|
hostSplit := strings.SplitN(remaining, "/", 2)
|
|
|
|
if len(hostSplit) > 0 {
|
|
|
|
host, port, err := net.SplitHostPort(hostSplit[0])
|
2019-08-21 11:46:35 -05:00
|
|
|
if err != nil {
|
2020-01-09 14:35:53 -05:00
|
|
|
host, port, err = net.SplitHostPort(hostSplit[0] + ":")
|
|
|
|
if err != nil {
|
|
|
|
host = hostSplit[0]
|
|
|
|
}
|
2019-08-21 11:46:35 -05:00
|
|
|
}
|
2020-01-09 14:35:53 -05:00
|
|
|
a.Host = host
|
|
|
|
a.Port = port
|
2019-08-21 11:46:35 -05:00
|
|
|
}
|
2020-01-09 14:35:53 -05:00
|
|
|
if len(hostSplit) == 2 {
|
|
|
|
// all that remains is the path
|
|
|
|
a.Path = "/" + hostSplit[1]
|
|
|
|
}
|
|
|
|
|
|
|
|
// make sure port is valid
|
|
|
|
if a.Port != "" {
|
|
|
|
if portNum, err := strconv.Atoi(a.Port); err != nil {
|
|
|
|
return Address{}, fmt.Errorf("invalid port '%s': %v", a.Port, err)
|
|
|
|
} else if portNum < 0 || portNum > 65535 {
|
|
|
|
return Address{}, fmt.Errorf("port %d is out of range", portNum)
|
2019-08-21 11:46:35 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-01-09 14:35:53 -05:00
|
|
|
return a, nil
|
2019-08-21 11:46:35 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// String returns a human-readable form of a. It will
|
|
|
|
// be a cleaned-up and filled-out URL string.
|
2019-08-09 13:05:47 -05:00
|
|
|
func (a Address) String() string {
|
|
|
|
if a.Host == "" && a.Port == "" {
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
scheme := a.Scheme
|
|
|
|
if scheme == "" {
|
|
|
|
if a.Port == strconv.Itoa(certmagic.HTTPSPort) {
|
|
|
|
scheme = "https"
|
|
|
|
} else {
|
|
|
|
scheme = "http"
|
|
|
|
}
|
|
|
|
}
|
|
|
|
s := scheme
|
|
|
|
if s != "" {
|
|
|
|
s += "://"
|
|
|
|
}
|
|
|
|
if a.Port != "" &&
|
|
|
|
((scheme == "https" && a.Port != strconv.Itoa(caddyhttp.DefaultHTTPSPort)) ||
|
|
|
|
(scheme == "http" && a.Port != strconv.Itoa(caddyhttp.DefaultHTTPPort))) {
|
|
|
|
s += net.JoinHostPort(a.Host, a.Port)
|
|
|
|
} else {
|
|
|
|
s += a.Host
|
|
|
|
}
|
|
|
|
if a.Path != "" {
|
|
|
|
s += a.Path
|
|
|
|
}
|
|
|
|
return s
|
|
|
|
}
|
|
|
|
|
2019-08-21 11:46:35 -05:00
|
|
|
// Normalize returns a normalized version of a.
|
2019-08-09 13:05:47 -05:00
|
|
|
func (a Address) Normalize() Address {
|
|
|
|
path := a.Path
|
|
|
|
|
|
|
|
// ensure host is normalized if it's an IP address
|
2020-03-17 22:00:45 -05:00
|
|
|
host := strings.TrimSpace(a.Host)
|
2019-08-09 13:05:47 -05:00
|
|
|
if ip := net.ParseIP(host); ip != nil {
|
2021-10-20 11:27:59 -05:00
|
|
|
if ipv6 := ip.To16(); ipv6 != nil && ipv6.DefaultMask() == nil {
|
|
|
|
host = ipv6.String()
|
|
|
|
}
|
2019-08-09 13:05:47 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
return Address{
|
|
|
|
Original: a.Original,
|
2020-04-14 17:11:46 -05:00
|
|
|
Scheme: lowerExceptPlaceholders(a.Scheme),
|
|
|
|
Host: lowerExceptPlaceholders(host),
|
2019-08-09 13:05:47 -05:00
|
|
|
Port: a.Port,
|
|
|
|
Path: path,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-04-14 17:11:46 -05:00
|
|
|
// lowerExceptPlaceholders lowercases s except within
|
|
|
|
// placeholders (substrings in non-escaped '{ }' spans).
|
|
|
|
// See https://github.com/caddyserver/caddy/issues/3264
|
|
|
|
func lowerExceptPlaceholders(s string) string {
|
|
|
|
var sb strings.Builder
|
|
|
|
var escaped, inPlaceholder bool
|
|
|
|
for _, ch := range s {
|
|
|
|
if ch == '\\' && !escaped {
|
|
|
|
escaped = true
|
|
|
|
sb.WriteRune(ch)
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
if ch == '{' && !escaped {
|
|
|
|
inPlaceholder = true
|
|
|
|
}
|
|
|
|
if ch == '}' && inPlaceholder && !escaped {
|
|
|
|
inPlaceholder = false
|
|
|
|
}
|
|
|
|
if inPlaceholder {
|
|
|
|
sb.WriteRune(ch)
|
|
|
|
} else {
|
|
|
|
sb.WriteRune(unicode.ToLower(ch))
|
|
|
|
}
|
|
|
|
escaped = false
|
|
|
|
}
|
|
|
|
return sb.String()
|
|
|
|
}
|