Update for version 0.10.11

* Allow Response Headers in logs

* Remove log line

* remove unneeded log import

* Check if rr is nil.  Added test to check

* merge if statements

* remove temp file

.gitattributes

@@ -0,0 +1,14 @@
+# shell scripts should not use tabs to indent!
+*.bash    text eol=lf core.whitespace whitespace=tab-in-indent,trailing-space,tabwidth=2
+*.sh      text eol=lf core.whitespace whitespace=tab-in-indent,trailing-space,tabwidth=2
+
+# files for systemd (shell-similar)
+*.path    text eol=lf core.whitespace whitespace=tab-in-indent,trailing-space,tabwidth=2
+*.service text eol=lf core.whitespace whitespace=tab-in-indent,trailing-space,tabwidth=2
+*.timer   text eol=lf core.whitespace whitespace=tab-in-indent,trailing-space,tabwidth=2
+
+# go fmt will enforce this, but in case a user has not called "go fmt" allow GIT to catch this:
+*.go      text eol=lf core.whitespace whitespace=indent-with-non-tab,trailing-space,tabwidth=4
+
+*.yml     text eol=lf core.whitespace whitespace=tab-in-indent,trailing-space,tabwidth=2
+.git*     text eol=auto core.whitespace whitespace=trailing-space

.github/CONTRIBUTING.md

@@ -8,7 +8,7 @@ For starters, we invite you to join [the Caddy forum](https://caddy.community) w
 ## Common Tasks
 
 - [Contributing code](#contributing-code)
-- [Writing a Caddy module](#writing-a-caddy-module)
+- [Writing a plugin](#writing-a-plugin)
 - [Asking or answering questions for help using Caddy](#getting-help-using-caddy)
 - [Reporting a bug](#reporting-bugs)
 - [Suggesting an enhancement or a new feature](#suggesting-features)
@@ -17,21 +17,21 @@ For starters, we invite you to join [the Caddy forum](https://caddy.community) w
 Other menu items:
 
 - [Values](#values)
-- [Coordinated Disclosure](#coordinated-disclosure)
+- [Responsible Disclosure](#responsible-disclosure)
 - [Thank You](#thank-you)
 
 
 ### Contributing code
 
-You can have a huge impact on the project by helping with its code. To contribute code to Caddy, open a [pull request](https://github.com/caddyserver/caddy/pulls) (PR). If you're new to our community, that's okay: **we gladly welcome pull requests from anyone, regardless of your native language or coding experience.** You can get familiar with Caddy's code base by using [code search at Sourcegraph](https://sourcegraph.com/github.com/caddyserver/caddy/-/search).
+You can have a direct impact on the project by helping with its code. To contribute code to Caddy, open a [pull request](https://github.com/mholt/caddy/pulls) (PR). If you're new to our community, that's okay: **we gladly welcome pull requests from anyone, regardless of your native language or coding experience.** You can get familiar with Caddy's code base by using [code search at Sourcegraph](https://sourcegraph.com/github.com/mholt/caddy/-/search).
 
-We hold contributions to a high standard for quality :bowtie:, so don't be surprised if we ask for revisions—even if it seems small or insignificant. Please don't take it personally. :blue_heart: If your change is on the right track, we can guide you to make it mergable.
+We hold contributions to a high standard for quality :bowtie:, so don't be surprised if we ask for revisions—even if it seems small or insignificant. Please don't take it personally. :wink: If your change is on the right track, we can guide you to make it mergable.
 
 Here are some of the expectations we have of contributors:
 
-- **Open an issue to propose your change first.** This way we can avoid confusion, coordinate what everyone is working on, and ensure that any changes are in-line with the project's goals and the best interests of its users. We can also discuss the best possible implementation. If there's already an issue about it, comment on the existing issue to claim it.
+- If your change is more than just a minor alteration, **open an issue to propose your change first.** This way we can avoid confusion, coordinate what everyone is working on, and ensure that changes are in-line with the project's goals and the best interests of its users. If there's already an issue about it, comment on the existing issue to claim it.
 
-- **Keep pull requests small.** Smaller PRs are more likely to be merged because they are easier to review! We might ask you to break up large PRs into smaller ones. [An example of what we want to avoid.](https://twitter.com/iamdevloper/status/397664295875805184)
+- **Keep pull requests small.** Smaller PRs are more likely to be merged because they are easier to review! We might ask you to break up large PRs into smaller ones. [An example of what we DON'T do.](https://twitter.com/iamdevloper/status/397664295875805184)
 
 - **Keep related commits together in a PR.** We do want pull requests to be small, but you should also keep multiple related commits in the same PR if they rely on each other.
 
@@ -52,26 +52,26 @@ We often grant [collaborator status](#collaborator-instructions) to contributors
 
 Contributing to Go projects on GitHub is fun and easy. We recommend the following workflow:
 
-1. [Fork this repo](https://github.com/caddyserver/caddy). This makes a copy of the code you can write to.
+1. [Fork this repo](https://github.com/mholt/caddy). This makes a copy of the code you can write to.
 
-2. If you don't already have this repo (caddyserver/caddy.git) repo on your computer, get it with `go get github.com/caddyserver/caddy/v2`.
+2. If you don't already have this repo (mholt/caddy.git) repo on your computer, get it with `go get github.com/mholt/caddy/caddy`.
 
-3. Tell git that it can push the caddyserver/caddy.git repo to your fork by adding a remote: `git remote add myfork https://github.com/<your-username>/caddy.git`
+3. Tell git that it can push the mholt/caddy.git repo to your fork by adding a remote: `git remote add myfork https://github.com/you/caddy.git`
 
-4. Make your changes in the caddyserver/caddy.git repo on your computer.
+4. Make your changes in the mholt/caddy.git repo on your computer.
 
 5. Push your changes to your fork: `git push myfork`
 
-6. [Create a pull request](https://github.com/caddyserver/caddy/pull/new/master) to merge your changes into caddyserver/caddy @ master. (Click "compare across forks" and change the head fork.)
+6. [Create a pull request](https://github.com/mholt/caddy/pull/new/master) to merge your changes into mholt/caddy @ master. (Click "compare across forks" and change the head fork.)
 
 This workflow is nice because you don't have to change import paths. You can get fancier by using different branches if you want.
 
 
-### Writing a Caddy module
+### Writing a plugin
 
-Caddy can do more with modules! Anyone can write one. Caddy modules are Go libraries that get compiled into Caddy, extending its feature set. They can add directives to the Caddyfile, add new configuration adapters, and even implement new server types (e.g. HTTP, DNS).
+Caddy can do more with plugins! Anyone can write a plugin. Plugins are Go libraries that get compiled into Caddy, extending its feature set. They can add directives to the Caddyfile, change how the Caddyfile is loaded, and even implement new server types (e.g. HTTP, DNS). When it's ready, you can submit your plugin to the Caddy website so others can download it.
 
-[Learn how to write a module here](https://caddyserver.com/docs/extending-caddy). You should also share and discuss your module idea [on the forums](https://caddy.community) to have people test it out. We don't use the Caddy issue tracker for third-party modules.
+[Learn how to write and submit a plugin](https://github.com/mholt/caddy/wiki) on the wiki. You should also share and discuss your plugin idea [on the forums](https://caddy.community) to have people test it out. We don't use the Caddy issue tracker for plugins.
 
 
 ### Getting help using Caddy
@@ -83,7 +83,7 @@ Many people on the forums could benefit from your experience and expertise, too.
 
 ### Reporting bugs
 
-Like every software, Caddy has its flaws. If you find one, [search the issues](https://github.com/caddyserver/caddy/issues) to see if it has already been reported. If not, [open a new issue](https://github.com/caddyserver/caddy/issues/new) and describe the bug, and somebody will look into it! (This repository is only for Caddy and its standard modules.)
+Like every software, Caddy has its flaws. If you find one, [search the issues](https://github.com/mholt/caddy/issues) to see if it has already been reported. If not, [open a new issue](https://github.com/mholt/caddy/issues/new) and describe the bug, and somebody will look into it! (This repository is only for Caddy, not plugins.)
 
 **You can help stop bugs in their tracks!** Speed up the patch by identifying the bug in the code. This can sometimes be done by adding `fmt.Println()` statements (or similar) in relevant code paths to narrow down where the problem may be. It's a good way to [introduce yourself to the Go language](https://tour.golang.org), too.
 
@@ -93,50 +93,25 @@ We suggest reading [How to Report Bugs Effectively](http://www.chiark.greenend.o
 
 Please be kind. :smile: Remember that Caddy comes at no cost to you, and you're getting free support when we fix your issues. If we helped you, please consider helping someone else!
 
-#### Bug reporting expectations
-
-Maintainers---or more generally, developers---need three things to act on bugs:
-
-1. To agree or be convinced that it's a bug (reporter's responsibility).
-	- A bug is undesired or surprising behavior which violates documentation or the spec.
-
-2. To be able to understand what is happening (mostly reporter's responsibility).
-	- If the reporter can provide satisfactory instructions such that a developer can reproduce the bug, the developer will likely be able to understand the bug, write a test case, and implement a fix.
-	- Otherwise, the burden is on the reporter to test possible solutions. This is discouraged because it loosens the feedback loop, slows down debugging efforts, obscures the true nature of the problem from the developers, and is unlikely to result in new test cases.
-
-3. A solution, or ideas toward a solution (mostly maintainer's responsibility).
-	- Sometimes the best solution is a documentation change.
-	- Usually the developers have the best domain knowledge for inventing a solution, but reporters may have ideas or preferences for how they would like the software to work.
-	- Security, correctness, and project goals/vision all take priority over a user's preferences.
-	- It's simply good business to yield a solution that satisfies the users, and it's even better business to leave them impressed.
-
-Thus, at the very least, the reporter is expected to:
-
-1. Convince the reader that it's a bug (if it's not obvious).
-2. Reduce the problem down to the minimum specific steps required to reproduce it.
-
-The maintainer is usually able to do the rest; but of course the reporter may invest additional effort to speed up the process.
-
-
 
 ### Suggesting features
 
-First, [search to see if your feature has already been requested](https://github.com/caddyserver/caddy/issues). If it has, you can add a :+1: reaction to vote for it. If your feature idea is new, open an issue to request the feature. Please describe your idea thoroughly so that we know how to implement it! Really vague requests may not be helpful or actionable and, without clarification, will have to be closed.
+First, [search to see if your feature has already been requested](https://github.com/mholt/caddy/issues). If it has, you can add a :+1: reaction to vote for it. If your feature idea is new, open an issue to request the feature. You don't have to follow the bug template for feature requests. Please describe your idea thoroughly so that we know how to implement it! Really vague requests may not be helpful or actionable and without clarification will have to be closed.
 
-While we really do value your requests and implement many of them, not all features are a good fit for Caddy. Most of those [make good modules](#writing-a-caddy-module), which can be made by anyone! But if a feature is not in the best interest of the Caddy project or its users in general, we may politely decline to implement it into Caddy core.
+While we really do value your requests and implement many of them, not all features are a good fit for Caddy. Most of those [make good plugins](https://github.com/mholt/caddy/wiki), though, which can be made by anyone! But if a feature is not in the best interest of the Caddy project or its users in general, we may politely decline to implement it into Caddy core.
 
 
 ### Improving documentation
 
-Caddy's documentation is available at [https://caddyserver.com/docs](https://caddyserver.com/docs) and its source is in the [website repo](https://github.com/caddyserver/website). If you would like to make a fix to the docs, please submit an issue there describing the change to make.
+Caddy's documentation is available at [https://caddyserver.com/docs](https://caddyserver.com/docs). If you would like to make a fix to the docs, feel free to contribute at the [caddyserver/website](https://github.com/caddyserver/website) repository!
 
-Note that third-party module documentation is not hosted by the Caddy website, other than basic usage examples. They are managed by the individual module authors, and you will have to contact them to change their documentation.
+Note that plugin documentation is not hosted by the Caddy website, other than basic usage examples. They are managed by the individual plugin authors, and you will have to contact them to change their documentation.
 
 
 
 ## Collaborator Instructions
 
-Collaborators have push rights to the repository. We grant this permission after one or more successful, high-quality PRs are merged! We thank them for their help.The expectations we have of collaborators are:
+Collabators have push rights to the repository. We grant this permission after one or more successful, high-quality PRs are merged! We thank them for their help.The expectations we have of collaborators are:
 
 - **Help review pull requests.** Be meticulous, but also kind. We love our contributors, but we critique the contribution to make it better. Multiple, thorough reviews make for the best contributions! Here are some questions to consider:
 	- Can the change be made more elegant?
@@ -153,9 +128,9 @@ Collaborators have push rights to the repository. We grant this permission after
 
 - **Prefer squashed commits over a messy merge.** If there are many little commits, please [squash the commits](https://stackoverflow.com/a/11732910/1048862) so we don't clutter the commit history.
 
-- **Don't accept new dependencies lightly.** Dependencies can make the world crash and burn, but they are sometimes necessary. Choose carefully. Extremely small dependencies (a few lines of code) can be inlined. The rest may not be needed. For those that are, Caddy uses [go modules](https://github.com/golang/go/wiki/Modules). All external dependencies must be installed as modules, and _Caddy must not export any types defined by those dependencies_. Check this diligently!
+- **Don't accept new dependencies lightly.** Dependencies can make the world crash and burn, but they are sometimes necessary. Choose carefully. Extremely small dependencies (a few lines of code) can be inlined. The rest may not be needed. For those that are, Caddy vendors all dependencies with the help of [gvt](https://github.com/FiloSottile/gvt). All external dependencies must be vendored, and _Caddy must not export any types defined by those dependencies_. Check this diligently!
 
-- **Be extra careful in some areas of the code.** There are some critical areas in the Caddy code base that we review extra meticulously: the `caddyhttp` and `caddytls` packages especially.
+- **Be extra careful in some areas of the code.** There are some critical areas in the Caddy code base that we review extra meticulously: the `caddy` and `caddytls` packages especially.
 
 - **Make sure tests test the actual thing.** Double-check that the tests fail without the change, and pass with it. It's important that they assert what they're purported to assert.
 
@@ -174,11 +149,12 @@ Collaborators have push rights to the repository. We grant this permission after
 - The ends justify the means, if the means are good. A good tree won't produce bad fruit. But if we cut corners or are hasty in our process, the end result will not be good.
 
 
-## Security Policy
+## Responsible Disclosure
 
-If you think you've found a security vulnerability, please refer to our [Security Policy](https://github.com/caddyserver/caddy/security/policy) document.
+If you've found a security vulnerability, please email me, the author, directly: Matthew dot Holt at Gmail. I'll need enough information to verify the bug and make a patch. It will speed things up if you suggest a working patch. If your report is valid and a patch is released, we will not reveal your identity by default. If you wish to be credited, please give me the name to use. Thanks for responsibly helping Caddy&mdash;and thousands of websites&mdash;be more secure!
 
 
 ## Thank you
 
-Thanks for your help! Caddy would not be what it is today without your contributions.
+Thanks for your help! Caddy would not be what it is today without your
+contributions.

.github/FUNDING.yml

@@ -1,12 +0,0 @@
-# These are supported funding model platforms
-
-github: [mholt] # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
-patreon: # Replace with a single Patreon username
-open_collective: # Replace with a single Open Collective username
-ko_fi: # Replace with a single Ko-fi username
-tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
-community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
-liberapay: # Replace with a single Liberapay username
-issuehunt: # Replace with a single IssueHunt username
-otechie: # Replace with a single Otechie username
-custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,32 @@
+<!--
+Are you asking for help with using Caddy? Please use our forum instead: https://caddy.community. If you are filing a bug report, please take a few minutes to carefully answer the following questions. If your issue is not a bug report, you do not need to use this template. Thanks!)
+-->
+
+### 1. What version of Caddy are you using (`caddy -version`)?
+
+
+### 2. What are you trying to do?
+
+
+### 3. What is your entire Caddyfile?
+```text
+(paste Caddyfile here)
+```
+
+### 4. How did you run Caddy (give the full command and describe the execution environment)?
+
+
+### 5. Please paste any relevant HTTP request(s) here.
+
+<!-- Paste curl command, or full HTTP request including headers and body, here. -->
+
+
+### 6. What did you expect to see?
+
+
+### 7. What did you see instead (give full error messages and/or log)?
+
+
+### 8. How can someone who is starting from scratch reproduce the bug as minimally as possible?
+
+<!-- Please strip away any extra infrastructure such as containers, reverse proxies, upstream apps, caches, dependencies, etc, to prove this is a bug in Caddy and not an external misconfiguration. Your chances of getting this bug fixed go way up the easier it is to replicate. Thank you! -->

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,19 @@
+<!--
+Thank you for contributing to Caddy! Please fill this out to help us make the most of your pull request.
+-->
+
+### 1. What does this change do, exactly?
+
+
+### 2. Please link to the relevant issues.
+
+
+### 3. Which documentation changes (if any) need to be made because of this PR?
+
+
+### 4. Checklist
+
+- [ ] I have written tests and verified that they fail without my change
+- [ ] I have squashed any insignificant commits
+- [ ] This change has comments for package types, values, functions, and non-obvious lines of code
+- [ ] I am willing to help maintain this change if there are issues with it later

.github/SECURITY.md

@@ -1,27 +0,0 @@
-# Security Policy
-
-The Caddy project would like to make sure that it stays on top of all practically-exploitable vulnerabilities.
-
-Some security problems are more the result of interplay between different components of the Web, rather than a vulnerability in the web server itself. Please report only vulnerabilities in the web server itself, as we cannot coerce the rest of the Web to be fixed (for example, we do not consider IP spoofing or BGP hijacks a vulnerability in the Caddy web server).
-
-Please note that we consider publicly-registered domain names to be public information. This necessary in order to maintain the integrity of certificate transparency, public DNS, and other public trust systems.
-
-## Supported Versions
-
-| Version | Supported          |
-| ------- | ------------------ |
-| 2.x     | :white_check_mark: |
-| 1.x     | :x:                |
-| < 1.x   | :x:                |
-
-## Reporting a Vulnerability
-
-Please email Matt Holt (the author) directly: matt [at] lightcodelabs [dot com].
-
-We'll need enough information to verify the bug and make a patch. It will speed things up if you suggest a working patch, such as a code diff, and explain why and how it works. Reports that are not actionable, do not contain enough information, are too pushy/demanding, or are not able to convince us that it is a viable and practical attack on the web server itself may be deferred to a later time or possibly ignored, resources permitting. Priority will be given to credible, responsible reports that are constructive, specific, and actionable. Thank you for understanding.
-
-Please also understand that due to our nature as an open source project, we do not have a budget to award security bounties. We can only thank you.
-
-If your report is valid and a patch is released, we will not reveal your identity by default. If you wish to be credited, please give us the name to use and/or your GitHub username. If you don't provide this we can't credit you.
-
-Thanks for responsibly helping Caddy&mdash;and thousands of websites&mdash;be more secure!

.github/workflows/ci.yml

@@ -1,161 +0,0 @@
-# Used as inspiration: https://github.com/mvdan/github-actions-golang
-
-name: Tests
-
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-    branches:
-      - master
-
-jobs:
-  test:
-    strategy:
-      # Default is true, cancels jobs for other platforms in the matrix if one fails
-      fail-fast: false
-      matrix:
-        os: [ ubuntu-latest, macos-latest, windows-latest ]
-        go: [ '1.14', '1.15' ]
-
-        # Set some variables per OS, usable via ${{ matrix.VAR }}
-        # CADDY_BIN_PATH: the path to the compiled Caddy binary, for artifact publishing
-        # SUCCESS: the typical value for $? per OS (Windows/pwsh returns 'True')
-        include:
-        - os: ubuntu-latest
-          CADDY_BIN_PATH: ./cmd/caddy/caddy
-          SUCCESS: 0
-
-        - os: macos-latest
-          CADDY_BIN_PATH: ./cmd/caddy/caddy
-          SUCCESS: 0
-
-        - os: windows-latest
-          CADDY_BIN_PATH: ./cmd/caddy/caddy.exe
-          SUCCESS: 'True'
-
-    runs-on: ${{ matrix.os }}
-
-    steps:
-    - name: Install Go
-      uses: actions/setup-go@v2
-      with:
-        go-version: ${{ matrix.go }}
-
-    - name: Checkout code
-      uses: actions/checkout@v2
-
-    # These tools would be useful if we later decide to reinvestigate
-    # publishing test/coverage reports to some tool for easier consumption
-    # - name: Install test and coverage analysis tools
-    #   run: |
-    #     go get github.com/axw/gocov/gocov
-    #     go get github.com/AlekSi/gocov-xml
-    #     go get -u github.com/jstemmer/go-junit-report
-    #     echo "::add-path::$(go env GOPATH)/bin"
-
-    - name: Print Go version and environment
-      id: vars
-      run: |
-        printf "Using go at: $(which go)\n"
-        printf "Go version: $(go version)\n"
-        printf "\n\nGo environment:\n\n"
-        go env
-        printf "\n\nSystem environment:\n\n"
-        env
-        # Calculate the short SHA1 hash of the git commit
-        echo "::set-output name=short_sha::$(git rev-parse --short HEAD)"
-        echo "::set-output name=go_cache::$(go env GOCACHE)"
-
-    - name: Cache the build cache
-      uses: actions/cache@v2
-      with:
-        path: ${{ steps.vars.outputs.go_cache }}
-        key: ${{ runner.os }}-${{ matrix.go }}-go-ci-${{ hashFiles('**/go.sum') }}
-        restore-keys: |
-          ${{ runner.os }}-${{ matrix.go }}-go-ci
-
-    - name: Get dependencies
-      run: |
-        go get -v -t -d ./...
-        # mkdir test-results
-
-    - name: Build Caddy
-      working-directory: ./cmd/caddy
-      env:
-        CGO_ENABLED: 0
-      run: |
-        go build -trimpath -ldflags="-w -s" -v
-
-    - name: Publish Build Artifact
-      uses: actions/upload-artifact@v1
-      with:
-        name: caddy_${{ runner.os }}_go${{ matrix.go }}_${{ steps.vars.outputs.short_sha }}
-        path: ${{ matrix.CADDY_BIN_PATH }}
-
-    # Commented bits below were useful to allow the job to continue
-    # even if the tests fail, so we can publish the report separately
-    # For info about set-output, see https://stackoverflow.com/questions/57850553/github-actions-check-steps-status
-    - name: Run tests
-      # id: step_test
-      # continue-on-error: true
-      run: |
-        # (go test -v -coverprofile=cover-profile.out -race ./... 2>&1) > test-results/test-result.out
-        go test -v -coverprofile="cover-profile.out" -short -race ./...
-        # echo "::set-output name=status::$?"
-
-    # Relevant step if we reinvestigate publishing test/coverage reports
-    # - name: Prepare coverage reports
-    #   run: |
-    #     mkdir coverage
-    #     gocov convert cover-profile.out > coverage/coverage.json
-    #     # Because Windows doesn't work with input redirection like *nix, but output redirection works.
-    #     (cat ./coverage/coverage.json | gocov-xml) > coverage/coverage.xml
-
-    # To return the correct result even though we set 'continue-on-error: true'
-    # - name: Coerce correct build result
-    #   if: matrix.os != 'windows-latest' && steps.step_test.outputs.status != ${{ matrix.SUCCESS }}
-    #   run: |
-    #     echo "step_test ${{ steps.step_test.outputs.status }}\n"
-    #     exit 1
-
-  s390x-test:
-    name: test (s390x on IBM Z)
-    runs-on: ubuntu-latest
-    if: github.event.pull_request.head.repo.full_name == github.repository
-    continue-on-error: true  # August 2020: s390x VM is down due to weather and power issues
-    steps:
-      - name: Checkout code into the Go module directory
-        uses: actions/checkout@v2
-      - name: Run Tests
-        run: |
-          mkdir -p ~/.ssh && echo -e "${SSH_KEY//_/\\n}" > ~/.ssh/id_ecdsa && chmod og-rwx ~/.ssh/id_ecdsa
-
-          # short sha is enough?
-          short_sha=$(git rev-parse --short HEAD)
-
-          # The environment is fresh, so there's no point in keeping accepting and adding the key.
-          rsync -arz -e "ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null" --progress --delete --exclude '.git' . caddy-ci@ci-s390x.caddyserver.com:/var/tmp/"$short_sha"
-          ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -t caddy-ci@ci-s390x.caddyserver.com "cd /var/tmp/$short_sha; CGO_ENABLED=0 /usr/local/go/bin/go test -v ./..."
-          test_result=$?
-
-          # There's no need leaving the files around
-          ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null caddy-ci@ci-s390x.caddyserver.com "rm -rf /var/tmp/'$short_sha'"
-
-          echo "Test exit code: $test_result"
-          exit $test_result
-        env:
-          SSH_KEY: ${{ secrets.S390X_SSH_KEY }}
-
-  goreleaser-check:
-    runs-on: ubuntu-latest
-    steps:
-      - name: checkout
-        uses: actions/checkout@v2
-      - uses: goreleaser/goreleaser-action@v2
-        with:
-          version: latest
-          args: check
-        env:
-          TAG: ${{ steps.vars.outputs.version_tag }}

.github/workflows/cross-build.yml

@@ -1,60 +0,0 @@
-name: Cross-Build
-
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-    branches:
-      - master
-
-jobs:
-  cross-build-test:
-    strategy:
-      fail-fast: false
-      matrix:
-        goos: ['android', 'linux', 'solaris', 'illumos', 'dragonfly', 'freebsd', 'openbsd', 'plan9', 'windows', 'darwin', 'netbsd']
-        go: [ '1.14', '1.15' ]
-    runs-on: ubuntu-latest
-    continue-on-error: true
-    steps:
-      - name: Install Go
-        uses: actions/setup-go@v2
-        with:
-          go-version: ${{ matrix.go }}
-
-      - name: Print Go version and environment
-        id: vars
-        run: |
-          printf "Using go at: $(which go)\n"
-          printf "Go version: $(go version)\n"
-          printf "\n\nGo environment:\n\n"
-          go env
-          printf "\n\nSystem environment:\n\n"
-          env
-          echo "::set-output name=go_cache::$(go env GOCACHE)"
-
-      - name: Cache the build cache
-        uses: actions/cache@v2
-        with:
-          path: ${{ steps.vars.outputs.go_cache }}
-          key: cross-build-go${{ matrix.go }}-${{ matrix.goos }}-${{ hashFiles('**/go.sum') }}
-          restore-keys: |
-            cross-build-go${{ matrix.go }}-${{ matrix.goos }}
-
-      - name: Checkout code into the Go module directory
-        uses: actions/checkout@v2
-
-      - name: Run Build
-        env:
-          CGO_ENABLED: 0
-          GOOS: ${{ matrix.goos }}
-        shell: bash
-        continue-on-error: true
-        working-directory: ./cmd/caddy
-        run: |
-          GOOS=$GOOS go build -trimpath -o caddy-"$GOOS"-amd64 2> /dev/null
-          if [ $? -ne 0 ]; then
-            echo "::warning ::$GOOS Build Failed"
-            exit 0
-          fi

.github/workflows/lint.yml

@@ -1,23 +0,0 @@
-name: Lint
-
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-    branches:
-      - master
-
-jobs:
-  # From https://github.com/golangci/golangci-lint-action
-  golangci:
-    name: lint
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: golangci-lint
-        uses: golangci/golangci-lint-action@v2
-        with:
-          version: v1.31
-          # Optional: show only new issues if it's a pull request. The default value is `false`.
-          # only-new-issues: true

.github/workflows/release.yml

@@ -1,83 +0,0 @@
-name: Release
-
-on:
-  push:
-    tags:
-      - 'v*.*.*'
-
-jobs:
-  release:
-    name: Release
-    strategy:
-      matrix:
-        os: [ ubuntu-latest ]
-        go: [ '1.15' ]
-    runs-on: ${{ matrix.os }}
-
-    steps:
-    - name: Install Go
-      uses: actions/setup-go@v2
-      with:
-        go-version: ${{ matrix.go }}
-
-    - name: Checkout code
-      uses: actions/checkout@v2
-
-    # So GoReleaser can generate the changelog properly
-    - name: Unshallowify the repo clone
-      run: git fetch --prune --unshallow
-
-    # https://github.community/t5/GitHub-Actions/How-to-get-just-the-tag-name/m-p/32167/highlight/true#M1027
-    - name: Print Go version and environment
-      id: vars
-      run: |
-        printf "Using go at: $(which go)\n"
-        printf "Go version: $(go version)\n"
-        printf "\n\nGo environment:\n\n"
-        go env
-        printf "\n\nSystem environment:\n\n"
-        env
-        echo "::set-output name=version_tag::${GITHUB_REF/refs\/tags\//}"
-        echo "::set-output name=short_sha::$(git rev-parse --short HEAD)"
-        echo "::set-output name=go_cache::$(go env GOCACHE)"
-
-        # Parse semver
-        TAG=${GITHUB_REF/refs\/tags\//}
-        SEMVER_RE='[^0-9]*\([0-9]*\)[.]\([0-9]*\)[.]\([0-9]*\)\([0-9A-Za-z\.-]*\)'
-        TAG_MAJOR=`echo ${TAG#v} | sed -e "s#$SEMVER_RE#\1#"`
-        TAG_MINOR=`echo ${TAG#v} | sed -e "s#$SEMVER_RE#\2#"`
-        TAG_PATCH=`echo ${TAG#v} | sed -e "s#$SEMVER_RE#\3#"`
-        TAG_SPECIAL=`echo ${TAG#v} | sed -e "s#$SEMVER_RE#\4#"`
-        echo "::set-output name=tag_major::${TAG_MAJOR}"
-        echo "::set-output name=tag_minor::${TAG_MINOR}"
-        echo "::set-output name=tag_patch::${TAG_PATCH}"
-        echo "::set-output name=tag_special::${TAG_SPECIAL}"
-
-    - name: Cache the build cache
-      uses: actions/cache@v2
-      with:
-        path: ${{ steps.vars.outputs.go_cache }}
-        key: ${{ runner.os }}-go${{ matrix.go }}-release-${{ hashFiles('**/go.sum') }}
-        restore-keys: |
-          ${{ runner.os }}-go${{ matrix.go }}-release
-
-    # GoReleaser will take care of publishing those artifacts into the release
-    - name: Run GoReleaser
-      uses: goreleaser/goreleaser-action@v2
-      with:
-        version: latest
-        args: release --rm-dist
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        TAG: ${{ steps.vars.outputs.version_tag }}
-
-    # Only publish on non-special tags (e.g. non-beta)
-    - name: Publish .deb to Gemfury
-      if: ${{ steps.vars.outputs.tag_special == '' }}
-      env:
-        GEMFURY_PUSH_TOKEN: ${{ secrets.GEMFURY_PUSH_TOKEN }}
-      run: |
-        for filename in dist/*.deb; do
-          curl -F package=@"$filename" https://${GEMFURY_PUSH_TOKEN}:@push.fury.io/caddy/
-        done
-

.github/workflows/release_published.yml

@@ -1,34 +0,0 @@
-name: Release Published
-
-# Event payload: https://developer.github.com/webhooks/event-payloads/#release
-on:
-  release:
-    types: [published]
-
-jobs:
-  release:
-    name: Release Published
-    strategy:
-      matrix:
-        os: [ ubuntu-latest ]
-    runs-on: ${{ matrix.os }}
-
-    steps:
-
-    # See https://github.com/peter-evans/repository-dispatch
-    - name: Trigger event on caddyserver/dist
-      uses: peter-evans/repository-dispatch@v1
-      with:
-        token: ${{ secrets.REPO_DISPATCH_TOKEN }}
-        repository: caddyserver/dist
-        event-type: release-tagged
-        client-payload: '{"tag": "${{ github.event.release.tag_name }}"}'
-
-    - name: Trigger event on caddyserver/caddy-docker
-      uses: peter-evans/repository-dispatch@v1
-      with:
-        token: ${{ secrets.REPO_DISPATCH_TOKEN }}
-        repository: caddyserver/caddy-docker
-        event-type: release-tagged
-        client-payload: '{"tag": "${{ github.event.release.tag_name }}"}'
-

.gitignore

@@ -1,24 +1,21 @@
-_gitignore/
-*.log
-Caddyfile
-!caddyfile/
-
-# artifacts from pprof tooling
-*.prof
-*.test
-
-# build artifacts and helpers
-cmd/caddy/caddy
-cmd/caddy/caddy.exe
-cmd/caddy/setcap*
-
-# mac specific
 .DS_Store
+Thumbs.db
+_gitignore/
+Vagrantfile
+.vagrant/
+/.idea
 
-# go modules
-vendor
+dist/builds/
+dist/release/
 
-# goreleaser artifacts
-dist
-caddy-build
-caddy-dist
+error.log
+access.log
+
+/*.conf
+Caddyfile
+
+og_static/
+
+.vscode/
+
+*.bat

.golangci.yml

@@ -1,98 +0,0 @@
-linters-settings:
-  errcheck:
-    ignore: fmt:.*,io/ioutil:^Read.*,go.uber.org/zap/zapcore:^Add.*
-    ignoretests: true
-
-linters:
-  disable-all: true
-  enable:
-    - bodyclose
-    - deadcode
-    - errcheck
-    - gofmt
-    - goimports
-    - gosec
-    - gosimple
-    - govet
-    - ineffassign
-    - misspell
-    - prealloc
-    - staticcheck
-    - structcheck
-    - typecheck
-    - unconvert
-    - unused
-    - varcheck
-  # these are implicitly disabled:
-  # - asciicheck
-  # - depguard
-  # - dogsled
-  # - dupl
-  # - exhaustive
-  # - exportloopref
-  # - funlen
-  # - gci
-  # - gochecknoglobals
-  # - gochecknoinits
-  # - gocognit
-  # - goconst
-  # - gocritic
-  # - gocyclo
-  # - godot
-  # - godox
-  # - goerr113
-  # - gofumpt
-  # - goheader
-  # - golint
-  # - gomnd
-  # - gomodguard
-  # - goprintffuncname
-  # - interfacer
-  # - lll
-  # - maligned
-  # - nakedret
-  # - nestif
-  # - nlreturn
-  # - noctx
-  # - nolintlint
-  # - rowserrcheck
-  # - scopelint
-  # - sqlclosecheck
-  # - stylecheck
-  # - testpackage
-  # - unparam
-  # - whitespace
-  # - wsl
-
-run:
-  # default concurrency is a available CPU number.
-  # concurrency: 4 # explicitly omit this value to fully utilize available resources.
-  deadline: 5m
-  issues-exit-code: 1
-  tests: false
-
-# output configuration options
-output:
-  format: 'colored-line-number'
-  print-issued-lines: true
-  print-linter-name: true
-
-issues:
-  exclude-rules:
-    # we aren't calling unknown URL
-    - text: "G107" # G107: Url provided to HTTP request as taint input
-      linters:
-        - gosec
-    # as a web server that's expected to handle any template, this is totally in the hands of the user.
-    - text: "G203" # G203: Use of unescaped data in HTML templates
-      linters:
-        - gosec
-    # we're shelling out to known commands, not relying on user-defined input.
-    - text: "G204" # G204: Audit use of command execution
-      linters:
-        - gosec
-    # the choice of weakrand is deliberate, hence the named import "weakrand"
-    - path: modules/caddyhttp/reverseproxy/selectionpolicies.go
-      text: "G404" # G404: Insecure random number source (rand)
-      linters:
-        - gosec

.goreleaser.yml

@@ -1,117 +0,0 @@
-before:
-  hooks:
-    # The build is done in this particular way to build Caddy in a designated directory named in .gitignore.
-    # This is so we can run goreleaser on tag without Git complaining of being dirty. The main.go in cmd/caddy directory 
-    # cannot be built within that directory due to changes necessary for the build causing Git to be dirty, which
-    # subsequently causes gorleaser to refuse running.
-    - mkdir -p caddy-build
-    - cp cmd/caddy/main.go caddy-build/main.go
-    - cp ./go.mod caddy-build/go.mod
-    - sed -i.bkp 's|github.com/caddyserver/caddy/v2|caddy|g' ./caddy-build/go.mod
-    # GoReleaser doesn't seem to offer {{.Tag}} at this stage, so we have to embed it into the env
-    # so we run: TAG=$(git describe --abbrev=0) goreleaser release --rm-dist --skip-publish --skip-validate
-    - go mod edit -require=github.com/caddyserver/caddy/v2@{{.Env.TAG}} ./caddy-build/go.mod
-    - git clone --depth 1 https://github.com/caddyserver/dist caddy-dist
-    - go mod download
-
-builds:
-- env:
-  - CGO_ENABLED=0
-  - GO111MODULE=on
-  main: main.go
-  dir: ./caddy-build
-  binary: caddy
-  goos:
-  - darwin
-  - linux
-  - windows
-  - freebsd
-  goarch:
-  - amd64
-  - arm
-  - arm64
-  - s390x
-  - ppc64le
-  goarm:
-  - 5
-  - 6
-  - 7
-  ignore:
-    - goos: darwin
-      goarch: arm
-    - goos: darwin
-      goarch: ppc64le
-    - goos: darwin
-      goarch: s390x
-    - goos: windows
-      goarch: ppc64le
-    - goos: windows
-      goarch: s390x
-    - goos: freebsd
-      goarch: ppc64le
-    - goos: freebsd
-      goarch: s390x
-    - goos: freebsd
-      goarch: arm
-      goarm: 5
-  flags:
-  - -trimpath
-  ldflags:
-  - -s -w
-
-archives:
-  - format_overrides:
-      - goos: windows
-        format: zip
-    replacements:
-      darwin: mac
-checksum:
-  algorithm: sha512
-
-nfpms:
-  - id: default
-    package_name: caddy
-
-    vendor: Light Code Labs
-    homepage: https://caddyserver.com
-    maintainer: Matthew Holt <mholt@users.noreply.github.com>
-    description: |
-      Powerful, enterprise-ready, open source web server with automatic HTTPS written in Go
-    license: Apache 2.0
-
-    formats:
-      - deb
-      # - rpm
-
-    bindir: /usr/bin
-    files:
-      ./caddy-dist/init/caddy.service: /lib/systemd/system/caddy.service
-      ./caddy-dist/init/caddy-api.service: /lib/systemd/system/caddy-api.service
-      ./caddy-dist/welcome/index.html: /usr/share/caddy/index.html
-      ./caddy-dist/scripts/completions/bash-completion: /etc/bash_completion.d/caddy
-    config_files:
-      ./caddy-dist/config/Caddyfile: /etc/caddy/Caddyfile
-
-    scripts:
-      postinstall: ./caddy-dist/scripts/postinstall.sh
-      preremove: ./caddy-dist/scripts/preremove.sh
-      postremove: ./caddy-dist/scripts/postremove.sh
-
-
-release:
-  github:
-    owner: caddyserver
-    name: caddy
-  draft: true
-  prerelease: auto
-
-changelog:
-  sort: asc
-  filters:
-    exclude:
-    - '^chore:'
-    - '^ci:'
-    - '^docs?:'
-    - '^readme:'
-    - '^tests?:'
-    - '^\w+\s+' # a hack to remove commit messages without colons thus don't correspond to a package

.travis.yml

@@ -0,0 +1,38 @@
+language: go
+
+addons:
+  hosts:
+    - quic.clemente.io
+
+go:
+  - 1.x
+  - tip
+
+matrix:
+  allow_failures:
+    - go: tip
+  fast_finish: true
+
+before_install:
+  # Decrypts a script that installs an authenticated cookie
+  # for git to use when cloning from googlesource.com.
+  # Bypasses "bandwidth limit exceeded" errors.
+  # See github.com/golang/go/issues/12933
+ - if [ "$TRAVIS_PULL_REQUEST" = "false" ]; then openssl aes-256-cbc -K $encrypted_3df18f9af81d_key -iv $encrypted_3df18f9af81d_iv -in dist/gitcookie.sh.enc -out dist/gitcookie.sh -d; fi
+
+install:
+  - if [ "$TRAVIS_PULL_REQUEST" = "false" ]; then bash dist/gitcookie.sh; fi
+  - go get -t ./...
+  - go get github.com/golang/lint/golint
+  - go get github.com/FiloSottile/vendorcheck
+  # Install gometalinter
+  - go get github.com/alecthomas/gometalinter
+
+script:
+  - gometalinter --install
+  - gometalinter --disable-all -E vet -E gofmt -E misspell -E ineffassign -E goimports -E deadcode --tests --vendor ./...
+  - vendorcheck ./...
+  - go test -race ./...
+
+after_script:
+  - golint ./...

AUTHORS

@@ -1,10 +0,0 @@
-# This is the official list of Caddy Authors for copyright purposes.
-# Authors may be either individual people or legal entities.
-#
-# Not all individual contributors are authors. For the full list of
-# contributors, refer to the project's page on GitHub or the repo's
-# commit history.
-
-Matthew Holt <Matthew.Holt@gmail.com>
-Light Code Labs <sales@lightcodelabs.com>
-Ardan Labs <info@ardanlabs.com>

LICENSE.txt

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   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.

README.md

@@ -1,190 +1,167 @@
 <p align="center">
 	<a href="https://caddyserver.com"><img src="https://user-images.githubusercontent.com/1128849/36338535-05fb646a-136f-11e8-987b-e6901e717d5a.png" alt="Caddy" width="450"></a>
-	<br>
-	<h3 align="center">a <a href="https://zerossl.com"><img src="https://caddyserver.com/resources/images/zerossl-logo.svg" height="28" valign="middle"></a> project</h3>
 </p>
-<hr>
-<h3 align="center">Every site on HTTPS</h3>
-<p align="center">Caddy is an extensible server platform that uses TLS by default.</p>
+<h3 align="center">Every Site on HTTPS <!-- Serve Confidently --></h3>
+<p align="center">Caddy is a general-purpose HTTP/2 web server that serves HTTPS by default.</p>
 <p align="center">
-	<a href="https://github.com/caddyserver/caddy/actions?query=workflow%3ACross-Platform"><img src="https://github.com/caddyserver/caddy/workflows/Cross-Platform/badge.svg"></a>
-	<a href="https://pkg.go.dev/github.com/caddyserver/caddy/v2"><img src="https://img.shields.io/badge/godoc-reference-%23007d9c.svg"></a>
+	<a href="https://travis-ci.org/mholt/caddy"><img src="https://img.shields.io/travis/mholt/caddy.svg?label=linux+build"></a>
+	<a href="https://ci.appveyor.com/project/mholt/caddy"><img src="https://img.shields.io/appveyor/ci/mholt/caddy.svg?label=windows+build"></a>
+	<a href="https://godoc.org/github.com/mholt/caddy"><img src="https://img.shields.io/badge/godoc-reference-blue.svg"></a>
+	<a href="https://goreportcard.com/report/mholt/caddy"><img src="https://goreportcard.com/badge/github.com/mholt/caddy"></a>
 	<br>
 	<a href="https://twitter.com/caddyserver" title="@caddyserver on Twitter"><img src="https://img.shields.io/badge/twitter-@caddyserver-55acee.svg" alt="@caddyserver on Twitter"></a>
 	<a href="https://caddy.community" title="Caddy Forum"><img src="https://img.shields.io/badge/community-forum-ff69b4.svg" alt="Caddy Forum"></a>
-	<a href="https://sourcegraph.com/github.com/caddyserver/caddy?badge" title="Caddy on Sourcegraph"><img src="https://sourcegraph.com/github.com/caddyserver/caddy/-/badge.svg" alt="Caddy on Sourcegraph"></a>
+	<a href="https://sourcegraph.com/github.com/mholt/caddy?badge" title="Caddy on Sourcegraph"><img src="https://sourcegraph.com/github.com/mholt/caddy/-/badge.svg" alt="Caddy on Sourcegraph"></a>
 </p>
 <p align="center">
-	<a href="https://github.com/caddyserver/caddy/releases">Releases</a> ·
-	<a href="https://caddyserver.com/docs/">Documentation</a> ·
-	<a href="https://caddy.community">Get Help</a>
+	<a href="https://caddyserver.com/download">Download</a> ·
+	<a href="https://caddyserver.com/docs">Documentation</a> ·
+	<a href="https://caddy.community">Community</a>
 </p>
 
+---
 
+Caddy is a **production-ready** open-source web server that is fast, easy to use, and makes you more productive.
 
-### Menu
+Available for Windows, Mac, Linux, BSD, Solaris, and [Android](https://github.com/mholt/caddy/wiki/Running-Caddy-on-Android).
+
+## Menu
 
 - [Features](#features)
 - [Install](#install)
-- [Build from source](#build-from-source)
-	- [For development](#for-development)
-	- [With version information and/or plugins](#with-version-information-andor-plugins)
-- [Quick start](#quick-start)
-- [Overview](#overview)
-- [Full documentation](#full-documentation)
-- [Getting help](#getting-help)
-- [About](#about)
+- [Quick Start](#quick-start)
+- [Running in Production](#running-in-production)
+- [Contributing](#contributing)
+- [Donors](#donors)
+- [About the Project](#about-the-project)
 
-<p align="center">
-	<b>Powered by</b>
-	<br>
-	<a href="https://github.com/caddyserver/certmagic"><img src="https://user-images.githubusercontent.com/1128849/49704830-49d37200-fbd5-11e8-8385-767e0cd033c3.png" alt="CertMagic" width="250"></a>
-</p>
+## Features
 
-
-## [Features](https://caddyserver.com/v2)
-
-- **Easy configuration** with the [Caddyfile](https://caddyserver.com/docs/caddyfile)
-- **Powerful configuration** with its [native JSON config](https://caddyserver.com/docs/json/)
-- **Dynamic configuration** with the [JSON API](https://caddyserver.com/docs/api)
-- [**Config adapters**](https://caddyserver.com/docs/config-adapters) if you don't like JSON
-- **Automatic HTTPS** by default
-	- [ZeroSSL](https://zerossl.com) and [Let's Encrypt](https://letsencrypt.org) for public names
-	- Fully-managed local CA for internal names & IPs
-	- Can coordinate with other Caddy instances in a cluster
-	- Multi-issuer fallback
-- **Stays up when other servers go down** due to TLS/OCSP/certificate-related issues
-- **Production-ready** after serving trillions of requests and managing millions of TLS certificates
-- **Scales to tens of thousands of sites** ... and probably more
-- **HTTP/1.1, HTTP/2, and experimental HTTP/3** support
-- **Highly extensible** [modular architecture](https://caddyserver.com/docs/architecture) lets Caddy do anything without bloat
+- **Easy configuration** with the Caddyfile
+- **Automatic HTTPS** on by default (via [Let's Encrypt](https://letsencrypt.org))
+- **HTTP/2** by default
+- **Virtual hosting** so multiple sites just work
+- Experimental **QUIC support** for cutting-edge transmissions
+- TLS session ticket **key rotation** for more secure connections
+- **Extensible with plugins** because a convenient web server is a helpful one
 - **Runs anywhere** with **no external dependencies** (not even libc)
-- Written in Go, a language with higher **memory safety guarantees** than other servers
-- Actually **fun to use**
-- So, so much more to [discover](https://caddyserver.com/v2)
+
+[See a more complete list of features built into Caddy.](https://caddyserver.com/features) On top of all those, Caddy does even more with plugins: choose which plugins you want at [download](https://caddyserver.com/download).
+
+Altogether, Caddy can do things other web servers simply cannot do. Its features and plugins save you time and mistakes, and will cheer you up. Your Caddy instance takes care of the details for you!
+
 
 ## Install
 
-The simplest, cross-platform way is to download from [GitHub Releases](https://github.com/caddyserver/caddy/releases) and place the executable file in your PATH.
+Caddy binaries have no dependencies and are available for every platform. Get Caddy either of these ways:
 
-For other install options, see https://caddyserver.com/docs/download.
+- **[Download page](https://caddyserver.com/download)** (RECOMMENDED) allows you to customize your build in the browser
+- **[Latest release](https://github.com/mholt/caddy/releases/latest)** for pre-built, vanilla binaries
 
-## Build from source
 
-Requirements:
+## Build
 
-- [Go 1.14 or newer](https://golang.org/dl/)
+To build from source you need **[Git](https://git-scm.com/downloads)** and **[Go](https://golang.org/doc/install)** (1.9 or newer). Follow these instruction for fast building:
 
-### For development
- 
-_**Note:** These steps [will not embed proper version information](https://github.com/golang/go/issues/29228). For that, please follow the instructions in the next section._
+- Get the source with `go get github.com/mholt/caddy/caddy` and then run `go get github.com/caddyserver/builds`
+- Now `cd $GOPATH/src/github.com/mholt/caddy/caddy` and run `go run build.go`
 
-```bash
-$ git clone "https://github.com/caddyserver/caddy.git"
-$ cd caddy/cmd/caddy/
-$ go build
-```
+Then make sure the `caddy` binary is in your PATH.
 
-When you run Caddy, it may try to bind to low ports unless otherwise specified in your config. If your OS requires elevated privileges, you will need to give your new binary permission to do so. On Linux, this can be done easily with: `sudo setcap cap_net_bind_service=+ep ./caddy`
+To build for other platforms, use build.go with the `--goos` and `--goarch` flags.
 
-If you prefer to use `go run` which creates temporary binaries, you can still do this. Make an executable file called `setcap.sh` (or whatever you want) with these contents:
 
-```bash
-#!/bin/sh
-sudo setcap cap_net_bind_service=+ep "$1"
-"$@"
-```
+## Quick Start
 
-then you can use `go run` like so:
-
-```bash
-$ go run -exec ./setcap.sh main.go
-```
-
-If you don't want to type your password for `setcap`, use `sudo visudo` to edit your sudoers file and allow your user account to run that command without a password, for example:
+To serve static files from the current working directory, run:
 
 ```
-username ALL=(ALL:ALL) NOPASSWD: /usr/sbin/setcap
+caddy
 ```
 
-replacing `username` with your actual username. Please be careful and only do this if you know what you are doing! We are only qualified to document how to use Caddy, not Go tooling or your computer, and we are providing these instructions for convenience only; please learn how to use your own computer at your own risk and make any needful adjustments.
+Caddy's default port is 2015, so open your browser to [http://localhost:2015](http://localhost:2015).
 
-### With version information and/or plugins
+### Go from 0 to HTTPS in 5 seconds
 
-Using [our builder tool, `xcaddy`](https://github.com/caddyserver/xcaddy)...
+If the `caddy` binary has permission to bind to low ports and your domain name's DNS records point to the machine you're on:
 
 ```
-$ xcaddy build
+caddy -host example.com
 ```
 
-...the following steps are automated:
+This command serves static files from the current directory over HTTPS. Certificates are automatically obtained and renewed for you! Caddy is also automatically configuring ports 80 and 443 for you, and redirecting HTTP to HTTPS. Cool, huh?
 
-1. Create a new folder: `mkdir caddy`
-2. Change into it: `cd caddy`
-3. Copy [Caddy's main.go](https://github.com/caddyserver/caddy/blob/master/cmd/caddy/main.go) into the empty folder. Add imports for any custom plugins you want to add.
-4. Initialize a Go module: `go mod init caddy`
-5. (Optional) Pin Caddy version: `go get github.com/caddyserver/caddy/v2@version` replacing `version` with a git tag or commit.
-6. (Optional) Add plugins by adding their import: `_ "import/path/here"`
-7. Compile: `go build`
+### Customizing your site
+
+To customize how your site is served, create a file named Caddyfile by your site and paste this into it:
+
+```plain
+localhost
+
+push
+browse
+websocket /echo cat
+ext    .html
+log    /var/log/access.log
+proxy  /api 127.0.0.1:7005
+header /api Access-Control-Allow-Origin *
+```
+
+When you run `caddy` in that directory, it will automatically find and use that Caddyfile.
+
+This simple file enables server push (via Link headers), allows directory browsing (for folders without an index file), hosts a WebSocket echo server at /echo, serves clean URLs, logs requests to an access log, proxies all API requests to a backend on port 7005, and adds the coveted  `Access-Control-Allow-Origin: *` header for all responses from the API.
+
+Wow! Caddy can do a lot with just a few lines.
+
+### Doing more with Caddy
+
+To host multiple sites and do more with the Caddyfile, please see the [Caddyfile tutorial](https://caddyserver.com/tutorial/caddyfile).
+
+Sites with qualifying hostnames are served over [HTTPS by default](https://caddyserver.com/docs/automatic-https).
+
+Caddy has a nice little command line interface. Run `caddy -h` to view basic help or see the [CLI documentation](https://caddyserver.com/docs/cli) for details.
 
 
+## Running in Production
+
+Caddy is production-ready if you find it to be a good fit for your site and workflow.
+
+**Running as root:** We advise against this. You can still listen on ports < 1024 on Linux using setcap like so: `sudo setcap cap_net_bind_service=+ep ./caddy`
+
+The Caddy project does not officially maintain any system-specific integrations nor suggest how to administer your own system. But your download file includes [unofficial resources](https://github.com/mholt/caddy/tree/master/dist/init) contributed by the community that you may find helpful for running Caddy in production.
+
+How you choose to run Caddy is up to you. Many users are satisfied with `nohup caddy &`. Others use `screen`. Users who need Caddy to come back up after reboots either do so in the script that caused the reboot, add a command to an init script, or configure a service with their OS.
+
+If you have questions or concerns about Caddy' underlying crypto implementations, consult Go's [crypto packages](https://golang.org/pkg/crypto), starting with their documentation, then issues, then the code itself; as Caddy uses mainly those libraries.
 
 
-## Quick start
+## Contributing
 
-The [Caddy website](https://caddyserver.com/docs/) has documentation that includes tutorials, quick-start guides, reference, and more.
+**[Join our forum](https://caddy.community) where you can chat with other Caddy users and developers!** To get familiar with the code base, try [Caddy code search on Sourcegraph](https://sourcegraph.com/github.com/mholt/caddy/-/search)!
 
-**We recommend that all users -- regardless of experience level -- do our [Getting Started](https://caddyserver.com/docs/getting-started) guide to become familiar with using Caddy.**
+Please see our [contributing guidelines](https://github.com/mholt/caddy/blob/master/.github/CONTRIBUTING.md) for instructions. If you want to write a plugin, check out the [developer wiki](https://github.com/mholt/caddy/wiki).
 
-If you've only got a minute, [the website has several quick-start tutorials](https://caddyserver.com/docs/quick-starts) to choose from! However, after finishing a quick-start tutorial, please read more documentation to understand how the software works. 🙂
+We use GitHub issues and pull requests only for discussing bug reports and the development of specific changes. We welcome all other topics on the [forum](https://caddy.community)!
+
+If you want to contribute to the documentation, please submit pull requests to [caddyserver/website](https://github.com/caddyserver/website).
+
+Thanks for making Caddy -- and the Web -- better!
 
 
+## Donors
+
+- [DigitalOcean](https://m.do.co/c/6d7bdafccf96) is hosting the Caddy project.
+- [DNSimple](https://dnsimple.link/resolving-caddy) provides DNS services for Caddy's sites.
+- [DNS Spy](https://dnsspy.io) keeps an eye on Caddy's DNS properties.
+
+We thank them for their services. **If you want to help keep Caddy free, please [become a sponsor](https://caddyserver.com/pricing)!**
 
 
-## Overview
+## About the Project
 
-Caddy is most often used as an HTTPS server, but it is suitable for any long-running Go program. First and foremost, it is a platform to run Go applications. Caddy "apps" are just Go programs that are implemented as Caddy modules. Two apps -- `tls` and `http` -- ship standard with Caddy.
+Caddy was born out of the need for a "batteries-included" web server that runs anywhere and doesn't have to take its configuration with it. Caddy took inspiration from [spark](https://github.com/rif/spark), [nginx](https://github.com/nginx/nginx), lighttpd,
+[Websocketd](https://github.com/joewalnes/websocketd) and [Vagrant](https://www.vagrantup.com/), which provides a pleasant mixture of features from each of them.
 
-Caddy apps instantly benefit from [automated documentation](https://caddyserver.com/docs/json/), graceful on-line [config changes via API](https://caddyserver.com/docs/api), and unification with other Caddy apps.
+**The name "Caddy" is trademarked:** The name of the software is "Caddy", not "Caddy Server" or "CaddyServer". Please call it "Caddy" or, if you wish to clarify, "the Caddy web server". See [brand guidelines](https://caddyserver.com/brand). Caddy is a registered trademark of Light Code Labs, LLC.
 
-Although [JSON](https://caddyserver.com/docs/json/) is Caddy's native config language, Caddy can accept input from [config adapters](https://caddyserver.com/docs/config-adapters) which can essentially convert any config format of your choice into JSON: Caddyfile, JSON 5, YAML, TOML, NGINX config, and more.
-
-The primary way to configure Caddy is through [its API](https://caddyserver.com/docs/api), but if you prefer config files, the [command-line interface](https://caddyserver.com/docs/command-line) supports those too.
-
-Caddy exposes an unprecedented level of control compared to any web server in existence. In Caddy, you are usually setting the actual values of the initialized types in memory that power everything from your HTTP handlers and TLS handshakes to your storage medium. Caddy is also ridiculously extensible, with a powerful plugin system that makes vast improvements over other web servers.
-
-To wield the power of this design, you need to know how the config document is structured. Please see [our documentation site](https://caddyserver.com/docs/) for details about [Caddy's config structure](https://caddyserver.com/docs/json/).
-
-Nearly all of Caddy's configuration is contained in a single config document, rather than being scattered across CLI flags and env variables and a configuration file as with other web servers. This makes managing your server config more straightforward and reduces hidden variables/factors.
-
-
-## Full documentation
-
-Our website has complete documentation:
-
-**https://caddyserver.com/docs/**
-
-The docs are also open source. You can contribute to them here: https://github.com/caddyserver/website
-
-
-
-## Getting help
-
-- We **strongly recommend** that all professionals or companies using Caddy get a support contract through [Ardan Labs](https://www.ardanlabs.com/my/contact-us?dd=caddy) before help is needed.
-
-- A [sponsorship](https://github.com/sponsors/mholt) goes a long way!
-
-- Individuals can exchange help for free on our community forum at https://caddy.community. Remember that people give help out of their spare time and good will. The best way to get help is to give it first!
-
-Please use our [issue tracker](https://github.com/caddyserver/caddy/issues) only for bug reports and feature requests, i.e. actionable development items (support questions will usually be referred to the forums).
-
-
-
-## About
-
-**The name "Caddy" is trademarked.** The name of the software is "Caddy", not "Caddy Server" or "CaddyServer". Please call it "Caddy" or, if you wish to clarify, "the Caddy web server". Caddy is a registered trademark of apilayer GmbH.
-
-- _Project on Twitter: [@caddyserver](https://twitter.com/caddyserver)_
-- _Author on Twitter: [@mholt6](https://twitter.com/mholt6)_
-
-Caddy is a project of [ZeroSSL](https://zerossl.com), an [apilayer](https://apilayer.com) company.
+*Author on Twitter: [@mholt6](https://twitter.com/mholt6)*

admin.go

@@ -1,872 +0,0 @@
-// 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 caddy
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"errors"
-	"expvar"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"net"
-	"net/http"
-	"net/http/pprof"
-	"net/url"
-	"os"
-	"path"
-	"regexp"
-	"strconv"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/prometheus/client_golang/prometheus"
-	"go.uber.org/zap"
-)
-
-// TODO: is there a way to make the admin endpoint so that it can be plugged into the HTTP app? see issue #2833
-
-// AdminConfig configures Caddy's API endpoint, which is used
-// to manage Caddy while it is running.
-type AdminConfig struct {
-	// If true, the admin endpoint will be completely disabled.
-	// Note that this makes any runtime changes to the config
-	// impossible, since the interface to do so is through the
-	// admin endpoint.
-	Disabled bool `json:"disabled,omitempty"`
-
-	// The address to which the admin endpoint's listener should
-	// bind itself. Can be any single network address that can be
-	// parsed by Caddy. Default: localhost:2019
-	Listen string `json:"listen,omitempty"`
-
-	// If true, CORS headers will be emitted, and requests to the
-	// API will be rejected if their `Host` and `Origin` headers
-	// do not match the expected value(s). Use `origins` to
-	// customize which origins/hosts are allowed.If `origins` is
-	// not set, the listen address is the only value allowed by
-	// default.
-	EnforceOrigin bool `json:"enforce_origin,omitempty"`
-
-	// The list of allowed origins/hosts for API requests. Only needed
-	// if accessing the admin endpoint from a host different from the
-	// socket's network interface or if `enforce_origin` is true. If not
-	// set, the listener address will be the default value. If set but
-	// empty, no origins will be allowed.
-	Origins []string `json:"origins,omitempty"`
-
-	// Options related to configuration management.
-	Config *ConfigSettings `json:"config,omitempty"`
-}
-
-// ConfigSettings configures the, uh, configuration... and
-// management thereof.
-type ConfigSettings struct {
-	// Whether to keep a copy of the active config on disk. Default is true.
-	Persist *bool `json:"persist,omitempty"`
-}
-
-// listenAddr extracts a singular listen address from ac.Listen,
-// returning the network and the address of the listener.
-func (admin AdminConfig) listenAddr() (NetworkAddress, error) {
-	input := admin.Listen
-	if input == "" {
-		input = DefaultAdminListen
-	}
-	listenAddr, err := ParseNetworkAddress(input)
-	if err != nil {
-		return NetworkAddress{}, fmt.Errorf("parsing admin listener address: %v", err)
-	}
-	if listenAddr.PortRangeSize() != 1 {
-		return NetworkAddress{}, fmt.Errorf("admin endpoint must have exactly one address; cannot listen on %v", listenAddr)
-	}
-	return listenAddr, nil
-}
-
-// newAdminHandler reads admin's config and returns an http.Handler suitable
-// for use in an admin endpoint server, which will be listening on listenAddr.
-func (admin AdminConfig) newAdminHandler(addr NetworkAddress) adminHandler {
-	muxWrap := adminHandler{
-		enforceOrigin:  admin.EnforceOrigin,
-		enforceHost:    !addr.isWildcardInterface(),
-		allowedOrigins: admin.allowedOrigins(addr),
-		mux:            http.NewServeMux(),
-	}
-
-	addRouteWithMetrics := func(pattern string, handlerLabel string, h http.Handler) {
-		labels := prometheus.Labels{"path": pattern, "handler": handlerLabel}
-		h = instrumentHandlerCounter(
-			adminMetrics.requestCount.MustCurryWith(labels),
-			h,
-		)
-		muxWrap.mux.Handle(pattern, h)
-	}
-	// addRoute just calls muxWrap.mux.Handle after
-	// wrapping the handler with error handling
-	addRoute := func(pattern string, handlerLabel string, h AdminHandler) {
-		wrapper := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			err := h.ServeHTTP(w, r)
-			if err != nil {
-				labels := prometheus.Labels{
-					"path":    pattern,
-					"handler": handlerLabel,
-					"method":  strings.ToUpper(r.Method),
-				}
-				adminMetrics.requestErrors.With(labels).Inc()
-			}
-			muxWrap.handleError(w, r, err)
-		})
-		addRouteWithMetrics(pattern, handlerLabel, wrapper)
-	}
-
-	const handlerLabel = "admin"
-
-	// register standard config control endpoints
-	addRoute("/"+rawConfigKey+"/", handlerLabel, AdminHandlerFunc(handleConfig))
-	addRoute("/id/", handlerLabel, AdminHandlerFunc(handleConfigID))
-	addRoute("/stop", handlerLabel, AdminHandlerFunc(handleStop))
-
-	// register debugging endpoints
-	addRouteWithMetrics("/debug/pprof/", handlerLabel, http.HandlerFunc(pprof.Index))
-	addRouteWithMetrics("/debug/pprof/cmdline", handlerLabel, http.HandlerFunc(pprof.Cmdline))
-	addRouteWithMetrics("/debug/pprof/profile", handlerLabel, http.HandlerFunc(pprof.Profile))
-	addRouteWithMetrics("/debug/pprof/symbol", handlerLabel, http.HandlerFunc(pprof.Symbol))
-	addRouteWithMetrics("/debug/pprof/trace", handlerLabel, http.HandlerFunc(pprof.Trace))
-	addRouteWithMetrics("/debug/vars", handlerLabel, expvar.Handler())
-
-	// register third-party module endpoints
-	for _, m := range GetModules("admin.api") {
-		router := m.New().(AdminRouter)
-		handlerLabel := m.ID.Name()
-		for _, route := range router.Routes() {
-			addRoute(route.Pattern, handlerLabel, route.Handler)
-		}
-	}
-
-	return muxWrap
-}
-
-// allowedOrigins returns a list of origins that are allowed.
-// If admin.Origins is nil (null), the provided listen address
-// will be used as the default origin. If admin.Origins is
-// empty, no origins will be allowed, effectively bricking the
-// endpoint for non-unix-socket endpoints, but whatever.
-func (admin AdminConfig) allowedOrigins(addr NetworkAddress) []string {
-	uniqueOrigins := make(map[string]struct{})
-	for _, o := range admin.Origins {
-		uniqueOrigins[o] = struct{}{}
-	}
-	if admin.Origins == nil {
-		if addr.isLoopback() {
-			if addr.IsUnixNetwork() {
-				// RFC 2616, Section 14.26:
-				// "A client MUST include a Host header field in all HTTP/1.1 request
-				// messages. If the requested URI does not include an Internet host
-				// name for the service being requested, then the Host header field MUST
-				// be given with an empty value."
-				uniqueOrigins[""] = struct{}{}
-			} else {
-				uniqueOrigins[net.JoinHostPort("localhost", addr.port())] = struct{}{}
-				uniqueOrigins[net.JoinHostPort("::1", addr.port())] = struct{}{}
-				uniqueOrigins[net.JoinHostPort("127.0.0.1", addr.port())] = struct{}{}
-			}
-		}
-		if !addr.IsUnixNetwork() {
-			uniqueOrigins[addr.JoinHostPort(0)] = struct{}{}
-		}
-	}
-	allowed := make([]string, 0, len(uniqueOrigins))
-	for origin := range uniqueOrigins {
-		allowed = append(allowed, origin)
-	}
-	return allowed
-}
-
-// replaceAdmin replaces the running admin server according
-// to the relevant configuration in cfg. If no configuration
-// for the admin endpoint exists in cfg, a default one is
-// used, so that there is always an admin server (unless it
-// is explicitly configured to be disabled).
-func replaceAdmin(cfg *Config) error {
-	// always be sure to close down the old admin endpoint
-	// as gracefully as possible, even if the new one is
-	// disabled -- careful to use reference to the current
-	// (old) admin endpoint since it will be different
-	// when the function returns
-	oldAdminServer := adminServer
-	defer func() {
-		// do the shutdown asynchronously so that any
-		// current API request gets a response; this
-		// goroutine may last a few seconds
-		if oldAdminServer != nil {
-			go func(oldAdminServer *http.Server) {
-				err := stopAdminServer(oldAdminServer)
-				if err != nil {
-					Log().Named("admin").Error("stopping current admin endpoint", zap.Error(err))
-				}
-			}(oldAdminServer)
-		}
-	}()
-
-	// always get a valid admin config
-	adminConfig := DefaultAdminConfig
-	if cfg != nil && cfg.Admin != nil {
-		adminConfig = cfg.Admin
-	}
-
-	// if new admin endpoint is to be disabled, we're done
-	if adminConfig.Disabled {
-		Log().Named("admin").Warn("admin endpoint disabled")
-		return nil
-	}
-
-	// extract a singular listener address
-	addr, err := adminConfig.listenAddr()
-	if err != nil {
-		return err
-	}
-
-	handler := adminConfig.newAdminHandler(addr)
-
-	ln, err := Listen(addr.Network, addr.JoinHostPort(0))
-	if err != nil {
-		return err
-	}
-
-	adminServer = &http.Server{
-		Handler:           handler,
-		ReadTimeout:       10 * time.Second,
-		ReadHeaderTimeout: 5 * time.Second,
-		IdleTimeout:       60 * time.Second,
-		MaxHeaderBytes:    1024 * 64,
-	}
-
-	adminLogger := Log().Named("admin")
-	go func() {
-		if err := adminServer.Serve(ln); !errors.Is(err, http.ErrServerClosed) {
-			adminLogger.Error("admin server shutdown for unknown reason", zap.Error(err))
-		}
-	}()
-
-	adminLogger.Info("admin endpoint started",
-		zap.String("address", addr.String()),
-		zap.Bool("enforce_origin", adminConfig.EnforceOrigin),
-		zap.Strings("origins", handler.allowedOrigins))
-
-	if !handler.enforceHost {
-		adminLogger.Warn("admin endpoint on open interface; host checking disabled",
-			zap.String("address", addr.String()))
-	}
-
-	return nil
-}
-
-func stopAdminServer(srv *http.Server) error {
-	if srv == nil {
-		return fmt.Errorf("no admin server")
-	}
-	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-	defer cancel()
-	err := srv.Shutdown(ctx)
-	if err != nil {
-		return fmt.Errorf("shutting down admin server: %v", err)
-	}
-	Log().Named("admin").Info("stopped previous server")
-	return nil
-}
-
-// AdminRouter is a type which can return routes for the admin API.
-type AdminRouter interface {
-	Routes() []AdminRoute
-}
-
-// AdminRoute represents a route for the admin endpoint.
-type AdminRoute struct {
-	Pattern string
-	Handler AdminHandler
-}
-
-type adminHandler struct {
-	enforceOrigin  bool
-	enforceHost    bool
-	allowedOrigins []string
-	mux            *http.ServeMux
-}
-
-// ServeHTTP is the external entry point for API requests.
-// It will only be called once per request.
-func (h adminHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	log := Log().Named("admin.api").With(
-		zap.String("method", r.Method),
-		zap.String("host", r.Host),
-		zap.String("uri", r.RequestURI),
-		zap.String("remote_addr", r.RemoteAddr),
-		zap.Reflect("headers", r.Header),
-	)
-	if r.RequestURI == "/metrics" {
-		log.Debug("received request")
-	} else {
-		log.Info("received request")
-	}
-	h.serveHTTP(w, r)
-}
-
-// serveHTTP is the internal entry point for API requests. It may
-// be called more than once per request, for example if a request
-// is rewritten (i.e. internal redirect).
-func (h adminHandler) serveHTTP(w http.ResponseWriter, r *http.Request) {
-	if strings.Contains(r.Header.Get("Upgrade"), "websocket") {
-		// I've never been able demonstrate a vulnerability myself, but apparently
-		// WebSocket connections originating from browsers aren't subject to CORS
-		// restrictions, so we'll just be on the safe side
-		h.handleError(w, r, fmt.Errorf("websocket connections aren't allowed"))
-		return
-	}
-
-	if h.enforceHost {
-		// DNS rebinding mitigation
-		err := h.checkHost(r)
-		if err != nil {
-			h.handleError(w, r, err)
-			return
-		}
-	}
-
-	if h.enforceOrigin {
-		// cross-site mitigation
-		origin, err := h.checkOrigin(r)
-		if err != nil {
-			h.handleError(w, r, err)
-			return
-		}
-
-		if r.Method == http.MethodOptions {
-			w.Header().Set("Access-Control-Allow-Methods", "OPTIONS, GET, POST, PUT, PATCH, DELETE")
-			w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Content-Length, Cache-Control")
-			w.Header().Set("Access-Control-Allow-Credentials", "true")
-		}
-		w.Header().Set("Access-Control-Allow-Origin", origin)
-	}
-
-	// TODO: authentication & authorization, if configured
-
-	h.mux.ServeHTTP(w, r)
-}
-
-func (h adminHandler) handleError(w http.ResponseWriter, r *http.Request, err error) {
-	if err == nil {
-		return
-	}
-	if err == ErrInternalRedir {
-		h.serveHTTP(w, r)
-		return
-	}
-
-	apiErr, ok := err.(APIError)
-	if !ok {
-		apiErr = APIError{
-			Code: http.StatusInternalServerError,
-			Err:  err,
-		}
-	}
-	if apiErr.Code == 0 {
-		apiErr.Code = http.StatusInternalServerError
-	}
-	if apiErr.Message == "" && apiErr.Err != nil {
-		apiErr.Message = apiErr.Err.Error()
-	}
-
-	Log().Named("admin.api").Error("request error",
-		zap.Error(err),
-		zap.Int("status_code", apiErr.Code),
-	)
-
-	w.Header().Set("Content-Type", "application/json")
-	w.WriteHeader(apiErr.Code)
-	encErr := json.NewEncoder(w).Encode(apiErr)
-	if encErr != nil {
-		Log().Named("admin.api").Error("failed to encode error response", zap.Error(encErr))
-	}
-}
-
-// checkHost returns a handler that wraps next such that
-// it will only be called if the request's Host header matches
-// a trustworthy/expected value. This helps to mitigate DNS
-// rebinding attacks.
-func (h adminHandler) checkHost(r *http.Request) error {
-	var allowed bool
-	for _, allowedHost := range h.allowedOrigins {
-		if r.Host == allowedHost {
-			allowed = true
-			break
-		}
-	}
-	if !allowed {
-		return APIError{
-			Code: http.StatusForbidden,
-			Err:  fmt.Errorf("host not allowed: %s", r.Host),
-		}
-	}
-	return nil
-}
-
-// checkOrigin ensures that the Origin header, if
-// set, matches the intended target; prevents arbitrary
-// sites from issuing requests to our listener. It
-// returns the origin that was obtained from r.
-func (h adminHandler) checkOrigin(r *http.Request) (string, error) {
-	origin := h.getOriginHost(r)
-	if origin == "" {
-		return origin, APIError{
-			Code: http.StatusForbidden,
-			Err:  fmt.Errorf("missing required Origin header"),
-		}
-	}
-	if !h.originAllowed(origin) {
-		return origin, APIError{
-			Code: http.StatusForbidden,
-			Err:  fmt.Errorf("client is not allowed to access from origin %s", origin),
-		}
-	}
-	return origin, nil
-}
-
-func (h adminHandler) getOriginHost(r *http.Request) string {
-	origin := r.Header.Get("Origin")
-	if origin == "" {
-		origin = r.Header.Get("Referer")
-	}
-	originURL, err := url.Parse(origin)
-	if err == nil && originURL.Host != "" {
-		origin = originURL.Host
-	}
-	return origin
-}
-
-func (h adminHandler) originAllowed(origin string) bool {
-	for _, allowedOrigin := range h.allowedOrigins {
-		originCopy := origin
-		if !strings.Contains(allowedOrigin, "://") {
-			// no scheme specified, so allow both
-			originCopy = strings.TrimPrefix(originCopy, "http://")
-			originCopy = strings.TrimPrefix(originCopy, "https://")
-		}
-		if originCopy == allowedOrigin {
-			return true
-		}
-	}
-	return false
-}
-
-func handleConfig(w http.ResponseWriter, r *http.Request) error {
-	switch r.Method {
-	case http.MethodGet:
-		w.Header().Set("Content-Type", "application/json")
-
-		err := readConfig(r.URL.Path, w)
-		if err != nil {
-			return APIError{Code: http.StatusBadRequest, Err: err}
-		}
-
-		return nil
-
-	case http.MethodPost,
-		http.MethodPut,
-		http.MethodPatch,
-		http.MethodDelete:
-
-		// DELETE does not use a body, but the others do
-		var body []byte
-		if r.Method != http.MethodDelete {
-			if ct := r.Header.Get("Content-Type"); !strings.Contains(ct, "/json") {
-				return APIError{
-					Code: http.StatusBadRequest,
-					Err:  fmt.Errorf("unacceptable content-type: %v; 'application/json' required", ct),
-				}
-			}
-
-			buf := bufPool.Get().(*bytes.Buffer)
-			buf.Reset()
-			defer bufPool.Put(buf)
-
-			_, err := io.Copy(buf, r.Body)
-			if err != nil {
-				return APIError{
-					Code: http.StatusBadRequest,
-					Err:  fmt.Errorf("reading request body: %v", err),
-				}
-			}
-			body = buf.Bytes()
-		}
-
-		forceReload := r.Header.Get("Cache-Control") == "must-revalidate"
-
-		err := changeConfig(r.Method, r.URL.Path, body, forceReload)
-		if err != nil {
-			return err
-		}
-
-	default:
-		return APIError{
-			Code: http.StatusMethodNotAllowed,
-			Err:  fmt.Errorf("method %s not allowed", r.Method),
-		}
-	}
-
-	return nil
-}
-
-func handleConfigID(w http.ResponseWriter, r *http.Request) error {
-	idPath := r.URL.Path
-
-	parts := strings.Split(idPath, "/")
-	if len(parts) < 3 || parts[2] == "" {
-		return fmt.Errorf("request path is missing object ID")
-	}
-	if parts[0] != "" || parts[1] != "id" {
-		return fmt.Errorf("malformed object path")
-	}
-	id := parts[2]
-
-	// map the ID to the expanded path
-	currentCfgMu.RLock()
-	expanded, ok := rawCfgIndex[id]
-	defer currentCfgMu.RUnlock()
-	if !ok {
-		return fmt.Errorf("unknown object ID '%s'", id)
-	}
-
-	// piece the full URL path back together
-	parts = append([]string{expanded}, parts[3:]...)
-	r.URL.Path = path.Join(parts...)
-
-	return ErrInternalRedir
-}
-
-func handleStop(w http.ResponseWriter, r *http.Request) error {
-	err := handleUnload(w, r)
-	if err != nil {
-		Log().Named("admin.api").Error("unload error", zap.Error(err))
-	}
-	if adminServer != nil {
-		// use goroutine so that we can finish responding to API request
-		go func() {
-			err := stopAdminServer(adminServer)
-			var exitCode int
-			if err != nil {
-				exitCode = ExitCodeFailedQuit
-				Log().Named("admin.api").Error("failed to stop admin server gracefully", zap.Error(err))
-			}
-			Log().Named("admin.api").Info("stopping now, bye!! 👋")
-			os.Exit(exitCode)
-		}()
-	}
-	return nil
-}
-
-// handleUnload stops the current configuration that is running.
-// Note that doing this can also be accomplished with DELETE /config/
-// but we leave this function because handleStop uses it.
-func handleUnload(w http.ResponseWriter, r *http.Request) error {
-	if r.Method != http.MethodPost {
-		return APIError{
-			Code: http.StatusMethodNotAllowed,
-			Err:  fmt.Errorf("method not allowed"),
-		}
-	}
-	Log().Named("admin.api").Info("unloading")
-	if err := stopAndCleanup(); err != nil {
-		Log().Named("admin.api").Error("error unloading", zap.Error(err))
-	} else {
-		Log().Named("admin.api").Info("unloading completed")
-	}
-	return nil
-}
-
-// unsyncedConfigAccess traverses into the current config and performs
-// the operation at path according to method, using body and out as
-// needed. This is a low-level, unsynchronized function; most callers
-// will want to use changeConfig or readConfig instead. This requires a
-// read or write lock on currentCfgMu, depending on method (GET needs
-// only a read lock; all others need a write lock).
-func unsyncedConfigAccess(method, path string, body []byte, out io.Writer) error {
-	var err error
-	var val interface{}
-
-	// if there is a request body, decode it into the
-	// variable that will be set in the config according
-	// to method and path
-	if len(body) > 0 {
-		err = json.Unmarshal(body, &val)
-		if err != nil {
-			return fmt.Errorf("decoding request body: %v", err)
-		}
-	}
-
-	enc := json.NewEncoder(out)
-
-	cleanPath := strings.Trim(path, "/")
-	if cleanPath == "" {
-		return fmt.Errorf("no traversable path")
-	}
-
-	parts := strings.Split(cleanPath, "/")
-	if len(parts) == 0 {
-		return fmt.Errorf("path missing")
-	}
-
-	// A path that ends with "..." implies:
-	// 1) the part before it is an array
-	// 2) the payload is an array
-	// and means that the user wants to expand the elements
-	// in the payload array and append each one into the
-	// destination array, like so:
-	//     array = append(array, elems...)
-	// This special case is handled below.
-	ellipses := parts[len(parts)-1] == "..."
-	if ellipses {
-		parts = parts[:len(parts)-1]
-	}
-
-	var ptr interface{} = rawCfg
-
-traverseLoop:
-	for i, part := range parts {
-		switch v := ptr.(type) {
-		case map[string]interface{}:
-			// if the next part enters a slice, and the slice is our destination,
-			// handle it specially (because appending to the slice copies the slice
-			// header, which does not replace the original one like we want)
-			if arr, ok := v[part].([]interface{}); ok && i == len(parts)-2 {
-				var idx int
-				if method != http.MethodPost {
-					idxStr := parts[len(parts)-1]
-					idx, err = strconv.Atoi(idxStr)
-					if err != nil {
-						return fmt.Errorf("[%s] invalid array index '%s': %v",
-							path, idxStr, err)
-					}
-					if idx < 0 || idx >= len(arr) {
-						return fmt.Errorf("[%s] array index out of bounds: %s", path, idxStr)
-					}
-				}
-
-				switch method {
-				case http.MethodGet:
-					err = enc.Encode(arr[idx])
-					if err != nil {
-						return fmt.Errorf("encoding config: %v", err)
-					}
-				case http.MethodPost:
-					if ellipses {
-						valArray, ok := val.([]interface{})
-						if !ok {
-							return fmt.Errorf("final element is not an array")
-						}
-						v[part] = append(arr, valArray...)
-					} else {
-						v[part] = append(arr, val)
-					}
-				case http.MethodPut:
-					// avoid creation of new slice and a second copy (see
-					// https://github.com/golang/go/wiki/SliceTricks#insert)
-					arr = append(arr, nil)
-					copy(arr[idx+1:], arr[idx:])
-					arr[idx] = val
-					v[part] = arr
-				case http.MethodPatch:
-					arr[idx] = val
-				case http.MethodDelete:
-					v[part] = append(arr[:idx], arr[idx+1:]...)
-				default:
-					return fmt.Errorf("unrecognized method %s", method)
-				}
-				break traverseLoop
-			}
-
-			if i == len(parts)-1 {
-				switch method {
-				case http.MethodGet:
-					err = enc.Encode(v[part])
-					if err != nil {
-						return fmt.Errorf("encoding config: %v", err)
-					}
-				case http.MethodPost:
-					// if the part is an existing list, POST appends to
-					// it, otherwise it just sets or creates the value
-					if arr, ok := v[part].([]interface{}); ok {
-						if ellipses {
-							valArray, ok := val.([]interface{})
-							if !ok {
-								return fmt.Errorf("final element is not an array")
-							}
-							v[part] = append(arr, valArray...)
-						} else {
-							v[part] = append(arr, val)
-						}
-					} else {
-						v[part] = val
-					}
-				case http.MethodPut:
-					if _, ok := v[part]; ok {
-						return fmt.Errorf("[%s] key already exists: %s", path, part)
-					}
-					v[part] = val
-				case http.MethodPatch:
-					if _, ok := v[part]; !ok {
-						return fmt.Errorf("[%s] key does not exist: %s", path, part)
-					}
-					v[part] = val
-				case http.MethodDelete:
-					delete(v, part)
-				default:
-					return fmt.Errorf("unrecognized method %s", method)
-				}
-			} else {
-				// if we are "PUTting" a new resource, the key(s) in its path
-				// might not exist yet; that's OK but we need to make them as
-				// we go, while we still have a pointer from the level above
-				if v[part] == nil && method == http.MethodPut {
-					v[part] = make(map[string]interface{})
-				}
-				ptr = v[part]
-			}
-
-		case []interface{}:
-			partInt, err := strconv.Atoi(part)
-			if err != nil {
-				return fmt.Errorf("[/%s] invalid array index '%s': %v",
-					strings.Join(parts[:i+1], "/"), part, err)
-			}
-			if partInt < 0 || partInt >= len(v) {
-				return fmt.Errorf("[/%s] array index out of bounds: %s",
-					strings.Join(parts[:i+1], "/"), part)
-			}
-			ptr = v[partInt]
-
-		default:
-			return fmt.Errorf("invalid traversal path at: %s", strings.Join(parts[:i+1], "/"))
-		}
-	}
-
-	return nil
-}
-
-// RemoveMetaFields removes meta fields like "@id" from a JSON message
-// by using a simple regular expression. (An alternate way to do this
-// would be to delete them from the raw, map[string]interface{}
-// representation as they are indexed, then iterate the index we made
-// and add them back after encoding as JSON, but this is simpler.)
-func RemoveMetaFields(rawJSON []byte) []byte {
-	return idRegexp.ReplaceAllFunc(rawJSON, func(in []byte) []byte {
-		// matches with a comma on both sides (when "@id" property is
-		// not the first or last in the object) need to keep exactly
-		// one comma for correct JSON syntax
-		comma := []byte{','}
-		if bytes.HasPrefix(in, comma) && bytes.HasSuffix(in, comma) {
-			return comma
-		}
-		return []byte{}
-	})
-}
-
-// AdminHandler is like http.Handler except ServeHTTP may return an error.
-//
-// If any handler encounters an error, it should be returned for proper
-// handling.
-type AdminHandler interface {
-	ServeHTTP(http.ResponseWriter, *http.Request) error
-}
-
-// AdminHandlerFunc is a convenience type like http.HandlerFunc.
-type AdminHandlerFunc func(http.ResponseWriter, *http.Request) error
-
-// ServeHTTP implements the Handler interface.
-func (f AdminHandlerFunc) ServeHTTP(w http.ResponseWriter, r *http.Request) error {
-	return f(w, r)
-}
-
-// APIError is a structured error that every API
-// handler should return for consistency in logging
-// and client responses. If Message is unset, then
-// Err.Error() will be serialized in its place.
-type APIError struct {
-	Code    int    `json:"-"`
-	Err     error  `json:"-"`
-	Message string `json:"error"`
-}
-
-func (e APIError) Error() string {
-	if e.Err != nil {
-		return e.Err.Error()
-	}
-	return e.Message
-}
-
-var (
-	// DefaultAdminListen is the address for the admin
-	// listener, if none is specified at startup.
-	DefaultAdminListen = "localhost:2019"
-
-	// ErrInternalRedir indicates an internal redirect
-	// and is useful when admin API handlers rewrite
-	// the request; in that case, authentication and
-	// authorization needs to happen again for the
-	// rewritten request.
-	ErrInternalRedir = fmt.Errorf("internal redirect; re-authorization required")
-
-	// DefaultAdminConfig is the default configuration
-	// for the administration endpoint.
-	DefaultAdminConfig = &AdminConfig{
-		Listen: DefaultAdminListen,
-	}
-)
-
-// PIDFile writes a pidfile to the file at filename. It
-// will get deleted before the process gracefully exits.
-func PIDFile(filename string) error {
-	pid := []byte(strconv.Itoa(os.Getpid()) + "\n")
-	err := ioutil.WriteFile(filename, pid, 0600)
-	if err != nil {
-		return err
-	}
-	pidfile = filename
-	return nil
-}
-
-// idRegexp is used to match ID fields and their associated values
-// in the config. It also matches adjacent commas so that syntax
-// can be preserved no matter where in the object the field appears.
-// It supports string and most numeric values.
-var idRegexp = regexp.MustCompile(`(?m),?\s*"` + idKey + `"\s*:\s*(-?[0-9]+(\.[0-9]+)?|(?U)".*")\s*,?`)
-
-// pidfile is the name of the pidfile, if any.
-var pidfile string
-
-const (
-	rawConfigKey = "config"
-	idKey        = "@id"
-)
-
-var bufPool = sync.Pool{
-	New: func() interface{} {
-		return new(bytes.Buffer)
-	},
-}
-
-var adminServer *http.Server

admin_test.go

@@ -1,132 +0,0 @@
-// 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 caddy
-
-import (
-	"encoding/json"
-	"reflect"
-	"testing"
-)
-
-func TestUnsyncedConfigAccess(t *testing.T) {
-	// each test is performed in sequence, so
-	// each change builds on the previous ones;
-	// the config is not reset between tests
-	for i, tc := range []struct {
-		method    string
-		path      string // rawConfigKey will be prepended
-		payload   string
-		expect    string // JSON representation of what the whole config is expected to be after the request
-		shouldErr bool
-	}{
-		{
-			method:  "POST",
-			path:    "",
-			payload: `{"foo": "bar", "list": ["a", "b", "c"]}`, // starting value
-			expect:  `{"foo": "bar", "list": ["a", "b", "c"]}`,
-		},
-		{
-			method:  "POST",
-			path:    "/foo",
-			payload: `"jet"`,
-			expect:  `{"foo": "jet", "list": ["a", "b", "c"]}`,
-		},
-		{
-			method:  "POST",
-			path:    "/bar",
-			payload: `{"aa": "bb", "qq": "zz"}`,
-			expect:  `{"foo": "jet", "bar": {"aa": "bb", "qq": "zz"}, "list": ["a", "b", "c"]}`,
-		},
-		{
-			method: "DELETE",
-			path:   "/bar/qq",
-			expect: `{"foo": "jet", "bar": {"aa": "bb"}, "list": ["a", "b", "c"]}`,
-		},
-		{
-			method:  "POST",
-			path:    "/list",
-			payload: `"e"`,
-			expect:  `{"foo": "jet", "bar": {"aa": "bb"}, "list": ["a", "b", "c", "e"]}`,
-		},
-		{
-			method:  "PUT",
-			path:    "/list/3",
-			payload: `"d"`,
-			expect:  `{"foo": "jet", "bar": {"aa": "bb"}, "list": ["a", "b", "c", "d", "e"]}`,
-		},
-		{
-			method: "DELETE",
-			path:   "/list/3",
-			expect: `{"foo": "jet", "bar": {"aa": "bb"}, "list": ["a", "b", "c", "e"]}`,
-		},
-		{
-			method:  "PATCH",
-			path:    "/list/3",
-			payload: `"d"`,
-			expect:  `{"foo": "jet", "bar": {"aa": "bb"}, "list": ["a", "b", "c", "d"]}`,
-		},
-		{
-			method:  "POST",
-			path:    "/list/...",
-			payload: `["e", "f", "g"]`,
-			expect:  `{"foo": "jet", "bar": {"aa": "bb"}, "list": ["a", "b", "c", "d", "e", "f", "g"]}`,
-		},
-	} {
-		err := unsyncedConfigAccess(tc.method, rawConfigKey+tc.path, []byte(tc.payload), nil)
-
-		if tc.shouldErr && err == nil {
-			t.Fatalf("Test %d: Expected error return value, but got: %v", i, err)
-		}
-		if !tc.shouldErr && err != nil {
-			t.Fatalf("Test %d: Should not have had error return value, but got: %v", i, err)
-		}
-
-		// decode the expected config so we can do a convenient DeepEqual
-		var expectedDecoded interface{}
-		err = json.Unmarshal([]byte(tc.expect), &expectedDecoded)
-		if err != nil {
-			t.Fatalf("Test %d: Unmarshaling expected config: %v", i, err)
-		}
-
-		// make sure the resulting config is as we expect it
-		if !reflect.DeepEqual(rawCfg[rawConfigKey], expectedDecoded) {
-			t.Fatalf("Test %d:\nExpected:\n\t%#v\nActual:\n\t%#v",
-				i, expectedDecoded, rawCfg[rawConfigKey])
-		}
-	}
-}
-
-func BenchmarkLoad(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		cfg := []byte(`{
-			"apps": {
-				"http": {
-					"servers": {
-						"myserver": {
-							"listen": ["tcp/localhost:8080-8084"],
-							"read_timeout": "30s"
-						},
-						"yourserver": {
-							"listen": ["127.0.0.1:5000"],
-							"read_header_timeout": "15s"
-						}
-					}
-				}
-			}
-		}
-		`)
-		Load(cfg, true)
-	}
-}

appveyor.yml

@@ -0,0 +1,37 @@
+version: "{build}"
+
+hosts:
+  quic.clemente.io: 127.0.0.1
+
+os: Windows Server 2012 R2
+
+clone_folder: c:\gopath\src\github.com\mholt\caddy
+
+environment:
+  GOPATH: c:\gopath
+
+install:
+  - rmdir c:\go /s /q
+  - appveyor DownloadFile https://storage.googleapis.com/golang/go1.9.windows-amd64.zip
+  - 7z x go1.9.windows-amd64.zip -y -oC:\ > NUL
+  - set PATH=%GOPATH%\bin;%PATH%
+  - go version
+  - go env
+  - go get -t ./...
+  - go get github.com/golang/lint/golint
+  - go get github.com/FiloSottile/vendorcheck
+  # Install gometalinter
+  - go get github.com/alecthomas/gometalinter
+
+build: off
+
+test_script:
+  - gometalinter --install
+  - gometalinter --disable-all -E vet -E gofmt -E misspell -E ineffassign -E goimports -E deadcode --tests --vendor ./...
+  - vendorcheck ./...
+  - go test -race ./...
+
+after_test:
+  - golint ./...
+
+deploy: off

assets.go

@@ -0,0 +1,48 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// 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 caddy
+
+import (
+	"os"
+	"path/filepath"
+	"runtime"
+)
+
+// AssetsPath returns the path to the folder
+// where the application may store data. If
+// CADDYPATH env variable is set, that value
+// is used. Otherwise, the path is the result
+// of evaluating "$HOME/.caddy".
+func AssetsPath() string {
+	if caddyPath := os.Getenv("CADDYPATH"); caddyPath != "" {
+		return caddyPath
+	}
+	return filepath.Join(userHomeDir(), ".caddy")
+}
+
+// userHomeDir returns the user's home directory according to
+// environment variables.
+//
+// Credit: http://stackoverflow.com/a/7922977/1048862
+func userHomeDir() string {
+	if runtime.GOOS == "windows" {
+		home := os.Getenv("HOMEDRIVE") + os.Getenv("HOMEPATH")
+		if home == "" {
+			home = os.Getenv("USERPROFILE")
+		}
+		return home
+	}
+	return os.Getenv("HOME")
+}

assets_test.go

@@ -0,0 +1,39 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// 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 caddy
+
+import (
+	"os"
+	"strings"
+	"testing"
+)
+
+func TestAssetsPath(t *testing.T) {
+	if actual := AssetsPath(); !strings.HasSuffix(actual, ".caddy") {
+		t.Errorf("Expected path to be a .caddy folder, got: %v", actual)
+	}
+
+	err := os.Setenv("CADDYPATH", "testpath")
+	if err != nil {
+		t.Error("Could not set CADDYPATH")
+	}
+	if actual, expected := AssetsPath(), "testpath"; actual != expected {
+		t.Errorf("Expected path to be %v, got: %v", expected, actual)
+	}
+	err = os.Setenv("CADDYPATH", "")
+	if err != nil {
+		t.Error("Could not set CADDYPATH")
+	}
+}

caddy/build.go

@@ -0,0 +1,87 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// 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.
+
+// +build dev
+
+// build.go automates proper versioning of caddy binaries.
+// Use it like:   go run build.go
+// You can customize the build with the -goos, -goarch, and
+// -goarm CLI options:   go run build.go -goos=windows
+//
+// To get proper version information, this program must be
+// run from the directory of this file, and the source code
+// must be a working git repository, since it needs to know
+// if the source is in a clean state.
+//
+// This program is NOT required to build Caddy from source
+// since it is go-gettable. (You can run plain `go build`
+// in this directory to get a binary.) However, issues filed
+// without version information will likely be closed.
+package main
+
+import (
+	"flag"
+	"fmt"
+	"log"
+	"os"
+	"os/exec"
+	"path/filepath"
+
+	"github.com/caddyserver/builds"
+)
+
+var goos, goarch, goarm string
+
+func init() {
+	flag.StringVar(&goos, "goos", "", "GOOS for which to build")
+	flag.StringVar(&goarch, "goarch", "", "GOARCH for which to build")
+	flag.StringVar(&goarm, "goarm", "", "GOARM for which to build")
+}
+
+func main() {
+	flag.Parse()
+
+	gopath := os.Getenv("GOPATH")
+
+	pwd, err := os.Getwd()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	ldflags, err := builds.MakeLdFlags(filepath.Join(pwd, ".."))
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	args := []string{"build", "-ldflags", ldflags}
+	args = append(args, "-asmflags", fmt.Sprintf("-trimpath=%s", gopath))
+	args = append(args, "-gcflags", fmt.Sprintf("-trimpath=%s", gopath))
+	cmd := exec.Command("go", args...)
+	cmd.Stderr = os.Stderr
+	cmd.Stdout = os.Stdout
+	cmd.Env = os.Environ()
+	for _, env := range []string{
+		"CGO_ENABLED=0",
+		"GOOS=" + goos,
+		"GOARCH=" + goarch,
+		"GOARM=" + goarm,
+	} {
+		cmd.Env = append(cmd.Env, env)
+	}
+
+	err = cmd.Run()
+	if err != nil {
+		log.Fatal(err)
+	}
+}

caddy/caddymain/run.go

@@ -0,0 +1,294 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// 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 caddymain
+
+import (
+	"errors"
+	"flag"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"os"
+	"runtime"
+	"strconv"
+	"strings"
+
+	"gopkg.in/natefinch/lumberjack.v2"
+
+	"github.com/xenolf/lego/acme"
+
+	"github.com/mholt/caddy"
+	// plug in the HTTP server type
+	_ "github.com/mholt/caddy/caddyhttp"
+
+	"github.com/mholt/caddy/caddytls"
+	// This is where other plugins get plugged in (imported)
+)
+
+func init() {
+	caddy.TrapSignals()
+	setVersion()
+
+	flag.BoolVar(&caddytls.Agreed, "agree", false, "Agree to the CA's Subscriber Agreement")
+	flag.StringVar(&caddytls.DefaultCAUrl, "ca", "https://acme-v01.api.letsencrypt.org/directory", "URL to certificate authority's ACME server directory")
+	flag.BoolVar(&caddytls.DisableHTTPChallenge, "disable-http-challenge", caddytls.DisableHTTPChallenge, "Disable the ACME HTTP challenge")
+	flag.BoolVar(&caddytls.DisableTLSSNIChallenge, "disable-tls-sni-challenge", caddytls.DisableTLSSNIChallenge, "Disable the ACME TLS-SNI challenge")
+	flag.StringVar(&conf, "conf", "", "Caddyfile to load (default \""+caddy.DefaultConfigFile+"\")")
+	flag.StringVar(&cpu, "cpu", "100%", "CPU cap")
+	flag.BoolVar(&plugins, "plugins", false, "List installed plugins")
+	flag.StringVar(&caddytls.DefaultEmail, "email", "", "Default ACME CA account email address")
+	flag.DurationVar(&acme.HTTPClient.Timeout, "catimeout", acme.HTTPClient.Timeout, "Default ACME CA HTTP timeout")
+	flag.StringVar(&logfile, "log", "", "Process log file")
+	flag.StringVar(&caddy.PidFile, "pidfile", "", "Path to write pid file")
+	flag.BoolVar(&caddy.Quiet, "quiet", false, "Quiet mode (no initialization output)")
+	flag.StringVar(&revoke, "revoke", "", "Hostname for which to revoke the certificate")
+	flag.StringVar(&serverType, "type", "http", "Type of server to run")
+	flag.BoolVar(&version, "version", false, "Show version")
+	flag.BoolVar(&validate, "validate", false, "Parse the Caddyfile but do not start the server")
+
+	caddy.RegisterCaddyfileLoader("flag", caddy.LoaderFunc(confLoader))
+	caddy.SetDefaultCaddyfileLoader("default", caddy.LoaderFunc(defaultLoader))
+}
+
+// Run is Caddy's main() function.
+func Run() {
+	flag.Parse()
+
+	caddy.AppName = appName
+	caddy.AppVersion = appVersion
+	acme.UserAgent = appName + "/" + appVersion
+
+	// Set up process log before anything bad happens
+	switch logfile {
+	case "stdout":
+		log.SetOutput(os.Stdout)
+	case "stderr":
+		log.SetOutput(os.Stderr)
+	case "":
+		log.SetOutput(ioutil.Discard)
+	default:
+		log.SetOutput(&lumberjack.Logger{
+			Filename:   logfile,
+			MaxSize:    100,
+			MaxAge:     14,
+			MaxBackups: 10,
+		})
+	}
+
+	// Check for one-time actions
+	if revoke != "" {
+		err := caddytls.Revoke(revoke)
+		if err != nil {
+			mustLogFatalf("%v", err)
+		}
+		fmt.Printf("Revoked certificate for %s\n", revoke)
+		os.Exit(0)
+	}
+	if version {
+		fmt.Printf("%s %s (unofficial)\n", appName, appVersion)
+		if devBuild && gitShortStat != "" {
+			fmt.Printf("%s\n%s\n", gitShortStat, gitFilesModified)
+		}
+		os.Exit(0)
+	}
+	if plugins {
+		fmt.Println(caddy.DescribePlugins())
+		os.Exit(0)
+	}
+
+	// Set CPU cap
+	err := setCPU(cpu)
+	if err != nil {
+		mustLogFatalf("%v", err)
+	}
+
+	// Executes Startup events
+	caddy.EmitEvent(caddy.StartupEvent, nil)
+
+	// Get Caddyfile input
+	caddyfileinput, err := caddy.LoadCaddyfile(serverType)
+	if err != nil {
+		mustLogFatalf("%v", err)
+	}
+
+	if validate {
+		err := caddy.ValidateAndExecuteDirectives(caddyfileinput, nil, true)
+		if err != nil {
+			mustLogFatalf("%v", err)
+		}
+		msg := "Caddyfile is valid"
+		fmt.Println(msg)
+		log.Printf("[INFO] %s", msg)
+		os.Exit(0)
+	}
+
+	// Start your engines
+	instance, err := caddy.Start(caddyfileinput)
+	if err != nil {
+		mustLogFatalf("%v", err)
+	}
+
+	// Execute instantiation events
+	caddy.EmitEvent(caddy.InstanceStartupEvent, instance)
+
+	// Twiddle your thumbs
+	instance.Wait()
+}
+
+// mustLogFatalf wraps log.Fatalf() in a way that ensures the
+// output is always printed to stderr so the user can see it
+// if the user is still there, even if the process log was not
+// enabled. If this process is an upgrade, however, and the user
+// might not be there anymore, this just logs to the process
+// log and exits.
+func mustLogFatalf(format string, args ...interface{}) {
+	if !caddy.IsUpgrade() {
+		log.SetOutput(os.Stderr)
+	}
+	log.Fatalf(format, args...)
+}
+
+// confLoader loads the Caddyfile using the -conf flag.
+func confLoader(serverType string) (caddy.Input, error) {
+	if conf == "" {
+		return nil, nil
+	}
+
+	if conf == "stdin" {
+		return caddy.CaddyfileFromPipe(os.Stdin, serverType)
+	}
+
+	var contents []byte
+	if strings.Contains(conf, "*") {
+		// Let caddyfile.doImport logic handle the globbed path
+		contents = []byte("import " + conf)
+	} else {
+		var err error
+		contents, err = ioutil.ReadFile(conf)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return caddy.CaddyfileInput{
+		Contents:       contents,
+		Filepath:       conf,
+		ServerTypeName: serverType,
+	}, nil
+}
+
+// defaultLoader loads the Caddyfile from the current working directory.
+func defaultLoader(serverType string) (caddy.Input, error) {
+	contents, err := ioutil.ReadFile(caddy.DefaultConfigFile)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil, nil
+		}
+		return nil, err
+	}
+	return caddy.CaddyfileInput{
+		Contents:       contents,
+		Filepath:       caddy.DefaultConfigFile,
+		ServerTypeName: serverType,
+	}, nil
+}
+
+// setVersion figures out the version information
+// based on variables set by -ldflags.
+func setVersion() {
+	// A development build is one that's not at a tag or has uncommitted changes
+	devBuild = gitTag == "" || gitShortStat != ""
+
+	if buildDate != "" {
+		buildDate = " " + buildDate
+	}
+
+	// Only set the appVersion if -ldflags was used
+	if gitNearestTag != "" || gitTag != "" {
+		if devBuild && gitNearestTag != "" {
+			appVersion = fmt.Sprintf("%s (+%s%s)",
+				strings.TrimPrefix(gitNearestTag, "v"), gitCommit, buildDate)
+		} else if gitTag != "" {
+			appVersion = strings.TrimPrefix(gitTag, "v")
+		}
+	}
+}
+
+// setCPU parses string cpu and sets GOMAXPROCS
+// according to its value. It accepts either
+// a number (e.g. 3) or a percent (e.g. 50%).
+// If the percent resolves to less than a single
+// GOMAXPROCS, it rounds it up to GOMAXPROCS=1.
+func setCPU(cpu string) error {
+	var numCPU int
+
+	availCPU := runtime.NumCPU()
+
+	if strings.HasSuffix(cpu, "%") {
+		// Percent
+		var percent float32
+		pctStr := cpu[:len(cpu)-1]
+		pctInt, err := strconv.Atoi(pctStr)
+		if err != nil || pctInt < 1 || pctInt > 100 {
+			return errors.New("invalid CPU value: percentage must be between 1-100")
+		}
+		percent = float32(pctInt) / 100
+		numCPU = int(float32(availCPU) * percent)
+		if numCPU < 1 {
+			numCPU = 1
+		}
+	} else {
+		// Number
+		num, err := strconv.Atoi(cpu)
+		if err != nil || num < 1 {
+			return errors.New("invalid CPU value: provide a number or percent greater than 0")
+		}
+		numCPU = num
+	}
+
+	if numCPU > availCPU {
+		numCPU = availCPU
+	}
+
+	runtime.GOMAXPROCS(numCPU)
+	return nil
+}
+
+const appName = "Caddy"
+
+// Flags that control program flow or startup
+var (
+	serverType string
+	conf       string
+	cpu        string
+	logfile    string
+	revoke     string
+	version    bool
+	plugins    bool
+	validate   bool
+)
+
+// Build information obtained with the help of -ldflags
+var (
+	appVersion = "(untracked dev build)" // inferred at startup
+	devBuild   = true                    // inferred at startup
+
+	buildDate        string // date -u
+	gitTag           string // git describe --exact-match HEAD 2> /dev/null
+	gitNearestTag    string // git describe --abbrev=0 --tags HEAD
+	gitCommit        string // git rev-parse HEAD
+	gitShortStat     string // git diff-index --shortstat
+	gitFilesModified string // git diff-index --name-only HEAD
+)

caddy/caddymain/run_test.go

@@ -0,0 +1,59 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// 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 caddymain
+
+import (
+	"runtime"
+	"testing"
+)
+
+func TestSetCPU(t *testing.T) {
+	currentCPU := runtime.GOMAXPROCS(-1)
+	maxCPU := runtime.NumCPU()
+	halfCPU := int(0.5 * float32(maxCPU))
+	if halfCPU < 1 {
+		halfCPU = 1
+	}
+	for i, test := range []struct {
+		input     string
+		output    int
+		shouldErr bool
+	}{
+		{"1", 1, false},
+		{"-1", currentCPU, true},
+		{"0", currentCPU, true},
+		{"100%", maxCPU, false},
+		{"50%", halfCPU, false},
+		{"110%", currentCPU, true},
+		{"-10%", currentCPU, true},
+		{"invalid input", currentCPU, true},
+		{"invalid input%", currentCPU, true},
+		{"9999", maxCPU, false}, // over available CPU
+		{"1%", 1, false},        // under a single CPU; assume maxCPU < 100
+	} {
+		err := setCPU(test.input)
+		if test.shouldErr && err == nil {
+			t.Errorf("Test %d: Expected error, but there wasn't any", i)
+		}
+		if !test.shouldErr && err != nil {
+			t.Errorf("Test %d: Expected no error, but there was one: %v", i, err)
+		}
+		if actual, expected := runtime.GOMAXPROCS(-1), test.output; actual != expected {
+			t.Errorf("Test %d: GOMAXPROCS was %d but expected %d", i, actual, expected)
+		}
+		// teardown
+		runtime.GOMAXPROCS(currentCPU)
+	}
+}

caddy/main.go

@@ -1,4 +1,4 @@
-// Copyright 2015 Matthew Holt and The Caddy Authors
+// Copyright 2015 Light Code Labs, LLC
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -12,14 +12,17 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-// +build gofuzz
+// By moving the application's package main logic into
+// a package other than main, it becomes much easier to
+// wrap caddy for custom builds that are go-gettable.
+// https://caddy.community/t/my-wish-for-0-9-go-gettable-custom-builds/59?u=matt
 
-package caddy
+package main
 
-func FuzzReplacer(data []byte) (score int) {
-	NewReplacer().ReplaceAll(string(data), "")
-	NewReplacer().ReplaceAll(NewReplacer().ReplaceAll(string(data), ""), "")
-	NewReplacer().ReplaceAll(NewReplacer().ReplaceAll(string(data), ""), NewReplacer().ReplaceAll(string(data), ""))
-	NewReplacer().ReplaceAll(string(data[:len(data)/2]), string(data[len(data)/2:]))
-	return 0
+import "github.com/mholt/caddy/caddy/caddymain"
+
+var run = caddymain.Run // replaced for tests
+
+func main() {
+	run()
 }

caddy/main_test.go

@@ -0,0 +1,31 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// 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 main
+
+import "testing"
+
+// This works because it does not have the same signature as the
+// conventional "TestMain" function described in the testing package
+// godoc.
+func TestMain(t *testing.T) {
+	var ran bool
+	run = func() {
+		ran = true
+	}
+	main()
+	if !ran {
+		t.Error("Expected Run() to be called, but it wasn't")
+	}
+}

caddy_test.go

@@ -1,4 +1,4 @@
-// Copyright 2015 Matthew Holt and The Caddy Authors
+// Copyright 2015 Light Code Labs, LLC
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -15,60 +15,159 @@
 package caddy
 
 import (
+	"net"
+	"strconv"
 	"testing"
-	"time"
 )
 
-func TestParseDuration(t *testing.T) {
-	const day = 24 * time.Hour
-	for i, tc := range []struct {
-		input  string
-		expect time.Duration
-	}{
-		{
-			input:  "3h",
-			expect: 3 * time.Hour,
-		},
-		{
-			input:  "1d",
-			expect: day,
-		},
-		{
-			input:  "1d30m",
-			expect: day + 30*time.Minute,
-		},
-		{
-			input:  "1m2d",
-			expect: time.Minute + day*2,
-		},
-		{
-			input:  "1m2d30s",
-			expect: time.Minute + day*2 + 30*time.Second,
-		},
-		{
-			input:  "1d2d",
-			expect: 3 * day,
-		},
-		{
-			input:  "1.5d",
-			expect: time.Duration(1.5 * float64(day)),
-		},
-		{
-			input:  "4m1.25d",
-			expect: 4*time.Minute + time.Duration(1.25*float64(day)),
-		},
-		{
-			input:  "-1.25d12h",
-			expect: time.Duration(-1.25*float64(day)) - 12*time.Hour,
-		},
-	} {
-		actual, err := ParseDuration(tc.input)
+/*
+// TODO
+func TestCaddyStartStop(t *testing.T) {
+	caddyfile := "localhost:1984"
+
+	for i := 0; i < 2; i++ {
+		_, err := Start(CaddyfileInput{Contents: []byte(caddyfile)})
 		if err != nil {
-			t.Errorf("Test %d ('%s'): Got error: %v", i, tc.input, err)
-			continue
+			t.Fatalf("Error starting, iteration %d: %v", i, err)
 		}
-		if actual != tc.expect {
-			t.Errorf("Test %d ('%s'): Expected=%s Actual=%s", i, tc.input, tc.expect, actual)
+
+		client := http.Client{
+			Timeout: time.Duration(2 * time.Second),
+		}
+		resp, err := client.Get("http://localhost:1984")
+		if err != nil {
+			t.Fatalf("Expected GET request to succeed (iteration %d), but it failed: %v", i, err)
+		}
+		resp.Body.Close()
+
+		err = Stop()
+		if err != nil {
+			t.Fatalf("Error stopping, iteration %d: %v", i, err)
+		}
+	}
+}
+*/
+
+func TestIsLoopback(t *testing.T) {
+	for i, test := range []struct {
+		input  string
+		expect bool
+	}{
+		{"example.com", false},
+		{"localhost", true},
+		{"localhost:1234", true},
+		{"localhost:", true},
+		{"127.0.0.1", true},
+		{"127.0.0.1:443", true},
+		{"127.0.1.5", true},
+		{"10.0.0.5", false},
+		{"12.7.0.1", false},
+		{"[::1]", true},
+		{"[::1]:1234", true},
+		{"::1", true},
+		{"::", false},
+		{"[::]", false},
+		{"local", false},
+	} {
+		if got, want := IsLoopback(test.input), test.expect; got != want {
+			t.Errorf("Test %d (%s): expected %v but was %v", i, test.input, want, got)
+		}
+	}
+}
+
+func TestIsInternal(t *testing.T) {
+	for i, test := range []struct {
+		input  string
+		expect bool
+	}{
+		{"9.255.255.255", false},
+		{"10.0.0.0", true},
+		{"10.0.0.1", true},
+		{"10.255.255.254", true},
+		{"10.255.255.255", true},
+		{"11.0.0.0", false},
+		{"10.0.0.5:1234", true},
+		{"11.0.0.5:1234", false},
+
+		{"172.15.255.255", false},
+		{"172.16.0.0", true},
+		{"172.16.0.1", true},
+		{"172.31.255.254", true},
+		{"172.31.255.255", true},
+		{"172.32.0.0", false},
+		{"172.16.0.1:1234", true},
+
+		{"192.167.255.255", false},
+		{"192.168.0.0", true},
+		{"192.168.0.1", true},
+		{"192.168.255.254", true},
+		{"192.168.255.255", true},
+		{"192.169.0.0", false},
+		{"192.168.0.1:1234", true},
+
+		{"fbff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", false},
+		{"fc00::", true},
+		{"fc00::1", true},
+		{"[fc00::1]", true},
+		{"[fc00::1]:8888", true},
+		{"fdff:ffff:ffff:ffff:ffff:ffff:ffff:fffe", true},
+		{"fdff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", true},
+		{"fe00::", false},
+		{"fd12:3456:789a:1::1:1234", true},
+
+		{"example.com", false},
+		{"localhost", false},
+		{"localhost:1234", false},
+		{"localhost:", false},
+		{"127.0.0.1", false},
+		{"127.0.0.1:443", false},
+		{"127.0.1.5", false},
+		{"12.7.0.1", false},
+		{"[::1]", false},
+		{"[::1]:1234", false},
+		{"::1", false},
+		{"::", false},
+		{"[::]", false},
+		{"local", false},
+	} {
+		if got, want := IsInternal(test.input), test.expect; got != want {
+			t.Errorf("Test %d (%s): expected %v but was %v", i, test.input, want, got)
+		}
+	}
+}
+
+func TestListenerAddrEqual(t *testing.T) {
+	ln1, err := net.Listen("tcp", "[::]:0")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer ln1.Close()
+	ln1port := strconv.Itoa(ln1.Addr().(*net.TCPAddr).Port)
+
+	ln2, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer ln2.Close()
+	ln2port := strconv.Itoa(ln2.Addr().(*net.TCPAddr).Port)
+
+	for i, test := range []struct {
+		ln     net.Listener
+		addr   string
+		expect bool
+	}{
+		{ln1, ":" + ln2port, false},
+		{ln1, "0.0.0.0:" + ln2port, false},
+		{ln1, "0.0.0.0", false},
+		{ln1, ":" + ln1port, true},
+		{ln1, "0.0.0.0:" + ln1port, true},
+		{ln2, ":" + ln2port, false},
+		{ln2, "127.0.0.1:" + ln1port, false},
+		{ln2, "127.0.0.1", false},
+		{ln2, "127.0.0.1:" + ln2port, true},
+	} {
+		if got, want := listenerAddrEqual(test.ln, test.addr), test.expect; got != want {
+			t.Errorf("Test %d (%s == %s): expected %v but was %v", i, test.addr, test.ln.Addr().String(), want, got)
 		}
 	}
 }

caddyconfig/caddyfile/adapter.go

@@ -1,91 +0,0 @@
-// 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 caddyfile
-
-import (
-	"encoding/json"
-	"fmt"
-
-	"github.com/caddyserver/caddy/v2"
-	"github.com/caddyserver/caddy/v2/caddyconfig"
-)
-
-// Adapter adapts Caddyfile to Caddy JSON.
-type Adapter struct {
-	ServerType ServerType
-}
-
-// Adapt converts the Caddyfile config in body to Caddy JSON.
-func (a Adapter) Adapt(body []byte, options map[string]interface{}) ([]byte, []caddyconfig.Warning, error) {
-	if a.ServerType == nil {
-		return nil, nil, fmt.Errorf("no server type")
-	}
-	if options == nil {
-		options = make(map[string]interface{})
-	}
-
-	filename, _ := options["filename"].(string)
-	if filename == "" {
-		filename = "Caddyfile"
-	}
-
-	serverBlocks, err := Parse(filename, body)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	cfg, warnings, err := a.ServerType.Setup(serverBlocks, options)
-	if err != nil {
-		return nil, warnings, err
-	}
-
-	marshalFunc := json.Marshal
-	if options["pretty"] == "true" {
-		marshalFunc = caddyconfig.JSONIndent
-	}
-	result, err := marshalFunc(cfg)
-
-	return result, warnings, err
-}
-
-// Unmarshaler is a type that can unmarshal
-// Caddyfile tokens to set itself up for a
-// JSON encoding. The goal of an unmarshaler
-// is not to set itself up for actual use,
-// but to set itself up for being marshaled
-// into JSON. Caddyfile-unmarshaled values
-// will not be used directly; they will be
-// encoded as JSON and then used from that.
-// Implementations must be able to support
-// multiple segments (instances of their
-// directive or batch of tokens); typically
-// this means wrapping all token logic in
-// a loop: `for d.Next() { ... }`.
-type Unmarshaler interface {
-	UnmarshalCaddyfile(d *Dispenser) error
-}
-
-// ServerType is a type that can evaluate a Caddyfile and set up a caddy config.
-type ServerType interface {
-	// Setup takes the server blocks which
-	// contain tokens, as well as options
-	// (e.g. CLI flags) and creates a Caddy
-	// config, along with any warnings or
-	// an error.
-	Setup([]ServerBlock, map[string]interface{}) (*caddy.Config, []caddyconfig.Warning, error)
-}
-
-// Interface guard
-var _ caddyconfig.Adapter = (*Adapter)(nil)

caddyconfig/caddyfile/dispenser.go

@@ -1,396 +0,0 @@
-// 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 caddyfile
-
-import (
-	"errors"
-	"fmt"
-	"io"
-	"log"
-	"strings"
-)
-
-// Dispenser is a type that dispenses tokens, similarly to a lexer,
-// except that it can do so with some notion of structure. An empty
-// Dispenser is invalid; call NewDispenser to make a proper instance.
-type Dispenser struct {
-	tokens  []Token
-	cursor  int
-	nesting int
-}
-
-// NewDispenser returns a Dispenser filled with the given tokens.
-func NewDispenser(tokens []Token) *Dispenser {
-	return &Dispenser{
-		tokens: tokens,
-		cursor: -1,
-	}
-}
-
-// NewTestDispenser parses input into tokens and creates a new
-// Dispenser for test purposes only; any errors are fatal.
-func NewTestDispenser(input string) *Dispenser {
-	tokens, err := allTokens("Testfile", []byte(input))
-	if err != nil && err != io.EOF {
-		log.Fatalf("getting all tokens from input: %v", err)
-	}
-	return NewDispenser(tokens)
-}
-
-// Next loads the next token. Returns true if a token
-// was loaded; false otherwise. If false, all tokens
-// have been consumed.
-func (d *Dispenser) Next() bool {
-	if d.cursor < len(d.tokens)-1 {
-		d.cursor++
-		return true
-	}
-	return false
-}
-
-// Prev moves to the previous token. It does the inverse
-// of Next(), except this function may decrement the cursor
-// to -1 so that the next call to Next() points to the
-// first token; this allows dispensing to "start over". This
-// method returns true if the cursor ends up pointing to a
-// valid token.
-func (d *Dispenser) Prev() bool {
-	if d.cursor > -1 {
-		d.cursor--
-		return d.cursor > -1
-	}
-	return false
-}
-
-// NextArg loads the next token if it is on the same
-// line and if it is not a block opening (open curly
-// brace). Returns true if an argument token was
-// loaded; false otherwise. If false, all tokens on
-// the line have been consumed except for potentially
-// a block opening. It handles imported tokens
-// correctly.
-func (d *Dispenser) NextArg() bool {
-	if !d.nextOnSameLine() {
-		return false
-	}
-	if d.Val() == "{" {
-		// roll back; a block opening is not an argument
-		d.cursor--
-		return false
-	}
-	return true
-}
-
-// nextOnSameLine advances the cursor if the next
-// token is on the same line of the same file.
-func (d *Dispenser) nextOnSameLine() bool {
-	if d.cursor < 0 {
-		d.cursor++
-		return true
-	}
-	if d.cursor >= len(d.tokens) {
-		return false
-	}
-	if d.cursor < len(d.tokens)-1 &&
-		d.tokens[d.cursor].File == d.tokens[d.cursor+1].File &&
-		d.tokens[d.cursor].Line+d.numLineBreaks(d.cursor) == d.tokens[d.cursor+1].Line {
-		d.cursor++
-		return true
-	}
-	return false
-}
-
-// NextLine loads the next token only if it is not on the same
-// line as the current token, and returns true if a token was
-// loaded; false otherwise. If false, there is not another token
-// or it is on the same line. It handles imported tokens correctly.
-func (d *Dispenser) NextLine() bool {
-	if d.cursor < 0 {
-		d.cursor++
-		return true
-	}
-	if d.cursor >= len(d.tokens) {
-		return false
-	}
-	if d.cursor < len(d.tokens)-1 &&
-		(d.tokens[d.cursor].File != d.tokens[d.cursor+1].File ||
-			d.tokens[d.cursor].Line+d.numLineBreaks(d.cursor) < d.tokens[d.cursor+1].Line) {
-		d.cursor++
-		return true
-	}
-	return false
-}
-
-// NextBlock can be used as the condition of a for loop
-// to load the next token as long as it opens a block or
-// is already in a block nested more than initialNestingLevel.
-// In other words, a loop over NextBlock() will iterate
-// all tokens in the block assuming the next token is an
-// open curly brace, until the matching closing brace.
-// The open and closing brace tokens for the outer-most
-// block will be consumed internally and omitted from
-// the iteration.
-//
-// Proper use of this method looks like this:
-//
-//     for nesting := d.Nesting(); d.NextBlock(nesting); {
-//     }
-//
-// However, in simple cases where it is known that the
-// Dispenser is new and has not already traversed state
-// by a loop over NextBlock(), this will do:
-//
-//     for d.NextBlock(0) {
-//     }
-//
-// As with other token parsing logic, a loop over
-// NextBlock() should be contained within a loop over
-// Next(), as it is usually prudent to skip the initial
-// token.
-func (d *Dispenser) NextBlock(initialNestingLevel int) bool {
-	if d.nesting > initialNestingLevel {
-		if !d.Next() {
-			return false // should be EOF error
-		}
-		if d.Val() == "}" && !d.nextOnSameLine() {
-			d.nesting--
-		} else if d.Val() == "{" && !d.nextOnSameLine() {
-			d.nesting++
-		}
-		return d.nesting > initialNestingLevel
-	}
-	if !d.nextOnSameLine() { // block must open on same line
-		return false
-	}
-	if d.Val() != "{" {
-		d.cursor-- // roll back if not opening brace
-		return false
-	}
-	d.Next() // consume open curly brace
-	if d.Val() == "}" {
-		return false // open and then closed right away
-	}
-	d.nesting++
-	return true
-}
-
-// Nesting returns the current nesting level. Necessary
-// if using NextBlock()
-func (d *Dispenser) Nesting() int {
-	return d.nesting
-}
-
-// Val gets the text of the current token. If there is no token
-// loaded, it returns empty string.
-func (d *Dispenser) Val() string {
-	if d.cursor < 0 || d.cursor >= len(d.tokens) {
-		return ""
-	}
-	return d.tokens[d.cursor].Text
-}
-
-// Line gets the line number of the current token.
-// If there is no token loaded, it returns 0.
-func (d *Dispenser) Line() int {
-	if d.cursor < 0 || d.cursor >= len(d.tokens) {
-		return 0
-	}
-	return d.tokens[d.cursor].Line
-}
-
-// File gets the filename where the current token originated.
-func (d *Dispenser) File() string {
-	if d.cursor < 0 || d.cursor >= len(d.tokens) {
-		return ""
-	}
-	return d.tokens[d.cursor].File
-}
-
-// Args is a convenience function that loads the next arguments
-// (tokens on the same line) into an arbitrary number of strings
-// pointed to in targets. If there are not enough argument tokens
-// available to fill targets, false is returned and the remaining
-// targets are left unchanged. If all the targets are filled,
-// then true is returned.
-func (d *Dispenser) Args(targets ...*string) bool {
-	for i := 0; i < len(targets); i++ {
-		if !d.NextArg() {
-			return false
-		}
-		*targets[i] = d.Val()
-	}
-	return true
-}
-
-// AllArgs is like Args, but if there are more argument tokens
-// available than there are targets, false is returned. The
-// number of available argument tokens must match the number of
-// targets exactly to return true.
-func (d *Dispenser) AllArgs(targets ...*string) bool {
-	if !d.Args(targets...) {
-		return false
-	}
-	if d.NextArg() {
-		d.Prev()
-		return false
-	}
-	return true
-}
-
-// RemainingArgs loads any more arguments (tokens on the same line)
-// into a slice and returns them. Open curly brace tokens also indicate
-// the end of arguments, and the curly brace is not included in
-// the return value nor is it loaded.
-func (d *Dispenser) RemainingArgs() []string {
-	var args []string
-	for d.NextArg() {
-		args = append(args, d.Val())
-	}
-	return args
-}
-
-// NewFromNextSegment returns a new dispenser with a copy of
-// the tokens from the current token until the end of the
-// "directive" whether that be to the end of the line or
-// the end of a block that starts at the end of the line;
-// in other words, until the end of the segment.
-func (d *Dispenser) NewFromNextSegment() *Dispenser {
-	return NewDispenser(d.NextSegment())
-}
-
-// NextSegment returns a copy of the tokens from the current
-// token until the end of the line or block that starts at
-// the end of the line.
-func (d *Dispenser) NextSegment() Segment {
-	tkns := Segment{d.Token()}
-	for d.NextArg() {
-		tkns = append(tkns, d.Token())
-	}
-	var openedBlock bool
-	for nesting := d.Nesting(); d.NextBlock(nesting); {
-		if !openedBlock {
-			// because NextBlock() consumes the initial open
-			// curly brace, we rewind here to append it, since
-			// our case is special in that we want the new
-			// dispenser to have all the tokens including
-			// surrounding curly braces
-			d.Prev()
-			tkns = append(tkns, d.Token())
-			d.Next()
-			openedBlock = true
-		}
-		tkns = append(tkns, d.Token())
-	}
-	if openedBlock {
-		// include closing brace
-		tkns = append(tkns, d.Token())
-
-		// do not consume the closing curly brace; the
-		// next iteration of the enclosing loop will
-		// call Next() and consume it
-	}
-	return tkns
-}
-
-// Token returns the current token.
-func (d *Dispenser) Token() Token {
-	if d.cursor < 0 || d.cursor >= len(d.tokens) {
-		return Token{}
-	}
-	return d.tokens[d.cursor]
-}
-
-// Reset sets d's cursor to the beginning, as
-// if this was a new and unused dispenser.
-func (d *Dispenser) Reset() {
-	d.cursor = -1
-	d.nesting = 0
-}
-
-// ArgErr returns an argument error, meaning that another
-// argument was expected but not found. In other words,
-// a line break or open curly brace was encountered instead of
-// an argument.
-func (d *Dispenser) ArgErr() error {
-	if d.Val() == "{" {
-		return d.Err("Unexpected token '{', expecting argument")
-	}
-	return d.Errf("Wrong argument count or unexpected line ending after '%s'", d.Val())
-}
-
-// SyntaxErr creates a generic syntax error which explains what was
-// found and what was expected.
-func (d *Dispenser) SyntaxErr(expected string) error {
-	msg := fmt.Sprintf("%s:%d - Syntax error: Unexpected token '%s', expecting '%s'", d.File(), d.Line(), d.Val(), expected)
-	return errors.New(msg)
-}
-
-// EOFErr returns an error indicating that the dispenser reached
-// the end of the input when searching for the next token.
-func (d *Dispenser) EOFErr() error {
-	return d.Errf("Unexpected EOF")
-}
-
-// Err generates a custom parse-time error with a message of msg.
-func (d *Dispenser) Err(msg string) error {
-	msg = fmt.Sprintf("%s:%d - Error during parsing: %s", d.File(), d.Line(), msg)
-	return errors.New(msg)
-}
-
-// Errf is like Err, but for formatted error messages
-func (d *Dispenser) Errf(format string, args ...interface{}) error {
-	return d.Err(fmt.Sprintf(format, args...))
-}
-
-// Delete deletes the current token and returns the updated slice
-// of tokens. The cursor is not advanced to the next token.
-// Because deletion modifies the underlying slice, this method
-// should only be called if you have access to the original slice
-// of tokens and/or are using the slice of tokens outside this
-// Dispenser instance. If you do not re-assign the slice with the
-// return value of this method, inconsistencies in the token
-// array will become apparent (or worse, hide from you like they
-// did me for 3 and a half freaking hours late one night).
-func (d *Dispenser) Delete() []Token {
-	if d.cursor >= 0 && d.cursor <= len(d.tokens)-1 {
-		d.tokens = append(d.tokens[:d.cursor], d.tokens[d.cursor+1:]...)
-		d.cursor--
-	}
-	return d.tokens
-}
-
-// numLineBreaks counts how many line breaks are in the token
-// value given by the token index tknIdx. It returns 0 if the
-// token does not exist or there are no line breaks.
-func (d *Dispenser) numLineBreaks(tknIdx int) int {
-	if tknIdx < 0 || tknIdx >= len(d.tokens) {
-		return 0
-	}
-	return strings.Count(d.tokens[tknIdx].Text, "\n")
-}
-
-// isNewLine determines whether the current token is on a different
-// line (higher line number) than the previous token. It handles imported
-// tokens correctly. If there isn't a previous token, it returns true.
-func (d *Dispenser) isNewLine() bool {
-	if d.cursor < 1 {
-		return true
-	}
-	if d.cursor > len(d.tokens)-1 {
-		return false
-	}
-	return d.tokens[d.cursor-1].File != d.tokens[d.cursor].File ||
-		d.tokens[d.cursor-1].Line+d.numLineBreaks(d.cursor-1) < d.tokens[d.cursor].Line
-}

caddyconfig/caddyfile/formatter.go

@@ -1,213 +0,0 @@
-// 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 caddyfile
-
-import (
-	"bytes"
-	"io"
-	"unicode"
-)
-
-// Format formats the input Caddyfile to a standard, nice-looking
-// appearance. It works by reading each rune of the input and taking
-// control over all the bracing and whitespace that is written; otherwise,
-// words, comments, placeholders, and escaped characters are all treated
-// literally and written as they appear in the input.
-func Format(input []byte) []byte {
-	input = bytes.TrimSpace(input)
-
-	out := new(bytes.Buffer)
-	rdr := bytes.NewReader(input)
-
-	var (
-		last rune // the last character that was written to the result
-
-		space           = true // whether current/previous character was whitespace (beginning of input counts as space)
-		beginningOfLine = true // whether we are at beginning of line
-
-		openBrace        bool // whether current word/token is or started with open curly brace
-		openBraceWritten bool // if openBrace, whether that brace was written or not
-		openBraceSpace   bool // whether there was a non-newline space before open brace
-
-		newLines int // count of newlines consumed
-
-		comment bool // whether we're in a comment
-		quoted  bool // whether we're in a quoted segment
-		escaped bool // whether current char is escaped
-
-		nesting int // indentation level
-	)
-
-	write := func(ch rune) {
-		out.WriteRune(ch)
-		last = ch
-	}
-
-	indent := func() {
-		for tabs := nesting; tabs > 0; tabs-- {
-			write('\t')
-		}
-	}
-
-	nextLine := func() {
-		write('\n')
-		beginningOfLine = true
-	}
-
-	for {
-		ch, _, err := rdr.ReadRune()
-		if err != nil {
-			if err == io.EOF {
-				break
-			}
-			panic(err)
-		}
-
-		if comment {
-			if ch == '\n' {
-				comment = false
-			} else {
-				write(ch)
-				continue
-			}
-		}
-
-		if !escaped && ch == '\\' {
-			if space {
-				write(' ')
-				space = false
-			}
-			write(ch)
-			escaped = true
-			continue
-		}
-
-		if escaped {
-			write(ch)
-			escaped = false
-			continue
-		}
-
-		if quoted {
-			if ch == '"' {
-				quoted = false
-			}
-			write(ch)
-			continue
-		}
-
-		if space && ch == '"' {
-			quoted = true
-		}
-
-		if unicode.IsSpace(ch) {
-			space = true
-			if ch == '\n' {
-				newLines++
-			}
-			continue
-		}
-		spacePrior := space
-		space = false
-
-		//////////////////////////////////////////////////////////
-		// I find it helpful to think of the formatting loop in two
-		// main sections; by the time we reach this point, we
-		// know we are in a "regular" part of the file: we know
-		// the character is not a space, not in a literal segment
-		// like a comment or quoted, it's not escaped, etc.
-		//////////////////////////////////////////////////////////
-
-		if ch == '#' {
-			comment = true
-		}
-
-		if openBrace && spacePrior && !openBraceWritten {
-			if nesting == 0 && last == '}' {
-				nextLine()
-				nextLine()
-			}
-
-			openBrace = false
-			if beginningOfLine {
-				indent()
-			} else if !openBraceSpace {
-				write(' ')
-			}
-			write('{')
-			openBraceWritten = true
-			nextLine()
-			newLines = 0
-			nesting++
-		}
-
-		switch {
-		case ch == '{':
-			openBrace = true
-			openBraceWritten = false
-			openBraceSpace = spacePrior && !beginningOfLine
-			if openBraceSpace {
-				write(' ')
-			}
-			continue
-
-		case ch == '}' && (spacePrior || !openBrace):
-			if last != '\n' {
-				nextLine()
-			}
-			if nesting > 0 {
-				nesting--
-			}
-			indent()
-			write('}')
-			newLines = 0
-			continue
-		}
-
-		if newLines > 2 {
-			newLines = 2
-		}
-		for i := 0; i < newLines; i++ {
-			nextLine()
-		}
-		newLines = 0
-		if beginningOfLine {
-			indent()
-		}
-		if nesting == 0 && last == '}' && beginningOfLine {
-			nextLine()
-			nextLine()
-		}
-
-		if !beginningOfLine && spacePrior {
-			write(' ')
-		}
-
-		if openBrace && !openBraceWritten {
-			write('{')
-			openBraceWritten = true
-		}
-		write(ch)
-
-		beginningOfLine = false
-	}
-
-	// the Caddyfile does not need any leading or trailing spaces, but...
-	trimmedResult := bytes.TrimSpace(out.Bytes())
-
-	// ...Caddyfiles should, however, end with a newline because
-	// newlines are significant to the syntax of the file
-	return append(trimmedResult, '\n')
-}

caddyconfig/caddyfile/formatter_test.go

@@ -1,327 +0,0 @@
-// 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 caddyfile
-
-import (
-	"strings"
-	"testing"
-)
-
-func TestFormatter(t *testing.T) {
-	for i, tc := range []struct {
-		description string
-		input       string
-		expect      string
-	}{
-		{
-			description: "very simple",
-			input: `abc   def
-	g hi jkl
-mn`,
-			expect: `abc def
-g hi jkl
-mn`,
-		},
-		{
-			description: "basic indentation, line breaks, and nesting",
-			input: `  a
-b
-
-	c {
-		d
-}
-
-e { f
-}
-
-
-
-g {
-h {
-i
-}
-}
-
-j { k {
-l
-}
-}
-
-m {
-	n { o
-	}
-	p { q r
-s }
-}
-
-	{
-{ t
-		u
-
-	v
-
-w
-}
-}`,
-			expect: `a
-b
-
-c {
-	d
-}
-
-e {
-	f
-}
-
-g {
-	h {
-		i
-	}
-}
-
-j {
-	k {
-		l
-	}
-}
-
-m {
-	n {
-		o
-	}
-	p {
-		q r
-		s
-	}
-}
-
-{
-	{
-		t
-		u
-
-		v
-
-		w
-	}
-}`,
-		},
-		{
-			description: "block spacing",
-			input: `a{
-	b
-}
-
-c{ d
-}`,
-			expect: `a {
-	b
-}
-
-c {
-	d
-}`,
-		},
-		{
-			description: "advanced spacing",
-			input: `abc {
-	def
-}ghi{
-	jkl mno
-pqr}`,
-			expect: `abc {
-	def
-}
-
-ghi {
-	jkl mno
-	pqr
-}`,
-		},
-		{
-			description: "env var placeholders",
-			input: `{$A}
-
-b {
-{$C}
-}
-
-d { {$E}
-}
-
-{ {$F}
-}
-`,
-			expect: `{$A}
-
-b {
-	{$C}
-}
-
-d {
-	{$E}
-}
-
-{
-	{$F}
-}`,
-		},
-		{
-			description: "comments",
-			input: `#a "\n"
-
- #b {
-	c
-}
-
-d {
-e#f
-# g
-}
-
-h { # i
-}`,
-			expect: `#a "\n"
-
-#b {
-c
-}
-
-d {
-	e#f
-	# g
-}
-
-h {
-	# i
-}`,
-		},
-		{
-			description: "quotes and escaping",
-			input: `"a \"b\" "#c
-	d
-
-e {
-"f"
-}
-
-g { "h"
-}
-
-i {
-	"foo
-bar"
-}
-
-j {
-"\"k\" l m"
-}`,
-			expect: `"a \"b\" "#c
-d
-
-e {
-	"f"
-}
-
-g {
-	"h"
-}
-
-i {
-	"foo
-bar"
-}
-
-j {
-	"\"k\" l m"
-}`,
-		},
-		{
-			description: "bad nesting (too many open)",
-			input: `a
-{
-	{
-}`,
-			expect: `a {
-	{
-	}
-`,
-		},
-		{
-			description: "bad nesting (too many close)",
-			input: `a
-{
-	{
-}}}`,
-			expect: `a {
-	{
-	}
-}
-}
-`,
-		},
-		{
-			description: "json",
-			input: `foo
-bar      "{\"key\":34}"
-`,
-			expect: `foo
-bar "{\"key\":34}"`,
-		},
-		{
-			description: "escaping after spaces",
-			input:       `foo \"literal\"`,
-			expect:      `foo \"literal\"`,
-		},
-		{
-			description: "simple placeholders as standalone tokens",
-			input:       `foo {bar}`,
-			expect:      `foo {bar}`,
-		},
-		{
-			description: "simple placeholders within tokens",
-			input:       `foo{bar} foo{bar}baz`,
-			expect:      `foo{bar} foo{bar}baz`,
-		},
-		{
-			description: "placeholders and malformed braces",
-			input:       `foo{bar} foo{ bar}baz`,
-			expect: `foo{bar} foo {
-	bar
-}
-
-baz`,
-		},
-		{
-			description: "hash within string is not a comment",
-			input:       `redir / /some/#/path`,
-			expect:      `redir / /some/#/path`,
-		},
-	} {
-		// the formatter should output a trailing newline,
-		// even if the tests aren't written to expect that
-		if !strings.HasSuffix(tc.expect, "\n") {
-			tc.expect += "\n"
-		}
-
-		actual := Format([]byte(tc.input))
-
-		if string(actual) != tc.expect {
-			t.Errorf("\n[TEST %d: %s]\n====== EXPECTED ======\n%s\n====== ACTUAL ======\n%s^^^^^^^^^^^^^^^^^^^^^",
-				i, tc.description, string(tc.expect), string(actual))
-		}
-	}
-}

caddyconfig/caddyfile/testdata/import_args0.txt

@@ -1 +0,0 @@
-{args.0}

caddyconfig/caddyfile/testdata/import_args1.txt

@@ -1 +0,0 @@
-{args.0} {args.1}

caddyconfig/configadapters.go

@@ -1,136 +0,0 @@
-// 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 caddyconfig
-
-import (
-	"encoding/json"
-	"fmt"
-
-	"github.com/caddyserver/caddy/v2"
-)
-
-// Adapter is a type which can adapt a configuration to Caddy JSON.
-// It returns the results and any warnings, or an error.
-type Adapter interface {
-	Adapt(body []byte, options map[string]interface{}) ([]byte, []Warning, error)
-}
-
-// Warning represents a warning or notice related to conversion.
-type Warning struct {
-	File      string `json:"file,omitempty"`
-	Line      int    `json:"line,omitempty"`
-	Directive string `json:"directive,omitempty"`
-	Message   string `json:"message,omitempty"`
-}
-
-// JSON encodes val as JSON, returning it as a json.RawMessage. Any
-// marshaling errors (which are highly unlikely with correct code)
-// are converted to warnings. This is convenient when filling config
-// structs that require a json.RawMessage, without having to worry
-// about errors.
-func JSON(val interface{}, warnings *[]Warning) json.RawMessage {
-	b, err := json.Marshal(val)
-	if err != nil {
-		if warnings != nil {
-			*warnings = append(*warnings, Warning{Message: err.Error()})
-		}
-		return nil
-	}
-	return b
-}
-
-// JSONModuleObject is like JSON(), except it marshals val into a JSON object
-// with an added key named fieldName with the value fieldVal. This is useful
-// for encoding module values where the module name has to be described within
-// the object by a certain key; for example, `"handler": "file_server"` for a
-// file server HTTP handler (fieldName="handler" and fieldVal="file_server").
-// The val parameter must encode into a map[string]interface{} (i.e. it must be
-// a struct or map). Any errors are converted into warnings.
-func JSONModuleObject(val interface{}, fieldName, fieldVal string, warnings *[]Warning) json.RawMessage {
-	// encode to a JSON object first
-	enc, err := json.Marshal(val)
-	if err != nil {
-		if warnings != nil {
-			*warnings = append(*warnings, Warning{Message: err.Error()})
-		}
-		return nil
-	}
-
-	// then decode the object
-	var tmp map[string]interface{}
-	err = json.Unmarshal(enc, &tmp)
-	if err != nil {
-		if warnings != nil {
-			*warnings = append(*warnings, Warning{Message: err.Error()})
-		}
-		return nil
-	}
-
-	// so we can easily add the module's field with its appointed value
-	tmp[fieldName] = fieldVal
-
-	// then re-marshal as JSON
-	result, err := json.Marshal(tmp)
-	if err != nil {
-		if warnings != nil {
-			*warnings = append(*warnings, Warning{Message: err.Error()})
-		}
-		return nil
-	}
-
-	return result
-}
-
-// JSONIndent is used to JSON-marshal the final resulting Caddy
-// configuration in a consistent, human-readable way.
-func JSONIndent(val interface{}) ([]byte, error) {
-	return json.MarshalIndent(val, "", "\t")
-}
-
-// RegisterAdapter registers a config adapter with the given name.
-// This should usually be done at init-time. It panics if the
-// adapter cannot be registered successfully.
-func RegisterAdapter(name string, adapter Adapter) {
-	if _, ok := configAdapters[name]; ok {
-		panic(fmt.Errorf("%s: already registered", name))
-	}
-	configAdapters[name] = adapter
-	caddy.RegisterModule(adapterModule{name, adapter})
-}
-
-// GetAdapter returns the adapter with the given name,
-// or nil if one with that name is not registered.
-func GetAdapter(name string) Adapter {
-	return configAdapters[name]
-}
-
-// adapterModule is a wrapper type that can turn any config
-// adapter into a Caddy module, which has the benefit of being
-// counted with other modules, even though they do not
-// technically extend the Caddy configuration structure.
-// See caddyserver/caddy#3132.
-type adapterModule struct {
-	name string
-	Adapter
-}
-
-func (am adapterModule) CaddyModule() caddy.ModuleInfo {
-	return caddy.ModuleInfo{
-		ID:  caddy.ModuleID("caddy.adapters." + am.name),
-		New: func() caddy.Module { return am },
-	}
-}
-
-var configAdapters = make(map[string]Adapter)

caddyconfig/httpcaddyfile/addresses.go

@@ -1,400 +0,0 @@
-// 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"
-	"sort"
-	"strconv"
-	"strings"
-	"unicode"
-
-	"github.com/caddyserver/caddy/v2"
-	"github.com/caddyserver/caddy/v2/caddyconfig/caddyfile"
-	"github.com/caddyserver/caddy/v2/modules/caddyhttp"
-	"github.com/caddyserver/certmagic"
-)
-
-// 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
-// because that is more convenient: it would be a potential security risk
-// 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.)
-func (st *ServerType) mapAddressToServerBlocks(originalServerBlocks []serverBlock,
-	options map[string]interface{}) (map[string][]serverBlock, error) {
-	sbmap := make(map[string][]serverBlock)
-
-	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)
-		for j, key := range sblock.block.Keys {
-			// 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)
-			addrs, err := st.listenerAddrsForServerBlockKey(sblock, key, options)
-			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)
-			}
-		}
-
-		// 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
-		for addr, keys := range addrToKeys {
-			// 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())
-			}
-			sbmap[addr] = append(sbmap[addr], serverBlock{
-				block: caddyfile.ServerBlock{
-					Keys:     keys,
-					Segments: sblock.block.Segments,
-				},
-				pile: sblock.pile,
-				keys: parsedKeys,
-			})
-		}
-	}
-
-	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.
-func (st *ServerType) consolidateAddrMappings(addrToServerBlocks map[string][]serverBlock) []sbAddrAssociation {
-	sbaddrs := make([]sbAddrAssociation, 0, len(addrToServerBlocks))
-	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)
-			}
-		}
-
-		sbaddrs = append(sbaddrs, a)
-	}
-
-	// 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]
-	})
-
-	return sbaddrs
-}
-
-func (st *ServerType) listenerAddrsForServerBlockKey(sblock serverBlock, key string,
-	options map[string]interface{}) ([]string, error) {
-	addr, err := ParseAddress(key)
-	if err != nil {
-		return nil, fmt.Errorf("parsing key: %v", err)
-	}
-	addr = addr.Normalize()
-
-	// figure out the HTTP and HTTPS ports; either
-	// use defaults, or override with user config
-	httpPort, httpsPort := strconv.Itoa(caddyhttp.DefaultHTTPPort), strconv.Itoa(caddyhttp.DefaultHTTPSPort)
-	if hport, ok := options["http_port"]; ok {
-		httpPort = strconv.Itoa(hport.(int))
-	}
-	if hsport, ok := options["https_port"]; ok {
-		httpsPort = strconv.Itoa(hsport.(int))
-	}
-
-	// default port is the HTTPS port
-	lnPort := httpsPort
-	if addr.Port != "" {
-		// port explicitly defined
-		lnPort = addr.Port
-	} else if addr.Scheme == "http" {
-		// port inferred from scheme
-		lnPort = httpPort
-	}
-
-	// 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)
-	}
-
-	// the bind directive specifies hosts, but is optional
-	lnHosts := make([]string, 0, len(sblock.pile))
-	for _, cfgVal := range sblock.pile["bind"] {
-		lnHosts = append(lnHosts, cfgVal.Value.([]string)...)
-	}
-	if len(lnHosts) == 0 {
-		lnHosts = []string{""}
-	}
-
-	// use a map to prevent duplication
-	listeners := make(map[string]struct{})
-	for _, host := range lnHosts {
-		addr, err := caddy.ParseNetworkAddress(host)
-		if err == nil && addr.IsUnixNetwork() {
-			listeners[host] = struct{}{}
-		} else {
-			listeners[net.JoinHostPort(host, lnPort)] = struct{}{}
-		}
-	}
-
-	// now turn map into list
-	listenersList := make([]string, 0, len(listeners))
-	for lnStr := range listeners {
-		listenersList = append(listenersList, lnStr)
-	}
-
-	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
-}
-
-// 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) {
-	const maxLen = 4096
-	if len(str) > maxLen {
-		str = str[:maxLen]
-	}
-	remaining := strings.TrimSpace(str)
-	a := Address{Original: remaining}
-
-	// 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]
-	}
-
-	// extract host and port
-	hostSplit := strings.SplitN(remaining, "/", 2)
-	if len(hostSplit) > 0 {
-		host, port, err := net.SplitHostPort(hostSplit[0])
-		if err != nil {
-			host, port, err = net.SplitHostPort(hostSplit[0] + ":")
-			if err != nil {
-				host = hostSplit[0]
-			}
-		}
-		a.Host = host
-		a.Port = port
-	}
-	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)
-		}
-	}
-
-	return a, nil
-}
-
-// String returns a human-readable form of a. It will
-// be a cleaned-up and filled-out URL string.
-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
-}
-
-// Normalize returns a normalized version of a.
-func (a Address) Normalize() Address {
-	path := a.Path
-
-	// ensure host is normalized if it's an IP address
-	host := strings.TrimSpace(a.Host)
-	if ip := net.ParseIP(host); ip != nil {
-		host = ip.String()
-	}
-
-	return Address{
-		Original: a.Original,
-		Scheme:   lowerExceptPlaceholders(a.Scheme),
-		Host:     lowerExceptPlaceholders(host),
-		Port:     a.Port,
-		Path:     path,
-	}
-}
-
-// Key returns a string form of a, much like String() does, but this
-// method doesn't add anything default that wasn't in the original.
-func (a Address) Key() string {
-	res := ""
-	if a.Scheme != "" {
-		res += a.Scheme + "://"
-	}
-	if a.Host != "" {
-		res += a.Host
-	}
-	// insert port only if the original has its own explicit port
-	if a.Port != "" &&
-		len(a.Original) >= len(res) &&
-		strings.HasPrefix(a.Original[len(res):], ":"+a.Port) {
-		res += ":" + a.Port
-	}
-	if a.Path != "" {
-		res += a.Path
-	}
-	return res
-}
-
-// 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()
-}

caddyconfig/httpcaddyfile/addresses_test.go

@@ -1,183 +0,0 @@
-package httpcaddyfile
-
-import (
-	"testing"
-)
-
-func TestParseAddress(t *testing.T) {
-	for i, test := range []struct {
-		input                    string
-		scheme, host, port, path string
-		shouldErr                bool
-	}{
-		{``, "", "", "", "", false},
-		{`localhost`, "", "localhost", "", "", false},
-		{`localhost:1234`, "", "localhost", "1234", "", false},
-		{`localhost:`, "", "localhost", "", "", false},
-		{`0.0.0.0`, "", "0.0.0.0", "", "", false},
-		{`127.0.0.1:1234`, "", "127.0.0.1", "1234", "", false},
-		{`:1234`, "", "", "1234", "", false},
-		{`[::1]`, "", "::1", "", "", false},
-		{`[::1]:1234`, "", "::1", "1234", "", false},
-		{`:`, "", "", "", "", false},
-		{`:http`, "", "", "", "", true},
-		{`:https`, "", "", "", "", true},
-		{`localhost:http`, "", "", "", "", true}, // using service name in port is verboten, as of Go 1.12.8
-		{`localhost:https`, "", "", "", "", true},
-		{`http://localhost:https`, "", "", "", "", true}, // conflict
-		{`http://localhost:http`, "", "", "", "", true},  // repeated scheme
-		{`host:https/path`, "", "", "", "", true},
-		{`http://localhost:443`, "http", "localhost", "443", "", false}, // NOTE: not conventional
-		{`https://localhost:80`, "https", "localhost", "80", "", false}, // NOTE: not conventional
-		{`http://localhost`, "http", "localhost", "", "", false},
-		{`https://localhost`, "https", "localhost", "", "", false},
-		{`http://{env.APP_DOMAIN}`, "http", "{env.APP_DOMAIN}", "", "", false},
-		{`{env.APP_DOMAIN}:80`, "", "{env.APP_DOMAIN}", "80", "", false},
-		{`{env.APP_DOMAIN}/path`, "", "{env.APP_DOMAIN}", "", "/path", false},
-		{`example.com/{env.APP_PATH}`, "", "example.com", "", "/{env.APP_PATH}", false},
-		{`http://127.0.0.1`, "http", "127.0.0.1", "", "", false},
-		{`https://127.0.0.1`, "https", "127.0.0.1", "", "", false},
-		{`http://[::1]`, "http", "::1", "", "", false},
-		{`http://localhost:1234`, "http", "localhost", "1234", "", false},
-		{`https://127.0.0.1:1234`, "https", "127.0.0.1", "1234", "", false},
-		{`http://[::1]:1234`, "http", "::1", "1234", "", false},
-		{``, "", "", "", "", false},
-		{`::1`, "", "::1", "", "", false},
-		{`localhost::`, "", "localhost::", "", "", false},
-		{`#$%@`, "", "#$%@", "", "", false}, // don't want to presume what the hostname could be
-		{`host/path`, "", "host", "", "/path", false},
-		{`http://host/`, "http", "host", "", "/", false},
-		{`//asdf`, "", "", "", "//asdf", false},
-		{`:1234/asdf`, "", "", "1234", "/asdf", false},
-		{`http://host/path`, "http", "host", "", "/path", false},
-		{`https://host:443/path/foo`, "https", "host", "443", "/path/foo", false},
-		{`host:80/path`, "", "host", "80", "/path", false},
-		{`/path`, "", "", "", "/path", false},
-	} {
-		actual, err := ParseAddress(test.input)
-
-		if err != nil && !test.shouldErr {
-			t.Errorf("Test %d (%s): Expected no error, but had error: %v", i, test.input, err)
-		}
-		if err == nil && test.shouldErr {
-			t.Errorf("Test %d (%s): Expected error, but had none (%#v)", i, test.input, actual)
-		}
-
-		if !test.shouldErr && actual.Original != test.input {
-			t.Errorf("Test %d (%s): Expected original '%s', got '%s'", i, test.input, test.input, actual.Original)
-		}
-		if actual.Scheme != test.scheme {
-			t.Errorf("Test %d (%s): Expected scheme '%s', got '%s'", i, test.input, test.scheme, actual.Scheme)
-		}
-		if actual.Host != test.host {
-			t.Errorf("Test %d (%s): Expected host '%s', got '%s'", i, test.input, test.host, actual.Host)
-		}
-		if actual.Port != test.port {
-			t.Errorf("Test %d (%s): Expected port '%s', got '%s'", i, test.input, test.port, actual.Port)
-		}
-		if actual.Path != test.path {
-			t.Errorf("Test %d (%s): Expected path '%s', got '%s'", i, test.input, test.path, actual.Path)
-		}
-	}
-}
-
-func TestAddressString(t *testing.T) {
-	for i, test := range []struct {
-		addr     Address
-		expected string
-	}{
-		{Address{Scheme: "http", Host: "host", Port: "1234", Path: "/path"}, "http://host:1234/path"},
-		{Address{Scheme: "", Host: "host", Port: "", Path: ""}, "http://host"},
-		{Address{Scheme: "", Host: "host", Port: "80", Path: ""}, "http://host"},
-		{Address{Scheme: "", Host: "host", Port: "443", Path: ""}, "https://host"},
-		{Address{Scheme: "https", Host: "host", Port: "443", Path: ""}, "https://host"},
-		{Address{Scheme: "https", Host: "host", Port: "", Path: ""}, "https://host"},
-		{Address{Scheme: "", Host: "host", Port: "80", Path: "/path"}, "http://host/path"},
-		{Address{Scheme: "http", Host: "", Port: "1234", Path: ""}, "http://:1234"},
-		{Address{Scheme: "", Host: "", Port: "", Path: ""}, ""},
-	} {
-		actual := test.addr.String()
-		if actual != test.expected {
-			t.Errorf("Test %d: expected '%s' but got '%s'", i, test.expected, actual)
-		}
-	}
-}
-
-func TestKeyNormalization(t *testing.T) {
-	testCases := []struct {
-		input  string
-		expect string
-	}{
-		{
-			input:  "example.com",
-			expect: "example.com",
-		},
-		{
-			input:  "http://host:1234/path",
-			expect: "http://host:1234/path",
-		},
-		{
-			input:  "HTTP://A/ABCDEF",
-			expect: "http://a/ABCDEF",
-		},
-		{
-			input:  "A/ABCDEF",
-			expect: "a/ABCDEF",
-		},
-		{
-			input:  "A:2015/Path",
-			expect: "a:2015/Path",
-		},
-		{
-			input:  "sub.{env.MY_DOMAIN}",
-			expect: "sub.{env.MY_DOMAIN}",
-		},
-		{
-			input:  "sub.ExAmPle",
-			expect: "sub.example",
-		},
-		{
-			input:  "sub.\\{env.MY_DOMAIN\\}",
-			expect: "sub.\\{env.my_domain\\}",
-		},
-		{
-			input:  "sub.{env.MY_DOMAIN}.com",
-			expect: "sub.{env.MY_DOMAIN}.com",
-		},
-		{
-			input:  ":80",
-			expect: ":80",
-		},
-		{
-			input:  ":443",
-			expect: ":443",
-		},
-		{
-			input:  ":1234",
-			expect: ":1234",
-		},
-		{
-			input:  "",
-			expect: "",
-		},
-		{
-			input:  ":",
-			expect: "",
-		},
-		{
-			input:  "[::]",
-			expect: "::",
-		},
-	}
-	for i, tc := range testCases {
-		addr, err := ParseAddress(tc.input)
-		if err != nil {
-			t.Errorf("Test %d: Parsing address '%s': %v", i, tc.input, err)
-			continue
-		}
-		if actual := addr.Normalize().Key(); actual != tc.expect {
-			t.Errorf("Test %d: Input '%s': Expected '%s' but got '%s'", i, tc.input, tc.expect, actual)
-		}
-
-	}
-}

caddyconfig/httpcaddyfile/builtins.go

@@ -1,660 +0,0 @@
-// 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 (
-	"encoding/base64"
-	"encoding/pem"
-	"fmt"
-	"html"
-	"io/ioutil"
-	"net/http"
-	"reflect"
-	"strings"
-
-	"github.com/caddyserver/caddy/v2"
-	"github.com/caddyserver/caddy/v2/caddyconfig"
-	"github.com/caddyserver/caddy/v2/caddyconfig/caddyfile"
-	"github.com/caddyserver/caddy/v2/modules/caddyhttp"
-	"github.com/caddyserver/caddy/v2/modules/caddytls"
-	"github.com/caddyserver/certmagic"
-	"github.com/mholt/acmez/acme"
-	"go.uber.org/zap/zapcore"
-)
-
-func init() {
-	RegisterDirective("bind", parseBind)
-	RegisterDirective("tls", parseTLS)
-	RegisterHandlerDirective("root", parseRoot)
-	RegisterHandlerDirective("redir", parseRedir)
-	RegisterHandlerDirective("respond", parseRespond)
-	RegisterHandlerDirective("route", parseRoute)
-	RegisterHandlerDirective("handle", parseHandle)
-	RegisterDirective("handle_errors", parseHandleErrors)
-	RegisterDirective("log", parseLog)
-}
-
-// parseBind parses the bind directive. Syntax:
-//
-//     bind <addresses...>
-//
-func parseBind(h Helper) ([]ConfigValue, error) {
-	var lnHosts []string
-	for h.Next() {
-		lnHosts = append(lnHosts, h.RemainingArgs()...)
-	}
-	return h.NewBindAddresses(lnHosts), nil
-}
-
-// parseTLS parses the tls directive. Syntax:
-//
-//     tls [<email>|internal]|[<cert_file> <key_file>] {
-//         protocols <min> [<max>]
-//         ciphers   <cipher_suites...>
-//         curves    <curves...>
-//         client_auth {
-//             mode                   [request|require|verify_if_given|require_and_verify]
-//             trusted_ca_cert        <base64_der>
-//             trusted_ca_cert_file   <filename>
-//             trusted_leaf_cert      <base64_der>
-//             trusted_leaf_cert_file <filename>
-//         }
-//         alpn      <values...>
-//         load      <paths...>
-//         ca        <acme_ca_endpoint>
-//         ca_root   <pem_file>
-//         dns       <provider_name> [...]
-//         on_demand
-//         eab    <key_id> <mac_key>
-//         issuer <module_name> [...]
-//     }
-//
-func parseTLS(h Helper) ([]ConfigValue, error) {
-	cp := new(caddytls.ConnectionPolicy)
-	var fileLoader caddytls.FileLoader
-	var folderLoader caddytls.FolderLoader
-	var certSelector caddytls.CustomCertSelectionPolicy
-	var acmeIssuer *caddytls.ACMEIssuer
-	var internalIssuer *caddytls.InternalIssuer
-	var issuers []certmagic.Issuer
-	var onDemand bool
-
-	for h.Next() {
-		// file certificate loader
-		firstLine := h.RemainingArgs()
-		switch len(firstLine) {
-		case 0:
-		case 1:
-			if firstLine[0] == "internal" {
-				internalIssuer = new(caddytls.InternalIssuer)
-			} else if !strings.Contains(firstLine[0], "@") {
-				return nil, h.Err("single argument must either be 'internal' or an email address")
-			} else {
-				if acmeIssuer == nil {
-					acmeIssuer = new(caddytls.ACMEIssuer)
-				}
-				acmeIssuer.Email = firstLine[0]
-			}
-
-		case 2:
-			certFilename := firstLine[0]
-			keyFilename := firstLine[1]
-
-			// tag this certificate so if multiple certs match, specifically
-			// this one that the user has provided will be used, see #2588:
-			// https://github.com/caddyserver/caddy/issues/2588 ... but we
-			// must be careful about how we do this; being careless will
-			// lead to failed handshakes
-			//
-			// we need to remember which cert files we've seen, since we
-			// must load each cert only once; otherwise, they each get a
-			// different tag... since a cert loaded twice has the same
-			// bytes, it will overwrite the first one in the cache, and
-			// only the last cert (and its tag) will survive, so a any conn
-			// policy that is looking for any tag but the last one to be
-			// loaded won't find it, and TLS handshakes will fail (see end)
-			// of issue #3004)
-			//
-			// tlsCertTags maps certificate filenames to their tag.
-			// This is used to remember which tag is used for each
-			// certificate files, since we need to avoid loading
-			// the same certificate files more than once, overwriting
-			// previous tags
-			tlsCertTags, ok := h.State["tlsCertTags"].(map[string]string)
-			if !ok {
-				tlsCertTags = make(map[string]string)
-				h.State["tlsCertTags"] = tlsCertTags
-			}
-
-			tag, ok := tlsCertTags[certFilename]
-			if !ok {
-				// haven't seen this cert file yet, let's give it a tag
-				// and add a loader for it
-				tag = fmt.Sprintf("cert%d", len(tlsCertTags))
-				fileLoader = append(fileLoader, caddytls.CertKeyFilePair{
-					Certificate: certFilename,
-					Key:         keyFilename,
-					Tags:        []string{tag},
-				})
-				// remember this for next time we see this cert file
-				tlsCertTags[certFilename] = tag
-			}
-			certSelector.AnyTag = append(certSelector.AnyTag, tag)
-
-		default:
-			return nil, h.ArgErr()
-		}
-
-		var hasBlock bool
-		for nesting := h.Nesting(); h.NextBlock(nesting); {
-			hasBlock = true
-
-			switch h.Val() {
-			case "protocols":
-				args := h.RemainingArgs()
-				if len(args) == 0 {
-					return nil, h.SyntaxErr("one or two protocols")
-				}
-				if len(args) > 0 {
-					if _, ok := caddytls.SupportedProtocols[args[0]]; !ok {
-						return nil, h.Errf("Wrong protocol name or protocol not supported: '%s'", args[0])
-					}
-					cp.ProtocolMin = args[0]
-				}
-				if len(args) > 1 {
-					if _, ok := caddytls.SupportedProtocols[args[1]]; !ok {
-						return nil, h.Errf("Wrong protocol name or protocol not supported: '%s'", args[1])
-					}
-					cp.ProtocolMax = args[1]
-				}
-
-			case "ciphers":
-				for h.NextArg() {
-					if !caddytls.CipherSuiteNameSupported(h.Val()) {
-						return nil, h.Errf("Wrong cipher suite name or cipher suite not supported: '%s'", h.Val())
-					}
-					cp.CipherSuites = append(cp.CipherSuites, h.Val())
-				}
-
-			case "curves":
-				for h.NextArg() {
-					if _, ok := caddytls.SupportedCurves[h.Val()]; !ok {
-						return nil, h.Errf("Wrong curve name or curve not supported: '%s'", h.Val())
-					}
-					cp.Curves = append(cp.Curves, h.Val())
-				}
-
-			case "client_auth":
-				cp.ClientAuthentication = &caddytls.ClientAuthentication{}
-				for nesting := h.Nesting(); h.NextBlock(nesting); {
-					subdir := h.Val()
-					switch subdir {
-					case "mode":
-						if !h.Args(&cp.ClientAuthentication.Mode) {
-							return nil, h.ArgErr()
-						}
-						if h.NextArg() {
-							return nil, h.ArgErr()
-						}
-
-					case "trusted_ca_cert",
-						"trusted_leaf_cert":
-						if !h.NextArg() {
-							return nil, h.ArgErr()
-						}
-						if subdir == "trusted_ca_cert" {
-							cp.ClientAuthentication.TrustedCACerts = append(cp.ClientAuthentication.TrustedCACerts, h.Val())
-						} else {
-							cp.ClientAuthentication.TrustedLeafCerts = append(cp.ClientAuthentication.TrustedLeafCerts, h.Val())
-						}
-
-					case "trusted_ca_cert_file",
-						"trusted_leaf_cert_file":
-						if !h.NextArg() {
-							return nil, h.ArgErr()
-						}
-						filename := h.Val()
-						certDataPEM, err := ioutil.ReadFile(filename)
-						if err != nil {
-							return nil, err
-						}
-						block, _ := pem.Decode(certDataPEM)
-						if block == nil || block.Type != "CERTIFICATE" {
-							return nil, h.Errf("no CERTIFICATE pem block found in %s", h.Val())
-						}
-						if subdir == "trusted_ca_cert_file" {
-							cp.ClientAuthentication.TrustedCACerts = append(cp.ClientAuthentication.TrustedCACerts,
-								base64.StdEncoding.EncodeToString(block.Bytes))
-						} else {
-							cp.ClientAuthentication.TrustedLeafCerts = append(cp.ClientAuthentication.TrustedLeafCerts,
-								base64.StdEncoding.EncodeToString(block.Bytes))
-						}
-
-					default:
-						return nil, h.Errf("unknown subdirective for client_auth: %s", subdir)
-					}
-				}
-
-			case "alpn":
-				args := h.RemainingArgs()
-				if len(args) == 0 {
-					return nil, h.ArgErr()
-				}
-				cp.ALPN = args
-
-			case "load":
-				folderLoader = append(folderLoader, h.RemainingArgs()...)
-
-			case "ca":
-				arg := h.RemainingArgs()
-				if len(arg) != 1 {
-					return nil, h.ArgErr()
-				}
-				if acmeIssuer == nil {
-					acmeIssuer = new(caddytls.ACMEIssuer)
-				}
-				acmeIssuer.CA = arg[0]
-
-			case "eab":
-				arg := h.RemainingArgs()
-				if len(arg) != 2 {
-					return nil, h.ArgErr()
-				}
-				if acmeIssuer == nil {
-					acmeIssuer = new(caddytls.ACMEIssuer)
-				}
-				acmeIssuer.ExternalAccount = &acme.EAB{
-					KeyID:  arg[0],
-					MACKey: arg[1],
-				}
-
-			case "issuer":
-				if !h.NextArg() {
-					return nil, h.ArgErr()
-				}
-				modName := h.Val()
-				mod, err := caddy.GetModule("tls.issuance." + modName)
-				if err != nil {
-					return nil, h.Errf("getting issuer module '%s': %v", modName, err)
-				}
-				unm, ok := mod.New().(caddyfile.Unmarshaler)
-				if !ok {
-					return nil, h.Errf("issuer module '%s' is not a Caddyfile unmarshaler", mod.ID)
-				}
-				err = unm.UnmarshalCaddyfile(h.NewFromNextSegment())
-				if err != nil {
-					return nil, err
-				}
-				issuer, ok := unm.(certmagic.Issuer)
-				if !ok {
-					return nil, h.Errf("module %s is not a certmagic.Issuer", mod.ID)
-				}
-				issuers = append(issuers, issuer)
-
-			case "dns":
-				if !h.NextArg() {
-					return nil, h.ArgErr()
-				}
-				provName := h.Val()
-				if acmeIssuer == nil {
-					acmeIssuer = new(caddytls.ACMEIssuer)
-				}
-				if acmeIssuer.Challenges == nil {
-					acmeIssuer.Challenges = new(caddytls.ChallengesConfig)
-					acmeIssuer.Challenges.DNS = new(caddytls.DNSChallengeConfig)
-				}
-				dnsProvModule, err := caddy.GetModule("dns.providers." + provName)
-				if err != nil {
-					return nil, h.Errf("getting DNS provider module named '%s': %v", provName, err)
-				}
-				dnsProvModuleInstance := dnsProvModule.New()
-				if unm, ok := dnsProvModuleInstance.(caddyfile.Unmarshaler); ok {
-					err = unm.UnmarshalCaddyfile(h.NewFromNextSegment())
-					if err != nil {
-						return nil, err
-					}
-				}
-				acmeIssuer.Challenges.DNS.ProviderRaw = caddyconfig.JSONModuleObject(dnsProvModuleInstance, "name", provName, h.warnings)
-
-			case "ca_root":
-				arg := h.RemainingArgs()
-				if len(arg) != 1 {
-					return nil, h.ArgErr()
-				}
-				if acmeIssuer == nil {
-					acmeIssuer = new(caddytls.ACMEIssuer)
-				}
-				acmeIssuer.TrustedRootsPEMFiles = append(acmeIssuer.TrustedRootsPEMFiles, arg[0])
-
-			case "on_demand":
-				if h.NextArg() {
-					return nil, h.ArgErr()
-				}
-				onDemand = true
-
-			default:
-				return nil, h.Errf("unknown subdirective: %s", h.Val())
-			}
-		}
-
-		// a naked tls directive is not allowed
-		if len(firstLine) == 0 && !hasBlock {
-			return nil, h.ArgErr()
-		}
-	}
-
-	// begin building the final config values
-	configVals := []ConfigValue{}
-
-	// certificate loaders
-	if len(fileLoader) > 0 {
-		configVals = append(configVals, ConfigValue{
-			Class: "tls.cert_loader",
-			Value: fileLoader,
-		})
-	}
-	if len(folderLoader) > 0 {
-		configVals = append(configVals, ConfigValue{
-			Class: "tls.cert_loader",
-			Value: folderLoader,
-		})
-	}
-
-	if len(issuers) > 0 && (acmeIssuer != nil || internalIssuer != nil) {
-		// some tls subdirectives are shortcuts that implicitly configure issuers, and the
-		// user can also configure issuers explicitly using the issuer subdirective; the
-		// logic to support both would likely be complex, or at least unintuitive
-		return nil, h.Err("cannot mix issuer subdirective (explicit issuers) with other issuer-specific subdirectives (implicit issuers)")
-	}
-	for _, issuer := range issuers {
-		configVals = append(configVals, ConfigValue{
-			Class: "tls.cert_issuer",
-			Value: issuer,
-		})
-	}
-	if acmeIssuer != nil {
-		configVals = append(configVals, ConfigValue{
-			Class: "tls.cert_issuer",
-			Value: disambiguateACMEIssuer(acmeIssuer),
-		})
-	}
-	if internalIssuer != nil {
-		configVals = append(configVals, ConfigValue{
-			Class: "tls.cert_issuer",
-			Value: internalIssuer,
-		})
-	}
-
-	// on-demand TLS
-	if onDemand {
-		configVals = append(configVals, ConfigValue{
-			Class: "tls.on_demand",
-			Value: true,
-		})
-	}
-
-	// custom certificate selection
-	if len(certSelector.AnyTag) > 0 {
-		cp.CertSelection = &certSelector
-	}
-
-	// connection policy -- always add one, to ensure that TLS
-	// is enabled, because this directive was used (this is
-	// needed, for instance, when a site block has a key of
-	// just ":5000" - i.e. no hostname, and only on-demand TLS
-	// is enabled)
-	configVals = append(configVals, ConfigValue{
-		Class: "tls.connection_policy",
-		Value: cp,
-	})
-
-	return configVals, nil
-}
-
-// parseRoot parses the root directive. Syntax:
-//
-//     root [<matcher>] <path>
-//
-func parseRoot(h Helper) (caddyhttp.MiddlewareHandler, error) {
-	var root string
-	for h.Next() {
-		if !h.NextArg() {
-			return nil, h.ArgErr()
-		}
-		root = h.Val()
-		if h.NextArg() {
-			return nil, h.ArgErr()
-		}
-	}
-	return caddyhttp.VarsMiddleware{"root": root}, nil
-}
-
-// parseRedir parses the redir directive. Syntax:
-//
-//     redir [<matcher>] <to> [<code>]
-//
-func parseRedir(h Helper) (caddyhttp.MiddlewareHandler, error) {
-	if !h.Next() {
-		return nil, h.ArgErr()
-	}
-
-	if !h.NextArg() {
-		return nil, h.ArgErr()
-	}
-	to := h.Val()
-
-	var code string
-	if h.NextArg() {
-		code = h.Val()
-	}
-	if code == "permanent" {
-		code = "301"
-	}
-	if code == "temporary" || code == "" {
-		code = "302"
-	}
-	var body string
-	if code == "html" {
-		// Script tag comes first since that will better imitate a redirect in the browser's
-		// history, but the meta tag is a fallback for most non-JS clients.
-		const metaRedir = `<!DOCTYPE html>
-<html>
-	<head>
-		<title>Redirecting...</title>
-		<script>window.location.replace("%s");</script>
-		<meta http-equiv="refresh" content="0; URL='%s'">
-	</head>
-	<body>Redirecting to <a href="%s">%s</a>...</body>
-</html>
-`
-		safeTo := html.EscapeString(to)
-		body = fmt.Sprintf(metaRedir, safeTo, safeTo, safeTo, safeTo)
-	}
-
-	return caddyhttp.StaticResponse{
-		StatusCode: caddyhttp.WeakString(code),
-		Headers:    http.Header{"Location": []string{to}},
-		Body:       body,
-	}, nil
-}
-
-// parseRespond parses the respond directive.
-func parseRespond(h Helper) (caddyhttp.MiddlewareHandler, error) {
-	sr := new(caddyhttp.StaticResponse)
-	err := sr.UnmarshalCaddyfile(h.Dispenser)
-	if err != nil {
-		return nil, err
-	}
-	return sr, nil
-}
-
-// parseRoute parses the route directive.
-func parseRoute(h Helper) (caddyhttp.MiddlewareHandler, error) {
-	sr := new(caddyhttp.Subroute)
-
-	allResults, err := parseSegmentAsConfig(h)
-	if err != nil {
-		return nil, err
-	}
-
-	for _, result := range allResults {
-		switch handler := result.Value.(type) {
-		case caddyhttp.Route:
-			sr.Routes = append(sr.Routes, handler)
-		case caddyhttp.Subroute:
-			// directives which return a literal subroute instead of a route
-			// means they intend to keep those handlers together without
-			// them being reordered; we're doing that anyway since we're in
-			// the route directive, so just append its handlers
-			sr.Routes = append(sr.Routes, handler.Routes...)
-		default:
-			return nil, h.Errf("%s directive returned something other than an HTTP route or subroute: %#v (only handler directives can be used in routes)", result.directive, result.Value)
-		}
-	}
-
-	return sr, nil
-}
-
-func parseHandle(h Helper) (caddyhttp.MiddlewareHandler, error) {
-	return ParseSegmentAsSubroute(h)
-}
-
-func parseHandleErrors(h Helper) ([]ConfigValue, error) {
-	subroute, err := ParseSegmentAsSubroute(h)
-	if err != nil {
-		return nil, err
-	}
-	return []ConfigValue{
-		{
-			Class: "error_route",
-			Value: subroute,
-		},
-	}, nil
-}
-
-// parseLog parses the log directive. Syntax:
-//
-//     log {
-//         output <writer_module> ...
-//         format <encoder_module> ...
-//         level  <level>
-//     }
-//
-func parseLog(h Helper) ([]ConfigValue, error) {
-	var configValues []ConfigValue
-	for h.Next() {
-		// log does not currently support any arguments
-		if h.NextArg() {
-			return nil, h.ArgErr()
-		}
-
-		cl := new(caddy.CustomLog)
-
-		for h.NextBlock(0) {
-			switch h.Val() {
-			case "output":
-				if !h.NextArg() {
-					return nil, h.ArgErr()
-				}
-				moduleName := h.Val()
-
-				// can't use the usual caddyfile.Unmarshaler flow with the
-				// standard writers because they are in the caddy package
-				// (because they are the default) and implementing that
-				// interface there would unfortunately create circular import
-				var wo caddy.WriterOpener
-				switch moduleName {
-				case "stdout":
-					wo = caddy.StdoutWriter{}
-				case "stderr":
-					wo = caddy.StderrWriter{}
-				case "discard":
-					wo = caddy.DiscardWriter{}
-				default:
-					mod, err := caddy.GetModule("caddy.logging.writers." + moduleName)
-					if err != nil {
-						return nil, h.Errf("getting log writer module named '%s': %v", moduleName, err)
-					}
-					unm, ok := mod.New().(caddyfile.Unmarshaler)
-					if !ok {
-						return nil, h.Errf("log writer module '%s' is not a Caddyfile unmarshaler", mod)
-					}
-					err = unm.UnmarshalCaddyfile(h.NewFromNextSegment())
-					if err != nil {
-						return nil, err
-					}
-					wo, ok = unm.(caddy.WriterOpener)
-					if !ok {
-						return nil, h.Errf("module %s is not a WriterOpener", mod)
-					}
-				}
-				cl.WriterRaw = caddyconfig.JSONModuleObject(wo, "output", moduleName, h.warnings)
-
-			case "format":
-				if !h.NextArg() {
-					return nil, h.ArgErr()
-				}
-				moduleName := h.Val()
-				mod, err := caddy.GetModule("caddy.logging.encoders." + moduleName)
-				if err != nil {
-					return nil, h.Errf("getting log encoder module named '%s': %v", moduleName, err)
-				}
-				unm, ok := mod.New().(caddyfile.Unmarshaler)
-				if !ok {
-					return nil, h.Errf("log encoder module '%s' is not a Caddyfile unmarshaler", mod)
-				}
-				err = unm.UnmarshalCaddyfile(h.NewFromNextSegment())
-				if err != nil {
-					return nil, err
-				}
-				enc, ok := unm.(zapcore.Encoder)
-				if !ok {
-					return nil, h.Errf("module %s is not a zapcore.Encoder", mod)
-				}
-				cl.EncoderRaw = caddyconfig.JSONModuleObject(enc, "format", moduleName, h.warnings)
-
-			case "level":
-				if !h.NextArg() {
-					return nil, h.ArgErr()
-				}
-				cl.Level = h.Val()
-				if h.NextArg() {
-					return nil, h.ArgErr()
-				}
-
-			default:
-				return nil, h.Errf("unrecognized subdirective: %s", h.Val())
-			}
-		}
-
-		var val namedCustomLog
-		if !reflect.DeepEqual(cl, new(caddy.CustomLog)) {
-			logCounter, ok := h.State["logCounter"].(int)
-			if !ok {
-				logCounter = 0
-			}
-			val.name = fmt.Sprintf("log%d", logCounter)
-			cl.Include = []string{"http.log.access." + val.name}
-			val.log = cl
-			logCounter++
-			h.State["logCounter"] = logCounter
-		}
-		configValues = append(configValues, ConfigValue{
-			Class: "custom_log",
-			Value: val,
-		})
-	}
-	return configValues, nil
-}

caddyconfig/httpcaddyfile/builtins_test.go

@@ -1,62 +0,0 @@
-package httpcaddyfile
-
-import (
-	"testing"
-
-	"github.com/caddyserver/caddy/v2/caddyconfig/caddyfile"
-	_ "github.com/caddyserver/caddy/v2/modules/logging"
-)
-
-func TestLogDirectiveSyntax(t *testing.T) {
-	for i, tc := range []struct {
-		input       string
-		expectWarn  bool
-		expectError bool
-	}{
-		{
-			input: `:8080 {
-				log
-			}
-			`,
-			expectWarn:  false,
-			expectError: false,
-		},
-		{
-			input: `:8080 {
-				log {
-					output file foo.log
-				}
-			}
-			`,
-			expectWarn:  false,
-			expectError: false,
-		},
-		{
-			input: `:8080 {
-				log /foo {
-					output file foo.log
-				}
-			}
-			`,
-			expectWarn:  false,
-			expectError: true,
-		},
-	} {
-
-		adapter := caddyfile.Adapter{
-			ServerType: ServerType{},
-		}
-
-		_, warnings, err := adapter.Adapt([]byte(tc.input), nil)
-
-		if len(warnings) > 0 != tc.expectWarn {
-			t.Errorf("Test %d warning expectation failed Expected: %v, got %v", i, tc.expectWarn, warnings)
-			continue
-		}
-
-		if err != nil != tc.expectError {
-			t.Errorf("Test %d error expectation failed Expected: %v, got %s", i, tc.expectError, err)
-			continue
-		}
-	}
-}

caddyconfig/httpcaddyfile/directives.go

@@ -1,508 +0,0 @@
-// 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 (
-	"encoding/json"
-	"net"
-	"sort"
-	"strconv"
-	"strings"
-
-	"github.com/caddyserver/caddy/v2"
-	"github.com/caddyserver/caddy/v2/caddyconfig"
-	"github.com/caddyserver/caddy/v2/caddyconfig/caddyfile"
-	"github.com/caddyserver/caddy/v2/modules/caddyhttp"
-)
-
-// directiveOrder specifies the order
-// to apply directives in HTTP routes.
-//
-// The root directive goes first in case rewrites or
-// redirects depend on existence of files, i.e. the
-// file matcher, which must know the root first.
-//
-// The header directive goes second so that headers
-// can be manipulated before doing redirects.
-var directiveOrder = []string{
-	"map",
-	"root",
-
-	"header",
-	"request_body",
-
-	"redir",
-	"rewrite",
-
-	// URI manipulation
-	"uri",
-	"try_files",
-
-	// middleware handlers; some wrap responses
-	"basicauth",
-	"request_header",
-	"encode",
-	"templates",
-
-	// special routing & dispatching directives
-	"handle",
-	"handle_path",
-	"route",
-	"push",
-
-	// handlers that typically respond to requests
-	"respond",
-	"metrics",
-	"reverse_proxy",
-	"php_fastcgi",
-	"file_server",
-	"acme_server",
-}
-
-// directiveIsOrdered returns true if dir is
-// a known, ordered (sorted) directive.
-func directiveIsOrdered(dir string) bool {
-	for _, d := range directiveOrder {
-		if d == dir {
-			return true
-		}
-	}
-	return false
-}
-
-// RegisterDirective registers a unique directive dir with an
-// associated unmarshaling (setup) function. When directive dir
-// is encountered in a Caddyfile, setupFunc will be called to
-// unmarshal its tokens.
-func RegisterDirective(dir string, setupFunc UnmarshalFunc) {
-	if _, ok := registeredDirectives[dir]; ok {
-		panic("directive " + dir + " already registered")
-	}
-	registeredDirectives[dir] = setupFunc
-}
-
-// RegisterHandlerDirective is like RegisterDirective, but for
-// directives which specifically output only an HTTP handler.
-// Directives registered with this function will always have
-// an optional matcher token as the first argument.
-func RegisterHandlerDirective(dir string, setupFunc UnmarshalHandlerFunc) {
-	RegisterDirective(dir, func(h Helper) ([]ConfigValue, error) {
-		if !h.Next() {
-			return nil, h.ArgErr()
-		}
-
-		matcherSet, err := h.ExtractMatcherSet()
-		if err != nil {
-			return nil, err
-		}
-
-		val, err := setupFunc(h)
-		if err != nil {
-			return nil, err
-		}
-
-		return h.NewRoute(matcherSet, val), nil
-	})
-}
-
-// RegisterGlobalOption registers a unique global option opt with
-// an associated unmarshaling (setup) function. When the global
-// option opt is encountered in a Caddyfile, setupFunc will be
-// called to unmarshal its tokens.
-func RegisterGlobalOption(opt string, setupFunc UnmarshalGlobalFunc) {
-	if _, ok := registeredGlobalOptions[opt]; ok {
-		panic("global option " + opt + " already registered")
-	}
-	registeredGlobalOptions[opt] = setupFunc
-}
-
-// Helper is a type which helps setup a value from
-// Caddyfile tokens.
-type Helper struct {
-	*caddyfile.Dispenser
-	// State stores intermediate variables during caddyfile adaptation.
-	State        map[string]interface{}
-	options      map[string]interface{}
-	warnings     *[]caddyconfig.Warning
-	matcherDefs  map[string]caddy.ModuleMap
-	parentBlock  caddyfile.ServerBlock
-	groupCounter counter
-}
-
-// Option gets the option keyed by name.
-func (h Helper) Option(name string) interface{} {
-	return h.options[name]
-}
-
-// Caddyfiles returns the list of config files from
-// which tokens in the current server block were loaded.
-func (h Helper) Caddyfiles() []string {
-	// first obtain set of names of files involved
-	// in this server block, without duplicates
-	files := make(map[string]struct{})
-	for _, segment := range h.parentBlock.Segments {
-		for _, token := range segment {
-			files[token.File] = struct{}{}
-		}
-	}
-	// then convert the set into a slice
-	filesSlice := make([]string, 0, len(files))
-	for file := range files {
-		filesSlice = append(filesSlice, file)
-	}
-	return filesSlice
-}
-
-// JSON converts val into JSON. Any errors are added to warnings.
-func (h Helper) JSON(val interface{}) json.RawMessage {
-	return caddyconfig.JSON(val, h.warnings)
-}
-
-// MatcherToken assumes the next argument token is (possibly) a matcher,
-// and if so, returns the matcher set along with a true value. If the next
-// token is not a matcher, nil and false is returned. Note that a true
-// value may be returned with a nil matcher set if it is a catch-all.
-func (h Helper) MatcherToken() (caddy.ModuleMap, bool, error) {
-	if !h.NextArg() {
-		return nil, false, nil
-	}
-	return matcherSetFromMatcherToken(h.Dispenser.Token(), h.matcherDefs, h.warnings)
-}
-
-// ExtractMatcherSet is like MatcherToken, except this is a higher-level
-// method that returns the matcher set described by the matcher token,
-// or nil if there is none, and deletes the matcher token from the
-// dispenser and resets it as if this look-ahead never happened. Useful
-// when wrapping a route (one or more handlers) in a user-defined matcher.
-func (h Helper) ExtractMatcherSet() (caddy.ModuleMap, error) {
-	matcherSet, hasMatcher, err := h.MatcherToken()
-	if err != nil {
-		return nil, err
-	}
-	if hasMatcher {
-		// strip matcher token; we don't need to
-		// use the return value here because a
-		// new dispenser should have been made
-		// solely for this directive's tokens,
-		// with no other uses of same slice
-		h.Dispenser.Delete()
-	}
-	h.Dispenser.Reset() // pretend this lookahead never happened
-	return matcherSet, nil
-}
-
-// NewRoute returns config values relevant to creating a new HTTP route.
-func (h Helper) NewRoute(matcherSet caddy.ModuleMap,
-	handler caddyhttp.MiddlewareHandler) []ConfigValue {
-	mod, err := caddy.GetModule(caddy.GetModuleID(handler))
-	if err != nil {
-		*h.warnings = append(*h.warnings, caddyconfig.Warning{
-			File:    h.File(),
-			Line:    h.Line(),
-			Message: err.Error(),
-		})
-		return nil
-	}
-	var matcherSetsRaw []caddy.ModuleMap
-	if matcherSet != nil {
-		matcherSetsRaw = append(matcherSetsRaw, matcherSet)
-	}
-	return []ConfigValue{
-		{
-			Class: "route",
-			Value: caddyhttp.Route{
-				MatcherSetsRaw: matcherSetsRaw,
-				HandlersRaw:    []json.RawMessage{caddyconfig.JSONModuleObject(handler, "handler", mod.ID.Name(), h.warnings)},
-			},
-		},
-	}
-}
-
-// GroupRoutes adds the routes (caddyhttp.Route type) in vals to the
-// same group, if there is more than one route in vals.
-func (h Helper) GroupRoutes(vals []ConfigValue) {
-	// ensure there's at least two routes; group of one is pointless
-	var count int
-	for _, v := range vals {
-		if _, ok := v.Value.(caddyhttp.Route); ok {
-			count++
-			if count > 1 {
-				break
-			}
-		}
-	}
-	if count < 2 {
-		return
-	}
-
-	// now that we know the group will have some effect, do it
-	groupName := h.groupCounter.nextGroup()
-	for i := range vals {
-		if route, ok := vals[i].Value.(caddyhttp.Route); ok {
-			route.Group = groupName
-			vals[i].Value = route
-		}
-	}
-}
-
-// NewBindAddresses returns config values relevant to adding
-// listener bind addresses to the config.
-func (h Helper) NewBindAddresses(addrs []string) []ConfigValue {
-	return []ConfigValue{{Class: "bind", Value: addrs}}
-}
-
-// ParseSegmentAsSubroute parses the segment such that its subdirectives
-// are themselves treated as directives, from which a subroute is built
-// and returned.
-func ParseSegmentAsSubroute(h Helper) (caddyhttp.MiddlewareHandler, error) {
-	allResults, err := parseSegmentAsConfig(h)
-	if err != nil {
-		return nil, err
-	}
-
-	return buildSubroute(allResults, h.groupCounter)
-}
-
-// parseSegmentAsConfig parses the segment such that its subdirectives
-// are themselves treated as directives, including named matcher definitions,
-// and the raw Config structs are returned.
-func parseSegmentAsConfig(h Helper) ([]ConfigValue, error) {
-	var allResults []ConfigValue
-
-	for h.Next() {
-		// don't allow non-matcher args on the first line
-		if h.NextArg() {
-			return nil, h.ArgErr()
-		}
-
-		// slice the linear list of tokens into top-level segments
-		var segments []caddyfile.Segment
-		for nesting := h.Nesting(); h.NextBlock(nesting); {
-			segments = append(segments, h.NextSegment())
-		}
-
-		// copy existing matcher definitions so we can augment
-		// new ones that are defined only in this scope
-		matcherDefs := make(map[string]caddy.ModuleMap, len(h.matcherDefs))
-		for key, val := range h.matcherDefs {
-			matcherDefs[key] = val
-		}
-
-		// find and extract any embedded matcher definitions in this scope
-		for i := 0; i < len(segments); i++ {
-			seg := segments[i]
-			if strings.HasPrefix(seg.Directive(), matcherPrefix) {
-				// parse, then add the matcher to matcherDefs
-				err := parseMatcherDefinitions(caddyfile.NewDispenser(seg), matcherDefs)
-				if err != nil {
-					return nil, err
-				}
-				// remove the matcher segment (consumed), then step back the loop
-				segments = append(segments[:i], segments[i+1:]...)
-				i--
-			}
-		}
-
-		// with matchers ready to go, evaluate each directive's segment
-		for _, seg := range segments {
-			dir := seg.Directive()
-			dirFunc, ok := registeredDirectives[dir]
-			if !ok {
-				return nil, h.Errf("unrecognized directive: %s", dir)
-			}
-
-			subHelper := h
-			subHelper.Dispenser = caddyfile.NewDispenser(seg)
-			subHelper.matcherDefs = matcherDefs
-
-			results, err := dirFunc(subHelper)
-			if err != nil {
-				return nil, h.Errf("parsing caddyfile tokens for '%s': %v", dir, err)
-			}
-			for _, result := range results {
-				result.directive = dir
-				allResults = append(allResults, result)
-			}
-		}
-	}
-
-	return allResults, nil
-}
-
-// ConfigValue represents a value to be added to the final
-// configuration, or a value to be consulted when building
-// the final configuration.
-type ConfigValue struct {
-	// The kind of value this is. As the config is
-	// being built, the adapter will look in the
-	// "pile" for values belonging to a certain
-	// class when it is setting up a certain part
-	// of the config. The associated value will be
-	// type-asserted and placed accordingly.
-	Class string
-
-	// The value to be used when building the config.
-	// Generally its type is associated with the
-	// name of the Class.
-	Value interface{}
-
-	directive string
-}
-
-func sortRoutes(routes []ConfigValue) {
-	dirPositions := make(map[string]int)
-	for i, dir := range directiveOrder {
-		dirPositions[dir] = i
-	}
-
-	sort.SliceStable(routes, func(i, j int) bool {
-		// if the directives are different, just use the established directive order
-		iDir, jDir := routes[i].directive, routes[j].directive
-		if iDir != jDir {
-			return dirPositions[iDir] < dirPositions[jDir]
-		}
-
-		// directives are the same; sub-sort by path matcher length if there's
-		// only one matcher set and one path (this is a very common case and
-		// usually -- but not always -- helpful/expected, oh well; user can
-		// always take manual control of order using handler or route blocks)
-		iRoute, ok := routes[i].Value.(caddyhttp.Route)
-		if !ok {
-			return false
-		}
-		jRoute, ok := routes[j].Value.(caddyhttp.Route)
-		if !ok {
-			return false
-		}
-
-		// decode the path matchers, if there is just one of them
-		var iPM, jPM caddyhttp.MatchPath
-		if len(iRoute.MatcherSetsRaw) == 1 {
-			_ = json.Unmarshal(iRoute.MatcherSetsRaw[0]["path"], &iPM)
-		}
-		if len(jRoute.MatcherSetsRaw) == 1 {
-			_ = json.Unmarshal(jRoute.MatcherSetsRaw[0]["path"], &jPM)
-		}
-
-		// sort by longer path (more specific) first; missing path
-		// matchers or multi-matchers are treated as zero-length paths
-		var iPathLen, jPathLen int
-		if len(iPM) > 0 {
-			iPathLen = len(iPM[0])
-		}
-		if len(jPM) > 0 {
-			jPathLen = len(jPM[0])
-		}
-
-		// if both directives have no path matcher, use whichever one
-		// has any kind of matcher defined first.
-		if iPathLen == 0 && jPathLen == 0 {
-			return len(iRoute.MatcherSetsRaw) > 0 && len(jRoute.MatcherSetsRaw) == 0
-		}
-
-		// sort with the most-specific (longest) path first
-		return iPathLen > jPathLen
-	})
-}
-
-// serverBlock pairs a Caddyfile server block with
-// a "pile" of config values, keyed by class name,
-// as well as its parsed keys for convenience.
-type serverBlock struct {
-	block caddyfile.ServerBlock
-	pile  map[string][]ConfigValue // config values obtained from directives
-	keys  []Address
-}
-
-// hostsFromKeys returns a list of all the non-empty hostnames found in
-// the keys of the server block sb. If logger mode is false, a key with
-// an empty hostname portion will return an empty slice, since that
-// server block is interpreted to effectively match all hosts. An empty
-// string is never added to the slice.
-//
-// If loggerMode is true, then the non-standard ports of keys will be
-// joined to the hostnames. This is to effectively match the Host
-// header of requests that come in for that key.
-//
-// The resulting slice is not sorted but will never have duplicates.
-func (sb serverBlock) hostsFromKeys(loggerMode bool) []string {
-	// ensure each entry in our list is unique
-	hostMap := make(map[string]struct{})
-	for _, addr := range sb.keys {
-		if addr.Host == "" {
-			if !loggerMode {
-				// server block contains a key like ":443", i.e. the host portion
-				// is empty / catch-all, which means to match all hosts
-				return []string{}
-			}
-			// never append an empty string
-			continue
-		}
-		if loggerMode &&
-			addr.Port != "" &&
-			addr.Port != strconv.Itoa(caddyhttp.DefaultHTTPPort) &&
-			addr.Port != strconv.Itoa(caddyhttp.DefaultHTTPSPort) {
-			hostMap[net.JoinHostPort(addr.Host, addr.Port)] = struct{}{}
-		} else {
-			hostMap[addr.Host] = struct{}{}
-		}
-	}
-
-	// convert map to slice
-	sblockHosts := make([]string, 0, len(hostMap))
-	for host := range hostMap {
-		sblockHosts = append(sblockHosts, host)
-	}
-
-	return sblockHosts
-}
-
-// hasHostCatchAllKey returns true if sb has a key that
-// omits a host portion, i.e. it "catches all" hosts.
-func (sb serverBlock) hasHostCatchAllKey() bool {
-	for _, addr := range sb.keys {
-		if addr.Host == "" {
-			return true
-		}
-	}
-	return false
-}
-
-type (
-	// UnmarshalFunc is a function which can unmarshal Caddyfile
-	// tokens into zero or more config values using a Helper type.
-	// These are passed in a call to RegisterDirective.
-	UnmarshalFunc func(h Helper) ([]ConfigValue, error)
-
-	// UnmarshalHandlerFunc is like UnmarshalFunc, except the
-	// output of the unmarshaling is an HTTP handler. This
-	// function does not need to deal with HTTP request matching
-	// which is abstracted away. Since writing HTTP handlers
-	// with Caddyfile support is very common, this is a more
-	// convenient way to add a handler to the chain since a lot
-	// of the details common to HTTP handlers are taken care of
-	// for you. These are passed to a call to
-	// RegisterHandlerDirective.
-	UnmarshalHandlerFunc func(h Helper) (caddyhttp.MiddlewareHandler, error)
-
-	// UnmarshalGlobalFunc is a function which can unmarshal Caddyfile
-	// tokens into a global option config value using a Helper type.
-	// These are passed in a call to RegisterGlobalOption.
-	UnmarshalGlobalFunc func(d *caddyfile.Dispenser) (interface{}, error)
-)
-
-var registeredDirectives = make(map[string]UnmarshalFunc)
-
-var registeredGlobalOptions = make(map[string]UnmarshalGlobalFunc)

caddyconfig/httpcaddyfile/directives_test.go

@@ -1,94 +0,0 @@
-package httpcaddyfile
-
-import (
-	"reflect"
-	"sort"
-	"testing"
-)
-
-func TestHostsFromKeys(t *testing.T) {
-	for i, tc := range []struct {
-		keys             []Address
-		expectNormalMode []string
-		expectLoggerMode []string
-	}{
-		{
-			[]Address{
-				{Original: "foo", Host: "foo"},
-			},
-			[]string{"foo"},
-			[]string{"foo"},
-		},
-		{
-			[]Address{
-				{Original: "foo", Host: "foo"},
-				{Original: "bar", Host: "bar"},
-			},
-			[]string{"bar", "foo"},
-			[]string{"bar", "foo"},
-		},
-		{
-			[]Address{
-				{Original: ":2015", Port: "2015"},
-			},
-			[]string{}, []string{},
-		},
-		{
-			[]Address{
-				{Original: ":443", Port: "443"},
-			},
-			[]string{}, []string{},
-		},
-		{
-			[]Address{
-				{Original: "foo", Host: "foo"},
-				{Original: ":2015", Port: "2015"},
-			},
-			[]string{}, []string{"foo"},
-		},
-		{
-			[]Address{
-				{Original: "example.com:2015", Host: "example.com", Port: "2015"},
-			},
-			[]string{"example.com"},
-			[]string{"example.com:2015"},
-		},
-		{
-			[]Address{
-				{Original: "example.com:80", Host: "example.com", Port: "80"},
-			},
-			[]string{"example.com"},
-			[]string{"example.com"},
-		},
-		{
-			[]Address{
-				{Original: "https://:2015/foo", Scheme: "https", Port: "2015", Path: "/foo"},
-			},
-			[]string{},
-			[]string{},
-		},
-		{
-			[]Address{
-				{Original: "https://example.com:2015/foo", Scheme: "https", Host: "example.com", Port: "2015", Path: "/foo"},
-			},
-			[]string{"example.com"},
-			[]string{"example.com:2015"},
-		},
-	} {
-		sb := serverBlock{keys: tc.keys}
-
-		// test in normal mode
-		actual := sb.hostsFromKeys(false)
-		sort.Strings(actual)
-		if !reflect.DeepEqual(tc.expectNormalMode, actual) {
-			t.Errorf("Test %d (loggerMode=false): Expected: %v Actual: %v", i, tc.expectNormalMode, actual)
-		}
-
-		// test in logger mode
-		actual = sb.hostsFromKeys(true)
-		sort.Strings(actual)
-		if !reflect.DeepEqual(tc.expectLoggerMode, actual) {
-			t.Errorf("Test %d (loggerMode=true): Expected: %v Actual: %v", i, tc.expectLoggerMode, actual)
-		}
-	}
-}

caddyconfig/httpcaddyfile/httptype_test.go

@@ -1,237 +0,0 @@
-package httpcaddyfile
-
-import (
-	"testing"
-
-	"github.com/caddyserver/caddy/v2/caddyconfig/caddyfile"
-)
-
-func TestMatcherSyntax(t *testing.T) {
-	for i, tc := range []struct {
-		input       string
-		expectWarn  bool
-		expectError bool
-	}{
-		{
-			input: `http://localhost
-			@debug {
-				query showdebug=1
-			}
-			`,
-			expectWarn:  false,
-			expectError: false,
-		},
-		{
-			input: `http://localhost
-			@debug {
-				query bad format
-			}
-			`,
-			expectWarn:  false,
-			expectError: true,
-		},
-		{
-			input: `http://localhost
-			@debug {
-				not {
-					path /somepath*
-				}
-			}
-			`,
-			expectWarn:  false,
-			expectError: false,
-		},
-		{
-			input: `http://localhost
-			@debug {
-				not path /somepath*
-			}
-			`,
-			expectWarn:  false,
-			expectError: false,
-		},
-		{
-			input: `http://localhost
-			@debug not path /somepath*
-			`,
-			expectWarn:  false,
-			expectError: false,
-		},
-		{
-			input: `@matcher {
-				path /matcher-not-allowed/outside-of-site-block/*
-			}
-			http://localhost
-			`,
-			expectWarn:  false,
-			expectError: true,
-		},
-	} {
-
-		adapter := caddyfile.Adapter{
-			ServerType: ServerType{},
-		}
-
-		_, warnings, err := adapter.Adapt([]byte(tc.input), nil)
-
-		if len(warnings) > 0 != tc.expectWarn {
-			t.Errorf("Test %d warning expectation failed Expected: %v, got %v", i, tc.expectWarn, warnings)
-			continue
-		}
-
-		if err != nil != tc.expectError {
-			t.Errorf("Test %d error expectation failed Expected: %v, got %s", i, tc.expectError, err)
-			continue
-		}
-	}
-}
-
-func TestSpecificity(t *testing.T) {
-	for i, tc := range []struct {
-		input  string
-		expect int
-	}{
-		{"", 0},
-		{"*", 0},
-		{"*.*", 1},
-		{"{placeholder}", 0},
-		{"/{placeholder}", 1},
-		{"foo", 3},
-		{"example.com", 11},
-		{"a.example.com", 13},
-		{"*.example.com", 12},
-		{"/foo", 4},
-		{"/foo*", 4},
-		{"{placeholder}.example.com", 12},
-		{"{placeholder.example.com", 24},
-		{"}.", 2},
-		{"}{", 2},
-		{"{}", 0},
-		{"{{{}}", 1},
-	} {
-		actual := specificity(tc.input)
-		if actual != tc.expect {
-			t.Errorf("Test %d (%s): Expected %d but got %d", i, tc.input, tc.expect, actual)
-		}
-	}
-}
-
-func TestGlobalOptions(t *testing.T) {
-	for i, tc := range []struct {
-		input       string
-		expectWarn  bool
-		expectError bool
-	}{
-		{
-			input: `
-				{
-					email test@example.com
-				}
-				:80
-			`,
-			expectWarn:  false,
-			expectError: false,
-		},
-		{
-			input: `
-				{
-					admin off
-				}
-				:80
-			`,
-			expectWarn:  false,
-			expectError: false,
-		},
-		{
-			input: `
-				{
-					admin 127.0.0.1:2020
-				}
-				:80
-			`,
-			expectWarn:  false,
-			expectError: false,
-		},
-		{
-			input: `
-				{
-					admin {
-						disabled false
-					}
-				}
-				:80
-			`,
-			expectWarn:  false,
-			expectError: true,
-		},
-		{
-			input: `
-				{
-					admin {
-						enforce_origin
-						origins 192.168.1.1:2020 127.0.0.1:2020
-					}
-				}
-				:80
-			`,
-			expectWarn:  false,
-			expectError: false,
-		},
-		{
-			input: `
-				{
-					admin 127.0.0.1:2020 {
-						enforce_origin
-						origins 192.168.1.1:2020 127.0.0.1:2020
-					}
-				}
-				:80
-			`,
-			expectWarn:  false,
-			expectError: false,
-		},
-		{
-			input: `
-				{
-					admin 192.168.1.1:2020 127.0.0.1:2020 {
-						enforce_origin
-						origins 192.168.1.1:2020 127.0.0.1:2020
-					}
-				}
-				:80
-			`,
-			expectWarn:  false,
-			expectError: true,
-		},
-		{
-			input: `
-				{
-					admin off {
-						enforce_origin
-						origins 192.168.1.1:2020 127.0.0.1:2020
-					}
-				}
-				:80
-			`,
-			expectWarn:  false,
-			expectError: true,
-		},
-	} {
-
-		adapter := caddyfile.Adapter{
-			ServerType: ServerType{},
-		}
-
-		_, warnings, err := adapter.Adapt([]byte(tc.input), nil)
-
-		if len(warnings) > 0 != tc.expectWarn {
-			t.Errorf("Test %d warning expectation failed Expected: %v, got %v", i, tc.expectWarn, warnings)
-			continue
-		}
-
-		if err != nil != tc.expectError {
-			t.Errorf("Test %d error expectation failed Expected: %v, got %s", i, tc.expectError, err)
-			continue
-		}
-	}
-}

caddyconfig/httpcaddyfile/options.go

@@ -1,368 +0,0 @@
-// 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 (
-	"strconv"
-
-	"github.com/caddyserver/caddy/v2"
-	"github.com/caddyserver/caddy/v2/caddyconfig/caddyfile"
-	"github.com/caddyserver/caddy/v2/modules/caddytls"
-	"github.com/caddyserver/certmagic"
-	"github.com/mholt/acmez/acme"
-)
-
-func init() {
-	RegisterGlobalOption("debug", parseOptTrue)
-	RegisterGlobalOption("http_port", parseOptHTTPPort)
-	RegisterGlobalOption("https_port", parseOptHTTPSPort)
-	RegisterGlobalOption("default_sni", parseOptSingleString)
-	RegisterGlobalOption("order", parseOptOrder)
-	RegisterGlobalOption("experimental_http3", parseOptTrue)
-	RegisterGlobalOption("storage", parseOptStorage)
-	RegisterGlobalOption("acme_ca", parseOptSingleString)
-	RegisterGlobalOption("acme_ca_root", parseOptSingleString)
-	RegisterGlobalOption("acme_dns", parseOptSingleString)
-	RegisterGlobalOption("acme_eab", parseOptACMEEAB)
-	RegisterGlobalOption("cert_issuer", parseOptCertIssuer)
-	RegisterGlobalOption("email", parseOptSingleString)
-	RegisterGlobalOption("admin", parseOptAdmin)
-	RegisterGlobalOption("on_demand_tls", parseOptOnDemand)
-	RegisterGlobalOption("local_certs", parseOptTrue)
-	RegisterGlobalOption("key_type", parseOptSingleString)
-	RegisterGlobalOption("auto_https", parseOptAutoHTTPS)
-	RegisterGlobalOption("servers", parseServerOptions)
-}
-
-func parseOptTrue(d *caddyfile.Dispenser) (interface{}, error) {
-	return true, nil
-}
-
-func parseOptHTTPPort(d *caddyfile.Dispenser) (interface{}, error) {
-	var httpPort int
-	for d.Next() {
-		var httpPortStr string
-		if !d.AllArgs(&httpPortStr) {
-			return 0, d.ArgErr()
-		}
-		var err error
-		httpPort, err = strconv.Atoi(httpPortStr)
-		if err != nil {
-			return 0, d.Errf("converting port '%s' to integer value: %v", httpPortStr, err)
-		}
-	}
-	return httpPort, nil
-}
-
-func parseOptHTTPSPort(d *caddyfile.Dispenser) (interface{}, error) {
-	var httpsPort int
-	for d.Next() {
-		var httpsPortStr string
-		if !d.AllArgs(&httpsPortStr) {
-			return 0, d.ArgErr()
-		}
-		var err error
-		httpsPort, err = strconv.Atoi(httpsPortStr)
-		if err != nil {
-			return 0, d.Errf("converting port '%s' to integer value: %v", httpsPortStr, err)
-		}
-	}
-	return httpsPort, nil
-}
-
-func parseOptOrder(d *caddyfile.Dispenser) (interface{}, error) {
-	newOrder := directiveOrder
-
-	for d.Next() {
-		// get directive name
-		if !d.Next() {
-			return nil, d.ArgErr()
-		}
-		dirName := d.Val()
-		if _, ok := registeredDirectives[dirName]; !ok {
-			return nil, d.Errf("%s is not a registered directive", dirName)
-		}
-
-		// get positional token
-		if !d.Next() {
-			return nil, d.ArgErr()
-		}
-		pos := d.Val()
-
-		// if directive exists, first remove it
-		for i, d := range newOrder {
-			if d == dirName {
-				newOrder = append(newOrder[:i], newOrder[i+1:]...)
-				break
-			}
-		}
-
-		// act on the positional
-		switch pos {
-		case "first":
-			newOrder = append([]string{dirName}, newOrder...)
-			if d.NextArg() {
-				return nil, d.ArgErr()
-			}
-			directiveOrder = newOrder
-			return newOrder, nil
-		case "last":
-			newOrder = append(newOrder, dirName)
-			if d.NextArg() {
-				return nil, d.ArgErr()
-			}
-			directiveOrder = newOrder
-			return newOrder, nil
-		case "before":
-		case "after":
-		default:
-			return nil, d.Errf("unknown positional '%s'", pos)
-		}
-
-		// get name of other directive
-		if !d.NextArg() {
-			return nil, d.ArgErr()
-		}
-		otherDir := d.Val()
-		if d.NextArg() {
-			return nil, d.ArgErr()
-		}
-
-		// insert directive into proper position
-		for i, d := range newOrder {
-			if d == otherDir {
-				if pos == "before" {
-					newOrder = append(newOrder[:i], append([]string{dirName}, newOrder[i:]...)...)
-				} else if pos == "after" {
-					newOrder = append(newOrder[:i+1], append([]string{dirName}, newOrder[i+1:]...)...)
-				}
-				break
-			}
-		}
-	}
-
-	directiveOrder = newOrder
-
-	return newOrder, nil
-}
-
-func parseOptStorage(d *caddyfile.Dispenser) (interface{}, error) {
-	if !d.Next() { // consume option name
-		return nil, d.ArgErr()
-	}
-	if !d.Next() { // get storage module name
-		return nil, d.ArgErr()
-	}
-	modName := d.Val()
-	mod, err := caddy.GetModule("caddy.storage." + modName)
-	if err != nil {
-		return nil, d.Errf("getting storage module '%s': %v", modName, err)
-	}
-	unm, ok := mod.New().(caddyfile.Unmarshaler)
-	if !ok {
-		return nil, d.Errf("storage module '%s' is not a Caddyfile unmarshaler", mod.ID)
-	}
-	err = unm.UnmarshalCaddyfile(d.NewFromNextSegment())
-	if err != nil {
-		return nil, err
-	}
-	storage, ok := unm.(caddy.StorageConverter)
-	if !ok {
-		return nil, d.Errf("module %s is not a StorageConverter", mod.ID)
-	}
-	return storage, nil
-}
-
-func parseOptACMEEAB(d *caddyfile.Dispenser) (interface{}, error) {
-	eab := new(acme.EAB)
-	for d.Next() {
-		if d.NextArg() {
-			return nil, d.ArgErr()
-		}
-		for nesting := d.Nesting(); d.NextBlock(nesting); {
-			switch d.Val() {
-			case "key_id":
-				if !d.NextArg() {
-					return nil, d.ArgErr()
-				}
-				eab.KeyID = d.Val()
-
-			case "mac_key":
-				if !d.NextArg() {
-					return nil, d.ArgErr()
-				}
-				eab.MACKey = d.Val()
-
-			default:
-				return nil, d.Errf("unrecognized parameter '%s'", d.Val())
-			}
-		}
-	}
-	return eab, nil
-}
-
-func parseOptCertIssuer(d *caddyfile.Dispenser) (interface{}, error) {
-	if !d.Next() { // consume option name
-		return nil, d.ArgErr()
-	}
-	if !d.Next() { // get issuer module name
-		return nil, d.ArgErr()
-	}
-	modName := d.Val()
-	mod, err := caddy.GetModule("tls.issuance." + modName)
-	if err != nil {
-		return nil, d.Errf("getting issuer module '%s': %v", modName, err)
-	}
-	unm, ok := mod.New().(caddyfile.Unmarshaler)
-	if !ok {
-		return nil, d.Errf("issuer module '%s' is not a Caddyfile unmarshaler", mod.ID)
-	}
-	err = unm.UnmarshalCaddyfile(d.NewFromNextSegment())
-	if err != nil {
-		return nil, err
-	}
-	iss, ok := unm.(certmagic.Issuer)
-	if !ok {
-		return nil, d.Errf("module %s is not a certmagic.Issuer", mod.ID)
-	}
-	return iss, nil
-}
-
-func parseOptSingleString(d *caddyfile.Dispenser) (interface{}, error) {
-	d.Next() // consume parameter name
-	if !d.Next() {
-		return "", d.ArgErr()
-	}
-	val := d.Val()
-	if d.Next() {
-		return "", d.ArgErr()
-	}
-	return val, nil
-}
-
-func parseOptAdmin(d *caddyfile.Dispenser) (interface{}, error) {
-	adminCfg := new(caddy.AdminConfig)
-	for d.Next() {
-		if d.NextArg() {
-			listenAddress := d.Val()
-			if listenAddress == "off" {
-				adminCfg.Disabled = true
-				if d.Next() { // Do not accept any remaining options including block
-					return nil, d.Err("No more option is allowed after turning off admin config")
-				}
-			} else {
-				adminCfg.Listen = listenAddress
-				if d.NextArg() { // At most 1 arg is allowed
-					return nil, d.ArgErr()
-				}
-			}
-		}
-		for nesting := d.Nesting(); d.NextBlock(nesting); {
-			switch d.Val() {
-			case "enforce_origin":
-				adminCfg.EnforceOrigin = true
-
-			case "origins":
-				adminCfg.Origins = d.RemainingArgs()
-
-			default:
-				return nil, d.Errf("unrecognized parameter '%s'", d.Val())
-			}
-		}
-	}
-	if adminCfg.Listen == "" && !adminCfg.Disabled {
-		adminCfg.Listen = caddy.DefaultAdminListen
-	}
-	return adminCfg, nil
-}
-
-func parseOptOnDemand(d *caddyfile.Dispenser) (interface{}, error) {
-	var ond *caddytls.OnDemandConfig
-	for d.Next() {
-		if d.NextArg() {
-			return nil, d.ArgErr()
-		}
-		for nesting := d.Nesting(); d.NextBlock(nesting); {
-			switch d.Val() {
-			case "ask":
-				if !d.NextArg() {
-					return nil, d.ArgErr()
-				}
-				if ond == nil {
-					ond = new(caddytls.OnDemandConfig)
-				}
-				ond.Ask = d.Val()
-
-			case "interval":
-				if !d.NextArg() {
-					return nil, d.ArgErr()
-				}
-				dur, err := caddy.ParseDuration(d.Val())
-				if err != nil {
-					return nil, err
-				}
-				if ond == nil {
-					ond = new(caddytls.OnDemandConfig)
-				}
-				if ond.RateLimit == nil {
-					ond.RateLimit = new(caddytls.RateLimit)
-				}
-				ond.RateLimit.Interval = caddy.Duration(dur)
-
-			case "burst":
-				if !d.NextArg() {
-					return nil, d.ArgErr()
-				}
-				burst, err := strconv.Atoi(d.Val())
-				if err != nil {
-					return nil, err
-				}
-				if ond == nil {
-					ond = new(caddytls.OnDemandConfig)
-				}
-				if ond.RateLimit == nil {
-					ond.RateLimit = new(caddytls.RateLimit)
-				}
-				ond.RateLimit.Burst = burst
-
-			default:
-				return nil, d.Errf("unrecognized parameter '%s'", d.Val())
-			}
-		}
-	}
-	if ond == nil {
-		return nil, d.Err("expected at least one config parameter for on_demand_tls")
-	}
-	return ond, nil
-}
-
-func parseOptAutoHTTPS(d *caddyfile.Dispenser) (interface{}, error) {
-	d.Next() // consume parameter name
-	if !d.Next() {
-		return "", d.ArgErr()
-	}
-	val := d.Val()
-	if d.Next() {
-		return "", d.ArgErr()
-	}
-	if val != "off" && val != "disable_redirects" {
-		return "", d.Errf("auto_https must be either 'off' or 'disable_redirects'")
-	}
-	return val, nil
-}
-
-func parseServerOptions(d *caddyfile.Dispenser) (interface{}, error) {
-	return unmarshalCaddyfileServerOptions(d)
-}

caddyconfig/httpcaddyfile/serveroptions.go

@@ -1,235 +0,0 @@
-// 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 (
-	"encoding/json"
-	"fmt"
-
-	"github.com/caddyserver/caddy/v2"
-	"github.com/caddyserver/caddy/v2/caddyconfig"
-	"github.com/caddyserver/caddy/v2/caddyconfig/caddyfile"
-	"github.com/caddyserver/caddy/v2/modules/caddyhttp"
-	"github.com/dustin/go-humanize"
-)
-
-// serverOptions collects server config overrides parsed from Caddyfile global options
-type serverOptions struct {
-	// If set, will only apply these options to servers that contain a
-	// listener address that matches exactly. If empty, will apply to all
-	// servers that were not already matched by another serverOptions.
-	ListenerAddress string
-
-	// These will all map 1:1 to the caddyhttp.Server struct
-	ListenerWrappersRaw []json.RawMessage
-	ReadTimeout         caddy.Duration
-	ReadHeaderTimeout   caddy.Duration
-	WriteTimeout        caddy.Duration
-	IdleTimeout         caddy.Duration
-	MaxHeaderBytes      int
-	AllowH2C            bool
-	ExperimentalHTTP3   bool
-	StrictSNIHost       *bool
-}
-
-func unmarshalCaddyfileServerOptions(d *caddyfile.Dispenser) (interface{}, error) {
-	serverOpts := serverOptions{}
-	for d.Next() {
-		if d.NextArg() {
-			serverOpts.ListenerAddress = d.Val()
-			if d.NextArg() {
-				return nil, d.ArgErr()
-			}
-		}
-		for nesting := d.Nesting(); d.NextBlock(nesting); {
-			switch d.Val() {
-			case "listener_wrappers":
-				for nesting := d.Nesting(); d.NextBlock(nesting); {
-					mod, err := caddy.GetModule("caddy.listeners." + d.Val())
-					if err != nil {
-						return nil, fmt.Errorf("finding listener module '%s': %v", d.Val(), err)
-					}
-					unm, ok := mod.New().(caddyfile.Unmarshaler)
-					if !ok {
-						return nil, fmt.Errorf("listener module '%s' is not a Caddyfile unmarshaler", mod)
-					}
-					err = unm.UnmarshalCaddyfile(d.NewFromNextSegment())
-					if err != nil {
-						return nil, err
-					}
-					listenerWrapper, ok := unm.(caddy.ListenerWrapper)
-					if !ok {
-						return nil, fmt.Errorf("module %s is not a listener wrapper", mod)
-					}
-					jsonListenerWrapper := caddyconfig.JSONModuleObject(
-						listenerWrapper,
-						"wrapper",
-						listenerWrapper.(caddy.Module).CaddyModule().ID.Name(),
-						nil,
-					)
-					serverOpts.ListenerWrappersRaw = append(serverOpts.ListenerWrappersRaw, jsonListenerWrapper)
-				}
-
-			case "timeouts":
-				for nesting := d.Nesting(); d.NextBlock(nesting); {
-					switch d.Val() {
-					case "read_body":
-						if !d.NextArg() {
-							return nil, d.ArgErr()
-						}
-						dur, err := caddy.ParseDuration(d.Val())
-						if err != nil {
-							return nil, d.Errf("parsing read_body timeout duration: %v", err)
-						}
-						serverOpts.ReadTimeout = caddy.Duration(dur)
-
-					case "read_header":
-						if !d.NextArg() {
-							return nil, d.ArgErr()
-						}
-						dur, err := caddy.ParseDuration(d.Val())
-						if err != nil {
-							return nil, d.Errf("parsing read_header timeout duration: %v", err)
-						}
-						serverOpts.ReadHeaderTimeout = caddy.Duration(dur)
-
-					case "write":
-						if !d.NextArg() {
-							return nil, d.ArgErr()
-						}
-						dur, err := caddy.ParseDuration(d.Val())
-						if err != nil {
-							return nil, d.Errf("parsing write timeout duration: %v", err)
-						}
-						serverOpts.WriteTimeout = caddy.Duration(dur)
-
-					case "idle":
-						if !d.NextArg() {
-							return nil, d.ArgErr()
-						}
-						dur, err := caddy.ParseDuration(d.Val())
-						if err != nil {
-							return nil, d.Errf("parsing idle timeout duration: %v", err)
-						}
-						serverOpts.IdleTimeout = caddy.Duration(dur)
-
-					default:
-						return nil, d.Errf("unrecognized timeouts option '%s'", d.Val())
-					}
-				}
-
-			case "max_header_size":
-				var sizeStr string
-				if !d.AllArgs(&sizeStr) {
-					return nil, d.ArgErr()
-				}
-				size, err := humanize.ParseBytes(sizeStr)
-				if err != nil {
-					return nil, d.Errf("parsing max_header_size: %v", err)
-				}
-				serverOpts.MaxHeaderBytes = int(size)
-
-			case "protocol":
-				for nesting := d.Nesting(); d.NextBlock(nesting); {
-					switch d.Val() {
-					case "allow_h2c":
-						if d.NextArg() {
-							return nil, d.ArgErr()
-						}
-						serverOpts.AllowH2C = true
-
-					case "experimental_http3":
-						if d.NextArg() {
-							return nil, d.ArgErr()
-						}
-						serverOpts.ExperimentalHTTP3 = true
-
-					case "strict_sni_host":
-						if d.NextArg() {
-							return nil, d.ArgErr()
-						}
-						trueBool := true
-						serverOpts.StrictSNIHost = &trueBool
-
-					default:
-						return nil, d.Errf("unrecognized protocol option '%s'", d.Val())
-					}
-				}
-
-			default:
-				return nil, d.Errf("unrecognized servers option '%s'", d.Val())
-			}
-		}
-	}
-	return serverOpts, nil
-}
-
-// applyServerOptions sets the server options on the appropriate servers
-func applyServerOptions(
-	servers map[string]*caddyhttp.Server,
-	options map[string]interface{},
-	warnings *[]caddyconfig.Warning,
-) error {
-	// If experimental HTTP/3 is enabled, enable it on each server.
-	// We already know there won't be a conflict with serverOptions because
-	// we validated earlier that "experimental_http3" cannot be set at the same
-	// time as "servers"
-	if enableH3, ok := options["experimental_http3"].(bool); ok && enableH3 {
-		*warnings = append(*warnings, caddyconfig.Warning{Message: "the 'experimental_http3' global option is deprecated, please use the 'servers > protocol > experimental_http3' option instead"})
-		for _, srv := range servers {
-			srv.ExperimentalHTTP3 = true
-		}
-	}
-
-	serverOpts, ok := options["servers"].([]serverOptions)
-	if !ok {
-		return nil
-	}
-
-	for _, server := range servers {
-		// find the options that apply to this server
-		opts := func() *serverOptions {
-			for _, entry := range serverOpts {
-				if entry.ListenerAddress == "" {
-					return &entry
-				}
-				for _, listener := range server.Listen {
-					if entry.ListenerAddress == listener {
-						return &entry
-					}
-				}
-			}
-			return nil
-		}()
-
-		// if none apply, then move to the next server
-		if opts == nil {
-			continue
-		}
-
-		// set all the options
-		server.ListenerWrappersRaw = opts.ListenerWrappersRaw
-		server.ReadTimeout = opts.ReadTimeout
-		server.ReadHeaderTimeout = opts.ReadHeaderTimeout
-		server.WriteTimeout = opts.WriteTimeout
-		server.IdleTimeout = opts.IdleTimeout
-		server.MaxHeaderBytes = opts.MaxHeaderBytes
-		server.AllowH2C = opts.AllowH2C
-		server.ExperimentalHTTP3 = opts.ExperimentalHTTP3
-		server.StrictSNIHost = opts.StrictSNIHost
-	}
-
-	return nil
-}

caddyconfig/httpcaddyfile/tlsapp.go

@@ -1,576 +0,0 @@
-// 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 (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"reflect"
-	"sort"
-	"strconv"
-	"strings"
-
-	"github.com/caddyserver/caddy/v2"
-	"github.com/caddyserver/caddy/v2/caddyconfig"
-	"github.com/caddyserver/caddy/v2/modules/caddyhttp"
-	"github.com/caddyserver/caddy/v2/modules/caddytls"
-	"github.com/caddyserver/certmagic"
-	"github.com/mholt/acmez/acme"
-)
-
-func (st ServerType) buildTLSApp(
-	pairings []sbAddrAssociation,
-	options map[string]interface{},
-	warnings []caddyconfig.Warning,
-) (*caddytls.TLS, []caddyconfig.Warning, error) {
-
-	tlsApp := &caddytls.TLS{CertificatesRaw: make(caddy.ModuleMap)}
-	var certLoaders []caddytls.CertificateLoader
-
-	httpsPort := strconv.Itoa(caddyhttp.DefaultHTTPSPort)
-	if hsp, ok := options["https_port"].(int); ok {
-		httpsPort = strconv.Itoa(hsp)
-	}
-
-	// count how many server blocks have a TLS-enabled key with
-	// no host, and find all hosts that share a server block with
-	// a hostless key, so that they don't get forgotten/omitted
-	// by auto-HTTPS (since they won't appear in route matchers)
-	var serverBlocksWithTLSHostlessKey int
-	hostsSharedWithHostlessKey := make(map[string]struct{})
-	for _, pair := range pairings {
-		for _, sb := range pair.serverBlocks {
-			for _, addr := range sb.keys {
-				if addr.Host == "" {
-					// this address has no hostname, but if it's explicitly set
-					// to HTTPS, then we need to count it as being TLS-enabled
-					if addr.Scheme == "https" || addr.Port == httpsPort {
-						serverBlocksWithTLSHostlessKey++
-					}
-					// this server block has a hostless key, now
-					// go through and add all the hosts to the set
-					for _, otherAddr := range sb.keys {
-						if otherAddr.Original == addr.Original {
-							continue
-						}
-						if otherAddr.Host != "" {
-							hostsSharedWithHostlessKey[otherAddr.Host] = struct{}{}
-						}
-					}
-					break
-				}
-			}
-		}
-	}
-
-	// a catch-all automation policy is used as a "default" for all subjects that
-	// don't have custom configuration explicitly associated with them; this
-	// is only to add if the global settings or defaults are non-empty
-	catchAllAP, err := newBaseAutomationPolicy(options, warnings, false)
-	if err != nil {
-		return nil, warnings, err
-	}
-	if catchAllAP != nil {
-		if tlsApp.Automation == nil {
-			tlsApp.Automation = new(caddytls.AutomationConfig)
-		}
-		tlsApp.Automation.Policies = append(tlsApp.Automation.Policies, catchAllAP)
-	}
-
-	for _, p := range pairings {
-		for _, sblock := range p.serverBlocks {
-			// get values that populate an automation policy for this block
-			ap, err := newBaseAutomationPolicy(options, warnings, true)
-			if err != nil {
-				return nil, warnings, err
-			}
-
-			sblockHosts := sblock.hostsFromKeys(false)
-			if len(sblockHosts) == 0 && catchAllAP != nil {
-				ap = catchAllAP
-			}
-
-			// on-demand tls
-			if _, ok := sblock.pile["tls.on_demand"]; ok {
-				ap.OnDemand = true
-			}
-
-			// certificate issuers
-			if issuerVals, ok := sblock.pile["tls.cert_issuer"]; ok {
-				var issuers []certmagic.Issuer
-				for _, issuerVal := range issuerVals {
-					ap.Issuers = append(ap.Issuers, issuerVal.Value.(certmagic.Issuer))
-				}
-				if ap == catchAllAP && !reflect.DeepEqual(ap.Issuers, issuers) {
-					return nil, warnings, fmt.Errorf("automation policy from site block is also default/catch-all policy because of key without hostname, and the two are in conflict: %#v != %#v", ap.Issuers, issuers)
-				}
-			}
-
-			// custom bind host
-			for _, cfgVal := range sblock.pile["bind"] {
-				for _, iss := range ap.Issuers {
-					// if an issuer was already configured and it is NOT an ACME issuer,
-					// skip, since we intend to adjust only ACME issuers; ensure we
-					// include any issuer that embeds/wraps an underlying ACME issuer
-					var acmeIssuer *caddytls.ACMEIssuer
-					if acmeWrapper, ok := iss.(acmeCapable); ok {
-						acmeIssuer = acmeWrapper.GetACMEIssuer()
-					}
-					if acmeIssuer == nil {
-						continue
-					}
-
-					// proceed to configure the ACME issuer's bind host, without
-					// overwriting any existing settings
-					if acmeIssuer.Challenges == nil {
-						acmeIssuer.Challenges = new(caddytls.ChallengesConfig)
-					}
-					if acmeIssuer.Challenges.BindHost == "" {
-						// only binding to one host is supported
-						var bindHost string
-						if bindHosts, ok := cfgVal.Value.([]string); ok && len(bindHosts) > 0 {
-							bindHost = bindHosts[0]
-						}
-						acmeIssuer.Challenges.BindHost = bindHost
-					}
-				}
-			}
-
-			// first make sure this block is allowed to create an automation policy;
-			// doing so is forbidden if it has a key with no host (i.e. ":443")
-			// and if there is a different server block that also has a key with no
-			// host -- since a key with no host matches any host, we need its
-			// associated automation policy to have an empty Subjects list, i.e. no
-			// host filter, which is indistinguishable between the two server blocks
-			// because automation is not done in the context of a particular server...
-			// this is an example of a poor mapping from Caddyfile to JSON but that's
-			// the least-leaky abstraction I could figure out
-			if len(sblockHosts) == 0 {
-				if serverBlocksWithTLSHostlessKey > 1 {
-					// this server block and at least one other has a key with no host,
-					// making the two indistinguishable; it is misleading to define such
-					// a policy within one server block since it actually will apply to
-					// others as well
-					return nil, warnings, fmt.Errorf("cannot make a TLS automation policy from a server block that has a host-less address when there are other TLS-enabled server block addresses lacking a host")
-				}
-				if catchAllAP == nil {
-					// this server block has a key with no hosts, but there is not yet
-					// a catch-all automation policy (probably because no global options
-					// were set), so this one becomes it
-					catchAllAP = ap
-				}
-			}
-
-			// associate our new automation policy with this server block's hosts
-			ap.Subjects = sblockHosts
-			sort.Strings(ap.Subjects) // solely for deterministic test results
-
-			// if a combination of public and internal names were given
-			// for this same server block and no issuer was specified, we
-			// need to separate them out in the automation policies so
-			// that the internal names can use the internal issuer and
-			// the other names can use the default/public/ACME issuer
-			var ap2 *caddytls.AutomationPolicy
-			if len(ap.Issuers) == 0 {
-				var internal, external []string
-				for _, s := range ap.Subjects {
-					if !certmagic.SubjectQualifiesForCert(s) {
-						return nil, warnings, fmt.Errorf("subject does not qualify for certificate: '%s'", s)
-					}
-					// we don't use certmagic.SubjectQualifiesForPublicCert() because of one nuance:
-					// names like *.*.tld that may not qualify for a public certificate are actually
-					// fine when used with OnDemand, since OnDemand (currently) does not obtain
-					// wildcards (if it ever does, there will be a separate config option to enable
-					// it that we would need to check here) since the hostname is known at handshake;
-					// and it is unexpected to switch to internal issuer when the user wants to get
-					// regular certificates on-demand for a class of certs like *.*.tld.
-					if !certmagic.SubjectIsIP(s) && !certmagic.SubjectIsInternal(s) && (strings.Count(s, "*.") < 2 || ap.OnDemand) {
-						external = append(external, s)
-					} else {
-						internal = append(internal, s)
-					}
-				}
-				if len(external) > 0 && len(internal) > 0 {
-					ap.Subjects = external
-					apCopy := *ap
-					ap2 = &apCopy
-					ap2.Subjects = internal
-					ap2.IssuersRaw = []json.RawMessage{caddyconfig.JSONModuleObject(caddytls.InternalIssuer{}, "module", "internal", &warnings)}
-				}
-			}
-			if tlsApp.Automation == nil {
-				tlsApp.Automation = new(caddytls.AutomationConfig)
-			}
-			tlsApp.Automation.Policies = append(tlsApp.Automation.Policies, ap)
-			if ap2 != nil {
-				tlsApp.Automation.Policies = append(tlsApp.Automation.Policies, ap2)
-			}
-
-			// certificate loaders
-			if clVals, ok := sblock.pile["tls.cert_loader"]; ok {
-				for _, clVal := range clVals {
-					certLoaders = append(certLoaders, clVal.Value.(caddytls.CertificateLoader))
-				}
-			}
-		}
-	}
-
-	// group certificate loaders by module name, then add to config
-	if len(certLoaders) > 0 {
-		loadersByName := make(map[string]caddytls.CertificateLoader)
-		for _, cl := range certLoaders {
-			name := caddy.GetModuleName(cl)
-			// ugh... technically, we may have multiple FileLoader and FolderLoader
-			// modules (because the tls directive returns one per occurrence), but
-			// the config structure expects only one instance of each kind of loader
-			// module, so we have to combine them... instead of enumerating each
-			// possible cert loader module in a type switch, we can use reflection,
-			// which works on any cert loaders that are slice types
-			if reflect.TypeOf(cl).Kind() == reflect.Slice {
-				combined := reflect.ValueOf(loadersByName[name])
-				if !combined.IsValid() {
-					combined = reflect.New(reflect.TypeOf(cl)).Elem()
-				}
-				clVal := reflect.ValueOf(cl)
-				for i := 0; i < clVal.Len(); i++ {
-					combined = reflect.Append(combined, clVal.Index(i))
-				}
-				loadersByName[name] = combined.Interface().(caddytls.CertificateLoader)
-			}
-		}
-		for certLoaderName, loaders := range loadersByName {
-			tlsApp.CertificatesRaw[certLoaderName] = caddyconfig.JSON(loaders, &warnings)
-		}
-	}
-
-	// set any of the on-demand options, for if/when on-demand TLS is enabled
-	if onDemand, ok := options["on_demand_tls"].(*caddytls.OnDemandConfig); ok {
-		if tlsApp.Automation == nil {
-			tlsApp.Automation = new(caddytls.AutomationConfig)
-		}
-		tlsApp.Automation.OnDemand = onDemand
-	}
-
-	// if any hostnames appear on the same server block as a key with
-	// no host, they will not be used with route matchers because the
-	// hostless key matches all hosts, therefore, it wouldn't be
-	// considered for auto-HTTPS, so we need to make sure those hosts
-	// are manually considered for managed certificates; we also need
-	// to make sure that any of these names which are internal-only
-	// get internal certificates by default rather than ACME
-	var al caddytls.AutomateLoader
-	internalAP := &caddytls.AutomationPolicy{
-		IssuersRaw: []json.RawMessage{json.RawMessage(`{"module":"internal"}`)},
-	}
-	for h := range hostsSharedWithHostlessKey {
-		al = append(al, h)
-		if !certmagic.SubjectQualifiesForPublicCert(h) {
-			internalAP.Subjects = append(internalAP.Subjects, h)
-		}
-	}
-	if len(al) > 0 {
-		tlsApp.CertificatesRaw["automate"] = caddyconfig.JSON(al, &warnings)
-	}
-	if len(internalAP.Subjects) > 0 {
-		if tlsApp.Automation == nil {
-			tlsApp.Automation = new(caddytls.AutomationConfig)
-		}
-		tlsApp.Automation.Policies = append(tlsApp.Automation.Policies, internalAP)
-	}
-
-	// if there are any global options set for issuers (ACME ones in particular), make sure they
-	// take effect in every automation policy that does not have any issuers
-	if tlsApp.Automation != nil {
-		globalEmail := options["email"]
-		globalACMECA := options["acme_ca"]
-		globalACMECARoot := options["acme_ca_root"]
-		globalACMEDNS := options["acme_dns"]
-		globalACMEEAB := options["acme_eab"]
-		hasGlobalACMEDefaults := globalEmail != nil || globalACMECA != nil || globalACMECARoot != nil || globalACMEDNS != nil || globalACMEEAB != nil
-		if hasGlobalACMEDefaults {
-			for _, ap := range tlsApp.Automation.Policies {
-				if len(ap.Issuers) == 0 {
-					acme, zerosslACME := new(caddytls.ACMEIssuer), new(caddytls.ACMEIssuer)
-					zerossl := &caddytls.ZeroSSLIssuer{ACMEIssuer: zerosslACME}
-					ap.Issuers = []certmagic.Issuer{acme, zerossl} // TODO: keep this in sync with Caddy's other issuer defaults elsewhere, like in caddytls/automation.go (DefaultIssuers).
-
-					// if a non-ZeroSSL endpoint is specified, we assume we can't use the ZeroSSL issuer successfully
-					if globalACMECA != nil && !strings.Contains(globalACMECA.(string), "zerossl") {
-						ap.Issuers = []certmagic.Issuer{acme}
-					}
-				}
-			}
-		}
-	}
-
-	// finalize and verify policies; do cleanup
-	if tlsApp.Automation != nil {
-		for i, ap := range tlsApp.Automation.Policies {
-			// ensure all issuers have global defaults filled in
-			for j, issuer := range ap.Issuers {
-				err := fillInGlobalACMEDefaults(issuer, options)
-				if err != nil {
-					return nil, warnings, fmt.Errorf("filling in global issuer defaults for AP %d, issuer %d: %v", i, j, err)
-				}
-			}
-
-			// encode all issuer values we created, so they will be rendered in the output
-			if len(ap.Issuers) > 0 && ap.IssuersRaw == nil {
-				for _, iss := range ap.Issuers {
-					issuerName := iss.(caddy.Module).CaddyModule().ID.Name()
-					ap.IssuersRaw = append(ap.IssuersRaw, caddyconfig.JSONModuleObject(iss, "module", issuerName, &warnings))
-				}
-			}
-		}
-
-		// consolidate automation policies that are the exact same
-		tlsApp.Automation.Policies = consolidateAutomationPolicies(tlsApp.Automation.Policies)
-
-		// ensure automation policies don't overlap subjects (this should be
-		// an error at provision-time as well, but catch it in the adapt phase
-		// for convenience)
-		automationHostSet := make(map[string]struct{})
-		for _, ap := range tlsApp.Automation.Policies {
-			for _, s := range ap.Subjects {
-				if _, ok := automationHostSet[s]; ok {
-					return nil, warnings, fmt.Errorf("hostname appears in more than one automation policy, making certificate management ambiguous: %s", s)
-				}
-				automationHostSet[s] = struct{}{}
-			}
-		}
-
-		// if nothing remains, remove any excess values to clean up the resulting config
-		if len(tlsApp.Automation.Policies) == 0 {
-			tlsApp.Automation.Policies = nil
-		}
-		if reflect.DeepEqual(tlsApp.Automation, new(caddytls.AutomationConfig)) {
-			tlsApp.Automation = nil
-		}
-	}
-
-	return tlsApp, warnings, nil
-}
-
-type acmeCapable interface{ GetACMEIssuer() *caddytls.ACMEIssuer }
-
-func fillInGlobalACMEDefaults(issuer certmagic.Issuer, options map[string]interface{}) error {
-	acmeWrapper, ok := issuer.(acmeCapable)
-	if !ok {
-		return nil
-	}
-	acmeIssuer := acmeWrapper.GetACMEIssuer()
-	if acmeIssuer == nil {
-		return nil
-	}
-
-	globalEmail := options["email"]
-	globalACMECA := options["acme_ca"]
-	globalACMECARoot := options["acme_ca_root"]
-	globalACMEDNS := options["acme_dns"]
-	globalACMEEAB := options["acme_eab"]
-
-	if globalEmail != nil && acmeIssuer.Email == "" {
-		acmeIssuer.Email = globalEmail.(string)
-	}
-	if globalACMECA != nil && acmeIssuer.CA == "" {
-		acmeIssuer.CA = globalACMECA.(string)
-	}
-	if globalACMECARoot != nil && !sliceContains(acmeIssuer.TrustedRootsPEMFiles, globalACMECARoot.(string)) {
-		acmeIssuer.TrustedRootsPEMFiles = append(acmeIssuer.TrustedRootsPEMFiles, globalACMECARoot.(string))
-	}
-	if globalACMEDNS != nil && (acmeIssuer.Challenges == nil || acmeIssuer.Challenges.DNS == nil) {
-		provName := globalACMEDNS.(string)
-		dnsProvModule, err := caddy.GetModule("dns.providers." + provName)
-		if err != nil {
-			return fmt.Errorf("getting DNS provider module named '%s': %v", provName, err)
-		}
-		acmeIssuer.Challenges = &caddytls.ChallengesConfig{
-			DNS: &caddytls.DNSChallengeConfig{
-				ProviderRaw: caddyconfig.JSONModuleObject(dnsProvModule.New(), "name", provName, nil),
-			},
-		}
-	}
-	if globalACMEEAB != nil && acmeIssuer.ExternalAccount == nil {
-		acmeIssuer.ExternalAccount = globalACMEEAB.(*acme.EAB)
-	}
-	return nil
-}
-
-// newBaseAutomationPolicy returns a new TLS automation policy that gets
-// its values from the global options map. It should be used as the base
-// for any other automation policies. A nil policy (and no error) will be
-// returned if there are no default/global options. However, if always is
-// true, a non-nil value will always be returned (unless there is an error).
-func newBaseAutomationPolicy(options map[string]interface{}, warnings []caddyconfig.Warning, always bool) (*caddytls.AutomationPolicy, error) {
-	issuer, hasIssuer := options["cert_issuer"]
-	_, hasLocalCerts := options["local_certs"]
-	keyType, hasKeyType := options["key_type"]
-
-	hasGlobalAutomationOpts := hasIssuer || hasLocalCerts || hasKeyType
-
-	// if there are no global options related to automation policies
-	// set, then we can just return right away
-	if !hasGlobalAutomationOpts {
-		if always {
-			return new(caddytls.AutomationPolicy), nil
-		}
-		return nil, nil
-	}
-
-	ap := new(caddytls.AutomationPolicy)
-	if hasKeyType {
-		ap.KeyType = keyType.(string)
-	}
-
-	if hasIssuer && hasLocalCerts {
-		return nil, fmt.Errorf("global options are ambiguous: local_certs is confusing when combined with cert_issuer, because local_certs is also a specific kind of issuer")
-	}
-
-	if hasIssuer {
-		ap.Issuers = []certmagic.Issuer{issuer.(certmagic.Issuer)}
-	} else if hasLocalCerts {
-		ap.Issuers = []certmagic.Issuer{new(caddytls.InternalIssuer)}
-	}
-
-	return ap, nil
-}
-
-// disambiguateACMEIssuer returns an issuer based on the properties of acmeIssuer.
-// If acmeIssuer implicitly configures a certain kind of ACMEIssuer (for example,
-// ZeroSSL), the proper wrapper over acmeIssuer will be returned instead.
-func disambiguateACMEIssuer(acmeIssuer *caddytls.ACMEIssuer) certmagic.Issuer {
-	// as a special case, we integrate with ZeroSSL's ACME endpoint if it looks like an
-	// implicit ZeroSSL configuration (this requires a  wrapper type over ACMEIssuer
-	// because of the EAB generation; if EAB is provided, we can use plain ACMEIssuer)
-	if strings.Contains(acmeIssuer.CA, "acme.zerossl.com") && acmeIssuer.ExternalAccount == nil {
-		return &caddytls.ZeroSSLIssuer{ACMEIssuer: acmeIssuer}
-	}
-	return acmeIssuer
-}
-
-// consolidateAutomationPolicies combines automation policies that are the same,
-// for a cleaner overall output.
-func consolidateAutomationPolicies(aps []*caddytls.AutomationPolicy) []*caddytls.AutomationPolicy {
-	// sort from most specific to least specific; we depend on this ordering
-	sort.SliceStable(aps, func(i, j int) bool {
-		if automationPolicyIsSubset(aps[i], aps[j]) {
-			return true
-		}
-		if automationPolicyIsSubset(aps[j], aps[i]) {
-			return false
-		}
-		return len(aps[i].Subjects) > len(aps[j].Subjects)
-	})
-
-	// remove any empty policies (except subjects, of course)
-	emptyAP := new(caddytls.AutomationPolicy)
-	for i := 0; i < len(aps); i++ {
-		emptyAP.Subjects = aps[i].Subjects
-		if reflect.DeepEqual(aps[i], emptyAP) {
-			aps = append(aps[:i], aps[i+1:]...)
-			i--
-		}
-	}
-
-	// remove or combine duplicate policies
-	for i := 0; i < len(aps); i++ {
-		// compare only with next policies; we sorted by specificity so we must not delete earlier policies
-		for j := i + 1; j < len(aps); j++ {
-			// if they're exactly equal in every way, just keep one of them
-			if reflect.DeepEqual(aps[i], aps[j]) {
-				aps = append(aps[:j], aps[j+1:]...)
-				i--
-				break
-			}
-
-			// if the policy is the same, we can keep just one, but we have
-			// to be careful which one we keep; if only one has any hostnames
-			// defined, then we need to keep the one without any hostnames,
-			// otherwise the one without any subjects (a catch-all) would be
-			// eaten up by the one with subjects; and if both have subjects, we
-			// need to combine their lists
-			if reflect.DeepEqual(aps[i].IssuersRaw, aps[j].IssuersRaw) &&
-				bytes.Equal(aps[i].StorageRaw, aps[j].StorageRaw) &&
-				aps[i].MustStaple == aps[j].MustStaple &&
-				aps[i].KeyType == aps[j].KeyType &&
-				aps[i].OnDemand == aps[j].OnDemand &&
-				aps[i].RenewalWindowRatio == aps[j].RenewalWindowRatio {
-				if len(aps[i].Subjects) > 0 && len(aps[j].Subjects) == 0 {
-					// later policy (at j) has no subjects ("catch-all"), so we can
-					// remove the identical-but-more-specific policy that comes first
-					// AS LONG AS it is not shadowed by another policy before it; e.g.
-					// if policy i is for example.com, policy i+1 is '*.com', and policy
-					// j is catch-all, we cannot remove policy i because that would
-					// cause example.com to be served by the less specific policy for
-					// '*.com', which might be different (yes we've seen this happen)
-					if automationPolicyShadows(i, aps) >= j {
-						aps = append(aps[:i], aps[i+1:]...)
-					}
-				} else {
-					// avoid repeated subjects
-					for _, subj := range aps[j].Subjects {
-						if !sliceContains(aps[i].Subjects, subj) {
-							aps[i].Subjects = append(aps[i].Subjects, subj)
-						}
-					}
-					aps = append(aps[:j], aps[j+1:]...)
-					j--
-				}
-			}
-		}
-	}
-
-	return aps
-}
-
-// automationPolicyIsSubset returns true if a's subjects are a subset
-// of b's subjects.
-func automationPolicyIsSubset(a, b *caddytls.AutomationPolicy) bool {
-	if len(b.Subjects) == 0 {
-		return true
-	}
-	if len(a.Subjects) == 0 {
-		return false
-	}
-	for _, aSubj := range a.Subjects {
-		var inSuperset bool
-		for _, bSubj := range b.Subjects {
-			if certmagic.MatchWildcard(aSubj, bSubj) {
-				inSuperset = true
-				break
-			}
-		}
-		if !inSuperset {
-			return false
-		}
-	}
-	return true
-}
-
-// automationPolicyShadows returns the index of a policy that aps[i] shadows;
-// in other words, for all policies after position i, if that policy covers
-// the same subjects but is less specific, that policy's position is returned,
-// or -1 if no shadowing is found. For example, if policy i is for
-// "foo.example.com" and policy i+2 is for "*.example.com", then i+2 will be
-// returned, since that policy is shadowed by i, which is in front.
-func automationPolicyShadows(i int, aps []*caddytls.AutomationPolicy) int {
-	for j := i + 1; j < len(aps); j++ {
-		if automationPolicyIsSubset(aps[i], aps[j]) {
-			return j
-		}
-	}
-	return -1
-}

caddyconfig/httpcaddyfile/tlsapp_test.go

@@ -1,56 +0,0 @@
-package httpcaddyfile
-
-import (
-	"testing"
-
-	"github.com/caddyserver/caddy/v2/modules/caddytls"
-)
-
-func TestAutomationPolicyIsSubset(t *testing.T) {
-	for i, test := range []struct {
-		a, b   []string
-		expect bool
-	}{
-		{
-			a:      []string{"example.com"},
-			b:      []string{},
-			expect: true,
-		},
-		{
-			a:      []string{},
-			b:      []string{"example.com"},
-			expect: false,
-		},
-		{
-			a:      []string{"foo.example.com"},
-			b:      []string{"*.example.com"},
-			expect: true,
-		},
-		{
-			a:      []string{"foo.example.com"},
-			b:      []string{"foo.example.com"},
-			expect: true,
-		},
-		{
-			a:      []string{"foo.example.com"},
-			b:      []string{"example.com"},
-			expect: false,
-		},
-		{
-			a:      []string{"example.com", "foo.example.com"},
-			b:      []string{"*.com", "*.*.com"},
-			expect: true,
-		},
-		{
-			a:      []string{"example.com", "foo.example.com"},
-			b:      []string{"*.com"},
-			expect: false,
-		},
-	} {
-		apA := &caddytls.AutomationPolicy{Subjects: test.a}
-		apB := &caddytls.AutomationPolicy{Subjects: test.b}
-		if actual := automationPolicyIsSubset(apA, apB); actual != test.expect {
-			t.Errorf("Test %d: Expected %t but got %t (A: %v  B: %v)", i, test.expect, actual, test.a, test.b)
-		}
-	}
-}

caddyconfig/load.go

@@ -1,153 +0,0 @@
-// 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 caddyconfig
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"io"
-	"mime"
-	"net/http"
-	"strings"
-	"sync"
-
-	"github.com/caddyserver/caddy/v2"
-)
-
-func init() {
-	caddy.RegisterModule(adminLoad{})
-}
-
-// adminLoad is a module that provides the /load endpoint
-// for the Caddy admin API. The only reason it's not baked
-// into the caddy package directly is because of the import
-// of the caddyconfig package for its GetAdapter function.
-// If the caddy package depends on the caddyconfig package,
-// then the caddyconfig package will not be able to import
-// the caddy package, and it can more easily cause backward
-// edges in the dependency tree (i.e. import cycle).
-// Fortunately, the admin API has first-class support for
-// adding endpoints from modules.
-type adminLoad struct{}
-
-// CaddyModule returns the Caddy module information.
-func (adminLoad) CaddyModule() caddy.ModuleInfo {
-	return caddy.ModuleInfo{
-		ID:  "admin.api.load",
-		New: func() caddy.Module { return new(adminLoad) },
-	}
-}
-
-// Routes returns a route for the /load endpoint.
-func (al adminLoad) Routes() []caddy.AdminRoute {
-	return []caddy.AdminRoute{
-		{
-			Pattern: "/load",
-			Handler: caddy.AdminHandlerFunc(al.handleLoad),
-		},
-	}
-}
-
-// handleLoad replaces the entire current configuration with
-// a new one provided in the response body. It supports config
-// adapters through the use of the Content-Type header. A
-// config that is identical to the currently-running config
-// will be a no-op unless Cache-Control: must-revalidate is set.
-func (adminLoad) handleLoad(w http.ResponseWriter, r *http.Request) error {
-	if r.Method != http.MethodPost {
-		return caddy.APIError{
-			Code: http.StatusMethodNotAllowed,
-			Err:  fmt.Errorf("method not allowed"),
-		}
-	}
-
-	buf := bufPool.Get().(*bytes.Buffer)
-	buf.Reset()
-	defer bufPool.Put(buf)
-
-	_, err := io.Copy(buf, r.Body)
-	if err != nil {
-		return caddy.APIError{
-			Code: http.StatusBadRequest,
-			Err:  fmt.Errorf("reading request body: %v", err),
-		}
-	}
-	body := buf.Bytes()
-
-	// if the config is formatted other than Caddy's native
-	// JSON, we need to adapt it before loading it
-	if ctHeader := r.Header.Get("Content-Type"); ctHeader != "" {
-		ct, _, err := mime.ParseMediaType(ctHeader)
-		if err != nil {
-			return caddy.APIError{
-				Code: http.StatusBadRequest,
-				Err:  fmt.Errorf("invalid Content-Type: %v", err),
-			}
-		}
-		if !strings.HasSuffix(ct, "/json") {
-			slashIdx := strings.Index(ct, "/")
-			if slashIdx < 0 {
-				return caddy.APIError{
-					Code: http.StatusBadRequest,
-					Err:  fmt.Errorf("malformed Content-Type"),
-				}
-			}
-			adapterName := ct[slashIdx+1:]
-			cfgAdapter := GetAdapter(adapterName)
-			if cfgAdapter == nil {
-				return caddy.APIError{
-					Code: http.StatusBadRequest,
-					Err:  fmt.Errorf("unrecognized config adapter '%s'", adapterName),
-				}
-			}
-			result, warnings, err := cfgAdapter.Adapt(body, nil)
-			if err != nil {
-				return caddy.APIError{
-					Code: http.StatusBadRequest,
-					Err:  fmt.Errorf("adapting config using %s adapter: %v", adapterName, err),
-				}
-			}
-			if len(warnings) > 0 {
-				respBody, err := json.Marshal(warnings)
-				if err != nil {
-					caddy.Log().Named("admin.api.load").Error(err.Error())
-				}
-				_, _ = w.Write(respBody)
-			}
-			body = result
-		}
-	}
-
-	forceReload := r.Header.Get("Cache-Control") == "must-revalidate"
-
-	err = caddy.Load(body, forceReload)
-	if err != nil {
-		return caddy.APIError{
-			Code: http.StatusBadRequest,
-			Err:  fmt.Errorf("loading config: %v", err),
-		}
-	}
-
-	caddy.Log().Named("admin.api").Info("load complete")
-
-	return nil
-}
-
-var bufPool = sync.Pool{
-	New: func() interface{} {
-		return new(bytes.Buffer)
-	},
-}

caddyfile/dispenser.go

@@ -0,0 +1,260 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// 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 caddyfile
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"strings"
+)
+
+// Dispenser is a type that dispenses tokens, similarly to a lexer,
+// except that it can do so with some notion of structure and has
+// some really convenient methods.
+type Dispenser struct {
+	filename string
+	tokens   []Token
+	cursor   int
+	nesting  int
+}
+
+// NewDispenser returns a Dispenser, ready to use for parsing the given input.
+func NewDispenser(filename string, input io.Reader) Dispenser {
+	tokens, _ := allTokens(input) // ignoring error because nothing to do with it
+	return Dispenser{
+		filename: filename,
+		tokens:   tokens,
+		cursor:   -1,
+	}
+}
+
+// NewDispenserTokens returns a Dispenser filled with the given tokens.
+func NewDispenserTokens(filename string, tokens []Token) Dispenser {
+	return Dispenser{
+		filename: filename,
+		tokens:   tokens,
+		cursor:   -1,
+	}
+}
+
+// Next loads the next token. Returns true if a token
+// was loaded; false otherwise. If false, all tokens
+// have been consumed.
+func (d *Dispenser) Next() bool {
+	if d.cursor < len(d.tokens)-1 {
+		d.cursor++
+		return true
+	}
+	return false
+}
+
+// NextArg loads the next token if it is on the same
+// line. Returns true if a token was loaded; false
+// otherwise. If false, all tokens on the line have
+// been consumed. It handles imported tokens correctly.
+func (d *Dispenser) NextArg() bool {
+	if d.cursor < 0 {
+		d.cursor++
+		return true
+	}
+	if d.cursor >= len(d.tokens) {
+		return false
+	}
+	if d.cursor < len(d.tokens)-1 &&
+		d.tokens[d.cursor].File == d.tokens[d.cursor+1].File &&
+		d.tokens[d.cursor].Line+d.numLineBreaks(d.cursor) == d.tokens[d.cursor+1].Line {
+		d.cursor++
+		return true
+	}
+	return false
+}
+
+// NextLine loads the next token only if it is not on the same
+// line as the current token, and returns true if a token was
+// loaded; false otherwise. If false, there is not another token
+// or it is on the same line. It handles imported tokens correctly.
+func (d *Dispenser) NextLine() bool {
+	if d.cursor < 0 {
+		d.cursor++
+		return true
+	}
+	if d.cursor >= len(d.tokens) {
+		return false
+	}
+	if d.cursor < len(d.tokens)-1 &&
+		(d.tokens[d.cursor].File != d.tokens[d.cursor+1].File ||
+			d.tokens[d.cursor].Line+d.numLineBreaks(d.cursor) < d.tokens[d.cursor+1].Line) {
+		d.cursor++
+		return true
+	}
+	return false
+}
+
+// NextBlock can be used as the condition of a for loop
+// to load the next token as long as it opens a block or
+// is already in a block. It returns true if a token was
+// loaded, or false when the block's closing curly brace
+// was loaded and thus the block ended. Nested blocks are
+// not supported.
+func (d *Dispenser) NextBlock() bool {
+	if d.nesting > 0 {
+		d.Next()
+		if d.Val() == "}" {
+			d.nesting--
+			return false
+		}
+		return true
+	}
+	if !d.NextArg() { // block must open on same line
+		return false
+	}
+	if d.Val() != "{" {
+		d.cursor-- // roll back if not opening brace
+		return false
+	}
+	d.Next()
+	if d.Val() == "}" {
+		// Open and then closed right away
+		return false
+	}
+	d.nesting++
+	return true
+}
+
+// Val gets the text of the current token. If there is no token
+// loaded, it returns empty string.
+func (d *Dispenser) Val() string {
+	if d.cursor < 0 || d.cursor >= len(d.tokens) {
+		return ""
+	}
+	return d.tokens[d.cursor].Text
+}
+
+// Line gets the line number of the current token. If there is no token
+// loaded, it returns 0.
+func (d *Dispenser) Line() int {
+	if d.cursor < 0 || d.cursor >= len(d.tokens) {
+		return 0
+	}
+	return d.tokens[d.cursor].Line
+}
+
+// File gets the filename of the current token. If there is no token loaded,
+// it returns the filename originally given when parsing started.
+func (d *Dispenser) File() string {
+	if d.cursor < 0 || d.cursor >= len(d.tokens) {
+		return d.filename
+	}
+	if tokenFilename := d.tokens[d.cursor].File; tokenFilename != "" {
+		return tokenFilename
+	}
+	return d.filename
+}
+
+// Args is a convenience function that loads the next arguments
+// (tokens on the same line) into an arbitrary number of strings
+// pointed to in targets. If there are fewer tokens available
+// than string pointers, the remaining strings will not be changed
+// and false will be returned. If there were enough tokens available
+// to fill the arguments, then true will be returned.
+func (d *Dispenser) Args(targets ...*string) bool {
+	enough := true
+	for i := 0; i < len(targets); i++ {
+		if !d.NextArg() {
+			enough = false
+			break
+		}
+		*targets[i] = d.Val()
+	}
+	return enough
+}
+
+// RemainingArgs loads any more arguments (tokens on the same line)
+// into a slice and returns them. Open curly brace tokens also indicate
+// the end of arguments, and the curly brace is not included in
+// the return value nor is it loaded.
+func (d *Dispenser) RemainingArgs() []string {
+	var args []string
+
+	for d.NextArg() {
+		if d.Val() == "{" {
+			d.cursor--
+			break
+		}
+		args = append(args, d.Val())
+	}
+
+	return args
+}
+
+// ArgErr returns an argument error, meaning that another
+// argument was expected but not found. In other words,
+// a line break or open curly brace was encountered instead of
+// an argument.
+func (d *Dispenser) ArgErr() error {
+	if d.Val() == "{" {
+		return d.Err("Unexpected token '{', expecting argument")
+	}
+	return d.Errf("Wrong argument count or unexpected line ending after '%s'", d.Val())
+}
+
+// SyntaxErr creates a generic syntax error which explains what was
+// found and what was expected.
+func (d *Dispenser) SyntaxErr(expected string) error {
+	msg := fmt.Sprintf("%s:%d - Syntax error: Unexpected token '%s', expecting '%s'", d.File(), d.Line(), d.Val(), expected)
+	return errors.New(msg)
+}
+
+// EOFErr returns an error indicating that the dispenser reached
+// the end of the input when searching for the next token.
+func (d *Dispenser) EOFErr() error {
+	return d.Errf("Unexpected EOF")
+}
+
+// Err generates a custom parse-time error with a message of msg.
+func (d *Dispenser) Err(msg string) error {
+	msg = fmt.Sprintf("%s:%d - Error during parsing: %s", d.File(), d.Line(), msg)
+	return errors.New(msg)
+}
+
+// Errf is like Err, but for formatted error messages
+func (d *Dispenser) Errf(format string, args ...interface{}) error {
+	return d.Err(fmt.Sprintf(format, args...))
+}
+
+// numLineBreaks counts how many line breaks are in the token
+// value given by the token index tknIdx. It returns 0 if the
+// token does not exist or there are no line breaks.
+func (d *Dispenser) numLineBreaks(tknIdx int) int {
+	if tknIdx < 0 || tknIdx >= len(d.tokens) {
+		return 0
+	}
+	return strings.Count(d.tokens[tknIdx].Text, "\n")
+}
+
+// isNewLine determines whether the current token is on a different
+// line (higher line number) than the previous token. It handles imported
+// tokens correctly. If there isn't a previous token, it returns true.
+func (d *Dispenser) isNewLine() bool {
+	if d.cursor < 1 {
+		return true
+	}
+	if d.cursor > len(d.tokens)-1 {
+		return false
+	}
+	return d.tokens[d.cursor-1].File != d.tokens[d.cursor].File ||
+		d.tokens[d.cursor-1].Line+d.numLineBreaks(d.cursor-1) < d.tokens[d.cursor].Line
+}

caddyfile/dispenser_test.go

@@ -1,4 +1,4 @@
-// Copyright 2015 Matthew Holt and The Caddy Authors
+// Copyright 2015 Light Code Labs, LLC
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -25,7 +25,7 @@ func TestDispenser_Val_Next(t *testing.T) {
 			  dir1 arg1
 			  dir2 arg2 arg3
 			  dir3`
-	d := NewTestDispenser(input)
+	d := NewDispenser("Testfile", strings.NewReader(input))
 
 	if val := d.Val(); val != "" {
 		t.Fatalf("Val(): Should return empty string when no token loaded; got '%s'", val)
@@ -63,7 +63,7 @@ func TestDispenser_NextArg(t *testing.T) {
 	input := `dir1 arg1
 			  dir2 arg2 arg3
 			  dir3`
-	d := NewTestDispenser(input)
+	d := NewDispenser("Testfile", strings.NewReader(input))
 
 	assertNext := func(shouldLoad bool, expectedVal string, expectedCursor int) {
 		if d.Next() != shouldLoad {
@@ -110,7 +110,7 @@ func TestDispenser_NextLine(t *testing.T) {
 	input := `host:port
 			  dir1 arg1
 			  dir2 arg2 arg3`
-	d := NewTestDispenser(input)
+	d := NewDispenser("Testfile", strings.NewReader(input))
 
 	assertNextLine := func(shouldLoad bool, expectedVal string, expectedCursor int) {
 		if d.NextLine() != shouldLoad {
@@ -143,10 +143,10 @@ func TestDispenser_NextBlock(t *testing.T) {
 			  }
 			  foobar2 {
 			  }`
-	d := NewTestDispenser(input)
+	d := NewDispenser("Testfile", strings.NewReader(input))
 
 	assertNextBlock := func(shouldLoad bool, expectedCursor, expectedNesting int) {
-		if loaded := d.NextBlock(0); loaded != shouldLoad {
+		if loaded := d.NextBlock(); loaded != shouldLoad {
 			t.Errorf("NextBlock(): Should return %v but got %v", shouldLoad, loaded)
 		}
 		if d.cursor != expectedCursor {
@@ -173,7 +173,7 @@ func TestDispenser_Args(t *testing.T) {
 			  dir2 arg4 arg5
 			  dir3 arg6 arg7
 			  dir4`
-	d := NewTestDispenser(input)
+	d := NewDispenser("Testfile", strings.NewReader(input))
 
 	d.Next() // dir1
 
@@ -240,7 +240,7 @@ func TestDispenser_RemainingArgs(t *testing.T) {
 			  dir2 arg4 arg5
 			  dir3 arg6 { arg7
 			  dir4`
-	d := NewTestDispenser(input)
+	d := NewDispenser("Testfile", strings.NewReader(input))
 
 	d.Next() // dir1
 
@@ -277,7 +277,7 @@ func TestDispenser_ArgErr_Err(t *testing.T) {
 	input := `dir1 {
 			  }
 			  dir2 arg1 arg2`
-	d := NewTestDispenser(input)
+	d := NewDispenser("Testfile", strings.NewReader(input))
 
 	d.cursor = 1 // {
 

caddyfile/json.go

@@ -0,0 +1,198 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// 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 caddyfile
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+const filename = "Caddyfile"
+
+// ToJSON converts caddyfile to its JSON representation.
+func ToJSON(caddyfile []byte) ([]byte, error) {
+	var j EncodedCaddyfile
+
+	serverBlocks, err := Parse(filename, bytes.NewReader(caddyfile), nil)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, sb := range serverBlocks {
+		block := EncodedServerBlock{
+			Keys: sb.Keys,
+			Body: [][]interface{}{},
+		}
+
+		// Extract directives deterministically by sorting them
+		var directives = make([]string, len(sb.Tokens))
+		for dir := range sb.Tokens {
+			directives = append(directives, dir)
+		}
+		sort.Strings(directives)
+
+		// Convert each directive's tokens into our JSON structure
+		for _, dir := range directives {
+			disp := NewDispenserTokens(filename, sb.Tokens[dir])
+			for disp.Next() {
+				block.Body = append(block.Body, constructLine(&disp))
+			}
+		}
+
+		// tack this block onto the end of the list
+		j = append(j, block)
+	}
+
+	result, err := json.Marshal(j)
+	if err != nil {
+		return nil, err
+	}
+
+	return result, nil
+}
+
+// constructLine transforms tokens into a JSON-encodable structure;
+// but only one line at a time, to be used at the top-level of
+// a server block only (where the first token on each line is a
+// directive) - not to be used at any other nesting level.
+func constructLine(d *Dispenser) []interface{} {
+	var args []interface{}
+
+	args = append(args, d.Val())
+
+	for d.NextArg() {
+		if d.Val() == "{" {
+			args = append(args, constructBlock(d))
+			continue
+		}
+		args = append(args, d.Val())
+	}
+
+	return args
+}
+
+// constructBlock recursively processes tokens into a
+// JSON-encodable structure. To be used in a directive's
+// block. Goes to end of block.
+func constructBlock(d *Dispenser) [][]interface{} {
+	block := [][]interface{}{}
+
+	for d.Next() {
+		if d.Val() == "}" {
+			break
+		}
+		block = append(block, constructLine(d))
+	}
+
+	return block
+}
+
+// FromJSON converts JSON-encoded jsonBytes to Caddyfile text
+func FromJSON(jsonBytes []byte) ([]byte, error) {
+	var j EncodedCaddyfile
+	var result string
+
+	err := json.Unmarshal(jsonBytes, &j)
+	if err != nil {
+		return nil, err
+	}
+
+	for sbPos, sb := range j {
+		if sbPos > 0 {
+			result += "\n\n"
+		}
+		for i, key := range sb.Keys {
+			if i > 0 {
+				result += ", "
+			}
+			//result += standardizeScheme(key)
+			result += key
+		}
+		result += jsonToText(sb.Body, 1)
+	}
+
+	return []byte(result), nil
+}
+
+// jsonToText recursively transforms a scope of JSON into plain
+// Caddyfile text.
+func jsonToText(scope interface{}, depth int) string {
+	var result string
+
+	switch val := scope.(type) {
+	case string:
+		if strings.ContainsAny(val, "\" \n\t\r") {
+			result += `"` + strings.Replace(val, "\"", "\\\"", -1) + `"`
+		} else {
+			result += val
+		}
+	case int:
+		result += strconv.Itoa(val)
+	case float64:
+		result += fmt.Sprintf("%v", val)
+	case bool:
+		result += fmt.Sprintf("%t", val)
+	case [][]interface{}:
+		result += " {\n"
+		for _, arg := range val {
+			result += strings.Repeat("\t", depth) + jsonToText(arg, depth+1) + "\n"
+		}
+		result += strings.Repeat("\t", depth-1) + "}"
+	case []interface{}:
+		for i, v := range val {
+			if block, ok := v.([]interface{}); ok {
+				result += "{\n"
+				for _, arg := range block {
+					result += strings.Repeat("\t", depth) + jsonToText(arg, depth+1) + "\n"
+				}
+				result += strings.Repeat("\t", depth-1) + "}"
+				continue
+			}
+			result += jsonToText(v, depth)
+			if i < len(val)-1 {
+				result += " "
+			}
+		}
+	}
+
+	return result
+}
+
+// TODO: Will this function come in handy somewhere else?
+/*
+// standardizeScheme turns an address like host:https into https://host,
+// or "host:" into "host".
+func standardizeScheme(addr string) string {
+	if hostname, port, err := net.SplitHostPort(addr); err == nil {
+		if port == "http" || port == "https" {
+			addr = port + "://" + hostname
+		}
+	}
+	return strings.TrimSuffix(addr, ":")
+}
+*/
+
+// EncodedCaddyfile encapsulates a slice of EncodedServerBlocks.
+type EncodedCaddyfile []EncodedServerBlock
+
+// EncodedServerBlock represents a server block ripe for encoding.
+type EncodedServerBlock struct {
+	Keys []string        `json:"keys"`
+	Body [][]interface{} `json:"body"`
+}

caddyfile/json_test.go

@@ -0,0 +1,178 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// 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 caddyfile
+
+import "testing"
+
+var tests = []struct {
+	caddyfile, json string
+}{
+	{ // 0
+		caddyfile: `foo {
+	root /bar
+}`,
+		json: `[{"keys":["foo"],"body":[["root","/bar"]]}]`,
+	},
+	{ // 1
+		caddyfile: `host1, host2 {
+	dir {
+		def
+	}
+}`,
+		json: `[{"keys":["host1","host2"],"body":[["dir",[["def"]]]]}]`,
+	},
+	{ // 2
+		caddyfile: `host1, host2 {
+	dir abc {
+		def ghi
+		jkl
+	}
+}`,
+		json: `[{"keys":["host1","host2"],"body":[["dir","abc",[["def","ghi"],["jkl"]]]]}]`,
+	},
+	{ // 3
+		caddyfile: `host1:1234, host2:5678 {
+	dir abc {
+	}
+}`,
+		json: `[{"keys":["host1:1234","host2:5678"],"body":[["dir","abc",[]]]}]`,
+	},
+	{ // 4
+		caddyfile: `host {
+	foo "bar baz"
+}`,
+		json: `[{"keys":["host"],"body":[["foo","bar baz"]]}]`,
+	},
+	{ // 5
+		caddyfile: `host, host:80 {
+	foo "bar \"baz\""
+}`,
+		json: `[{"keys":["host","host:80"],"body":[["foo","bar \"baz\""]]}]`,
+	},
+	{ // 6
+		caddyfile: `host {
+	foo "bar
+baz"
+}`,
+		json: `[{"keys":["host"],"body":[["foo","bar\nbaz"]]}]`,
+	},
+	{ // 7
+		caddyfile: `host {
+	dir 123 4.56 true
+}`,
+		json: `[{"keys":["host"],"body":[["dir","123","4.56","true"]]}]`, // NOTE: I guess we assume numbers and booleans should be encoded as strings...?
+	},
+	{ // 8
+		caddyfile: `http://host, https://host {
+}`,
+		json: `[{"keys":["http://host","https://host"],"body":[]}]`, // hosts in JSON are always host:port format (if port is specified), for consistency
+	},
+	{ // 9
+		caddyfile: `host {
+	dir1 a b
+	dir2 c d
+}`,
+		json: `[{"keys":["host"],"body":[["dir1","a","b"],["dir2","c","d"]]}]`,
+	},
+	{ // 10
+		caddyfile: `host {
+	dir a b
+	dir c d
+}`,
+		json: `[{"keys":["host"],"body":[["dir","a","b"],["dir","c","d"]]}]`,
+	},
+	{ // 11
+		caddyfile: `host {
+	dir1 a b
+	dir2 {
+		c
+		d
+	}
+}`,
+		json: `[{"keys":["host"],"body":[["dir1","a","b"],["dir2",[["c"],["d"]]]]}]`,
+	},
+	{ // 12
+		caddyfile: `host1 {
+	dir1
+}
+
+host2 {
+	dir2
+}`,
+		json: `[{"keys":["host1"],"body":[["dir1"]]},{"keys":["host2"],"body":[["dir2"]]}]`,
+	},
+}
+
+func TestToJSON(t *testing.T) {
+	for i, test := range tests {
+		output, err := ToJSON([]byte(test.caddyfile))
+		if err != nil {
+			t.Errorf("Test %d: %v", i, err)
+		}
+		if string(output) != test.json {
+			t.Errorf("Test %d\nExpected:\n'%s'\nActual:\n'%s'", i, test.json, string(output))
+		}
+	}
+}
+
+func TestFromJSON(t *testing.T) {
+	for i, test := range tests {
+		output, err := FromJSON([]byte(test.json))
+		if err != nil {
+			t.Errorf("Test %d: %v", i, err)
+		}
+		if string(output) != test.caddyfile {
+			t.Errorf("Test %d\nExpected:\n'%s'\nActual:\n'%s'", i, test.caddyfile, string(output))
+		}
+	}
+}
+
+// TODO: Will these tests come in handy somewhere else?
+/*
+func TestStandardizeAddress(t *testing.T) {
+	// host:https should be converted to https://host
+	output, err := ToJSON([]byte(`host:https`))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if expected, actual := `[{"keys":["https://host"],"body":[]}]`, string(output); expected != actual {
+		t.Errorf("Expected:\n'%s'\nActual:\n'%s'", expected, actual)
+	}
+
+	output, err = FromJSON([]byte(`[{"keys":["https://host"],"body":[]}]`))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if expected, actual := "https://host {\n}", string(output); expected != actual {
+		t.Errorf("Expected:\n'%s'\nActual:\n'%s'", expected, actual)
+	}
+
+	// host: should be converted to just host
+	output, err = ToJSON([]byte(`host:`))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if expected, actual := `[{"keys":["host"],"body":[]}]`, string(output); expected != actual {
+		t.Errorf("Expected:\n'%s'\nActual:\n'%s'", expected, actual)
+	}
+	output, err = FromJSON([]byte(`[{"keys":["host:"],"body":[]}]`))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if expected, actual := "host {\n}", string(output); expected != actual {
+		t.Errorf("Expected:\n'%s'\nActual:\n'%s'", expected, actual)
+	}
+}
+*/

caddyfile/lexer.go

@@ -16,7 +16,6 @@ package caddyfile
 
 import (
 	"bufio"
-	"bytes"
 	"io"
 	"unicode"
 )
@@ -27,10 +26,9 @@ type (
 	// are separated by whitespace. A word can be enclosed
 	// in quotes if it contains whitespace.
 	lexer struct {
-		reader       *bufio.Reader
-		token        Token
-		line         int
-		skippedLines int
+		reader *bufio.Reader
+		token  Token
+		line   int
 	}
 
 	// Token represents a single parsable unit.
@@ -74,7 +72,7 @@ func (l *lexer) load(input io.Reader) error {
 // a token was loaded; false otherwise.
 func (l *lexer) next() bool {
 	var val []rune
-	var comment, quoted, btQuoted, escaped bool
+	var comment, quoted, escaped bool
 
 	makeToken := func() bool {
 		l.token.Text = string(val)
@@ -93,32 +91,27 @@ func (l *lexer) next() bool {
 			panic(err)
 		}
 
-		if !escaped && !btQuoted && ch == '\\' {
-			escaped = true
-			continue
-		}
-
-		if quoted || btQuoted {
-			if quoted && escaped {
-				// all is literal in quoted area,
-				// so only escape quotes
-				if ch != '"' {
-					val = append(val, '\\')
-				}
-				escaped = false
-			} else {
-				if quoted && ch == '"' {
-					return makeToken()
-				}
-				if btQuoted && ch == '`' {
+		if quoted {
+			if !escaped {
+				if ch == '\\' {
+					escaped = true
+					continue
+				} else if ch == '"' {
+					quoted = false
 					return makeToken()
 				}
 			}
 			if ch == '\n' {
-				l.line += 1 + l.skippedLines
-				l.skippedLines = 0
+				l.line++
+			}
+			if escaped {
+				// only escape quotes
+				if ch != '"' {
+					val = append(val, '\\')
+				}
 			}
 			val = append(val, ch)
+			escaped = false
 			continue
 		}
 
@@ -127,13 +120,7 @@ func (l *lexer) next() bool {
 				continue
 			}
 			if ch == '\n' {
-				if escaped {
-					l.skippedLines++
-					escaped = false
-				} else {
-					l.line += 1 + l.skippedLines
-					l.skippedLines = 0
-				}
+				l.line++
 				comment = false
 			}
 			if len(val) > 0 {
@@ -142,9 +129,10 @@ func (l *lexer) next() bool {
 			continue
 		}
 
-		if ch == '#' && len(val) == 0 {
+		if ch == '#' {
 			comment = true
 		}
+
 		if comment {
 			continue
 		}
@@ -155,35 +143,8 @@ func (l *lexer) next() bool {
 				quoted = true
 				continue
 			}
-			if ch == '`' {
-				btQuoted = true
-				continue
-			}
-		}
-
-		if escaped {
-			val = append(val, '\\')
-			escaped = false
 		}
 
 		val = append(val, ch)
 	}
 }
-
-// Tokenize takes bytes as input and lexes it into
-// a list of tokens that can be parsed as a Caddyfile.
-// Also takes a filename to fill the token's File as
-// the source of the tokens, which is important to
-// determine relative paths for `import` directives.
-func Tokenize(input []byte, filename string) ([]Token, error) {
-	l := lexer{}
-	if err := l.load(bytes.NewReader(input)); err != nil {
-		return nil, err
-	}
-	var tokens []Token
-	for l.next() {
-		l.token.File = filename
-		tokens = append(tokens, l.token)
-	}
-	return tokens, nil
-}

caddyfile/lexer_test.go

@@ -15,35 +15,36 @@
 package caddyfile
 
 import (
+	"strings"
 	"testing"
 )
 
 type lexerTestCase struct {
-	input    []byte
+	input    string
 	expected []Token
 }
 
 func TestLexer(t *testing.T) {
 	testCases := []lexerTestCase{
 		{
-			input: []byte(`host:123`),
+			input: `host:123`,
 			expected: []Token{
 				{Line: 1, Text: "host:123"},
 			},
 		},
 		{
-			input: []byte(`host:123
+			input: `host:123
 
-					directive`),
+					directive`,
 			expected: []Token{
 				{Line: 1, Text: "host:123"},
 				{Line: 3, Text: "directive"},
 			},
 		},
 		{
-			input: []byte(`host:123 {
+			input: `host:123 {
 						directive
-					}`),
+					}`,
 			expected: []Token{
 				{Line: 1, Text: "host:123"},
 				{Line: 1, Text: "{"},
@@ -52,7 +53,7 @@ func TestLexer(t *testing.T) {
 			},
 		},
 		{
-			input: []byte(`host:123 { directive }`),
+			input: `host:123 { directive }`,
 			expected: []Token{
 				{Line: 1, Text: "host:123"},
 				{Line: 1, Text: "{"},
@@ -61,12 +62,12 @@ func TestLexer(t *testing.T) {
 			},
 		},
 		{
-			input: []byte(`host:123 {
+			input: `host:123 {
 						#comment
 						directive
 						# comment
 						foobar # another comment
-					}`),
+					}`,
 			expected: []Token{
 				{Line: 1, Text: "host:123"},
 				{Line: 1, Text: "{"},
@@ -76,28 +77,8 @@ func TestLexer(t *testing.T) {
 			},
 		},
 		{
-			input: []byte(`host:123 {
-						# hash inside string is not a comment
-						redir / /some/#/path
-					}`),
-			expected: []Token{
-				{Line: 1, Text: "host:123"},
-				{Line: 1, Text: "{"},
-				{Line: 3, Text: "redir"},
-				{Line: 3, Text: "/"},
-				{Line: 3, Text: "/some/#/path"},
-				{Line: 4, Text: "}"},
-			},
-		},
-		{
-			input: []byte("# comment at beginning of file\n# comment at beginning of line\nhost:123"),
-			expected: []Token{
-				{Line: 3, Text: "host:123"},
-			},
-		},
-		{
-			input: []byte(`a "quoted value" b
-					foobar`),
+			input: `a "quoted value" b
+					foobar`,
 			expected: []Token{
 				{Line: 1, Text: "a"},
 				{Line: 1, Text: "quoted value"},
@@ -106,7 +87,7 @@ func TestLexer(t *testing.T) {
 			},
 		},
 		{
-			input: []byte(`A "quoted \"value\" inside" B`),
+			input: `A "quoted \"value\" inside" B`,
 			expected: []Token{
 				{Line: 1, Text: "A"},
 				{Line: 1, Text: `quoted "value" inside`},
@@ -114,72 +95,22 @@ func TestLexer(t *testing.T) {
 			},
 		},
 		{
-			input: []byte("An escaped \"newline\\\ninside\" quotes"),
-			expected: []Token{
-				{Line: 1, Text: "An"},
-				{Line: 1, Text: "escaped"},
-				{Line: 1, Text: "newline\\\ninside"},
-				{Line: 2, Text: "quotes"},
-			},
-		},
-		{
-			input: []byte("An escaped newline\\\noutside quotes"),
-			expected: []Token{
-				{Line: 1, Text: "An"},
-				{Line: 1, Text: "escaped"},
-				{Line: 1, Text: "newline"},
-				{Line: 1, Text: "outside"},
-				{Line: 1, Text: "quotes"},
-			},
-		},
-		{
-			input: []byte("line1\\\nescaped\nline2\nline3"),
-			expected: []Token{
-				{Line: 1, Text: "line1"},
-				{Line: 1, Text: "escaped"},
-				{Line: 3, Text: "line2"},
-				{Line: 4, Text: "line3"},
-			},
-		},
-		{
-			input: []byte("line1\\\nescaped1\\\nescaped2\nline4\nline5"),
-			expected: []Token{
-				{Line: 1, Text: "line1"},
-				{Line: 1, Text: "escaped1"},
-				{Line: 1, Text: "escaped2"},
-				{Line: 4, Text: "line4"},
-				{Line: 5, Text: "line5"},
-			},
-		},
-		{
-			input: []byte(`"unescapable\ in quotes"`),
-			expected: []Token{
-				{Line: 1, Text: `unescapable\ in quotes`},
-			},
-		},
-		{
-			input: []byte(`"don't\escape"`),
+			input: `"don't\escape"`,
 			expected: []Token{
 				{Line: 1, Text: `don't\escape`},
 			},
 		},
 		{
-			input: []byte(`"don't\\escape"`),
+			input: `"don't\\escape"`,
 			expected: []Token{
 				{Line: 1, Text: `don't\\escape`},
 			},
 		},
 		{
-			input: []byte(`un\escapable`),
-			expected: []Token{
-				{Line: 1, Text: `un\escapable`},
-			},
-		},
-		{
-			input: []byte(`A "quoted value with line
+			input: `A "quoted value with line
 					break inside" {
 						foobar
-					}`),
+					}`,
 			expected: []Token{
 				{Line: 1, Text: "A"},
 				{Line: 1, Text: "quoted value with line\n\t\t\t\t\tbreak inside"},
@@ -189,13 +120,13 @@ func TestLexer(t *testing.T) {
 			},
 		},
 		{
-			input: []byte(`"C:\php\php-cgi.exe"`),
+			input: `"C:\php\php-cgi.exe"`,
 			expected: []Token{
 				{Line: 1, Text: `C:\php\php-cgi.exe`},
 			},
 		},
 		{
-			input: []byte(`empty "" string`),
+			input: `empty "" string`,
 			expected: []Token{
 				{Line: 1, Text: `empty`},
 				{Line: 1, Text: ``},
@@ -203,7 +134,7 @@ func TestLexer(t *testing.T) {
 			},
 		},
 		{
-			input: []byte("skip those\r\nCR characters"),
+			input: "skip those\r\nCR characters",
 			expected: []Token{
 				{Line: 1, Text: "skip"},
 				{Line: 1, Text: "those"},
@@ -212,54 +143,28 @@ func TestLexer(t *testing.T) {
 			},
 		},
 		{
-			input: []byte("\xEF\xBB\xBF:8080"), // test with leading byte order mark
+			input: "\xEF\xBB\xBF:8080", // test with leading byte order mark
 			expected: []Token{
 				{Line: 1, Text: ":8080"},
 			},
 		},
-		{
-			input: []byte("simple `backtick quoted` string"),
-			expected: []Token{
-				{Line: 1, Text: `simple`},
-				{Line: 1, Text: `backtick quoted`},
-				{Line: 1, Text: `string`},
-			},
-		},
-		{
-			input: []byte("multiline `backtick\nquoted\n` string"),
-			expected: []Token{
-				{Line: 1, Text: `multiline`},
-				{Line: 1, Text: "backtick\nquoted\n"},
-				{Line: 3, Text: `string`},
-			},
-		},
-		{
-			input: []byte("nested `\"quotes inside\" backticks` string"),
-			expected: []Token{
-				{Line: 1, Text: `nested`},
-				{Line: 1, Text: `"quotes inside" backticks`},
-				{Line: 1, Text: `string`},
-			},
-		},
-		{
-			input: []byte("reverse-nested \"`backticks` inside\" quotes"),
-			expected: []Token{
-				{Line: 1, Text: `reverse-nested`},
-				{Line: 1, Text: "`backticks` inside"},
-				{Line: 1, Text: `quotes`},
-			},
-		},
 	}
 
 	for i, testCase := range testCases {
-		actual, err := Tokenize(testCase.input, "")
-		if err != nil {
-			t.Errorf("%v", err)
-		}
+		actual := tokenize(testCase.input)
 		lexerCompare(t, i, testCase.expected, actual)
 	}
 }
 
+func tokenize(input string) (tokens []Token) {
+	l := lexer{}
+	l.load(strings.NewReader(input))
+	for l.next() {
+		tokens = append(tokens, l.token)
+	}
+	return
+}
+
 func lexerCompare(t *testing.T, n int, expected, actual []Token) {
 	if len(expected) != len(actual) {
 		t.Errorf("Test case %d: expected %d token(s) but got %d", n, len(expected), len(actual))

caddyfile/parse.go

@@ -15,15 +15,11 @@
 package caddyfile
 
 import (
-	"bytes"
-	"io/ioutil"
+	"io"
 	"log"
 	"os"
 	"path/filepath"
-	"strconv"
 	"strings"
-
-	"github.com/caddyserver/caddy/v2"
 )
 
 // Parse parses the input just enough to group tokens, in
@@ -32,84 +28,33 @@ import (
 // Directives that do not appear in validDirectives will cause
 // an error. If you do not want to check for valid directives,
 // pass in nil instead.
-//
-// Environment variables in {$ENVIRONMENT_VARIABLE} notation
-// will be replaced before parsing begins.
-func Parse(filename string, input []byte) ([]ServerBlock, error) {
-	tokens, err := allTokens(filename, input)
-	if err != nil {
-		return nil, err
-	}
-	p := parser{Dispenser: NewDispenser(tokens)}
+func Parse(filename string, input io.Reader, validDirectives []string) ([]ServerBlock, error) {
+	p := parser{Dispenser: NewDispenser(filename, input), validDirectives: validDirectives}
 	return p.parseAll()
 }
 
-// replaceEnvVars replaces all occurrences of environment variables.
-func replaceEnvVars(input []byte) ([]byte, error) {
-	var offset int
-	for {
-		begin := bytes.Index(input[offset:], spanOpen)
-		if begin < 0 {
-			break
-		}
-		begin += offset // make beginning relative to input, not offset
-		end := bytes.Index(input[begin+len(spanOpen):], spanClose)
-		if end < 0 {
-			break
-		}
-		end += begin + len(spanOpen) // make end relative to input, not begin
-
-		// get the name; if there is no name, skip it
-		envString := input[begin+len(spanOpen) : end]
-		if len(envString) == 0 {
-			offset = end + len(spanClose)
-			continue
-		}
-
-		// split the string into a key and an optional default
-		envParts := strings.SplitN(string(envString), envVarDefaultDelimiter, 2)
-
-		// do a lookup for the env var, replace with the default if not found
-		envVarValue, found := os.LookupEnv(envParts[0])
-		if !found && len(envParts) == 2 {
-			envVarValue = envParts[1]
-		}
-
-		// get the value of the environment variable
-		// note that this causes one-level deep chaining
-		envVarBytes := []byte(envVarValue)
-
-		// splice in the value
-		input = append(input[:begin],
-			append(envVarBytes, input[end+len(spanClose):]...)...)
-
-		// continue at the end of the replacement
-		offset = begin + len(envVarBytes)
-	}
-	return input, nil
-}
-
 // allTokens lexes the entire input, but does not parse it.
 // It returns all the tokens from the input, unstructured
 // and in order.
-func allTokens(filename string, input []byte) ([]Token, error) {
-	input, err := replaceEnvVars(input)
+func allTokens(input io.Reader) ([]Token, error) {
+	l := new(lexer)
+	err := l.load(input)
 	if err != nil {
 		return nil, err
 	}
-	tokens, err := Tokenize(input, filename)
-	if err != nil {
-		return nil, err
+	var tokens []Token
+	for l.next() {
+		tokens = append(tokens, l.token)
 	}
 	return tokens, nil
 }
 
 type parser struct {
-	*Dispenser
+	Dispenser
 	block           ServerBlock // current server block being parsed
+	validDirectives []string    // a directive must be valid or it's an error
 	eof             bool        // if we encounter a valid EOF in a hard place
 	definedSnippets map[string][]Token
-	nesting         int
 }
 
 func (p *parser) parseAll() ([]ServerBlock, error) {
@@ -120,19 +65,17 @@ func (p *parser) parseAll() ([]ServerBlock, error) {
 		if err != nil {
 			return blocks, err
 		}
-		if len(p.block.Keys) > 0 || len(p.block.Segments) > 0 {
+		if len(p.block.Keys) > 0 {
 			blocks = append(blocks, p.block)
 		}
-		if p.nesting > 0 {
-			return blocks, p.EOFErr()
-		}
 	}
 
 	return blocks, nil
 }
 
 func (p *parser) parseOne() error {
-	p.block = ServerBlock{}
+	p.block = ServerBlock{Tokens: make(map[string][]Token)}
+
 	return p.begin()
 }
 
@@ -178,7 +121,7 @@ func (p *parser) addresses() error {
 	var expectingAnother bool
 
 	for {
-		tkn := p.Val()
+		tkn := replaceEnvVars(p.Val())
 
 		// special case: import directive replaces tokens during parse-time
 		if tkn == "import" && p.isNewLine() {
@@ -239,7 +182,7 @@ func (p *parser) blockContents() error {
 		return err
 	}
 
-	// only look for close curly brace if there was an opening
+	// Only look for close curly brace if there was an opening
 	if errOpenCurlyBrace == nil {
 		err = p.closeCurlyBrace()
 		if err != nil {
@@ -258,7 +201,6 @@ func (p *parser) directives() error {
 	for p.Next() {
 		// end of server block
 		if p.Val() == "}" {
-			// p.nesting has already been decremented
 			break
 		}
 
@@ -272,15 +214,11 @@ func (p *parser) directives() error {
 			continue
 		}
 
-		// normal case: parse a directive as a new segment
-		// (a "segment" is a line which starts with a directive
-		// and which ends at the end of the line or at the end of
-		// the block that is opened at the end of the line)
+		// normal case: parse a directive on this line
 		if err := p.directive(); err != nil {
 			return err
 		}
 	}
-
 	return nil
 }
 
@@ -295,23 +233,15 @@ func (p *parser) doImport() error {
 	if !p.NextArg() {
 		return p.ArgErr()
 	}
-	importPattern := p.Val()
+	importPattern := replaceEnvVars(p.Val())
 	if importPattern == "" {
 		return p.Err("Import requires a non-empty filepath")
 	}
-
-	// grab remaining args as placeholder replacements
-	args := p.RemainingArgs()
-
-	// add args to the replacer
-	repl := caddy.NewReplacer()
-	for index, arg := range args {
-		repl.Set("args."+strconv.Itoa(index), arg)
+	if p.NextArg() {
+		return p.Err("Import takes only one argument (glob pattern or file)")
 	}
-
-	// splice out the import directive and its arguments
-	// (2 tokens, plus the length of args)
-	tokensBefore := p.tokens[:p.cursor-1-len(args)]
+	// splice out the import directive and its argument (2 tokens total)
+	tokensBefore := p.tokens[:p.cursor-1]
 	tokensAfter := p.tokens[p.cursor+1:]
 	var importedTokens []Token
 
@@ -319,12 +249,11 @@ func (p *parser) doImport() error {
 	if p.definedSnippets != nil && p.definedSnippets[importPattern] != nil {
 		importedTokens = p.definedSnippets[importPattern]
 	} else {
-		// make path relative to the file of the _token_ being processed rather
-		// than current working directory (issue #867) and then use glob to get
-		// list of matching filenames
-		absFile, err := filepath.Abs(p.Dispenser.File())
+		// make path relative to Caddyfile rather than current working directory (issue #867)
+		// and then use glob to get list of matching filenames
+		absFile, err := filepath.Abs(p.Dispenser.filename)
 		if err != nil {
-			return p.Errf("Failed to get absolute path of file: %s: %v", p.Dispenser.File(), err)
+			return p.Errf("Failed to get absolute path of file: %s: %v", p.Dispenser.filename, err)
 		}
 
 		var matches []string
@@ -334,19 +263,14 @@ func (p *parser) doImport() error {
 		} else {
 			globPattern = importPattern
 		}
-		if strings.Count(globPattern, "*") > 1 || strings.Count(globPattern, "?") > 1 ||
-			(strings.Contains(globPattern, "[") && strings.Contains(globPattern, "]")) {
-			// See issue #2096 - a pattern with many glob expansions can hang for too long
-			return p.Errf("Glob pattern may only contain one wildcard (*), but has others: %s", globPattern)
-		}
 		matches, err = filepath.Glob(globPattern)
 
 		if err != nil {
 			return p.Errf("Failed to use import pattern %s: %v", importPattern, err)
 		}
 		if len(matches) == 0 {
-			if strings.ContainsAny(globPattern, "*?[]") {
-				log.Printf("[WARNING] No files matching import glob pattern: %s", importPattern)
+			if strings.Contains(globPattern, "*") {
+				log.Printf("[WARNING] No files matching import pattern: %s", importPattern)
 			} else {
 				return p.Errf("File to import not found: %s", importPattern)
 			}
@@ -359,24 +283,38 @@ func (p *parser) doImport() error {
 			if err != nil {
 				return err
 			}
+
+			var importLine int
+			for i, token := range newTokens {
+				if token.Text == "import" {
+					importLine = token.Line
+					continue
+				}
+				if token.Line == importLine {
+					var abs string
+					if filepath.IsAbs(token.Text) {
+						abs = token.Text
+					} else if !filepath.IsAbs(importFile) {
+						abs = filepath.Join(filepath.Dir(absFile), token.Text)
+					} else {
+						abs = filepath.Join(filepath.Dir(importFile), token.Text)
+					}
+					newTokens[i] = Token{
+						Text: abs,
+						Line: token.Line,
+						File: token.File,
+					}
+				}
+			}
+
 			importedTokens = append(importedTokens, newTokens...)
 		}
 	}
 
-	// copy the tokens so we don't overwrite p.definedSnippets
-	tokensCopy := make([]Token, len(importedTokens))
-	copy(tokensCopy, importedTokens)
-
-	// run the argument replacer on the tokens
-	for index, token := range tokensCopy {
-		token.Text = repl.ReplaceKnown(token.Text, "")
-		tokensCopy[index] = token
-	}
-
 	// splice the imported tokens in the place of the import statement
 	// and rewind cursor so Next() will land on first imported token
-	p.tokens = append(tokensBefore, append(tokensCopy, tokensAfter...)...)
-	p.cursor -= len(args) + 1
+	p.tokens = append(tokensBefore, append(importedTokens, tokensAfter...)...)
+	p.cursor--
 
 	return nil
 }
@@ -396,12 +334,7 @@ func (p *parser) doSingleImport(importFile string) ([]Token, error) {
 		return nil, p.Errf("Could not import %s: is a directory", importFile)
 	}
 
-	input, err := ioutil.ReadAll(file)
-	if err != nil {
-		return nil, p.Errf("Could not read imported file %s: %v", importFile, err)
-	}
-
-	importedTokens, err := allTokens(importFile, input)
+	importedTokens, err := allTokens(file)
 	if err != nil {
 		return nil, p.Errf("Could not read tokens while importing %s: %v", importFile, err)
 	}
@@ -410,7 +343,7 @@ func (p *parser) doSingleImport(importFile string) ([]Token, error) {
 	// (we use full, absolute path to avoid bugs: issue #1892)
 	filename, err := filepath.Abs(importFile)
 	if err != nil {
-		return nil, p.Errf("Failed to get absolute path of file: %s: %v", importFile, err)
+		return nil, p.Errf("Failed to get absolute path of file: %s: %v", p.Dispenser.filename, err)
 	}
 	for i := 0; i < len(importedTokens); i++ {
 		importedTokens[i].File = filename
@@ -426,40 +359,35 @@ func (p *parser) doSingleImport(importFile string) ([]Token, error) {
 // are loaded into the current server block for later use
 // by directive setup functions.
 func (p *parser) directive() error {
+	dir := p.Val()
+	nesting := 0
 
-	// a segment is a list of tokens associated with this directive
-	var segment Segment
+	// TODO: More helpful error message ("did you mean..." or "maybe you need to install its server type")
+	if !p.validDirective(dir) {
+		return p.Errf("Unknown directive '%s'", dir)
+	}
 
-	// the directive itself is appended as a relevant token
-	segment = append(segment, p.Token())
+	// The directive itself is appended as a relevant token
+	p.block.Tokens[dir] = append(p.block.Tokens[dir], p.tokens[p.cursor])
 
 	for p.Next() {
 		if p.Val() == "{" {
-			p.nesting++
-		} else if p.isNewLine() && p.nesting == 0 {
+			nesting++
+		} else if p.isNewLine() && nesting == 0 {
 			p.cursor-- // read too far
 			break
-		} else if p.Val() == "}" && p.nesting > 0 {
-			p.nesting--
-		} else if p.Val() == "}" && p.nesting == 0 {
+		} else if p.Val() == "}" && nesting > 0 {
+			nesting--
+		} else if p.Val() == "}" && nesting == 0 {
 			return p.Err("Unexpected '}' because no matching opening brace")
-		} else if p.Val() == "import" && p.isNewLine() {
-			if err := p.doImport(); err != nil {
-				return err
-			}
-			p.cursor-- // cursor is advanced when we continue, so roll back one more
-			continue
 		}
-
-		segment = append(segment, p.Token())
+		p.tokens[p.cursor].Text = replaceEnvVars(p.tokens[p.cursor].Text)
+		p.block.Tokens[dir] = append(p.block.Tokens[dir], p.tokens[p.cursor])
 	}
 
-	p.block.Segments = append(p.block.Segments, segment)
-
-	if p.nesting > 0 {
+	if nesting > 0 {
 		return p.EOFErr()
 	}
-
 	return nil
 }
 
@@ -485,6 +413,51 @@ func (p *parser) closeCurlyBrace() error {
 	return nil
 }
 
+// validDirective returns true if dir is in p.validDirectives.
+func (p *parser) validDirective(dir string) bool {
+	if p.validDirectives == nil {
+		return true
+	}
+	for _, d := range p.validDirectives {
+		if d == dir {
+			return true
+		}
+	}
+	return false
+}
+
+// replaceEnvVars replaces environment variables that appear in the token
+// and understands both the $UNIX and %WINDOWS% syntaxes.
+func replaceEnvVars(s string) string {
+	s = replaceEnvReferences(s, "{%", "%}")
+	s = replaceEnvReferences(s, "{$", "}")
+	return s
+}
+
+// replaceEnvReferences performs the actual replacement of env variables
+// in s, given the placeholder start and placeholder end strings.
+func replaceEnvReferences(s, refStart, refEnd string) string {
+	index := strings.Index(s, refStart)
+	for index != -1 {
+		endIndex := strings.Index(s, refEnd)
+		if endIndex != -1 {
+			ref := s[index : endIndex+len(refEnd)]
+			s = strings.Replace(s, ref, os.Getenv(ref[len(refStart):len(ref)-len(refEnd)]), -1)
+		} else {
+			return s
+		}
+		index = strings.Index(s, refStart)
+	}
+	return s
+}
+
+// ServerBlock associates any number of keys (usually addresses
+// of some sort) with tokens (grouped by directive name).
+type ServerBlock struct {
+	Keys   []string
+	Tokens map[string][]Token
+}
+
 func (p *parser) isSnippet() (bool, string) {
 	keys := p.block.Keys
 	// A snippet block is a single key with parens. Nothing else qualifies.
@@ -496,69 +469,29 @@ func (p *parser) isSnippet() (bool, string) {
 
 // read and store everything in a block for later replay.
 func (p *parser) snippetTokens() ([]Token, error) {
+	// TODO: disallow imports in snippets for simplicity at import time
 	// snippet must have curlies.
 	err := p.openCurlyBrace()
 	if err != nil {
 		return nil, err
 	}
-	nesting := 1 // count our own nesting in snippets
+	count := 1
 	tokens := []Token{}
 	for p.Next() {
 		if p.Val() == "}" {
-			nesting--
-			if nesting == 0 {
+			count--
+			if count == 0 {
 				break
 			}
 		}
 		if p.Val() == "{" {
-			nesting++
+			count++
 		}
 		tokens = append(tokens, p.tokens[p.cursor])
 	}
 	// make sure we're matched up
-	if nesting != 0 {
+	if count != 0 {
 		return nil, p.SyntaxErr("}")
 	}
 	return tokens, nil
 }
-
-// ServerBlock associates any number of keys from the
-// head of the server block with tokens, which are
-// grouped by segments.
-type ServerBlock struct {
-	Keys     []string
-	Segments []Segment
-}
-
-// DispenseDirective returns a dispenser that contains
-// all the tokens in the server block.
-func (sb ServerBlock) DispenseDirective(dir string) *Dispenser {
-	var tokens []Token
-	for _, seg := range sb.Segments {
-		if len(seg) > 0 && seg[0].Text == dir {
-			tokens = append(tokens, seg...)
-		}
-	}
-	return NewDispenser(tokens)
-}
-
-// Segment is a list of tokens which begins with a directive
-// and ends at the end of the directive (either at the end of
-// the line, or at the end of a block it opens).
-type Segment []Token
-
-// Directive returns the directive name for the segment.
-// The directive name is the text of the first token.
-func (s Segment) Directive() string {
-	if len(s) > 0 {
-		return s[0].Text
-	}
-	return ""
-}
-
-// spanOpen and spanClose are used to bound spans that
-// contain the name of an environment variable.
-var (
-	spanOpen, spanClose    = []byte{'{', '$'}, []byte{'}'}
-	envVarDefaultDelimiter = ":"
-)

caddyfile/parse_test.go

@@ -15,17 +15,17 @@
 package caddyfile
 
 import (
-	"bytes"
 	"io/ioutil"
 	"os"
 	"path/filepath"
+	"strings"
 	"testing"
 )
 
 func TestAllTokens(t *testing.T) {
-	input := []byte("a b c\nd e")
+	input := strings.NewReader("a b c\nd e")
 	expected := []string{"a", "b", "c", "d", "e"}
-	tokens, err := allTokens("TestAllTokens", input)
+	tokens, err := allTokens(input)
 
 	if err != nil {
 		t.Fatalf("Expected no error, got %v", err)
@@ -53,67 +53,84 @@ func TestParseOneAndImport(t *testing.T) {
 		input     string
 		shouldErr bool
 		keys      []string
-		numTokens []int // number of tokens to expect in each segment
+		tokens    map[string]int // map of directive name to number of tokens expected
 	}{
 		{`localhost`, false, []string{
 			"localhost",
-		}, []int{}},
+		}, map[string]int{}},
 
 		{`localhost
 		  dir1`, false, []string{
 			"localhost",
-		}, []int{1}},
+		}, map[string]int{
+			"dir1": 1,
+		}},
 
 		{`localhost:1234
 		  dir1 foo bar`, false, []string{
 			"localhost:1234",
-		}, []int{3},
-		},
+		}, map[string]int{
+			"dir1": 3,
+		}},
 
 		{`localhost {
 		    dir1
 		  }`, false, []string{
 			"localhost",
-		}, []int{1}},
+		}, map[string]int{
+			"dir1": 1,
+		}},
 
 		{`localhost:1234 {
 		    dir1 foo bar
 		    dir2
 		  }`, false, []string{
 			"localhost:1234",
-		}, []int{3, 1}},
+		}, map[string]int{
+			"dir1": 3,
+			"dir2": 1,
+		}},
 
 		{`http://localhost https://localhost
 		  dir1 foo bar`, false, []string{
 			"http://localhost",
 			"https://localhost",
-		}, []int{3}},
+		}, map[string]int{
+			"dir1": 3,
+		}},
 
 		{`http://localhost https://localhost {
 		    dir1 foo bar
 		  }`, false, []string{
 			"http://localhost",
 			"https://localhost",
-		}, []int{3}},
+		}, map[string]int{
+			"dir1": 3,
+		}},
 
 		{`http://localhost, https://localhost {
 		    dir1 foo bar
 		  }`, false, []string{
 			"http://localhost",
 			"https://localhost",
-		}, []int{3}},
+		}, map[string]int{
+			"dir1": 3,
+		}},
 
 		{`http://localhost, {
 		  }`, true, []string{
 			"http://localhost",
-		}, []int{}},
+		}, map[string]int{}},
 
 		{`host1:80, http://host2.com
 		  dir1 foo bar
 		  dir2 baz`, false, []string{
 			"host1:80",
 			"http://host2.com",
-		}, []int{3, 2}},
+		}, map[string]int{
+			"dir1": 3,
+			"dir2": 2,
+		}},
 
 		{`http://host1.com,
 		  http://host2.com,
@@ -121,7 +138,7 @@ func TestParseOneAndImport(t *testing.T) {
 			"http://host1.com",
 			"http://host2.com",
 			"https://host3.com",
-		}, []int{}},
+		}, map[string]int{}},
 
 		{`http://host1.com:1234, https://host2.com
 		  dir1 foo {
@@ -130,7 +147,10 @@ func TestParseOneAndImport(t *testing.T) {
 		  dir2`, false, []string{
 			"http://host1.com:1234",
 			"https://host2.com",
-		}, []int{6, 1}},
+		}, map[string]int{
+			"dir1": 6,
+			"dir2": 1,
+		}},
 
 		{`127.0.0.1
 		  dir1 {
@@ -140,25 +160,34 @@ func TestParseOneAndImport(t *testing.T) {
 		    foo bar
 		  }`, false, []string{
 			"127.0.0.1",
-		}, []int{5, 5}},
+		}, map[string]int{
+			"dir1": 5,
+			"dir2": 5,
+		}},
 
 		{`localhost
 		  dir1 {
 		    foo`, true, []string{
 			"localhost",
-		}, []int{3}},
+		}, map[string]int{
+			"dir1": 3,
+		}},
 
 		{`localhost
 		  dir1 {
 		  }`, false, []string{
 			"localhost",
-		}, []int{3}},
+		}, map[string]int{
+			"dir1": 3,
+		}},
 
 		{`localhost
 		  dir1 {
 		  } }`, true, []string{
 			"localhost",
-		}, []int{}},
+		}, map[string]int{
+			"dir1": 3,
+		}},
 
 		{`localhost
 		  dir1 {
@@ -168,41 +197,37 @@ func TestParseOneAndImport(t *testing.T) {
 		  }
 		  dir2 foo bar`, false, []string{
 			"localhost",
-		}, []int{7, 3}},
+		}, map[string]int{
+			"dir1": 7,
+			"dir2": 3,
+		}},
 
-		{``, false, []string{}, []int{}},
+		{``, false, []string{}, map[string]int{}},
 
 		{`localhost
 		  dir1 arg1
 		  import testdata/import_test1.txt`, false, []string{
 			"localhost",
-		}, []int{2, 3, 1}},
+		}, map[string]int{
+			"dir1": 2,
+			"dir2": 3,
+			"dir3": 1,
+		}},
 
 		{`import testdata/import_test2.txt`, false, []string{
 			"host1",
-		}, []int{1, 2}},
+		}, map[string]int{
+			"dir1": 1,
+			"dir2": 2,
+		}},
 
-		{`import testdata/not_found.txt`, true, []string{}, []int{}},
+		{`import testdata/import_test1.txt testdata/import_test2.txt`, true, []string{}, map[string]int{}},
 
-		{`""`, false, []string{}, []int{}},
+		{`import testdata/not_found.txt`, true, []string{}, map[string]int{}},
 
-		{``, false, []string{}, []int{}},
+		{`""`, false, []string{}, map[string]int{}},
 
-		// import with args
-		{`import testdata/import_args0.txt a`, false, []string{"a"}, []int{}},
-		{`import testdata/import_args1.txt a b`, false, []string{"a", "b"}, []int{}},
-		{`import testdata/import_args*.txt a b`, false, []string{"a"}, []int{2}},
-
-		// test cases found by fuzzing!
-		{`import }{$"`, true, []string{}, []int{}},
-		{`import /*/*.txt`, true, []string{}, []int{}},
-		{`import /???/?*?o`, true, []string{}, []int{}},
-		{`import /??`, true, []string{}, []int{}},
-		{`import /[a-z]`, true, []string{}, []int{}},
-		{`import {$}`, true, []string{}, []int{}},
-		{`import {%}`, true, []string{}, []int{}},
-		{`import {$$}`, true, []string{}, []int{}},
-		{`import {%%}`, true, []string{}, []int{}},
+		{``, false, []string{}, map[string]int{}},
 	} {
 		result, err := testParseOne(test.input)
 
@@ -213,7 +238,6 @@ func TestParseOneAndImport(t *testing.T) {
 			t.Errorf("Test %d: Expected no error, but got: %v", i, err)
 		}
 
-		// t.Logf("%+v\n", result)
 		if len(result.Keys) != len(test.keys) {
 			t.Errorf("Test %d: Expected %d keys, got %d",
 				i, len(test.keys), len(result.Keys))
@@ -226,16 +250,15 @@ func TestParseOneAndImport(t *testing.T) {
 			}
 		}
 
-		if len(result.Segments) != len(test.numTokens) {
-			t.Errorf("Test %d: Expected %d segments, had %d",
-				i, len(test.numTokens), len(result.Segments))
+		if len(result.Tokens) != len(test.tokens) {
+			t.Errorf("Test %d: Expected %d directives, had %d",
+				i, len(test.tokens), len(result.Tokens))
 			continue
 		}
-
-		for j, seg := range result.Segments {
-			if len(seg) != test.numTokens[j] {
-				t.Errorf("Test %d, segment %d: Expected %d tokens, counted %d",
-					i, j, test.numTokens[j], len(seg))
+		for directive, tokens := range result.Tokens {
+			if len(tokens) != test.tokens[directive] {
+				t.Errorf("Test %d, directive '%s': Expected %d tokens, counted %d",
+					i, directive, test.tokens[directive], len(tokens))
 				continue
 			}
 		}
@@ -255,12 +278,12 @@ func TestRecursiveImport(t *testing.T) {
 			t.Errorf("got keys unexpected: expect localhost, got %v", got.Keys)
 			return false
 		}
-		if len(got.Segments) != 2 {
-			t.Errorf("got wrong number of segments: expect 2, got %d", len(got.Segments))
+		if len(got.Tokens) != 2 {
+			t.Errorf("got wrong number of tokens: expect 2, got %d", len(got.Tokens))
 			return false
 		}
-		if len(got.Segments[0]) != 1 || len(got.Segments[1]) != 2 {
-			t.Errorf("got unexpected tokens: %v", got.Segments)
+		if len(got.Tokens["dir1"]) != 1 || len(got.Tokens["dir2"]) != 2 {
+			t.Errorf("got unexpect tokens: %v", got.Tokens)
 			return false
 		}
 		return true
@@ -337,68 +360,6 @@ func TestRecursiveImport(t *testing.T) {
 	}
 }
 
-func TestDirectiveImport(t *testing.T) {
-	testParseOne := func(input string) (ServerBlock, error) {
-		p := testParser(input)
-		p.Next() // parseOne doesn't call Next() to start, so we must
-		err := p.parseOne()
-		return p.block, err
-	}
-
-	isExpected := func(got ServerBlock) bool {
-		if len(got.Keys) != 1 || got.Keys[0] != "localhost" {
-			t.Errorf("got keys unexpected: expect localhost, got %v", got.Keys)
-			return false
-		}
-		if len(got.Segments) != 2 {
-			t.Errorf("got wrong number of segments: expect 2, got %d", len(got.Segments))
-			return false
-		}
-		if len(got.Segments[0]) != 1 || len(got.Segments[1]) != 8 {
-			t.Errorf("got unexpected tokens: %v", got.Segments)
-			return false
-		}
-		return true
-	}
-
-	directiveFile, err := filepath.Abs("testdata/directive_import_test")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = ioutil.WriteFile(directiveFile, []byte(`prop1 1
-	prop2 2`), 0644)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.Remove(directiveFile)
-
-	// import from existing file
-	result, err := testParseOne(`localhost
-	dir1
-	proxy {
-		import testdata/directive_import_test
-		transparent
-	}`)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !isExpected(result) {
-		t.Error("directive import failed")
-	}
-
-	// import from nonexistent file
-	_, err = testParseOne(`localhost
-	dir1
-	proxy {
-		import testdata/nonexistent_file
-		transparent
-	}`)
-	if err == nil {
-		t.Fatal("expected error when importing a nonexistent file")
-	}
-}
-
 func TestParseAll(t *testing.T) {
 	for i, test := range []struct {
 		input     string
@@ -477,207 +438,115 @@ func TestParseAll(t *testing.T) {
 }
 
 func TestEnvironmentReplacement(t *testing.T) {
+	os.Setenv("PORT", "8080")
+	os.Setenv("ADDRESS", "servername.com")
 	os.Setenv("FOOBAR", "foobar")
-	os.Setenv("CHAINED", "$FOOBAR")
 
-	for i, test := range []struct {
-		input  string
-		expect string
-	}{
-		{
-			input:  "",
-			expect: "",
-		},
-		{
-			input:  "foo",
-			expect: "foo",
-		},
-		{
-			input:  "{$NOT_SET}",
-			expect: "",
-		},
-		{
-			input:  "foo{$NOT_SET}bar",
-			expect: "foobar",
-		},
-		{
-			input:  "{$FOOBAR}",
-			expect: "foobar",
-		},
-		{
-			input:  "foo {$FOOBAR} bar",
-			expect: "foo foobar bar",
-		},
-		{
-			input:  "foo{$FOOBAR}bar",
-			expect: "foofoobarbar",
-		},
-		{
-			input:  "foo\n{$FOOBAR}\nbar",
-			expect: "foo\nfoobar\nbar",
-		},
-		{
-			input:  "{$FOOBAR} {$FOOBAR}",
-			expect: "foobar foobar",
-		},
-		{
-			input:  "{$FOOBAR}{$FOOBAR}",
-			expect: "foobarfoobar",
-		},
-		{
-			input:  "{$CHAINED}",
-			expect: "$FOOBAR", // should not chain env expands
-		},
-		{
-			input:  "{$FOO:default}",
-			expect: "default",
-		},
-		{
-			input:  "foo{$BAR:bar}baz",
-			expect: "foobarbaz",
-		},
-		{
-			input:  "foo{$BAR:$FOOBAR}baz",
-			expect: "foo$FOOBARbaz", // should not chain env expands
-		},
-		{
-			input:  "{$FOOBAR",
-			expect: "{$FOOBAR",
-		},
-		{
-			input:  "{$LONGER_NAME $FOOBAR}",
-			expect: "",
-		},
-		{
-			input:  "{$}",
-			expect: "{$}",
-		},
-		{
-			input:  "{$$}",
-			expect: "",
-		},
-		{
-			input:  "{$",
-			expect: "{$",
-		},
-		{
-			input:  "}{$",
-			expect: "}{$",
-		},
-	} {
-		actual, err := replaceEnvVars([]byte(test.input))
-		if err != nil {
-			t.Fatal(err)
-		}
-		if !bytes.Equal(actual, []byte(test.expect)) {
-			t.Errorf("Test %d: Expected: '%s' but got '%s'", i, test.expect, actual)
-		}
+	// basic test; unix-style env vars
+	p := testParser(`{$ADDRESS}`)
+	blocks, _ := p.parseAll()
+	if actual, expected := blocks[0].Keys[0], "servername.com"; expected != actual {
+		t.Errorf("Expected key to be '%s' but was '%s'", expected, actual)
 	}
-}
 
-func TestSnippets(t *testing.T) {
-	p := testParser(`
-		(common) {
-			gzip foo
-			errors stderr
-		}
-		http://example.com {
-			import common
-		}
-	`)
-	blocks, err := p.parseAll()
-	if err != nil {
-		t.Fatal(err)
+	// multiple vars per token
+	p = testParser(`{$ADDRESS}:{$PORT}`)
+	blocks, _ = p.parseAll()
+	if actual, expected := blocks[0].Keys[0], "servername.com:8080"; expected != actual {
+		t.Errorf("Expected key to be '%s' but was '%s'", expected, actual)
 	}
-	if len(blocks) != 1 {
-		t.Fatalf("Expect exactly one server block. Got %d.", len(blocks))
+
+	// windows-style var and unix style in same token
+	p = testParser(`{%ADDRESS%}:{$PORT}`)
+	blocks, _ = p.parseAll()
+	if actual, expected := blocks[0].Keys[0], "servername.com:8080"; expected != actual {
+		t.Errorf("Expected key to be '%s' but was '%s'", expected, actual)
 	}
-	if actual, expected := blocks[0].Keys[0], "http://example.com"; expected != actual {
-		t.Errorf("Expected server name to be '%s' but was '%s'", expected, actual)
+
+	// reverse order
+	p = testParser(`{$ADDRESS}:{%PORT%}`)
+	blocks, _ = p.parseAll()
+	if actual, expected := blocks[0].Keys[0], "servername.com:8080"; expected != actual {
+		t.Errorf("Expected key to be '%s' but was '%s'", expected, actual)
 	}
-	if len(blocks[0].Segments) != 2 {
-		t.Fatalf("Server block should have tokens from import, got: %+v", blocks[0])
+
+	// env var in server block body as argument
+	p = testParser(":{%PORT%}\ndir1 {$FOOBAR}")
+	blocks, _ = p.parseAll()
+	if actual, expected := blocks[0].Keys[0], ":8080"; expected != actual {
+		t.Errorf("Expected key to be '%s' but was '%s'", expected, actual)
 	}
-	if actual, expected := blocks[0].Segments[0][0].Text, "gzip"; expected != actual {
+	if actual, expected := blocks[0].Tokens["dir1"][1].Text, "foobar"; expected != actual {
 		t.Errorf("Expected argument to be '%s' but was '%s'", expected, actual)
 	}
-	if actual, expected := blocks[0].Segments[1][1].Text, "stderr"; expected != actual {
+
+	// combined windows env vars in argument
+	p = testParser(":{%PORT%}\ndir1 {%ADDRESS%}/{%FOOBAR%}")
+	blocks, _ = p.parseAll()
+	if actual, expected := blocks[0].Tokens["dir1"][1].Text, "servername.com/foobar"; expected != actual {
 		t.Errorf("Expected argument to be '%s' but was '%s'", expected, actual)
 	}
-}
 
-func writeStringToTempFileOrDie(t *testing.T, str string) (pathToFile string) {
-	file, err := ioutil.TempFile("", t.Name())
-	if err != nil {
-		panic(err) // get a stack trace so we know where this was called from.
+	// malformed env var (windows)
+	p = testParser(":1234\ndir1 {%ADDRESS}")
+	blocks, _ = p.parseAll()
+	if actual, expected := blocks[0].Tokens["dir1"][1].Text, "{%ADDRESS}"; expected != actual {
+		t.Errorf("Expected host to be '%s' but was '%s'", expected, actual)
 	}
-	if _, err := file.WriteString(str); err != nil {
-		panic(err)
-	}
-	if err := file.Close(); err != nil {
-		panic(err)
-	}
-	return file.Name()
-}
 
-func TestImportedFilesIgnoreNonDirectiveImportTokens(t *testing.T) {
-	fileName := writeStringToTempFileOrDie(t, `
-		http://example.com {
-			# This isn't an import directive, it's just an arg with value 'import'
-			basicauth / import password
-		}
-	`)
-	// Parse the root file that imports the other one.
-	p := testParser(`import ` + fileName)
-	blocks, err := p.parseAll()
-	if err != nil {
-		t.Fatal(err)
+	// malformed (non-existent) env var (unix)
+	p = testParser(`:{$PORT$}`)
+	blocks, _ = p.parseAll()
+	if actual, expected := blocks[0].Keys[0], ":"; expected != actual {
+		t.Errorf("Expected key to be '%s' but was '%s'", expected, actual)
 	}
-	auth := blocks[0].Segments[0]
-	line := auth[0].Text + " " + auth[1].Text + " " + auth[2].Text + " " + auth[3].Text
-	if line != "basicauth / import password" {
-		// Previously, it would be changed to:
-		//   basicauth / import /path/to/test/dir/password
-		// referencing a file that (probably) doesn't exist and changing the
-		// password!
-		t.Errorf("Expected basicauth tokens to be 'basicauth / import password' but got %#q", line)
-	}
-}
 
-func TestSnippetAcrossMultipleFiles(t *testing.T) {
-	// Make the derived Caddyfile that expects (common) to be defined.
-	fileName := writeStringToTempFileOrDie(t, `
-		http://example.com {
-			import common
-		}
-	`)
-
-	// Parse the root file that defines (common) and then imports the other one.
-	p := testParser(`
-		(common) {
-			gzip foo
-		}
-		import ` + fileName + `
-	`)
-
-	blocks, err := p.parseAll()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(blocks) != 1 {
-		t.Fatalf("Expect exactly one server block. Got %d.", len(blocks))
-	}
-	if actual, expected := blocks[0].Keys[0], "http://example.com"; expected != actual {
-		t.Errorf("Expected server name to be '%s' but was '%s'", expected, actual)
-	}
-	if len(blocks[0].Segments) != 1 {
-		t.Fatalf("Server block should have tokens from import")
-	}
-	if actual, expected := blocks[0].Segments[0][0].Text, "gzip"; expected != actual {
+	// in quoted field
+	p = testParser(":1234\ndir1 \"Test {$FOOBAR} test\"")
+	blocks, _ = p.parseAll()
+	if actual, expected := blocks[0].Tokens["dir1"][1].Text, "Test foobar test"; expected != actual {
 		t.Errorf("Expected argument to be '%s' but was '%s'", expected, actual)
 	}
 }
 
 func testParser(input string) parser {
-	return parser{Dispenser: NewTestDispenser(input)}
+	buf := strings.NewReader(input)
+	p := parser{Dispenser: NewDispenser("Caddyfile", buf)}
+	return p
+}
+
+func TestSnippets(t *testing.T) {
+	p := testParser(`(common) {
+					gzip foo
+					errors stderr
+					
+				}	
+				http://example.com {
+					import common
+				}
+			`)
+	blocks, err := p.parseAll()
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, b := range blocks {
+		t.Log(b.Keys)
+		t.Log(b.Tokens)
+	}
+	if len(blocks) != 1 {
+		t.Fatalf("Expect exactly one server block. Got %d.", len(blocks))
+	}
+	if actual, expected := blocks[0].Keys[0], "http://example.com"; expected != actual {
+		t.Errorf("Expected server name to be '%s' but was '%s'", expected, actual)
+	}
+	if len(blocks[0].Tokens) != 2 {
+		t.Fatalf("Server block should have tokens from import")
+	}
+	if actual, expected := blocks[0].Tokens["gzip"][0].Text, "gzip"; expected != actual {
+		t.Errorf("Expected argument to be '%s' but was '%s'", expected, actual)
+	}
+	if actual, expected := blocks[0].Tokens["errors"][1].Text, "stderr"; expected != actual {
+		t.Errorf("Expected argument to be '%s' but was '%s'", expected, actual)
+	}
+
 }

caddyhttp/basicauth/basicauth.go

@@ -0,0 +1,189 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// 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 basicauth implements HTTP Basic Authentication for Caddy.
+//
+// This is useful for simple protections on a website, like requiring
+// a password to access an admin interface. This package assumes a
+// fairly small threat model.
+package basicauth
+
+import (
+	"bufio"
+	"context"
+	"crypto/sha1"
+	"crypto/subtle"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+
+	"github.com/jimstudt/http-authentication/basic"
+	"github.com/mholt/caddy/caddyhttp/httpserver"
+)
+
+// BasicAuth is middleware to protect resources with a username and password.
+// Note that HTTP Basic Authentication is not secure by itself and should
+// not be used to protect important assets without HTTPS. Even then, the
+// security of HTTP Basic Auth is disputed. Use discretion when deciding
+// what to protect with BasicAuth.
+type BasicAuth struct {
+	Next     httpserver.Handler
+	SiteRoot string
+	Rules    []Rule
+}
+
+// ServeHTTP implements the httpserver.Handler interface.
+func (a BasicAuth) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error) {
+	var protected, isAuthenticated bool
+	var realm string
+
+	for _, rule := range a.Rules {
+		for _, res := range rule.Resources {
+			if !httpserver.Path(r.URL.Path).Matches(res) {
+				continue
+			}
+
+			// path matches; this endpoint is protected
+			protected = true
+			realm = rule.Realm
+
+			// parse auth header
+			username, password, ok := r.BasicAuth()
+
+			// check credentials
+			if !ok ||
+				username != rule.Username ||
+				!rule.Password(password) {
+				continue
+			}
+
+			// by this point, authentication was successful
+			isAuthenticated = true
+
+			// let upstream middleware (e.g. fastcgi and cgi) know about authenticated
+			// user; this replaces the request with a wrapped instance
+			r = r.WithContext(context.WithValue(r.Context(),
+				httpserver.RemoteUserCtxKey, username))
+
+			// Provide username to be used in log by replacer
+			repl := httpserver.NewReplacer(r, nil, "-")
+			repl.Set("user", username)
+		}
+	}
+
+	if protected && !isAuthenticated {
+		// browsers show a message that says something like:
+		// "The website says: <realm>"
+		// which is kinda dumb, but whatever.
+		if realm == "" {
+			realm = "Restricted"
+		}
+		w.Header().Set("WWW-Authenticate", "Basic realm=\""+realm+"\"")
+		return http.StatusUnauthorized, nil
+	}
+
+	// Pass-through when no paths match
+	return a.Next.ServeHTTP(w, r)
+}
+
+// Rule represents a BasicAuth rule. A username and password
+// combination protect the associated resources, which are
+// file or directory paths.
+type Rule struct {
+	Username  string
+	Password  func(string) bool
+	Resources []string
+	Realm     string // See RFC 1945 and RFC 2617, default: "Restricted"
+}
+
+// PasswordMatcher determines whether a password matches a rule.
+type PasswordMatcher func(pw string) bool
+
+var (
+	htpasswords   map[string]map[string]PasswordMatcher
+	htpasswordsMu sync.Mutex
+)
+
+// GetHtpasswdMatcher matches password rules.
+func GetHtpasswdMatcher(filename, username, siteRoot string) (PasswordMatcher, error) {
+	filename = filepath.Join(siteRoot, filename)
+	htpasswordsMu.Lock()
+	if htpasswords == nil {
+		htpasswords = make(map[string]map[string]PasswordMatcher)
+	}
+	pm := htpasswords[filename]
+	if pm == nil {
+		fh, err := os.Open(filename)
+		if err != nil {
+			return nil, fmt.Errorf("open %q: %v", filename, err)
+		}
+		defer fh.Close()
+		pm = make(map[string]PasswordMatcher)
+		if err = parseHtpasswd(pm, fh); err != nil {
+			return nil, fmt.Errorf("parsing htpasswd %q: %v", fh.Name(), err)
+		}
+		htpasswords[filename] = pm
+	}
+	htpasswordsMu.Unlock()
+	if pm[username] == nil {
+		return nil, fmt.Errorf("username %q not found in %q", username, filename)
+	}
+	return pm[username], nil
+}
+
+func parseHtpasswd(pm map[string]PasswordMatcher, r io.Reader) error {
+	scanner := bufio.NewScanner(r)
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+		if line == "" || strings.IndexByte(line, '#') == 0 {
+			continue
+		}
+		i := strings.IndexByte(line, ':')
+		if i <= 0 {
+			return fmt.Errorf("malformed line, no color: %q", line)
+		}
+		user, encoded := line[:i], line[i+1:]
+		for _, p := range basic.DefaultSystems {
+			matcher, err := p(encoded)
+			if err != nil {
+				return err
+			}
+			if matcher != nil {
+				pm[user] = matcher.MatchesPassword
+				break
+			}
+		}
+	}
+	return scanner.Err()
+}
+
+// PlainMatcher returns a PasswordMatcher that does a constant-time
+// byte comparison against the password passw.
+func PlainMatcher(passw string) PasswordMatcher {
+	// compare hashes of equal length instead of actual password
+	// to avoid leaking password length
+	passwHash := sha1.New()
+	passwHash.Write([]byte(passw))
+	passwSum := passwHash.Sum(nil)
+	return func(pw string) bool {
+		pwHash := sha1.New()
+		pwHash.Write([]byte(pw))
+		pwSum := pwHash.Sum(nil)
+		return subtle.ConstantTimeCompare([]byte(pwSum), []byte(passwSum)) == 1
+	}
+}

caddyhttp/basicauth/basicauth_test.go

@@ -0,0 +1,196 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// 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 basicauth
+
+import (
+	"encoding/base64"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/mholt/caddy/caddyhttp/httpserver"
+)
+
+func TestBasicAuth(t *testing.T) {
+	var i int
+	// This handler is registered for tests in which the only authorized user is
+	// "okuser"
+	upstreamHandler := func(w http.ResponseWriter, r *http.Request) (int, error) {
+		remoteUser, _ := r.Context().Value(httpserver.RemoteUserCtxKey).(string)
+		if remoteUser != "okuser" {
+			t.Errorf("Test %d: expecting remote user 'okuser', got '%s'", i, remoteUser)
+		}
+		return http.StatusOK, nil
+	}
+	rws := []BasicAuth{
+		{
+			Next: httpserver.HandlerFunc(upstreamHandler),
+			Rules: []Rule{
+				{Username: "okuser", Password: PlainMatcher("okpass"),
+					Resources: []string{"/testing"}, Realm: "Resources"},
+			},
+		},
+		{
+			Next: httpserver.HandlerFunc(upstreamHandler),
+			Rules: []Rule{
+				{Username: "okuser", Password: PlainMatcher("okpass"),
+					Resources: []string{"/testing"}},
+			},
+		},
+	}
+
+	type testType struct {
+		from     string
+		result   int
+		user     string
+		password string
+	}
+
+	tests := []testType{
+		{"/testing", http.StatusOK, "okuser", "okpass"},
+		{"/testing", http.StatusUnauthorized, "baduser", "okpass"},
+		{"/testing", http.StatusUnauthorized, "okuser", "badpass"},
+		{"/testing", http.StatusUnauthorized, "OKuser", "okpass"},
+		{"/testing", http.StatusUnauthorized, "OKuser", "badPASS"},
+		{"/testing", http.StatusUnauthorized, "", "okpass"},
+		{"/testing", http.StatusUnauthorized, "okuser", ""},
+		{"/testing", http.StatusUnauthorized, "", ""},
+	}
+
+	var test testType
+	for _, rw := range rws {
+		expectRealm := rw.Rules[0].Realm
+		if expectRealm == "" {
+			expectRealm = "Restricted" // Default if Realm not specified in rule
+		}
+		for i, test = range tests {
+			req, err := http.NewRequest("GET", test.from, nil)
+			if err != nil {
+				t.Fatalf("Test %d: Could not create HTTP request: %v", i, err)
+			}
+			req.SetBasicAuth(test.user, test.password)
+
+			rec := httptest.NewRecorder()
+			result, err := rw.ServeHTTP(rec, req)
+			if err != nil {
+				t.Fatalf("Test %d: Could not ServeHTTP: %v", i, err)
+			}
+			if result != test.result {
+				t.Errorf("Test %d: Expected status code %d but was %d",
+					i, test.result, result)
+			}
+			if test.result == http.StatusUnauthorized {
+				headers := rec.Header()
+				if val, ok := headers["Www-Authenticate"]; ok {
+					if got, want := val[0], "Basic realm=\""+expectRealm+"\""; got != want {
+						t.Errorf("Test %d: Www-Authenticate header should be '%s', got: '%s'", i, want, got)
+					}
+				} else {
+					t.Errorf("Test %d: response should have a 'Www-Authenticate' header", i)
+				}
+			} else {
+				if req.Header.Get("Authorization") == "" {
+					// see issue #1508: https://github.com/mholt/caddy/issues/1508
+					t.Errorf("Test %d: Expected Authorization header to be retained after successful auth, but was empty", i)
+				}
+			}
+		}
+	}
+}
+
+func TestMultipleOverlappingRules(t *testing.T) {
+	rw := BasicAuth{
+		Next: httpserver.HandlerFunc(contentHandler),
+		Rules: []Rule{
+			{Username: "t", Password: PlainMatcher("p1"), Resources: []string{"/t"}},
+			{Username: "t1", Password: PlainMatcher("p2"), Resources: []string{"/t/t"}},
+		},
+	}
+
+	tests := []struct {
+		from   string
+		result int
+		cred   string
+	}{
+		{"/t", http.StatusOK, "t:p1"},
+		{"/t/t", http.StatusOK, "t:p1"},
+		{"/t/t", http.StatusOK, "t1:p2"},
+		{"/a", http.StatusOK, "t1:p2"},
+		{"/t/t", http.StatusUnauthorized, "t1:p3"},
+		{"/t", http.StatusUnauthorized, "t1:p2"},
+	}
+
+	for i, test := range tests {
+
+		req, err := http.NewRequest("GET", test.from, nil)
+		if err != nil {
+			t.Fatalf("Test %d: Could not create HTTP request %v", i, err)
+		}
+		auth := "Basic " + base64.StdEncoding.EncodeToString([]byte(test.cred))
+		req.Header.Set("Authorization", auth)
+
+		rec := httptest.NewRecorder()
+		result, err := rw.ServeHTTP(rec, req)
+		if err != nil {
+			t.Fatalf("Test %d: Could not ServeHTTP %v", i, err)
+		}
+		if result != test.result {
+			t.Errorf("Test %d: Expected Header '%d' but was '%d'",
+				i, test.result, result)
+		}
+
+	}
+
+}
+
+func contentHandler(w http.ResponseWriter, r *http.Request) (int, error) {
+	fmt.Fprintf(w, r.URL.String())
+	return http.StatusOK, nil
+}
+
+func TestHtpasswd(t *testing.T) {
+	htpasswdPasswd := "IedFOuGmTpT8"
+	htpasswdFile := `sha1:{SHA}dcAUljwz99qFjYR0YLTXx0RqLww=
+md5:$apr1$l42y8rex$pOA2VJ0x/0TwaFeAF9nX61`
+
+	htfh, err := ioutil.TempFile("", "basicauth-")
+	if err != nil {
+		t.Skip("Error creating temp file, will skip htpassword test")
+		return
+	}
+	defer os.Remove(htfh.Name())
+	if _, err = htfh.Write([]byte(htpasswdFile)); err != nil {
+		t.Fatalf("write htpasswd file %q: %v", htfh.Name(), err)
+	}
+	htfh.Close()
+
+	for i, username := range []string{"sha1", "md5"} {
+		rule := Rule{Username: username, Resources: []string{"/testing"}}
+
+		siteRoot := filepath.Dir(htfh.Name())
+		filename := filepath.Base(htfh.Name())
+		if rule.Password, err = GetHtpasswdMatcher(filename, rule.Username, siteRoot); err != nil {
+			t.Fatalf("GetHtpasswdMatcher(%q, %q): %v", htfh.Name(), rule.Username, err)
+		}
+		t.Logf("%d. username=%q", i, rule.Username)
+		if !rule.Password(htpasswdPasswd) || rule.Password(htpasswdPasswd+"!") {
+			t.Errorf("%d (%s) password does not match.", i, rule.Username)
+		}
+	}
+}

caddyhttp/basicauth/setup.go

@@ -0,0 +1,113 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// 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 basicauth
+
+import (
+	"strings"
+
+	"github.com/mholt/caddy"
+	"github.com/mholt/caddy/caddyhttp/httpserver"
+)
+
+func init() {
+	caddy.RegisterPlugin("basicauth", caddy.Plugin{
+		ServerType: "http",
+		Action:     setup,
+	})
+}
+
+// setup configures a new BasicAuth middleware instance.
+func setup(c *caddy.Controller) error {
+	cfg := httpserver.GetConfig(c)
+	root := cfg.Root
+
+	rules, err := basicAuthParse(c)
+	if err != nil {
+		return err
+	}
+
+	basic := BasicAuth{Rules: rules}
+
+	cfg.AddMiddleware(func(next httpserver.Handler) httpserver.Handler {
+		basic.Next = next
+		basic.SiteRoot = root
+		return basic
+	})
+
+	return nil
+}
+
+func basicAuthParse(c *caddy.Controller) ([]Rule, error) {
+	var rules []Rule
+	cfg := httpserver.GetConfig(c)
+
+	var err error
+	for c.Next() {
+		var rule Rule
+
+		args := c.RemainingArgs()
+
+		switch len(args) {
+		case 2:
+			rule.Username = args[0]
+			if rule.Password, err = passwordMatcher(rule.Username, args[1], cfg.Root); err != nil {
+				return rules, c.Errf("Get password matcher from %s: %v", c.Val(), err)
+			}
+		case 3:
+			rule.Resources = append(rule.Resources, args[0])
+			rule.Username = args[1]
+			if rule.Password, err = passwordMatcher(rule.Username, args[2], cfg.Root); err != nil {
+				return rules, c.Errf("Get password matcher from %s: %v", c.Val(), err)
+			}
+		default:
+			return rules, c.ArgErr()
+		}
+
+		// If nested block is present, process it here
+		for c.NextBlock() {
+			val := c.Val()
+			args = c.RemainingArgs()
+			switch len(args) {
+			case 0:
+				// Assume single argument is path resource
+				rule.Resources = append(rule.Resources, val)
+			case 1:
+				if val == "realm" {
+					if rule.Realm == "" {
+						rule.Realm = strings.Replace(args[0], `"`, `\"`, -1)
+					} else {
+						return rules, c.Errf("\"realm\" subdirective can only be specified once")
+					}
+				} else {
+					return rules, c.Errf("expecting \"realm\", got \"%s\"", val)
+				}
+			default:
+				return rules, c.ArgErr()
+			}
+		}
+
+		rules = append(rules, rule)
+	}
+
+	return rules, nil
+}
+
+func passwordMatcher(username, passw, siteRoot string) (PasswordMatcher, error) {
+	htpasswdPrefix := "htpasswd="
+	if !strings.HasPrefix(passw, htpasswdPrefix) {
+		return PlainMatcher(passw), nil
+	}
+	return GetHtpasswdMatcher(passw[len(htpasswdPrefix):], username, siteRoot)
+}

caddyhttp/basicauth/setup_test.go

@@ -0,0 +1,178 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// 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 basicauth
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/mholt/caddy"
+	"github.com/mholt/caddy/caddyhttp/httpserver"
+)
+
+func TestSetup(t *testing.T) {
+	c := caddy.NewTestController("http", `basicauth user pwd`)
+	err := setup(c)
+	if err != nil {
+		t.Errorf("Expected no errors, but got: %v", err)
+	}
+	mids := httpserver.GetConfig(c).Middleware()
+	if len(mids) == 0 {
+		t.Fatal("Expected middleware, got 0 instead")
+	}
+
+	handler := mids[0](httpserver.EmptyNext)
+	myHandler, ok := handler.(BasicAuth)
+	if !ok {
+		t.Fatalf("Expected handler to be type BasicAuth, got: %#v", handler)
+	}
+
+	if !httpserver.SameNext(myHandler.Next, httpserver.EmptyNext) {
+		t.Error("'Next' field of handler was not set properly")
+	}
+}
+
+func TestBasicAuthParse(t *testing.T) {
+	htpasswdPasswd := "IedFOuGmTpT8"
+	htpasswdFile := `sha1:{SHA}dcAUljwz99qFjYR0YLTXx0RqLww=
+md5:$apr1$l42y8rex$pOA2VJ0x/0TwaFeAF9nX61`
+
+	var skipHtpassword bool
+	htfh, err := ioutil.TempFile(".", "basicauth-")
+	if err != nil {
+		t.Logf("Error creating temp file (%v), will skip htpassword test", err)
+		skipHtpassword = true
+	} else {
+		if _, err = htfh.Write([]byte(htpasswdFile)); err != nil {
+			t.Fatalf("write htpasswd file %q: %v", htfh.Name(), err)
+		}
+		htfh.Close()
+		defer os.Remove(htfh.Name())
+	}
+
+	tests := []struct {
+		input     string
+		shouldErr bool
+		password  string
+		expected  []Rule
+	}{
+		{`basicauth user pwd`, false, "pwd", []Rule{
+			{Username: "user"},
+		}},
+		{`basicauth user pwd {
+		}`, false, "pwd", []Rule{
+			{Username: "user"},
+		}},
+		{`basicauth /resource1 user pwd {
+		}`, false, "pwd", []Rule{
+			{Username: "user", Resources: []string{"/resource1"}},
+		}},
+		{`basicauth /resource1 user pwd {
+			realm Resources
+		}`, false, "pwd", []Rule{
+			{Username: "user", Resources: []string{"/resource1"}, Realm: "Resources"},
+		}},
+		{`basicauth user pwd {
+			/resource1
+			/resource2
+		}`, false, "pwd", []Rule{
+			{Username: "user", Resources: []string{"/resource1", "/resource2"}},
+		}},
+		{`basicauth user pwd {
+			/resource1
+			/resource2
+			realm "Secure resources"
+		}`, false, "pwd", []Rule{
+			{Username: "user", Resources: []string{"/resource1", "/resource2"}, Realm: "Secure resources"},
+		}},
+		{`basicauth user pwd {
+			/resource1
+			realm "Secure resources"
+			realm Extra
+			/resource2
+		}`, true, "pwd", []Rule{}},
+		{`basicauth user pwd {
+			/resource1
+			foo "Resources"
+			/resource2
+		}`, true, "pwd", []Rule{}},
+		{`basicauth /resource user pwd`, false, "pwd", []Rule{
+			{Username: "user", Resources: []string{"/resource"}},
+		}},
+		{`basicauth /res1 user1 pwd1
+		  basicauth /res2 user2 pwd2`, false, "pwd", []Rule{
+			{Username: "user1", Resources: []string{"/res1"}},
+			{Username: "user2", Resources: []string{"/res2"}},
+		}},
+		{`basicauth user`, true, "", []Rule{}},
+		{`basicauth`, true, "", []Rule{}},
+		{`basicauth /resource user pwd asdf`, true, "", []Rule{}},
+
+		{`basicauth sha1 htpasswd=` + htfh.Name(), false, htpasswdPasswd, []Rule{
+			{Username: "sha1"},
+		}},
+	}
+
+	for i, test := range tests {
+		actual, err := basicAuthParse(caddy.NewTestController("http", test.input))
+
+		if err == nil && test.shouldErr {
+			t.Errorf("Test %d didn't error, but it should have", i)
+		} else if err != nil && !test.shouldErr {
+			t.Errorf("Test %d errored, but it shouldn't have; got '%v'", i, err)
+		}
+
+		if len(actual) != len(test.expected) {
+			t.Fatalf("Test %d expected %d rules, but got %d",
+				i, len(test.expected), len(actual))
+		}
+
+		for j, expectedRule := range test.expected {
+			actualRule := actual[j]
+
+			if actualRule.Username != expectedRule.Username {
+				t.Errorf("Test %d, rule %d: Expected username '%s', got '%s'",
+					i, j, expectedRule.Username, actualRule.Username)
+			}
+
+			if actualRule.Realm != expectedRule.Realm {
+				t.Errorf("Test %d, rule %d: Expected realm '%s', got '%s'",
+					i, j, expectedRule.Realm, actualRule.Realm)
+			}
+
+			if strings.Contains(test.input, "htpasswd=") && skipHtpassword {
+				continue
+			}
+			pwd := test.password
+			if len(actual) > 1 {
+				pwd = fmt.Sprintf("%s%d", pwd, j+1)
+			}
+			if !actualRule.Password(pwd) || actualRule.Password(test.password+"!") {
+				t.Errorf("Test %d, rule %d: Expected password '%v', got '%v'",
+					i, j, test.password, actualRule.Password(""))
+			}
+
+			expectedRes := fmt.Sprintf("%v", expectedRule.Resources)
+			actualRes := fmt.Sprintf("%v", actualRule.Resources)
+			if actualRes != expectedRes {
+				t.Errorf("Test %d, rule %d: Expected resource list %s, but got %s",
+					i, j, expectedRes, actualRes)
+			}
+		}
+	}
+}

caddyhttp/bind/bind.go

@@ -1,4 +1,4 @@
-// Copyright 2015 Matthew Holt and The Caddy Authors
+// Copyright 2015 Light Code Labs, LLC
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -12,27 +12,27 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package acmeserver
+package bind
 
 import (
-	"github.com/caddyserver/caddy/v2/caddyconfig/httpcaddyfile"
-	"github.com/caddyserver/caddy/v2/modules/caddyhttp"
+	"github.com/mholt/caddy"
+	"github.com/mholt/caddy/caddyhttp/httpserver"
 )
 
 func init() {
-	httpcaddyfile.RegisterHandlerDirective("acme_server", parseACMEServer)
+	caddy.RegisterPlugin("bind", caddy.Plugin{
+		ServerType: "http",
+		Action:     setupBind,
+	})
 }
 
-// parseACMEServer sets up an ACME server handler from Caddyfile tokens.
-//
-//     acme_server [<matcher>]
-//
-func parseACMEServer(h httpcaddyfile.Helper) (caddyhttp.MiddlewareHandler, error) {
-	var as Handler
-	for h.Next() {
-		if h.NextArg() {
-			return nil, h.ArgErr()
+func setupBind(c *caddy.Controller) error {
+	config := httpserver.GetConfig(c)
+	for c.Next() {
+		if !c.Args(&config.ListenHost) {
+			return c.ArgErr()
 		}
+		config.TLS.ListenHost = config.ListenHost // necessary for ACME challenges, see issue #309
 	}
-	return as, nil
+	return nil
 }

caddyhttp/bind/bind_test.go

@@ -0,0 +1,38 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// 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 bind
+
+import (
+	"testing"
+
+	"github.com/mholt/caddy"
+	"github.com/mholt/caddy/caddyhttp/httpserver"
+)
+
+func TestSetupBind(t *testing.T) {
+	c := caddy.NewTestController("http", `bind 1.2.3.4`)
+	err := setupBind(c)
+	if err != nil {
+		t.Fatalf("Expected no errors, but got: %v", err)
+	}
+
+	cfg := httpserver.GetConfig(c)
+	if got, want := cfg.ListenHost, "1.2.3.4"; got != want {
+		t.Errorf("Expected the config's ListenHost to be %s, was %s", want, got)
+	}
+	if got, want := cfg.TLS.ListenHost, "1.2.3.4"; got != want {
+		t.Errorf("Expected the TLS config's ListenHost to be %s, was %s", want, got)
+	}
+}

caddyhttp/browse/browse.go

@@ -0,0 +1,527 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// 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 browse provides middleware for listing files in a directory
+// when directory path is requested instead of a specific file.
+package browse
+
+import (
+	"bytes"
+	"encoding/json"
+	"net/http"
+	"net/url"
+	"os"
+	"path"
+	"sort"
+	"strconv"
+	"strings"
+	"text/template"
+	"time"
+
+	"github.com/dustin/go-humanize"
+	"github.com/mholt/caddy/caddyhttp/httpserver"
+	"github.com/mholt/caddy/caddyhttp/staticfiles"
+)
+
+const (
+	sortByName         = "name"
+	sortByNameDirFirst = "namedirfirst"
+	sortBySize         = "size"
+	sortByTime         = "time"
+)
+
+// Browse is an http.Handler that can show a file listing when
+// directories in the given paths are specified.
+type Browse struct {
+	Next          httpserver.Handler
+	Configs       []Config
+	IgnoreIndexes bool
+}
+
+// Config is a configuration for browsing in a particular path.
+type Config struct {
+	PathScope string // the base path the URL must match to enable browsing
+	Fs        staticfiles.FileServer
+	Variables interface{}
+	Template  *template.Template
+}
+
+// A Listing is the context used to fill out a template.
+type Listing struct {
+	// The name of the directory (the last element of the path)
+	Name string
+
+	// The full path of the request
+	Path string
+
+	// Whether the parent directory is browsable
+	CanGoUp bool
+
+	// The items (files and folders) in the path
+	Items []FileInfo
+
+	// The number of directories in the listing
+	NumDirs int
+
+	// The number of files (items that aren't directories) in the listing
+	NumFiles int
+
+	// Which sorting order is used
+	Sort string
+
+	// And which order
+	Order string
+
+	// If ≠0 then Items have been limited to that many elements
+	ItemsLimitedTo int
+
+	// Optional custom variables for use in browse templates
+	User interface{}
+
+	httpserver.Context
+}
+
+// Crumb represents part of a breadcrumb menu.
+type Crumb struct {
+	Link, Text string
+}
+
+// Breadcrumbs returns l.Path where every element maps
+// the link to the text to display.
+func (l Listing) Breadcrumbs() []Crumb {
+	var result []Crumb
+
+	if len(l.Path) == 0 {
+		return result
+	}
+
+	// skip trailing slash
+	lpath := l.Path
+	if lpath[len(lpath)-1] == '/' {
+		lpath = lpath[:len(lpath)-1]
+	}
+
+	parts := strings.Split(lpath, "/")
+	for i := range parts {
+		txt := parts[i]
+		if i == 0 && parts[i] == "" {
+			txt = "/"
+		}
+		result = append(result, Crumb{Link: strings.Repeat("../", len(parts)-i-1), Text: txt})
+	}
+
+	return result
+}
+
+// FileInfo is the info about a particular file or directory
+type FileInfo struct {
+	Name      string
+	Size      int64
+	URL       string
+	ModTime   time.Time
+	Mode      os.FileMode
+	IsDir     bool
+	IsSymlink bool
+}
+
+// HumanSize returns the size of the file as a human-readable string
+// in IEC format (i.e. power of 2 or base 1024).
+func (fi FileInfo) HumanSize() string {
+	return humanize.IBytes(uint64(fi.Size))
+}
+
+// HumanModTime returns the modified time of the file as a human-readable string.
+func (fi FileInfo) HumanModTime(format string) string {
+	return fi.ModTime.Format(format)
+}
+
+// Implement sorting for Listing
+type byName Listing
+type byNameDirFirst Listing
+type bySize Listing
+type byTime Listing
+
+// By Name
+func (l byName) Len() int      { return len(l.Items) }
+func (l byName) Swap(i, j int) { l.Items[i], l.Items[j] = l.Items[j], l.Items[i] }
+
+// Treat upper and lower case equally
+func (l byName) Less(i, j int) bool {
+	return strings.ToLower(l.Items[i].Name) < strings.ToLower(l.Items[j].Name)
+}
+
+// By Name Dir First
+func (l byNameDirFirst) Len() int      { return len(l.Items) }
+func (l byNameDirFirst) Swap(i, j int) { l.Items[i], l.Items[j] = l.Items[j], l.Items[i] }
+
+// Treat upper and lower case equally
+func (l byNameDirFirst) Less(i, j int) bool {
+
+	// if both are dir or file sort normally
+	if l.Items[i].IsDir == l.Items[j].IsDir {
+		return strings.ToLower(l.Items[i].Name) < strings.ToLower(l.Items[j].Name)
+	}
+
+	// always sort dir ahead of file
+	return l.Items[i].IsDir
+}
+
+// By Size
+func (l bySize) Len() int      { return len(l.Items) }
+func (l bySize) Swap(i, j int) { l.Items[i], l.Items[j] = l.Items[j], l.Items[i] }
+
+const directoryOffset = -1 << 31 // = math.MinInt32
+func (l bySize) Less(i, j int) bool {
+	iSize, jSize := l.Items[i].Size, l.Items[j].Size
+
+	// Directory sizes depend on the filesystem implementation,
+	// which is opaque to a visitor, and should indeed does not change if the operator choses to change the fs.
+	// For a consistent user experience directories are pulled to the front…
+	if l.Items[i].IsDir {
+		iSize = directoryOffset
+	}
+	if l.Items[j].IsDir {
+		jSize = directoryOffset
+	}
+	// … and sorted by name.
+	if l.Items[i].IsDir && l.Items[j].IsDir {
+		return strings.ToLower(l.Items[i].Name) < strings.ToLower(l.Items[j].Name)
+	}
+
+	return iSize < jSize
+}
+
+// By Time
+func (l byTime) Len() int           { return len(l.Items) }
+func (l byTime) Swap(i, j int)      { l.Items[i], l.Items[j] = l.Items[j], l.Items[i] }
+func (l byTime) Less(i, j int) bool { return l.Items[i].ModTime.Before(l.Items[j].ModTime) }
+
+// Add sorting method to "Listing"
+// it will apply what's in ".Sort" and ".Order"
+func (l Listing) applySort() {
+	// Check '.Order' to know how to sort
+	if l.Order == "desc" {
+		switch l.Sort {
+		case sortByName:
+			sort.Sort(sort.Reverse(byName(l)))
+		case sortByNameDirFirst:
+			sort.Sort(sort.Reverse(byNameDirFirst(l)))
+		case sortBySize:
+			sort.Sort(sort.Reverse(bySize(l)))
+		case sortByTime:
+			sort.Sort(sort.Reverse(byTime(l)))
+		default:
+			// If not one of the above, do nothing
+			return
+		}
+	} else { // If we had more Orderings we could add them here
+		switch l.Sort {
+		case sortByName:
+			sort.Sort(byName(l))
+		case sortByNameDirFirst:
+			sort.Sort(byNameDirFirst(l))
+		case sortBySize:
+			sort.Sort(bySize(l))
+		case sortByTime:
+			sort.Sort(byTime(l))
+		default:
+			// If not one of the above, do nothing
+			return
+		}
+	}
+}
+
+func directoryListing(files []os.FileInfo, canGoUp bool, urlPath string, config *Config) (Listing, bool) {
+	var (
+		fileinfos           []FileInfo
+		dirCount, fileCount int
+		hasIndexFile        bool
+	)
+
+	for _, f := range files {
+		name := f.Name()
+
+		for _, indexName := range config.Fs.IndexPages {
+			if name == indexName {
+				hasIndexFile = true
+				break
+			}
+		}
+
+		isDir := f.IsDir() || isSymlinkTargetDir(f, urlPath, config)
+
+		if isDir {
+			name += "/"
+			dirCount++
+		} else {
+			fileCount++
+		}
+
+		if config.Fs.IsHidden(f) {
+			continue
+		}
+
+		url := url.URL{Path: "./" + name} // prepend with "./" to fix paths with ':' in the name
+
+		fileinfos = append(fileinfos, FileInfo{
+			IsDir:     isDir,
+			IsSymlink: isSymlink(f),
+			Name:      f.Name(),
+			Size:      f.Size(),
+			URL:       url.String(),
+			ModTime:   f.ModTime().UTC(),
+			Mode:      f.Mode(),
+		})
+	}
+
+	return Listing{
+		Name:     path.Base(urlPath),
+		Path:     urlPath,
+		CanGoUp:  canGoUp,
+		Items:    fileinfos,
+		NumDirs:  dirCount,
+		NumFiles: fileCount,
+	}, hasIndexFile
+}
+
+// isSymlink return true if f is a symbolic link
+func isSymlink(f os.FileInfo) bool {
+	return f.Mode()&os.ModeSymlink != 0
+}
+
+// isSymlinkTargetDir return true if f's symbolic link target
+// is a directory. Return false if not a symbolic link.
+func isSymlinkTargetDir(f os.FileInfo, urlPath string, config *Config) bool {
+	if !isSymlink(f) {
+		return false
+	}
+
+	// a bit strange, but we want Stat thru the jailed filesystem to be safe
+	target, err := config.Fs.Root.Open(path.Join(urlPath, f.Name()))
+	if err != nil {
+		return false
+	}
+	defer target.Close()
+	targetInfo, err := target.Stat()
+	if err != nil {
+		return false
+	}
+
+	return targetInfo.IsDir()
+}
+
+// ServeHTTP determines if the request is for this plugin, and if all prerequisites are met.
+// If so, control is handed over to ServeListing.
+func (b Browse) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error) {
+	// See if there's a browse configuration to match the path
+	var bc *Config
+	for i := range b.Configs {
+		if httpserver.Path(r.URL.Path).Matches(b.Configs[i].PathScope) {
+			bc = &b.Configs[i]
+			break
+		}
+	}
+	if bc == nil {
+		return b.Next.ServeHTTP(w, r)
+	}
+
+	// Browse works on existing directories; delegate everything else
+	requestedFilepath, err := bc.Fs.Root.Open(r.URL.Path)
+	if err != nil {
+		switch {
+		case os.IsPermission(err):
+			return http.StatusForbidden, err
+		case os.IsExist(err):
+			return http.StatusNotFound, err
+		default:
+			return b.Next.ServeHTTP(w, r)
+		}
+	}
+	defer requestedFilepath.Close()
+
+	info, err := requestedFilepath.Stat()
+	if err != nil {
+		switch {
+		case os.IsPermission(err):
+			return http.StatusForbidden, err
+		case os.IsExist(err):
+			return http.StatusGone, err
+		default:
+			return b.Next.ServeHTTP(w, r)
+		}
+	}
+	if !info.IsDir() {
+		return b.Next.ServeHTTP(w, r)
+	}
+
+	// Do not reply to anything else because it might be nonsensical
+	switch r.Method {
+	case http.MethodGet, http.MethodHead:
+		// proceed, noop
+	case "PROPFIND", http.MethodOptions:
+		return http.StatusNotImplemented, nil
+	default:
+		return b.Next.ServeHTTP(w, r)
+	}
+
+	// Browsing navigation gets messed up if browsing a directory
+	// that doesn't end in "/" (which it should, anyway)
+	u := *r.URL
+	if u.Path == "" {
+		u.Path = "/"
+	}
+	if u.Path[len(u.Path)-1] != '/' {
+		u.Path += "/"
+		http.Redirect(w, r, u.String(), http.StatusMovedPermanently)
+		return http.StatusMovedPermanently, nil
+	}
+
+	return b.ServeListing(w, r, requestedFilepath, bc)
+}
+
+func (b Browse) loadDirectoryContents(requestedFilepath http.File, urlPath string, config *Config) (*Listing, bool, error) {
+	files, err := requestedFilepath.Readdir(-1)
+	if err != nil {
+		return nil, false, err
+	}
+
+	// Determine if user can browse up another folder
+	var canGoUp bool
+	curPathDir := path.Dir(strings.TrimSuffix(urlPath, "/"))
+	for _, other := range b.Configs {
+		if strings.HasPrefix(curPathDir, other.PathScope) {
+			canGoUp = true
+			break
+		}
+	}
+
+	// Assemble listing of directory contents
+	listing, hasIndex := directoryListing(files, canGoUp, urlPath, config)
+
+	return &listing, hasIndex, nil
+}
+
+// handleSortOrder gets and stores for a Listing the 'sort' and 'order',
+// and reads 'limit' if given. The latter is 0 if not given.
+//
+// This sets Cookies.
+func (b Browse) handleSortOrder(w http.ResponseWriter, r *http.Request, scope string) (sort string, order string, limit int, err error) {
+	sort, order, limitQuery := r.URL.Query().Get("sort"), r.URL.Query().Get("order"), r.URL.Query().Get("limit")
+
+	// If the query 'sort' or 'order' is empty, use defaults or any values previously saved in Cookies
+	switch sort {
+	case "":
+		sort = sortByNameDirFirst
+		if sortCookie, sortErr := r.Cookie("sort"); sortErr == nil {
+			sort = sortCookie.Value
+		}
+	case sortByName, sortByNameDirFirst, sortBySize, sortByTime:
+		http.SetCookie(w, &http.Cookie{Name: "sort", Value: sort, Path: scope, Secure: r.TLS != nil})
+	}
+
+	switch order {
+	case "":
+		order = "asc"
+		if orderCookie, orderErr := r.Cookie("order"); orderErr == nil {
+			order = orderCookie.Value
+		}
+	case "asc", "desc":
+		http.SetCookie(w, &http.Cookie{Name: "order", Value: order, Path: scope, Secure: r.TLS != nil})
+	}
+
+	if limitQuery != "" {
+		limit, err = strconv.Atoi(limitQuery)
+		if err != nil { // if the 'limit' query can't be interpreted as a number, return err
+			return
+		}
+	}
+
+	return
+}
+
+// ServeListing returns a formatted view of 'requestedFilepath' contents'.
+func (b Browse) ServeListing(w http.ResponseWriter, r *http.Request, requestedFilepath http.File, bc *Config) (int, error) {
+	listing, containsIndex, err := b.loadDirectoryContents(requestedFilepath, r.URL.Path, bc)
+	if err != nil {
+		switch {
+		case os.IsPermission(err):
+			return http.StatusForbidden, err
+		case os.IsExist(err):
+			return http.StatusGone, err
+		default:
+			return http.StatusInternalServerError, err
+		}
+	}
+	if containsIndex && !b.IgnoreIndexes { // directory isn't browsable
+		return b.Next.ServeHTTP(w, r)
+	}
+	listing.Context = httpserver.Context{
+		Root: bc.Fs.Root,
+		Req:  r,
+		URL:  r.URL,
+	}
+	listing.User = bc.Variables
+
+	// Copy the query values into the Listing struct
+	var limit int
+	listing.Sort, listing.Order, limit, err = b.handleSortOrder(w, r, bc.PathScope)
+	if err != nil {
+		return http.StatusBadRequest, err
+	}
+
+	listing.applySort()
+
+	if limit > 0 && limit <= len(listing.Items) {
+		listing.Items = listing.Items[:limit]
+		listing.ItemsLimitedTo = limit
+	}
+
+	var buf *bytes.Buffer
+	acceptHeader := strings.ToLower(strings.Join(r.Header["Accept"], ","))
+	switch {
+	case strings.Contains(acceptHeader, "application/json"):
+		if buf, err = b.formatAsJSON(listing, bc); err != nil {
+			return http.StatusInternalServerError, err
+		}
+		w.Header().Set("Content-Type", "application/json; charset=utf-8")
+
+	default: // There's no 'application/json' in the 'Accept' header; browse normally
+		if buf, err = b.formatAsHTML(listing, bc); err != nil {
+			return http.StatusInternalServerError, err
+		}
+		w.Header().Set("Content-Type", "text/html; charset=utf-8")
+
+	}
+
+	buf.WriteTo(w)
+
+	return http.StatusOK, nil
+}
+
+func (b Browse) formatAsJSON(listing *Listing, bc *Config) (*bytes.Buffer, error) {
+	marsh, err := json.Marshal(listing.Items)
+	if err != nil {
+		return nil, err
+	}
+
+	buf := new(bytes.Buffer)
+	_, err = buf.Write(marsh)
+	return buf, err
+}
+
+func (b Browse) formatAsHTML(listing *Listing, bc *Config) (*bytes.Buffer, error) {
+	buf := new(bytes.Buffer)
+	err := bc.Template.Execute(buf, listing)
+	return buf, err
+}

caddyhttp/browse/browse_test.go

@@ -0,0 +1,625 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// 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 browse
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"os"
+	"path/filepath"
+	"runtime"
+	"sort"
+	"strings"
+	"testing"
+	"text/template"
+	"time"
+
+	"github.com/mholt/caddy/caddyhttp/httpserver"
+	"github.com/mholt/caddy/caddyhttp/staticfiles"
+)
+
+const testDirPrefix = "caddy_browse_test"
+
+func TestSort(t *testing.T) {
+	// making up []fileInfo with bogus values;
+	// to be used to make up our "listing"
+	fileInfos := []FileInfo{
+		{
+			Name:    "fizz",
+			Size:    4,
+			ModTime: time.Now().AddDate(-1, 1, 0),
+		},
+		{
+			Name:    "buzz",
+			Size:    2,
+			ModTime: time.Now().AddDate(0, -3, 3),
+		},
+		{
+			Name:    "bazz",
+			Size:    1,
+			ModTime: time.Now().AddDate(0, -2, -23),
+		},
+		{
+			Name:    "jazz",
+			Size:    3,
+			ModTime: time.Now(),
+		},
+	}
+	listing := Listing{
+		Name:    "foobar",
+		Path:    "/fizz/buzz",
+		CanGoUp: false,
+		Items:   fileInfos,
+	}
+
+	// sort by name
+	listing.Sort = "name"
+	listing.applySort()
+	if !sort.IsSorted(byName(listing)) {
+		t.Errorf("The listing isn't name sorted: %v", listing.Items)
+	}
+
+	// sort by size
+	listing.Sort = "size"
+	listing.applySort()
+	if !sort.IsSorted(bySize(listing)) {
+		t.Errorf("The listing isn't size sorted: %v", listing.Items)
+	}
+
+	// sort by Time
+	listing.Sort = "time"
+	listing.applySort()
+	if !sort.IsSorted(byTime(listing)) {
+		t.Errorf("The listing isn't time sorted: %v", listing.Items)
+	}
+
+	// sort by name dir first
+	listing.Sort = "namedirfirst"
+	listing.applySort()
+	if !sort.IsSorted(byNameDirFirst(listing)) {
+		t.Errorf("The listing isn't namedirfirst sorted: %v", listing.Items)
+	}
+
+	// reverse by name
+	listing.Sort = "name"
+	listing.Order = "desc"
+	listing.applySort()
+	if !isReversed(byName(listing)) {
+		t.Errorf("The listing isn't reversed by name: %v", listing.Items)
+	}
+
+	// reverse by size
+	listing.Sort = "size"
+	listing.Order = "desc"
+	listing.applySort()
+	if !isReversed(bySize(listing)) {
+		t.Errorf("The listing isn't reversed by size: %v", listing.Items)
+	}
+
+	// reverse by time
+	listing.Sort = "time"
+	listing.Order = "desc"
+	listing.applySort()
+	if !isReversed(byTime(listing)) {
+		t.Errorf("The listing isn't reversed by time: %v", listing.Items)
+	}
+
+	// reverse by name dir first
+	listing.Sort = "namedirfirst"
+	listing.Order = "desc"
+	listing.applySort()
+	if !isReversed(byNameDirFirst(listing)) {
+		t.Errorf("The listing isn't reversed by namedirfirst: %v", listing.Items)
+	}
+}
+
+func TestBrowseHTTPMethods(t *testing.T) {
+	tmpl, err := template.ParseFiles("testdata/photos.tpl")
+	if err != nil {
+		t.Fatalf("An error occurred while parsing the template: %v", err)
+	}
+
+	b := Browse{
+		Next: httpserver.HandlerFunc(func(w http.ResponseWriter, r *http.Request) (int, error) {
+			return http.StatusTeapot, nil // not t.Fatalf, or we will not see what other methods yield
+		}),
+		Configs: []Config{
+			{
+				PathScope: "/photos",
+				Fs: staticfiles.FileServer{
+					Root: http.Dir("./testdata"),
+				},
+				Template: tmpl,
+			},
+		},
+	}
+
+	rec := httptest.NewRecorder()
+	for method, expected := range map[string]int{
+		http.MethodGet:     http.StatusOK,
+		http.MethodHead:    http.StatusOK,
+		http.MethodOptions: http.StatusNotImplemented,
+		"PROPFIND":         http.StatusNotImplemented,
+	} {
+		req, err := http.NewRequest(method, "/photos/", nil)
+		if err != nil {
+			t.Fatalf("Test: Could not create HTTP request: %v", err)
+		}
+		ctx := context.WithValue(req.Context(), httpserver.OriginalURLCtxKey, *req.URL)
+		req = req.WithContext(ctx)
+
+		code, _ := b.ServeHTTP(rec, req)
+		if code != expected {
+			t.Errorf("Wrong status with HTTP Method %s: expected %d, got %d", method, expected, code)
+		}
+	}
+}
+
+func TestBrowseTemplate(t *testing.T) {
+	tmpl, err := template.ParseFiles("testdata/photos.tpl")
+	if err != nil {
+		t.Fatalf("An error occurred while parsing the template: %v", err)
+	}
+
+	b := Browse{
+		Next: httpserver.HandlerFunc(func(w http.ResponseWriter, r *http.Request) (int, error) {
+			t.Fatalf("Next shouldn't be called")
+			return 0, nil
+		}),
+		Configs: []Config{
+			{
+				PathScope: "/photos",
+				Fs: staticfiles.FileServer{
+					Root: http.Dir("./testdata"),
+					Hide: []string{"photos/hidden.html"},
+				},
+				Template: tmpl,
+			},
+		},
+	}
+
+	req, err := http.NewRequest("GET", "/photos/", nil)
+	if err != nil {
+		t.Fatalf("Test: Could not create HTTP request: %v", err)
+	}
+	ctx := context.WithValue(req.Context(), httpserver.OriginalURLCtxKey, *req.URL)
+	req = req.WithContext(ctx)
+
+	rec := httptest.NewRecorder()
+
+	code, _ := b.ServeHTTP(rec, req)
+	if code != http.StatusOK {
+		t.Fatalf("Wrong status, expected %d, got %d", http.StatusOK, code)
+	}
+
+	respBody := rec.Body.String()
+	expectedBody := `<!DOCTYPE html>
+<html>
+<head>
+<title>Template</title>
+</head>
+<body>
+<h1>Header</h1>
+
+<h1>/photos/</h1>
+
+<a href="./test1/">test1</a><br>
+
+<a href="./test.html">test.html</a><br>
+
+<a href="./test2.html">test2.html</a><br>
+
+<a href="./test3.html">test3.html</a><br>
+
+</body>
+</html>
+`
+
+	if respBody != expectedBody {
+		t.Fatalf("Expected body: '%v' got: '%v'", expectedBody, respBody)
+	}
+
+}
+
+func TestBrowseJson(t *testing.T) {
+	b := Browse{
+		Next: httpserver.HandlerFunc(func(w http.ResponseWriter, r *http.Request) (int, error) {
+			t.Fatalf("Next shouldn't be called: %s", r.URL)
+			return 0, nil
+		}),
+		Configs: []Config{
+			{
+				PathScope: "/photos/",
+				Fs: staticfiles.FileServer{
+					Root: http.Dir("./testdata"),
+				},
+			},
+		},
+	}
+
+	//Getting the listing from the ./testdata/photos, the listing returned will be used to validate test results
+	testDataPath := filepath.Join("./testdata", "photos")
+	file, err := os.Open(testDataPath)
+	if err != nil {
+		if os.IsPermission(err) {
+			t.Fatalf("Os Permission Error")
+		}
+	}
+	defer file.Close()
+
+	files, err := file.Readdir(-1)
+	if err != nil {
+		t.Fatalf("Unable to Read Contents of the directory")
+	}
+	var fileinfos []FileInfo
+
+	for i, f := range files {
+		name := f.Name()
+
+		// Tests fail in CI environment because all file mod times are the same for
+		// some reason, making the sorting unpredictable. To hack around this,
+		// we ensure here that each file has a different mod time.
+		chTime := f.ModTime().UTC().Add(-(time.Duration(i) * time.Second))
+		if err := os.Chtimes(filepath.Join(testDataPath, name), chTime, chTime); err != nil {
+			t.Fatal(err)
+		}
+
+		if f.IsDir() {
+			name += "/"
+		}
+
+		url := url.URL{Path: "./" + name}
+
+		fileinfos = append(fileinfos, FileInfo{
+			IsDir:   f.IsDir(),
+			Name:    f.Name(),
+			Size:    f.Size(),
+			URL:     url.String(),
+			ModTime: chTime,
+			Mode:    f.Mode(),
+		})
+	}
+
+	// Test that sort=name returns correct listing.
+
+	listing := Listing{Items: fileinfos} // this listing will be used for validation inside the tests
+
+	tests := []struct {
+		QueryURL       string
+		SortBy         string
+		OrderBy        string
+		Limit          int
+		shouldErr      bool
+		expectedResult []FileInfo
+	}{
+		//test case 1: testing for default sort and  order and without the limit parameter, default sort is by name and the default order is ascending
+		//without the limit query entire listing will be produced
+		{"/?sort=name", "", "", -1, false, listing.Items},
+		//test case 2: limit is set to 1, orderBy and sortBy is default
+		{"/?limit=1&sort=name", "", "", 1, false, listing.Items[:1]},
+		//test case 3 : if the listing request is bigger than total size of listing then it should return everything
+		{"/?limit=100000000&sort=name", "", "", 100000000, false, listing.Items},
+		//test case 4 : testing for negative limit
+		{"/?limit=-1&sort=name", "", "", -1, false, listing.Items},
+		//test case 5 : testing with limit set to -1 and order set to descending
+		{"/?limit=-1&order=desc&sort=name", "", "desc", -1, false, listing.Items},
+		//test case 6 : testing with limit set to 2 and order set to descending
+		{"/?limit=2&order=desc&sort=name", "", "desc", 2, false, listing.Items},
+		//test case 7 : testing with limit set to 3 and order set to descending
+		{"/?limit=3&order=desc&sort=name", "", "desc", 3, false, listing.Items},
+		//test case 8 : testing with limit set to 3 and order set to ascending
+		{"/?limit=3&order=asc&sort=name", "", "asc", 3, false, listing.Items},
+		//test case 9 : testing with limit set to 1111111 and order set to ascending
+		{"/?limit=1111111&order=asc&sort=name", "", "asc", 1111111, false, listing.Items},
+		//test case 10 : testing with limit set to default and order set to ascending and sorting by size
+		{"/?order=asc&sort=size&sort=name", "size", "asc", -1, false, listing.Items},
+		//test case 11 : testing with limit set to default and order set to ascending and sorting by last modified
+		{"/?order=asc&sort=time&sort=name", "time", "asc", -1, false, listing.Items},
+		//test case 12 : testing with limit set to 1 and order set to ascending and sorting by last modified
+		{"/?order=asc&sort=time&limit=1&sort=name", "time", "asc", 1, false, listing.Items},
+		//test case 13 : testing with limit set to -100 and order set to ascending and sorting by last modified
+		{"/?order=asc&sort=time&limit=-100&sort=name", "time", "asc", -100, false, listing.Items},
+		//test case 14 : testing with limit set to -100 and order set to ascending and sorting by size
+		{"/?order=asc&sort=size&limit=-100&sort=name", "size", "asc", -100, false, listing.Items},
+	}
+
+	for i, test := range tests {
+		var marsh []byte
+		req, err := http.NewRequest("GET", "/photos"+test.QueryURL, nil)
+		if err != nil && !test.shouldErr {
+			t.Errorf("Test %d errored when making request, but it shouldn't have; got '%v'", i, err)
+		}
+		ctx := context.WithValue(req.Context(), httpserver.OriginalURLCtxKey, *req.URL)
+		req = req.WithContext(ctx)
+
+		req.Header.Set("Accept", "application/json")
+		rec := httptest.NewRecorder()
+
+		code, err := b.ServeHTTP(rec, req)
+		if err == nil && test.shouldErr {
+			t.Errorf("Test %d didn't error, but it should have", i)
+		} else if err != nil && !test.shouldErr {
+			t.Errorf("Test %d errored, but it shouldn't have; got '%v'", i, err)
+		}
+		if code != http.StatusOK {
+			t.Fatalf("In test %d: Wrong status, expected %d, got %d", i, http.StatusOK, code)
+		}
+		if rec.HeaderMap.Get("Content-Type") != "application/json; charset=utf-8" {
+			t.Fatalf("Expected Content type to be application/json; charset=utf-8, but got %s ", rec.HeaderMap.Get("Content-Type"))
+		}
+
+		actualJSONResponse := rec.Body.String()
+		copyOflisting := listing
+		if test.SortBy == "" {
+			copyOflisting.Sort = "name"
+		} else {
+			copyOflisting.Sort = test.SortBy
+		}
+		if test.OrderBy == "" {
+			copyOflisting.Order = "asc"
+		} else {
+			copyOflisting.Order = test.OrderBy
+		}
+
+		copyOflisting.applySort()
+
+		limit := test.Limit
+		if limit <= len(copyOflisting.Items) && limit > 0 {
+			marsh, err = json.Marshal(copyOflisting.Items[:limit])
+		} else { // if the 'limit' query is empty, or has the wrong value, list everything
+			marsh, err = json.Marshal(copyOflisting.Items)
+		}
+
+		if err != nil {
+			t.Fatalf("Unable to Marshal the listing ")
+		}
+		expectedJSON := string(marsh)
+
+		if actualJSONResponse != expectedJSON {
+			t.Errorf("JSON response doesn't match the expected for test number %d with sort=%s, order=%s\nExpected response %s\nActual response = %s\n",
+				i+1, test.SortBy, test.OrderBy, expectedJSON, actualJSONResponse)
+		}
+	}
+}
+
+// "sort" package has "IsSorted" function, but no "IsReversed";
+func isReversed(data sort.Interface) bool {
+	n := data.Len()
+	for i := n - 1; i > 0; i-- {
+		if !data.Less(i, i-1) {
+			return false
+		}
+	}
+	return true
+}
+
+func TestBrowseRedirect(t *testing.T) {
+	testCases := []struct {
+		url        string
+		statusCode int
+		returnCode int
+		location   string
+	}{
+		{
+			"http://www.example.com/photos",
+			http.StatusMovedPermanently,
+			http.StatusMovedPermanently,
+			"http://www.example.com/photos/",
+		},
+		{
+			"/photos",
+			http.StatusMovedPermanently,
+			http.StatusMovedPermanently,
+			"/photos/",
+		},
+	}
+
+	for i, tc := range testCases {
+		b := Browse{
+			Next: httpserver.HandlerFunc(func(w http.ResponseWriter, r *http.Request) (int, error) {
+				t.Fatalf("Test %d - Next shouldn't be called", i)
+				return 0, nil
+			}),
+			Configs: []Config{
+				{
+					PathScope: "/photos",
+					Fs: staticfiles.FileServer{
+						Root: http.Dir("./testdata"),
+					},
+				},
+			},
+		}
+
+		req, err := http.NewRequest("GET", tc.url, nil)
+		if err != nil {
+			t.Fatalf("Test %d - could not create HTTP request: %v", i, err)
+		}
+		ctx := context.WithValue(req.Context(), httpserver.OriginalURLCtxKey, *req.URL)
+		req = req.WithContext(ctx)
+
+		rec := httptest.NewRecorder()
+
+		returnCode, _ := b.ServeHTTP(rec, req)
+		if returnCode != tc.returnCode {
+			t.Fatalf("Test %d - wrong return code, expected %d, got %d",
+				i, tc.returnCode, returnCode)
+		}
+
+		if got := rec.Code; got != tc.statusCode {
+			t.Errorf("Test %d - wrong status, expected %d, got %d",
+				i, tc.statusCode, got)
+		}
+
+		if got := rec.Header().Get("Location"); got != tc.location {
+			t.Errorf("Test %d - wrong Location header, expected %s, got %s",
+				i, tc.location, got)
+		}
+	}
+}
+
+func TestDirSymlink(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		// Windows support for symlinks is limited, and we had a hard time getting
+		// all these tests to pass with the permissions of CI; so just skip them
+		fmt.Println("Skipping browse symlink tests on Windows...")
+		return
+	}
+
+	testCases := []struct {
+		source       string
+		target       string
+		pathScope    string
+		url          string
+		expectedName string
+		expectedURL  string
+	}{
+		// test case can expect a directory "dir" and a symlink to it called "symlink"
+
+		{"dir", "$TMP/rel_symlink_to_dir", "/", "/",
+			"rel_symlink_to_dir", "./rel_symlink_to_dir/"},
+		{"$TMP/dir", "$TMP/abs_symlink_to_dir", "/", "/",
+			"abs_symlink_to_dir", "./abs_symlink_to_dir/"},
+
+		{"../../dir", "$TMP/sub/dir/rel_symlink_to_dir", "/", "/sub/dir/",
+			"rel_symlink_to_dir", "./rel_symlink_to_dir/"},
+		{"$TMP/dir", "$TMP/sub/dir/abs_symlink_to_dir", "/", "/sub/dir/",
+			"abs_symlink_to_dir", "./abs_symlink_to_dir/"},
+
+		{"../../dir", "$TMP/with/scope/rel_symlink_to_dir", "/with/scope", "/with/scope/",
+			"rel_symlink_to_dir", "./rel_symlink_to_dir/"},
+		{"$TMP/dir", "$TMP/with/scope/abs_symlink_to_dir", "/with/scope", "/with/scope/",
+			"abs_symlink_to_dir", "./abs_symlink_to_dir/"},
+
+		{"../../../../dir", "$TMP/with/scope/sub/dir/rel_symlink_to_dir", "/with/scope", "/with/scope/sub/dir/",
+			"rel_symlink_to_dir", "./rel_symlink_to_dir/"},
+		{"$TMP/dir", "$TMP/with/scope/sub/dir/abs_symlink_to_dir", "/with/scope", "/with/scope/sub/dir/",
+			"abs_symlink_to_dir", "./abs_symlink_to_dir/"},
+
+		{"symlink", "$TMP/rel_symlink_to_symlink", "/", "/",
+			"rel_symlink_to_symlink", "./rel_symlink_to_symlink/"},
+		{"$TMP/symlink", "$TMP/abs_symlink_to_symlink", "/", "/",
+			"abs_symlink_to_symlink", "./abs_symlink_to_symlink/"},
+
+		{"../../symlink", "$TMP/sub/dir/rel_symlink_to_symlink", "/", "/sub/dir/",
+			"rel_symlink_to_symlink", "./rel_symlink_to_symlink/"},
+		{"$TMP/symlink", "$TMP/sub/dir/abs_symlink_to_symlink", "/", "/sub/dir/",
+			"abs_symlink_to_symlink", "./abs_symlink_to_symlink/"},
+
+		{"../../symlink", "$TMP/with/scope/rel_symlink_to_symlink", "/with/scope", "/with/scope/",
+			"rel_symlink_to_symlink", "./rel_symlink_to_symlink/"},
+		{"$TMP/symlink", "$TMP/with/scope/abs_symlink_to_symlink", "/with/scope", "/with/scope/",
+			"abs_symlink_to_symlink", "./abs_symlink_to_symlink/"},
+
+		{"../../../../symlink", "$TMP/with/scope/sub/dir/rel_symlink_to_symlink", "/with/scope", "/with/scope/sub/dir/",
+			"rel_symlink_to_symlink", "./rel_symlink_to_symlink/"},
+		{"$TMP/symlink", "$TMP/with/scope/sub/dir/abs_symlink_to_symlink", "/with/scope", "/with/scope/sub/dir/",
+			"abs_symlink_to_symlink", "./abs_symlink_to_symlink/"},
+	}
+
+	for i, tc := range testCases {
+		func() {
+			tmpdir, err := ioutil.TempDir("", testDirPrefix)
+			if err != nil {
+				t.Fatalf("failed to create test directory: %v", err)
+			}
+			defer os.RemoveAll(tmpdir)
+
+			if err := os.MkdirAll(filepath.Join(tmpdir, "dir"), 0755); err != nil {
+				t.Fatalf("failed to create test dir 'dir': %v", err)
+			}
+			if err := os.Symlink("dir", filepath.Join(tmpdir, "symlink")); err != nil {
+				t.Fatalf("failed to create test symlink 'symlink': %v", err)
+			}
+
+			sourceResolved := strings.Replace(tc.source, "$TMP", tmpdir, -1)
+			targetResolved := strings.Replace(tc.target, "$TMP", tmpdir, -1)
+
+			if err := os.MkdirAll(filepath.Dir(sourceResolved), 0755); err != nil {
+				t.Fatalf("failed to create source symlink dir: %v", err)
+			}
+			if err := os.MkdirAll(filepath.Dir(targetResolved), 0755); err != nil {
+				t.Fatalf("failed to create target symlink dir: %v", err)
+			}
+			if err := os.Symlink(sourceResolved, targetResolved); err != nil {
+				t.Fatalf("failed to create test symlink: %v", err)
+			}
+
+			b := Browse{
+				Next: httpserver.HandlerFunc(func(w http.ResponseWriter, r *http.Request) (int, error) {
+					t.Fatalf("Test %d - Next shouldn't be called", i)
+					return 0, nil
+				}),
+				Configs: []Config{
+					{
+						PathScope: tc.pathScope,
+						Fs: staticfiles.FileServer{
+							Root: http.Dir(tmpdir),
+						},
+					},
+				},
+			}
+
+			req, err := http.NewRequest("GET", tc.url, nil)
+			req.Header.Add("Accept", "application/json")
+			if err != nil {
+				t.Fatalf("Test %d - could not create HTTP request: %v", i, err)
+			}
+
+			rec := httptest.NewRecorder()
+
+			returnCode, _ := b.ServeHTTP(rec, req)
+			if returnCode != http.StatusOK {
+				t.Fatalf("Test %d - wrong return code, expected %d, got %d",
+					i, http.StatusOK, returnCode)
+			}
+
+			type jsonEntry struct {
+				Name      string
+				IsDir     bool
+				IsSymlink bool
+				URL       string
+			}
+			var entries []jsonEntry
+			if err := json.Unmarshal(rec.Body.Bytes(), &entries); err != nil {
+				t.Fatalf("Test %d - failed to parse json: %v", i, err)
+			}
+
+			found := false
+			for _, e := range entries {
+				if e.Name != tc.expectedName {
+					continue
+				}
+				found = true
+				if !e.IsDir {
+					t.Errorf("Test %d - expected to be a dir, got %v", i, e.IsDir)
+				}
+				if !e.IsSymlink {
+					t.Errorf("Test %d - expected to be a symlink, got %v", i, e.IsSymlink)
+				}
+				if e.URL != tc.expectedURL {
+					t.Errorf("Test %d - wrong URL, expected %v, got %v", i, tc.expectedURL, e.URL)
+				}
+			}
+			if !found {
+				t.Errorf("Test %d - failed, could not find name %v", i, tc.expectedName)
+			}
+		}()
+	}
+}

caddyhttp/browse/setup.go

@@ -1,4 +1,4 @@
-// Copyright 2015 Matthew Holt and The Caddy Authors
+// Copyright 2015 Light Code Labs, LLC
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -12,9 +12,108 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package fileserver
+package browse
 
-const defaultBrowseTemplate = `<!DOCTYPE html>
+import (
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"text/template"
+
+	"github.com/mholt/caddy"
+	"github.com/mholt/caddy/caddyhttp/httpserver"
+	"github.com/mholt/caddy/caddyhttp/staticfiles"
+)
+
+func init() {
+	caddy.RegisterPlugin("browse", caddy.Plugin{
+		ServerType: "http",
+		Action:     setup,
+	})
+}
+
+// setup configures a new Browse middleware instance.
+func setup(c *caddy.Controller) error {
+	configs, err := browseParse(c)
+	if err != nil {
+		return err
+	}
+
+	b := Browse{
+		Configs:       configs,
+		IgnoreIndexes: false,
+	}
+
+	httpserver.GetConfig(c).AddMiddleware(func(next httpserver.Handler) httpserver.Handler {
+		b.Next = next
+		return b
+	})
+
+	return nil
+}
+
+func browseParse(c *caddy.Controller) ([]Config, error) {
+	var configs []Config
+
+	cfg := httpserver.GetConfig(c)
+
+	appendCfg := func(bc Config) error {
+		for _, c := range configs {
+			if c.PathScope == bc.PathScope {
+				return fmt.Errorf("duplicate browsing config for %s", c.PathScope)
+			}
+		}
+		configs = append(configs, bc)
+		return nil
+	}
+
+	for c.Next() {
+		var bc Config
+
+		// First argument is directory to allow browsing; default is site root
+		if c.NextArg() {
+			bc.PathScope = c.Val()
+		} else {
+			bc.PathScope = "/"
+		}
+
+		bc.Fs = staticfiles.FileServer{
+			Root:       http.Dir(cfg.Root),
+			Hide:       cfg.HiddenFiles,
+			IndexPages: cfg.IndexPages,
+		}
+
+		// Second argument would be the template file to use
+		var tplText string
+		if c.NextArg() {
+			tplBytes, err := ioutil.ReadFile(c.Val())
+			if err != nil {
+				return configs, err
+			}
+			tplText = string(tplBytes)
+		} else {
+			tplText = defaultTemplate
+		}
+
+		// Build the template
+		tpl, err := template.New("listing").Parse(tplText)
+		if err != nil {
+			return configs, err
+		}
+		bc.Template = tpl
+
+		// Save configuration
+		err = appendCfg(bc)
+		if err != nil {
+			return configs, err
+		}
+	}
+
+	return configs, nil
+}
+
+// The default template to use when serving up directory listings
+const defaultTemplate = `<!DOCTYPE html>
 <html>
 	<head>
 		<title>{{html .Name}}</title>
@@ -26,7 +125,6 @@ const defaultBrowseTemplate = `<!DOCTYPE html>
 body {
 	font-family: sans-serif;
 	text-rendering: optimizespeed;
-	background-color: #ffffff;
 }
 
 a {
@@ -47,12 +145,12 @@ header,
 
 th:first-child,
 td:first-child {
-	width: 5%;
+	padding-left: 5%;
 }
 
 th:last-child,
 td:last-child {
-	width: 5%;
+	padding-right: 5%;
 }
 
 header {
@@ -143,21 +241,20 @@ td {
 	font-size: 14px;
 }
 
-td:nth-child(2) {
-	width: 80%;
+td:first-child {
+	width: 100%;
 }
 
-td:nth-child(3),
-th:nth-child(3) {
+td:nth-child(2) {
 	padding: 0 20px 0 20px;
 }
 
-th:nth-child(4),
-td:nth-child(4) {
+th:last-child,
+td:last-child {
 	text-align: right;
 }
 
-td:nth-child(2) svg {
+td:first-child svg {
 	position: absolute;
 }
 
@@ -204,12 +301,12 @@ footer {
 		display: none;
 	}
 
-	td:nth-child(2) {
+	td:first-child {
 		width: auto;
 	}
 
-	th:nth-child(3),
-	td:nth-child(3) {
+	th:nth-child(2),
+	td:nth-child(2) {
 		padding-right: 5%;
 		text-align: right;
 	}
@@ -228,7 +325,7 @@ footer {
 }
 </style>
 	</head>
-	<body onload='initFilter()'>
+	<body>
 		<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" height="0" width="0" style="position: absolute;">
 			<defs>
 				<!-- Folder -->
@@ -283,8 +380,8 @@ footer {
 				<div id="summary">
 					<span class="meta-item"><b>{{.NumDirs}}</b> director{{if eq 1 .NumDirs}}y{{else}}ies{{end}}</span>
 					<span class="meta-item"><b>{{.NumFiles}}</b> file{{if ne 1 .NumFiles}}s{{end}}</span>
-					{{- if ne 0 .Limit}}
-					<span class="meta-item">(of which only <b>{{.Limit}}</b> are displayed)</span>
+					{{- if ne 0 .ItemsLimitedTo}}
+					<span class="meta-item">(of which only <b>{{.ItemsLimitedTo}}</b> are displayed)</span>
 					{{- end}}
 					<span class="meta-item"><input type="text" placeholder="filter" id="filter" onkeyup='filter()'></span>
 				</div>
@@ -293,49 +390,46 @@ footer {
 				<table aria-describedby="summary">
 					<thead>
 					<tr>
-						<th></th>
 						<th>
 							{{- if and (eq .Sort "namedirfirst") (ne .Order "desc")}}
-							<a href="?sort=namedirfirst&order=desc{{if ne 0 .Limit}}&limit={{.Limit}}{{end}}{{if ne 0 .Offset}}&offset={{.Offset}}{{end}}" class="icon"><svg width="1em" height=".5em" version="1.1" viewBox="0 0 12.922194 6.0358899"><use xlink:href="#up-arrow"></use></svg></a>
+							<a href="?sort=namedirfirst&order=desc{{if ne 0 .ItemsLimitedTo}}&limit={{.ItemsLimitedTo}}{{end}}" class="icon"><svg width="1em" height=".5em" version="1.1" viewBox="0 0 12.922194 6.0358899"><use xlink:href="#up-arrow"></use></svg></a>
 							{{- else if and (eq .Sort "namedirfirst") (ne .Order "asc")}}
-							<a href="?sort=namedirfirst&order=asc{{if ne 0 .Limit}}&limit={{.Limit}}{{end}}{{if ne 0 .Offset}}&offset={{.Offset}}{{end}}" class="icon"><svg width="1em" height=".5em" version="1.1" viewBox="0 0 12.922194 6.0358899"><use xlink:href="#down-arrow"></use></svg></a>
+							<a href="?sort=namedirfirst&order=asc{{if ne 0 .ItemsLimitedTo}}&limit={{.ItemsLimitedTo}}{{end}}" class="icon"><svg width="1em" height=".5em" version="1.1" viewBox="0 0 12.922194 6.0358899"><use xlink:href="#down-arrow"></use></svg></a>
 							{{- else}}
-							<a href="?sort=namedirfirst&order=asc{{if ne 0 .Limit}}&limit={{.Limit}}{{end}}{{if ne 0 .Offset}}&offset={{.Offset}}{{end}}" class="icon sort"><svg class="top" width="1em" height=".5em" version="1.1" viewBox="0 0 12.922194 6.0358899"><use xlink:href="#up-arrow"></use></svg><svg class="bottom" width="1em" height=".5em" version="1.1" viewBox="0 0 12.922194 6.0358899"><use xlink:href="#down-arrow"></use></svg></a>
+							<a href="?sort=namedirfirst&order=asc{{if ne 0 .ItemsLimitedTo}}&limit={{.ItemsLimitedTo}}{{end}}" class="icon sort"><svg class="top" width="1em" height=".5em" version="1.1" viewBox="0 0 12.922194 6.0358899"><use xlink:href="#up-arrow"></use></svg><svg class="bottom" width="1em" height=".5em" version="1.1" viewBox="0 0 12.922194 6.0358899"><use xlink:href="#down-arrow"></use></svg></a>
 							{{- end}}
 							
 							{{- if and (eq .Sort "name") (ne .Order "desc")}}
-							<a href="?sort=name&order=desc{{if ne 0 .Limit}}&limit={{.Limit}}{{end}}{{if ne 0 .Offset}}&offset={{.Offset}}{{end}}">Name <svg width="1em" height=".5em" version="1.1" viewBox="0 0 12.922194 6.0358899"><use xlink:href="#up-arrow"></use></svg></a>
+							<a href="?sort=name&order=desc{{if ne 0 .ItemsLimitedTo}}&limit={{.ItemsLimitedTo}}{{end}}">Name <svg width="1em" height=".5em" version="1.1" viewBox="0 0 12.922194 6.0358899"><use xlink:href="#up-arrow"></use></svg></a>
 							{{- else if and (eq .Sort "name") (ne .Order "asc")}}
-							<a href="?sort=name&order=asc{{if ne 0 .Limit}}&limit={{.Limit}}{{end}}{{if ne 0 .Offset}}&offset={{.Offset}}{{end}}">Name <svg width="1em" height=".5em" version="1.1" viewBox="0 0 12.922194 6.0358899"><use xlink:href="#down-arrow"></use></svg></a>
+							<a href="?sort=name&order=asc{{if ne 0 .ItemsLimitedTo}}&limit={{.ItemsLimitedTo}}{{end}}">Name <svg width="1em" height=".5em" version="1.1" viewBox="0 0 12.922194 6.0358899"><use xlink:href="#down-arrow"></use></svg></a>
 							{{- else}}
-							<a href="?sort=name&order=asc{{if ne 0 .Limit}}&limit={{.Limit}}{{end}}{{if ne 0 .Offset}}&offset={{.Offset}}{{end}}">Name</a>
+							<a href="?sort=name&order=asc{{if ne 0 .ItemsLimitedTo}}&limit={{.ItemsLimitedTo}}{{end}}">Name</a>
 							{{- end}}
 						</th>
 						<th>
 							{{- if and (eq .Sort "size") (ne .Order "desc")}}
-							<a href="?sort=size&order=desc{{if ne 0 .Limit}}&limit={{.Limit}}{{end}}{{if ne 0 .Offset}}&offset={{.Offset}}{{end}}">Size <svg width="1em" height=".5em" version="1.1" viewBox="0 0 12.922194 6.0358899"><use xlink:href="#up-arrow"></use></svg></a>
+							<a href="?sort=size&order=desc{{if ne 0 .ItemsLimitedTo}}&limit={{.ItemsLimitedTo}}{{end}}">Size <svg width="1em" height=".5em" version="1.1" viewBox="0 0 12.922194 6.0358899"><use xlink:href="#up-arrow"></use></svg></a>
 							{{- else if and (eq .Sort "size") (ne .Order "asc")}}
-							<a href="?sort=size&order=asc{{if ne 0 .Limit}}&limit={{.Limit}}{{end}}{{if ne 0 .Offset}}&offset={{.Offset}}{{end}}">Size <svg width="1em" height=".5em" version="1.1" viewBox="0 0 12.922194 6.0358899"><use xlink:href="#down-arrow"></use></svg></a>
+							<a href="?sort=size&order=asc{{if ne 0 .ItemsLimitedTo}}&limit={{.ItemsLimitedTo}}{{end}}">Size <svg width="1em" height=".5em" version="1.1" viewBox="0 0 12.922194 6.0358899"><use xlink:href="#down-arrow"></use></svg></a>
 							{{- else}}
-							<a href="?sort=size&order=asc{{if ne 0 .Limit}}&limit={{.Limit}}{{end}}{{if ne 0 .Offset}}&offset={{.Offset}}{{end}}">Size</a>
+							<a href="?sort=size&order=asc{{if ne 0 .ItemsLimitedTo}}&limit={{.ItemsLimitedTo}}{{end}}">Size</a>
 							{{- end}}
 						</th>
 						<th class="hideable">
 							{{- if and (eq .Sort "time") (ne .Order "desc")}}
-							<a href="?sort=time&order=desc{{if ne 0 .Limit}}&limit={{.Limit}}{{end}}{{if ne 0 .Offset}}&offset={{.Offset}}{{end}}">Modified <svg width="1em" height=".5em" version="1.1" viewBox="0 0 12.922194 6.0358899"><use xlink:href="#up-arrow"></use></svg></a>
+							<a href="?sort=time&order=desc{{if ne 0 .ItemsLimitedTo}}&limit={{.ItemsLimitedTo}}{{end}}">Modified <svg width="1em" height=".5em" version="1.1" viewBox="0 0 12.922194 6.0358899"><use xlink:href="#up-arrow"></use></svg></a>
 							{{- else if and (eq .Sort "time") (ne .Order "asc")}}
-							<a href="?sort=time&order=asc{{if ne 0 .Limit}}&limit={{.Limit}}{{end}}{{if ne 0 .Offset}}&offset={{.Offset}}{{end}}">Modified <svg width="1em" height=".5em" version="1.1" viewBox="0 0 12.922194 6.0358899"><use xlink:href="#down-arrow"></use></svg></a>
+							<a href="?sort=time&order=asc{{if ne 0 .ItemsLimitedTo}}&limit={{.ItemsLimitedTo}}{{end}}">Modified <svg width="1em" height=".5em" version="1.1" viewBox="0 0 12.922194 6.0358899"><use xlink:href="#down-arrow"></use></svg></a>
 							{{- else}}
-							<a href="?sort=time&order=asc{{if ne 0 .Limit}}&limit={{.Limit}}{{end}}{{if ne 0 .Offset}}&offset={{.Offset}}{{end}}">Modified</a>
+							<a href="?sort=time&order=asc{{if ne 0 .ItemsLimitedTo}}&limit={{.ItemsLimitedTo}}{{end}}">Modified</a>
 							{{- end}}
 						</th>
-						<th class="hideable"></th>
 					</tr>
 					</thead>
 					<tbody>
 					{{- if .CanGoUp}}
 					<tr>
-						<td></td>
 						<td>
 							<a href="..">
 								<span class="goup">Go up</span>
@@ -343,12 +437,10 @@ footer {
 						</td>
 						<td>&mdash;</td>
 						<td class="hideable">&mdash;</td>
-						<td class="hideable"></td>
 					</tr>
 					{{- end}}
 					{{- range .Items}}
 					<tr class="file">
-						<td></td>
 						<td>
 							<a href="{{html .URL}}">
 								{{- if .IsDir}}
@@ -365,7 +457,6 @@ footer {
 						<td data-order="{{.Size}}">{{.HumanSize}}</td>
 						{{- end}}
 						<td class="hideable"><time datetime="{{.HumanModTime "2006-01-02T15:04:05Z"}}">{{.HumanModTime "01/02/2006 03:04:05 PM -07:00"}}</time></td>
-						<td class="hideable"></td>
 					</tr>
 					{{- end}}
 					</tbody>
@@ -379,16 +470,6 @@ footer {
 			var filterEl = document.getElementById('filter');
 			filterEl.focus();
 
-			function initFilter() {
-				if (!filterEl.value) {
-					var filterParam = new URL(window.location.href).searchParams.get('filter');
-					if (filterParam) {
-						filterEl.value = filterParam;
-					}
-				}
-				filter();
-			}
-
 			function filter() {
 				var q = filterEl.value.trim().toLowerCase();
 				var elems = document.querySelectorAll('tr.file');

caddyhttp/browse/setup_test.go

@@ -0,0 +1,95 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// 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 browse
+
+import (
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strconv"
+	"testing"
+	"time"
+
+	"github.com/mholt/caddy"
+	"github.com/mholt/caddy/caddyhttp/httpserver"
+)
+
+func TestSetup(t *testing.T) {
+	tempDirPath := os.TempDir()
+	_, err := os.Stat(tempDirPath)
+	if err != nil {
+		t.Fatalf("BeforeTest: Failed to find an existing directory for testing! Error was: %v", err)
+	}
+	nonExistentDirPath := filepath.Join(tempDirPath, strconv.Itoa(int(time.Now().UnixNano())))
+
+	tempTemplate, err := ioutil.TempFile(".", "tempTemplate")
+	if err != nil {
+		t.Fatalf("BeforeTest: Failed to create a temporary file in the working directory! Error was: %v", err)
+	}
+	defer os.Remove(tempTemplate.Name())
+
+	tempTemplatePath := filepath.Join(".", tempTemplate.Name())
+
+	for i, test := range []struct {
+		input             string
+		expectedPathScope []string
+		shouldErr         bool
+	}{
+		// test case #0 tests handling of multiple pathscopes
+		{"browse " + tempDirPath + "\n browse .", []string{tempDirPath, "."}, false},
+
+		// test case #1 tests instantiation of Config with default values
+		{"browse /", []string{"/"}, false},
+
+		// test case #2 tests detectaction of custom template
+		{"browse . " + tempTemplatePath, []string{"."}, false},
+
+		// test case #3 tests detection of non-existent template
+		{"browse . " + nonExistentDirPath, nil, true},
+
+		// test case #4 tests detection of duplicate pathscopes
+		{"browse " + tempDirPath + "\n browse " + tempDirPath, nil, true},
+	} {
+
+		c := caddy.NewTestController("http", test.input)
+		err := setup(c)
+		if err != nil && !test.shouldErr {
+			t.Errorf("Test case #%d received an error of %v", i, err)
+		}
+		if test.expectedPathScope == nil {
+			continue
+		}
+		mids := httpserver.GetConfig(c).Middleware()
+		mid := mids[len(mids)-1]
+		receivedConfigs := mid(nil).(Browse).Configs
+		for j, config := range receivedConfigs {
+			if config.PathScope != test.expectedPathScope[j] {
+				t.Errorf("Test case #%d expected a pathscope of %v, but got %v", i, test.expectedPathScope, config.PathScope)
+			}
+		}
+	}
+
+	// test case #6 tests startup with missing root directory in combination with default browse settings
+	controller := caddy.NewTestController("http", "browse")
+	cfg := httpserver.GetConfig(controller)
+
+	// Make sure non-existent root path doesn't return error
+	cfg.Root = nonExistentDirPath
+	err = setup(controller)
+
+	if err != nil {
+		t.Errorf("Test for non-existent browse path received an error, but shouldn't have: %v", err)
+	}
+}

caddyhttp/browse/testdata/header.html

@@ -0,0 +1 @@
+<h1>Header</h1>

caddyhttp/browse/testdata/photos.tpl

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>Template</title>
+</head>
+<body>
+{{.Include "header.html"}}
+<h1>{{.Path}}</h1>
+{{range .Items}}
+<a href="{{.URL}}">{{.Name}}</a><br>
+{{end}}
+</body>
+</html>

caddyhttp/browse/testdata/photos/hidden.html

@@ -0,0 +1 @@
+Should be hidden

caddyhttp/browse/testdata/photos/test.html

@@ -0,0 +1,8 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>Test</title>
+</head>
+<body>
+</body>
+</html>

caddyhttp/browse/testdata/photos/test1/test.html

@@ -0,0 +1,8 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>Test</title>
+</head>
+<body>
+</body>
+</html>

caddyhttp/browse/testdata/photos/test2.html

@@ -0,0 +1,8 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>Test 2</title>
+</head>
+<body>
+</body>
+</html>

caddyhttp/browse/testdata/photos/test3.html

@@ -0,0 +1,3 @@
+<!DOCTYPE html>
+<html>
+</html>

caddyhttp/caddyhttp.go

@@ -0,0 +1,50 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// 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 caddyhttp
+
+import (
+	// plug in the server
+	_ "github.com/mholt/caddy/caddyhttp/httpserver"
+
+	// plug in the standard directives
+	_ "github.com/mholt/caddy/caddyhttp/basicauth"
+	_ "github.com/mholt/caddy/caddyhttp/bind"
+	_ "github.com/mholt/caddy/caddyhttp/browse"
+	_ "github.com/mholt/caddy/caddyhttp/errors"
+	_ "github.com/mholt/caddy/caddyhttp/expvar"
+	_ "github.com/mholt/caddy/caddyhttp/extensions"
+	_ "github.com/mholt/caddy/caddyhttp/fastcgi"
+	_ "github.com/mholt/caddy/caddyhttp/gzip"
+	_ "github.com/mholt/caddy/caddyhttp/header"
+	_ "github.com/mholt/caddy/caddyhttp/index"
+	_ "github.com/mholt/caddy/caddyhttp/internalsrv"
+	_ "github.com/mholt/caddy/caddyhttp/limits"
+	_ "github.com/mholt/caddy/caddyhttp/log"
+	_ "github.com/mholt/caddy/caddyhttp/markdown"
+	_ "github.com/mholt/caddy/caddyhttp/mime"
+	_ "github.com/mholt/caddy/caddyhttp/pprof"
+	_ "github.com/mholt/caddy/caddyhttp/proxy"
+	_ "github.com/mholt/caddy/caddyhttp/push"
+	_ "github.com/mholt/caddy/caddyhttp/redirect"
+	_ "github.com/mholt/caddy/caddyhttp/requestid"
+	_ "github.com/mholt/caddy/caddyhttp/rewrite"
+	_ "github.com/mholt/caddy/caddyhttp/root"
+	_ "github.com/mholt/caddy/caddyhttp/status"
+	_ "github.com/mholt/caddy/caddyhttp/templates"
+	_ "github.com/mholt/caddy/caddyhttp/timeouts"
+	_ "github.com/mholt/caddy/caddyhttp/websocket"
+	_ "github.com/mholt/caddy/onevent"
+	_ "github.com/mholt/caddy/startupshutdown"
+)

caddyhttp/caddyhttp_test.go

@@ -0,0 +1,33 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// 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 caddyhttp
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/mholt/caddy"
+)
+
+// TODO: this test could be improved; the purpose is to
+// ensure that the standard plugins are in fact plugged in
+// and registered properly; this is a quick/naive way to do it.
+func TestStandardPlugins(t *testing.T) {
+	numStandardPlugins := 33 // importing caddyhttp plugs in this many plugins
+	s := caddy.DescribePlugins()
+	if got, want := strings.Count(s, "\n"), numStandardPlugins+5; got != want {
+		t.Errorf("Expected all standard plugins to be plugged in, got:\n%s", s)
+	}
+}

caddyhttp/errors/errors.go

@@ -0,0 +1,164 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// 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 errors implements an HTTP error handling middleware.
+package errors
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"runtime"
+	"strings"
+	"time"
+
+	"github.com/mholt/caddy"
+	"github.com/mholt/caddy/caddyhttp/httpserver"
+)
+
+func init() {
+	caddy.RegisterPlugin("errors", caddy.Plugin{
+		ServerType: "http",
+		Action:     setup,
+	})
+}
+
+// ErrorHandler handles HTTP errors (and errors from other middleware).
+type ErrorHandler struct {
+	Next             httpserver.Handler
+	GenericErrorPage string         // default error page filename
+	ErrorPages       map[int]string // map of status code to filename
+	Log              *httpserver.Logger
+	Debug            bool // if true, errors are written out to client rather than to a log
+}
+
+func (h ErrorHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error) {
+	defer h.recovery(w, r)
+
+	status, err := h.Next.ServeHTTP(w, r)
+
+	if err != nil {
+		errMsg := fmt.Sprintf("%s [ERROR %d %s] %v", time.Now().Format(timeFormat), status, r.URL.Path, err)
+		if h.Debug {
+			// Write error to response instead of to log
+			w.Header().Set("Content-Type", "text/plain; charset=utf-8")
+			w.WriteHeader(status)
+			fmt.Fprintln(w, errMsg)
+			return 0, err // returning 0 signals that a response has been written
+		}
+		h.Log.Println(errMsg)
+	}
+
+	if status >= 400 {
+		h.errorPage(w, r, status)
+		return 0, err
+	}
+
+	return status, err
+}
+
+// errorPage serves a static error page to w according to the status
+// code. If there is an error serving the error page, a plaintext error
+// message is written instead, and the extra error is logged.
+func (h ErrorHandler) errorPage(w http.ResponseWriter, r *http.Request, code int) {
+	// See if an error page for this status code was specified
+	if pagePath, ok := h.findErrorPage(code); ok {
+		// Try to open it
+		errorPage, err := os.Open(pagePath)
+		if err != nil {
+			// An additional error handling an error... <insert grumpy cat here>
+			h.Log.Printf("%s [NOTICE %d %s] could not load error page: %v",
+				time.Now().Format(timeFormat), code, r.URL.String(), err)
+			httpserver.DefaultErrorFunc(w, r, code)
+			return
+		}
+		defer errorPage.Close()
+
+		// Copy the page body into the response
+		w.Header().Set("Content-Type", "text/html; charset=utf-8")
+		w.WriteHeader(code)
+		_, err = io.Copy(w, errorPage)
+
+		if err != nil {
+			// Epic fail... sigh.
+			h.Log.Printf("%s [NOTICE %d %s] could not respond with %s: %v",
+				time.Now().Format(timeFormat), code, r.URL.String(), pagePath, err)
+			httpserver.DefaultErrorFunc(w, r, code)
+		}
+
+		return
+	}
+
+	// Default error response
+	httpserver.DefaultErrorFunc(w, r, code)
+}
+
+func (h ErrorHandler) findErrorPage(code int) (string, bool) {
+	if pagePath, ok := h.ErrorPages[code]; ok {
+		return pagePath, true
+	}
+
+	if h.GenericErrorPage != "" {
+		return h.GenericErrorPage, true
+	}
+
+	return "", false
+}
+
+func (h ErrorHandler) recovery(w http.ResponseWriter, r *http.Request) {
+	rec := recover()
+	if rec == nil {
+		return
+	}
+
+	// Obtain source of panic
+	// From: https://gist.github.com/swdunlop/9629168
+	var name, file string // function name, file name
+	var line int
+	var pc [16]uintptr
+	n := runtime.Callers(3, pc[:])
+	for _, pc := range pc[:n] {
+		fn := runtime.FuncForPC(pc)
+		if fn == nil {
+			continue
+		}
+		file, line = fn.FileLine(pc)
+		name = fn.Name()
+		if !strings.HasPrefix(name, "runtime.") {
+			break
+		}
+	}
+
+	// Trim file path
+	delim := "/caddy/"
+	pkgPathPos := strings.Index(file, delim)
+	if pkgPathPos > -1 && len(file) > pkgPathPos+len(delim) {
+		file = file[pkgPathPos+len(delim):]
+	}
+
+	panicMsg := fmt.Sprintf("%s [PANIC %s] %s:%d - %v", time.Now().Format(timeFormat), r.URL.String(), file, line, rec)
+	if h.Debug {
+		// Write error and stack trace to the response rather than to a log
+		var stackBuf [4096]byte
+		stack := stackBuf[:runtime.Stack(stackBuf[:], false)]
+		httpserver.WriteTextResponse(w, http.StatusInternalServerError, fmt.Sprintf("%s\n\n%s", panicMsg, stack))
+	} else {
+		// Currently we don't use the function name, since file:line is more conventional
+		h.Log.Printf(panicMsg)
+		h.errorPage(w, r, http.StatusInternalServerError)
+	}
+}
+
+const timeFormat = "02/Jan/2006:15:04:05 -0700"

caddyhttp/errors/errors_test.go

@@ -0,0 +1,272 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// 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 errors
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/mholt/caddy/caddyhttp/httpserver"
+)
+
+func TestErrors(t *testing.T) {
+	// create a temporary page
+	const content = "This is a error page"
+
+	path, err := createErrorPageFile("errors_test.html", content)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.Remove(path)
+
+	buf := bytes.Buffer{}
+	em := ErrorHandler{
+		ErrorPages: map[int]string{
+			http.StatusNotFound:  path,
+			http.StatusForbidden: "not_exist_file",
+		},
+		Log: httpserver.NewTestLogger(&buf),
+	}
+	_, notExistErr := os.Open("not_exist_file")
+
+	testErr := errors.New("test error")
+	tests := []struct {
+		next         httpserver.Handler
+		expectedCode int
+		expectedBody string
+		expectedLog  string
+		expectedErr  error
+	}{
+		{
+			next:         genErrorHandler(http.StatusOK, nil, "normal"),
+			expectedCode: http.StatusOK,
+			expectedBody: "normal",
+			expectedLog:  "",
+			expectedErr:  nil,
+		},
+		{
+			next:         genErrorHandler(http.StatusMovedPermanently, testErr, ""),
+			expectedCode: http.StatusMovedPermanently,
+			expectedBody: "",
+			expectedLog:  fmt.Sprintf("[ERROR %d %s] %v\n", http.StatusMovedPermanently, "/", testErr),
+			expectedErr:  testErr,
+		},
+		{
+			next:         genErrorHandler(http.StatusBadRequest, nil, ""),
+			expectedCode: 0,
+			expectedBody: fmt.Sprintf("%d %s\n", http.StatusBadRequest,
+				http.StatusText(http.StatusBadRequest)),
+			expectedLog: "",
+			expectedErr: nil,
+		},
+		{
+			next:         genErrorHandler(http.StatusNotFound, nil, ""),
+			expectedCode: 0,
+			expectedBody: content,
+			expectedLog:  "",
+			expectedErr:  nil,
+		},
+		{
+			next:         genErrorHandler(http.StatusForbidden, nil, ""),
+			expectedCode: 0,
+			expectedBody: fmt.Sprintf("%d %s\n", http.StatusForbidden,
+				http.StatusText(http.StatusForbidden)),
+			expectedLog: fmt.Sprintf("[NOTICE %d /] could not load error page: %v\n",
+				http.StatusForbidden, notExistErr),
+			expectedErr: nil,
+		},
+	}
+
+	req, err := http.NewRequest("GET", "/", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for i, test := range tests {
+		em.Next = test.next
+		buf.Reset()
+		rec := httptest.NewRecorder()
+		code, err := em.ServeHTTP(rec, req)
+
+		if err != test.expectedErr {
+			t.Errorf("Test %d: Expected error %v, but got %v",
+				i, test.expectedErr, err)
+		}
+		if code != test.expectedCode {
+			t.Errorf("Test %d: Expected status code %d, but got %d",
+				i, test.expectedCode, code)
+		}
+		if body := rec.Body.String(); body != test.expectedBody {
+			t.Errorf("Test %d: Expected body %q, but got %q",
+				i, test.expectedBody, body)
+		}
+		if log := buf.String(); !strings.Contains(log, test.expectedLog) {
+			t.Errorf("Test %d: Expected log %q, but got %q",
+				i, test.expectedLog, log)
+		}
+	}
+}
+
+func TestVisibleErrorWithPanic(t *testing.T) {
+	const panicMsg = "I'm a panic"
+	eh := ErrorHandler{
+		ErrorPages: make(map[int]string),
+		Debug:      true,
+		Next: httpserver.HandlerFunc(func(w http.ResponseWriter, r *http.Request) (int, error) {
+			panic(panicMsg)
+		}),
+	}
+
+	req, err := http.NewRequest("GET", "/", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	rec := httptest.NewRecorder()
+
+	code, err := eh.ServeHTTP(rec, req)
+
+	if code != 0 {
+		t.Errorf("Expected error handler to return 0 (it should write to response), got status %d", code)
+	}
+	if err != nil {
+		t.Errorf("Expected error handler to return nil error (it should panic!), but got '%v'", err)
+	}
+
+	body := rec.Body.String()
+
+	if !strings.Contains(body, "[PANIC /] caddyhttp/errors/errors_test.go") {
+		t.Errorf("Expected response body to contain error log line, but it didn't:\n%s", body)
+	}
+	if !strings.Contains(body, panicMsg) {
+		t.Errorf("Expected response body to contain panic message, but it didn't:\n%s", body)
+	}
+	if len(body) < 500 {
+		t.Errorf("Expected response body to contain stack trace, but it was too short: len=%d", len(body))
+	}
+}
+
+func TestGenericErrorPage(t *testing.T) {
+	// create temporary generic error page
+	const genericErrorContent = "This is a generic error page"
+
+	genericErrorPagePath, err := createErrorPageFile("generic_error_test.html", genericErrorContent)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.Remove(genericErrorPagePath)
+
+	// create temporary error page
+	const notFoundErrorContent = "This is a error page"
+
+	notFoundErrorPagePath, err := createErrorPageFile("not_found.html", notFoundErrorContent)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.Remove(notFoundErrorPagePath)
+
+	buf := bytes.Buffer{}
+	em := ErrorHandler{
+		GenericErrorPage: genericErrorPagePath,
+		ErrorPages: map[int]string{
+			http.StatusNotFound: notFoundErrorPagePath,
+		},
+		Log: httpserver.NewTestLogger(&buf),
+	}
+
+	tests := []struct {
+		next         httpserver.Handler
+		expectedCode int
+		expectedBody string
+		expectedLog  string
+		expectedErr  error
+	}{
+		{
+			next:         genErrorHandler(http.StatusNotFound, nil, ""),
+			expectedCode: 0,
+			expectedBody: notFoundErrorContent,
+			expectedLog:  "",
+			expectedErr:  nil,
+		},
+		{
+			next:         genErrorHandler(http.StatusInternalServerError, nil, ""),
+			expectedCode: 0,
+			expectedBody: genericErrorContent,
+			expectedLog:  "",
+			expectedErr:  nil,
+		},
+	}
+
+	req, err := http.NewRequest("GET", "/", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	for i, test := range tests {
+		em.Next = test.next
+		buf.Reset()
+		rec := httptest.NewRecorder()
+		code, err := em.ServeHTTP(rec, req)
+
+		if err != test.expectedErr {
+			t.Errorf("Test %d: Expected error %v, but got %v",
+				i, test.expectedErr, err)
+		}
+		if code != test.expectedCode {
+			t.Errorf("Test %d: Expected status code %d, but got %d",
+				i, test.expectedCode, code)
+		}
+		if body := rec.Body.String(); body != test.expectedBody {
+			t.Errorf("Test %d: Expected body %q, but got %q",
+				i, test.expectedBody, body)
+		}
+		if log := buf.String(); !strings.Contains(log, test.expectedLog) {
+			t.Errorf("Test %d: Expected log %q, but got %q",
+				i, test.expectedLog, log)
+		}
+	}
+}
+
+func genErrorHandler(status int, err error, body string) httpserver.Handler {
+	return httpserver.HandlerFunc(func(w http.ResponseWriter, r *http.Request) (int, error) {
+		if len(body) > 0 {
+			w.Header().Set("Content-Length", strconv.Itoa(len(body)))
+			fmt.Fprint(w, body)
+		}
+		return status, err
+	})
+}
+
+func createErrorPageFile(name string, content string) (string, error) {
+	errorPageFilePath := filepath.Join(os.TempDir(), name)
+	f, err := os.Create(errorPageFilePath)
+	if err != nil {
+		return "", err
+	}
+
+	_, err = f.WriteString(content)
+	if err != nil {
+		return "", err
+	}
+	f.Close()
+
+	return errorPageFilePath, nil
+}

caddyhttp/errors/setup.go

@@ -0,0 +1,134 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// 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 errors
+
+import (
+	"log"
+	"os"
+	"path/filepath"
+	"strconv"
+
+	"github.com/mholt/caddy"
+	"github.com/mholt/caddy/caddyhttp/httpserver"
+)
+
+// setup configures a new errors middleware instance.
+func setup(c *caddy.Controller) error {
+	handler, err := errorsParse(c)
+
+	if err != nil {
+		return err
+	}
+
+	handler.Log.Attach(c)
+
+	httpserver.GetConfig(c).AddMiddleware(func(next httpserver.Handler) httpserver.Handler {
+		handler.Next = next
+		return handler
+	})
+
+	return nil
+}
+
+func errorsParse(c *caddy.Controller) (*ErrorHandler, error) {
+
+	// Very important that we make a pointer because the startup
+	// function that opens the log file must have access to the
+	// same instance of the handler, not a copy.
+	handler := &ErrorHandler{
+		ErrorPages: make(map[int]string),
+		Log:        &httpserver.Logger{},
+	}
+
+	cfg := httpserver.GetConfig(c)
+
+	optionalBlock := func() error {
+		for c.NextBlock() {
+
+			what := c.Val()
+			where := c.RemainingArgs()
+
+			if httpserver.IsLogRollerSubdirective(what) {
+				var err error
+				err = httpserver.ParseRoller(handler.Log.Roller, what, where...)
+				if err != nil {
+					return err
+				}
+			} else {
+				if len(where) != 1 {
+					return c.ArgErr()
+				}
+				where := where[0]
+
+				// Error page; ensure it exists
+				if !filepath.IsAbs(where) {
+					where = filepath.Join(cfg.Root, where)
+				}
+
+				f, err := os.Open(where)
+				if err != nil {
+					log.Printf("[WARNING] Unable to open error page '%s': %v", where, err)
+				}
+				f.Close()
+
+				if what == "*" {
+					if handler.GenericErrorPage != "" {
+						return c.Errf("Duplicate status code entry: %s", what)
+					}
+					handler.GenericErrorPage = where
+				} else {
+					whatInt, err := strconv.Atoi(what)
+					if err != nil {
+						return c.Err("Expecting a numeric status code or '*', got '" + what + "'")
+					}
+
+					if _, exists := handler.ErrorPages[whatInt]; exists {
+						return c.Errf("Duplicate status code entry: %s", what)
+					}
+
+					handler.ErrorPages[whatInt] = where
+				}
+			}
+		}
+		return nil
+	}
+
+	for c.Next() {
+		// weird hack to avoid having the handler values overwritten.
+		if c.Val() == "}" {
+			continue
+		}
+
+		args := c.RemainingArgs()
+
+		if len(args) == 1 {
+			switch args[0] {
+			case "visible":
+				handler.Debug = true
+			default:
+				handler.Log.Output = args[0]
+				handler.Log.Roller = httpserver.DefaultLogRoller()
+			}
+		}
+
+		// Configuration may be in a block
+		err := optionalBlock()
+		if err != nil {
+			return handler, err
+		}
+	}
+
+	return handler, nil
+}

caddyhttp/errors/setup_test.go

@@ -0,0 +1,199 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// 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 errors
+
+import (
+	"path/filepath"
+	"reflect"
+	"testing"
+
+	"github.com/mholt/caddy"
+	"github.com/mholt/caddy/caddyhttp/httpserver"
+)
+
+func TestSetup(t *testing.T) {
+	c := caddy.NewTestController("http", `errors`)
+	err := setup(c)
+	if err != nil {
+		t.Errorf("Expected no errors, got: %v", err)
+	}
+	mids := httpserver.GetConfig(c).Middleware()
+	if len(mids) == 0 {
+		t.Fatal("Expected middlewares, was nil instead")
+	}
+
+	handler := mids[0](httpserver.EmptyNext)
+	myHandler, ok := handler.(*ErrorHandler)
+	if !ok {
+		t.Fatalf("Expected handler to be type ErrorHandler, got: %#v", handler)
+	}
+
+	expectedLogger := &httpserver.Logger{}
+
+	if !reflect.DeepEqual(expectedLogger, myHandler.Log) {
+		t.Errorf("Expected '%v' as the default Log, got: '%v'", expectedLogger, myHandler.Log)
+	}
+
+	if !httpserver.SameNext(myHandler.Next, httpserver.EmptyNext) {
+		t.Error("'Next' field of handler was not set properly")
+	}
+
+	// Test Startup function -- TODO
+	// if len(c.Startup) == 0 {
+	// 	t.Fatal("Expected 1 startup function, had 0")
+	// }
+	// c.Startup[0]()
+	// if myHandler.Log == nil {
+	// 	t.Error("Expected Log to be non-nil after startup because Debug is not enabled")
+	// }
+}
+
+func TestErrorsParse(t *testing.T) {
+	testAbs, err := filepath.Abs("./404.html")
+	if err != nil {
+		t.Error(err)
+	}
+	tests := []struct {
+		inputErrorsRules     string
+		shouldErr            bool
+		expectedErrorHandler ErrorHandler
+	}{
+		{`errors`, false, ErrorHandler{
+			ErrorPages: map[int]string{},
+			Log:        &httpserver.Logger{},
+		}},
+		{`errors errors.txt`, false, ErrorHandler{
+			ErrorPages: map[int]string{},
+			Log: &httpserver.Logger{
+				Output: "errors.txt",
+				Roller: httpserver.DefaultLogRoller(),
+			},
+		}},
+		{`errors visible`, false, ErrorHandler{
+			ErrorPages: map[int]string{},
+			Debug:      true,
+			Log:        &httpserver.Logger{},
+		}},
+		{`errors errors.txt {
+        404 404.html
+        500 500.html
+}`, false, ErrorHandler{
+			ErrorPages: map[int]string{
+				404: "404.html",
+				500: "500.html",
+			},
+			Log: &httpserver.Logger{
+				Output: "errors.txt",
+				Roller: httpserver.DefaultLogRoller(),
+			},
+		}},
+		{`errors errors.txt {
+			rotate_size 2
+			rotate_age 10
+			rotate_keep 3
+			rotate_compress
+		}`, false, ErrorHandler{
+			ErrorPages: map[int]string{},
+			Log: &httpserver.Logger{
+				Output: "errors.txt", Roller: &httpserver.LogRoller{
+					MaxSize:    2,
+					MaxAge:     10,
+					MaxBackups: 3,
+					Compress:   true,
+					LocalTime:  true,
+				},
+			},
+		}},
+		{`errors errors.txt {
+		rotate_size 3
+		rotate_age 11
+		rotate_keep 5
+        404 404.html
+        503 503.html
+}`, false, ErrorHandler{
+			ErrorPages: map[int]string{
+				404: "404.html",
+				503: "503.html",
+			},
+			Log: &httpserver.Logger{
+				Output: "errors.txt",
+				Roller: &httpserver.LogRoller{
+					MaxSize:    3,
+					MaxAge:     11,
+					MaxBackups: 5,
+					Compress:   false,
+					LocalTime:  true,
+				},
+			},
+		}},
+		{`errors errors.txt {
+        * generic_error.html
+        404 404.html
+        503 503.html
+}`, false, ErrorHandler{
+			Log: &httpserver.Logger{
+				Output: "errors.txt",
+				Roller: httpserver.DefaultLogRoller(),
+			},
+			GenericErrorPage: "generic_error.html",
+			ErrorPages: map[int]string{
+				404: "404.html",
+				503: "503.html",
+			},
+		}},
+		// test absolute file path
+		{`errors {
+			404 ` + testAbs + `
+		}`,
+			false, ErrorHandler{
+				ErrorPages: map[int]string{
+					404: testAbs,
+				},
+				Log: &httpserver.Logger{},
+			}},
+		{`errors errors.txt { rotate_size 2 rotate_age 10 rotate_keep 3 rotate_compress }`,
+			true, ErrorHandler{ErrorPages: map[int]string{}, Log: &httpserver.Logger{}}},
+		{`errors errors.txt {
+			rotate_compress invalid
+		}`,
+			true, ErrorHandler{ErrorPages: map[int]string{}, Log: &httpserver.Logger{}}},
+		// Next two test cases is the detection of duplicate status codes
+		{`errors {
+			503 503.html
+			503 503.html
+		}`, true, ErrorHandler{ErrorPages: map[int]string{}, Log: &httpserver.Logger{}}},
+
+		{`errors {
+			* generic_error.html
+			* generic_error.html
+		}`, true, ErrorHandler{ErrorPages: map[int]string{}, Log: &httpserver.Logger{}}},
+	}
+
+	for i, test := range tests {
+		actualErrorsRule, err := errorsParse(caddy.NewTestController("http", test.inputErrorsRules))
+
+		if err == nil && test.shouldErr {
+			t.Errorf("Test %d didn't error, but it should have", i)
+		} else if err != nil && !test.shouldErr {
+			t.Errorf("Test %d errored, but it shouldn't have; got '%v'", i, err)
+		} else if err != nil && test.shouldErr {
+			continue
+		}
+		if !reflect.DeepEqual(actualErrorsRule, &test.expectedErrorHandler) {
+			t.Errorf("Test %d expect %v, but got %v", i,
+				test.expectedErrorHandler, actualErrorsRule)
+		}
+	}
+}

caddyhttp/expvar/expvar.go

@@ -0,0 +1,59 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// 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 expvar
+
+import (
+	"expvar"
+	"fmt"
+	"net/http"
+
+	"github.com/mholt/caddy/caddyhttp/httpserver"
+)
+
+// ExpVar is a simple struct to hold expvar's configuration
+type ExpVar struct {
+	Next     httpserver.Handler
+	Resource Resource
+}
+
+// ServeHTTP handles requests to expvar's configured entry point with
+// expvar, or passes all other requests up the chain.
+func (e ExpVar) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error) {
+	if httpserver.Path(r.URL.Path).Matches(string(e.Resource)) {
+		expvarHandler(w, r)
+		return 0, nil
+	}
+	return e.Next.ServeHTTP(w, r)
+}
+
+// expvarHandler returns a JSON object will all the published variables.
+//
+// This is lifted straight from the expvar package.
+func expvarHandler(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Content-Type", "application/json; charset=utf-8")
+	fmt.Fprintf(w, "{\n")
+	first := true
+	expvar.Do(func(kv expvar.KeyValue) {
+		if !first {
+			fmt.Fprintf(w, ",\n")
+		}
+		first = false
+		fmt.Fprintf(w, "%q: %s", kv.Key, kv.Value)
+	})
+	fmt.Fprintf(w, "\n}\n")
+}
+
+// Resource contains the path to the expvar entry point
+type Resource string

caddyhttp/expvar/expvar_test.go

@@ -0,0 +1,60 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// 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 expvar
+
+import (
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/mholt/caddy/caddyhttp/httpserver"
+)
+
+func TestExpVar(t *testing.T) {
+	rw := ExpVar{
+		Next:     httpserver.HandlerFunc(contentHandler),
+		Resource: "/d/v",
+	}
+
+	tests := []struct {
+		from   string
+		result int
+	}{
+		{"/d/v", 0},
+		{"/x/y", http.StatusOK},
+	}
+
+	for i, test := range tests {
+		req, err := http.NewRequest("GET", test.from, nil)
+		if err != nil {
+			t.Fatalf("Test %d: Could not create HTTP request %v", i, err)
+		}
+		rec := httptest.NewRecorder()
+		result, err := rw.ServeHTTP(rec, req)
+		if err != nil {
+			t.Fatalf("Test %d: Could not ServeHTTP %v", i, err)
+		}
+		if result != test.result {
+			t.Errorf("Test %d: Expected Header '%d' but was '%d'",
+				i, test.result, result)
+		}
+	}
+}
+
+func contentHandler(w http.ResponseWriter, r *http.Request) (int, error) {
+	fmt.Fprintf(w, r.URL.String())
+	return http.StatusOK, nil
+}

caddyhttp/expvar/setup.go

@@ -0,0 +1,83 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// 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 expvar
+
+import (
+	"expvar"
+	"runtime"
+	"sync"
+
+	"github.com/mholt/caddy"
+	"github.com/mholt/caddy/caddyhttp/httpserver"
+)
+
+func init() {
+	caddy.RegisterPlugin("expvar", caddy.Plugin{
+		ServerType: "http",
+		Action:     setup,
+	})
+}
+
+// setup configures a new ExpVar middleware instance.
+func setup(c *caddy.Controller) error {
+	resource, err := expVarParse(c)
+	if err != nil {
+		return err
+	}
+
+	// publish any extra information/metrics we may want to capture
+	publishExtraVars()
+
+	ev := ExpVar{Resource: resource}
+
+	httpserver.GetConfig(c).AddMiddleware(func(next httpserver.Handler) httpserver.Handler {
+		ev.Next = next
+		return ev
+	})
+
+	return nil
+}
+
+func expVarParse(c *caddy.Controller) (Resource, error) {
+	var resource Resource
+	var err error
+
+	for c.Next() {
+		args := c.RemainingArgs()
+		switch len(args) {
+		case 0:
+			resource = Resource(defaultExpvarPath)
+		case 1:
+			resource = Resource(args[0])
+		default:
+			return resource, c.ArgErr()
+		}
+	}
+
+	return resource, err
+}
+
+func publishExtraVars() {
+	// By using sync.Once instead of an init() function, we don't clutter
+	// the app's expvar export unnecessarily, or risk colliding with it.
+	publishOnce.Do(func() {
+		expvar.Publish("Goroutines", expvar.Func(func() interface{} {
+			return runtime.NumGoroutine()
+		}))
+	})
+}
+
+var publishOnce sync.Once // publishing variables should only be done once
+var defaultExpvarPath = "/debug/vars"

caddyhttp/expvar/setup_test.go

@@ -0,0 +1,56 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// 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 expvar
+
+import (
+	"testing"
+
+	"github.com/mholt/caddy"
+	"github.com/mholt/caddy/caddyhttp/httpserver"
+)
+
+func TestSetup(t *testing.T) {
+	c := caddy.NewTestController("http", `expvar`)
+	err := setup(c)
+	if err != nil {
+		t.Errorf("Expected no errors, got: %v", err)
+	}
+	mids := httpserver.GetConfig(c).Middleware()
+	if len(mids) == 0 {
+		t.Fatal("Expected middleware, got 0 instead")
+	}
+
+	c = caddy.NewTestController("http", `expvar /d/v`)
+	err = setup(c)
+	if err != nil {
+		t.Errorf("Expected no errors, got: %v", err)
+	}
+	mids = httpserver.GetConfig(c).Middleware()
+	if len(mids) == 0 {
+		t.Fatal("Expected middleware, got 0 instead")
+	}
+
+	handler := mids[0](httpserver.EmptyNext)
+	myHandler, ok := handler.(ExpVar)
+	if !ok {
+		t.Fatalf("Expected handler to be type ExpVar, got: %#v", handler)
+	}
+	if myHandler.Resource != "/d/v" {
+		t.Errorf("Expected /d/v as expvar resource")
+	}
+	if !httpserver.SameNext(myHandler.Next, httpserver.EmptyNext) {
+		t.Error("'Next' field of handler was not set properly")
+	}
+}

caddyhttp/extensions/ext.go

@@ -0,0 +1,58 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// 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 extensions contains middleware for clean URLs.
+//
+// The root path of the site is passed in as well as possible extensions
+// to try internally for paths requested that don't match an existing
+// resource. The first path+ext combination that matches a valid file
+// will be used.
+package extensions
+
+import (
+	"net/http"
+	"os"
+	"path"
+	"strings"
+
+	"github.com/mholt/caddy/caddyhttp/httpserver"
+)
+
+// Ext can assume an extension from clean URLs.
+// It tries extensions in the order listed in Extensions.
+type Ext struct {
+	// Next handler in the chain
+	Next httpserver.Handler
+
+	// Path to site root
+	Root string
+
+	// List of extensions to try
+	Extensions []string
+}
+
+// ServeHTTP implements the httpserver.Handler interface.
+func (e Ext) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error) {
+	urlpath := strings.TrimSuffix(r.URL.Path, "/")
+	if len(r.URL.Path) > 0 && path.Ext(urlpath) == "" && r.URL.Path[len(r.URL.Path)-1] != '/' {
+		for _, ext := range e.Extensions {
+			_, err := os.Stat(httpserver.SafePath(e.Root, urlpath) + ext)
+			if err == nil {
+				r.URL.Path = urlpath + ext
+				break
+			}
+		}
+	}
+	return e.Next.ServeHTTP(w, r)
+}

caddyhttp/extensions/setup.go

@@ -0,0 +1,67 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// 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 extensions
+
+import (
+	"github.com/mholt/caddy"
+	"github.com/mholt/caddy/caddyhttp/httpserver"
+)
+
+func init() {
+	caddy.RegisterPlugin("ext", caddy.Plugin{
+		ServerType: "http",
+		Action:     setup,
+	})
+}
+
+// setup configures a new instance of 'extensions' middleware for clean URLs.
+func setup(c *caddy.Controller) error {
+	cfg := httpserver.GetConfig(c)
+	root := cfg.Root
+
+	exts, err := extParse(c)
+	if err != nil {
+		return err
+	}
+
+	httpserver.GetConfig(c).AddMiddleware(func(next httpserver.Handler) httpserver.Handler {
+		return Ext{
+			Next:       next,
+			Extensions: exts,
+			Root:       root,
+		}
+	})
+
+	return nil
+}
+
+// extParse sets up an instance of extension middleware
+// from a middleware controller and returns a list of extensions.
+func extParse(c *caddy.Controller) ([]string, error) {
+	var exts []string
+
+	for c.Next() {
+		// At least one extension is required
+		if !c.NextArg() {
+			return exts, c.ArgErr()
+		}
+		exts = append(exts, c.Val())
+
+		// Tack on any other extensions that may have been listed
+		exts = append(exts, c.RemainingArgs()...)
+	}
+
+	return exts, nil
+}

caddyhttp/extensions/setup_test.go

@@ -0,0 +1,89 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// 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 extensions
+
+import (
+	"testing"
+
+	"github.com/mholt/caddy"
+	"github.com/mholt/caddy/caddyhttp/httpserver"
+)
+
+func TestSetup(t *testing.T) {
+	c := caddy.NewTestController("http", `ext .html .htm .php`)
+	err := setup(c)
+	if err != nil {
+		t.Fatalf("Expected no errors, got: %v", err)
+	}
+
+	mids := httpserver.GetConfig(c).Middleware()
+	if len(mids) == 0 {
+		t.Fatal("Expected middleware, had 0 instead")
+	}
+
+	handler := mids[0](httpserver.EmptyNext)
+	myHandler, ok := handler.(Ext)
+
+	if !ok {
+		t.Fatalf("Expected handler to be type Ext, got: %#v", handler)
+	}
+
+	if myHandler.Extensions[0] != ".html" {
+		t.Errorf("Expected .html in the list of Extensions")
+	}
+	if myHandler.Extensions[1] != ".htm" {
+		t.Errorf("Expected .htm in the list of Extensions")
+	}
+	if myHandler.Extensions[2] != ".php" {
+		t.Errorf("Expected .php in the list of Extensions")
+	}
+	if !httpserver.SameNext(myHandler.Next, httpserver.EmptyNext) {
+		t.Error("'Next' field of handler was not set properly")
+	}
+
+}
+
+func TestExtParse(t *testing.T) {
+	tests := []struct {
+		inputExts    string
+		shouldErr    bool
+		expectedExts []string
+	}{
+		{`ext .html .htm .php`, false, []string{".html", ".htm", ".php"}},
+		{`ext .php .html .xml`, false, []string{".php", ".html", ".xml"}},
+		{`ext .txt .php .xml`, false, []string{".txt", ".php", ".xml"}},
+	}
+	for i, test := range tests {
+		actualExts, err := extParse(caddy.NewTestController("http", test.inputExts))
+
+		if err == nil && test.shouldErr {
+			t.Errorf("Test %d didn't error, but it should have", i)
+		} else if err != nil && !test.shouldErr {
+			t.Errorf("Test %d errored, but it shouldn't have; got '%v'", i, err)
+		}
+
+		if len(actualExts) != len(test.expectedExts) {
+			t.Fatalf("Test %d expected %d rules, but got %d",
+				i, len(test.expectedExts), len(actualExts))
+		}
+		for j, actualExt := range actualExts {
+			if actualExt != test.expectedExts[j] {
+				t.Fatalf("Test %d expected %dth extension to be  %s  , but got %s",
+					i, j, test.expectedExts[j], actualExt)
+			}
+		}
+	}
+
+}

caddyhttp/fastcgi/fastcgi.go

@@ -0,0 +1,467 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// 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 has middleware that acts as a FastCGI client. Requests
+// that get forwarded to FastCGI stop the middleware execution chain.
+// The most common use for this package is to serve PHP websites via php-fpm.
+package fastcgi
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"net/url"
+	"os"
+	"path"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"sync/atomic"
+	"time"
+
+	"github.com/mholt/caddy"
+	"github.com/mholt/caddy/caddyhttp/httpserver"
+)
+
+// Handler is a middleware type that can handle requests as a FastCGI client.
+type Handler struct {
+	Next    httpserver.Handler
+	Rules   []Rule
+	Root    string
+	FileSys http.FileSystem
+
+	// These are sent to CGI scripts in env variables
+	SoftwareName    string
+	SoftwareVersion string
+	ServerName      string
+	ServerPort      string
+}
+
+// ServeHTTP satisfies the httpserver.Handler interface.
+func (h Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error) {
+	for _, rule := range h.Rules {
+		// First requirement: Base path must match request path. If it doesn't,
+		// we check to make sure the leading slash is not missing, and if so,
+		// we check again with it prepended. This is in case people forget
+		// a leading slash when performing rewrites, and we don't want to expose
+		// the contents of the (likely PHP) script. See issue #1645.
+		hpath := httpserver.Path(r.URL.Path)
+		if !hpath.Matches(rule.Path) {
+			if strings.HasPrefix(string(hpath), "/") {
+				// this is a normal-looking path, and it doesn't match; try next rule
+				continue
+			}
+			hpath = httpserver.Path("/" + string(hpath)) // prepend leading slash
+			if !hpath.Matches(rule.Path) {
+				// even after fixing the request path, it still doesn't match; try next rule
+				continue
+			}
+		}
+		// The path must also be allowed (not ignored).
+		if !rule.AllowedPath(r.URL.Path) {
+			continue
+		}
+
+		// 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.
+
+		fpath := r.URL.Path
+
+		if idx, ok := httpserver.IndexFile(h.FileSys, fpath, rule.IndexFiles); ok {
+			fpath = idx
+			// Index file present.
+			// If request path cannot be split, return error.
+			if !rule.canSplit(fpath) {
+				return http.StatusInternalServerError, ErrIndexMissingSplit
+			}
+		} else {
+			// No index file present.
+			// If request path cannot be split, ignore request.
+			if !rule.canSplit(fpath) {
+				continue
+			}
+		}
+
+		// These criteria work well in this order for PHP sites
+		if !h.exists(fpath) || fpath[len(fpath)-1] == '/' || strings.HasSuffix(fpath, rule.Ext) {
+
+			// Create environment for CGI script
+			env, err := h.buildEnv(r, rule, fpath)
+			if err != nil {
+				return http.StatusInternalServerError, err
+			}
+
+			// Connect to FastCGI gateway
+			address, err := rule.Address()
+			if err != nil {
+				return http.StatusBadGateway, err
+			}
+			network, address := parseAddress(address)
+
+			ctx := context.Background()
+			if rule.ConnectTimeout > 0 {
+				var cancel context.CancelFunc
+				ctx, cancel = context.WithTimeout(ctx, rule.ConnectTimeout)
+				defer cancel()
+			}
+
+			fcgiBackend, err := DialContext(ctx, network, address)
+			if err != nil {
+				return http.StatusBadGateway, err
+			}
+			defer fcgiBackend.Close()
+
+			// read/write timeouts
+			if err := fcgiBackend.SetReadTimeout(rule.ReadTimeout); err != nil {
+				return http.StatusInternalServerError, err
+			}
+			if err := fcgiBackend.SetSendTimeout(rule.SendTimeout); err != nil {
+				return http.StatusInternalServerError, err
+			}
+
+			var resp *http.Response
+
+			var contentLength int64
+			// if ContentLength is already set
+			if r.ContentLength > 0 {
+				contentLength = r.ContentLength
+			} else {
+				contentLength, _ = strconv.ParseInt(r.Header.Get("Content-Length"), 10, 64)
+			}
+			switch r.Method {
+			case "HEAD":
+				resp, err = fcgiBackend.Head(env)
+			case "GET":
+				resp, err = fcgiBackend.Get(env, r.Body, contentLength)
+			case "OPTIONS":
+				resp, err = fcgiBackend.Options(env)
+			default:
+				resp, err = fcgiBackend.Post(env, r.Method, r.Header.Get("Content-Type"), r.Body, contentLength)
+			}
+
+			if resp != nil && resp.Body != nil {
+				defer resp.Body.Close()
+			}
+
+			if err != nil {
+				if err, ok := err.(net.Error); ok && err.Timeout() {
+					return http.StatusGatewayTimeout, err
+				} else if err != io.EOF {
+					return http.StatusBadGateway, err
+				}
+			}
+
+			// Write response header
+			writeHeader(w, resp)
+
+			// Write the response body
+			_, err = io.Copy(w, resp.Body)
+			if err != nil {
+				return http.StatusBadGateway, err
+			}
+
+			// Log any stderr output from upstream
+			if fcgiBackend.stderr.Len() != 0 {
+				// Remove trailing newline, error logger already does this.
+				err = LogError(strings.TrimSuffix(fcgiBackend.stderr.String(), "\n"))
+			}
+
+			// Normally we would return the status code if it is an error status (>= 400),
+			// however, upstream FastCGI apps don't know about our contract and have
+			// probably already written an error page. So we just return 0, indicating
+			// that the response body is already written. However, we do return any
+			// error value so it can be logged.
+			// Note that the proxy middleware works the same way, returning status=0.
+			return 0, err
+		}
+	}
+
+	return h.Next.ServeHTTP(w, r)
+}
+
+// parseAddress returns the network and address of fcgiAddress.
+// The first string is the network, "tcp" or "unix", implied from the scheme and address.
+// The second string is fcgiAddress, with scheme prefixes removed.
+// The two returned strings can be used as parameters to the Dial() function.
+func parseAddress(fcgiAddress string) (string, string) {
+	// check if address has tcp scheme explicitly set
+	if strings.HasPrefix(fcgiAddress, "tcp://") {
+		return "tcp", fcgiAddress[len("tcp://"):]
+	}
+	// check if address has fastcgi scheme explicitly set
+	if strings.HasPrefix(fcgiAddress, "fastcgi://") {
+		return "tcp", fcgiAddress[len("fastcgi://"):]
+	}
+	// check if unix socket
+	if trim := strings.HasPrefix(fcgiAddress, "unix"); strings.HasPrefix(fcgiAddress, "/") || trim {
+		if trim {
+			return "unix", fcgiAddress[len("unix:"):]
+		}
+		return "unix", fcgiAddress
+	}
+	// default case, a plain tcp address with no scheme
+	return "tcp", fcgiAddress
+}
+
+func writeHeader(w http.ResponseWriter, r *http.Response) {
+	for key, vals := range r.Header {
+		for _, val := range vals {
+			w.Header().Add(key, val)
+		}
+	}
+	w.WriteHeader(r.StatusCode)
+}
+
+func (h Handler) exists(path string) bool {
+	if _, err := os.Stat(h.Root + path); err == nil {
+		return true
+	}
+	return false
+}
+
+// buildEnv returns a set of CGI environment variables for the request.
+func (h Handler) buildEnv(r *http.Request, rule Rule, fpath string) (map[string]string, error) {
+	var env map[string]string
+
+	// Get absolute path of requested resource
+	absPath := filepath.Join(rule.Root, fpath)
+
+	// Separate remote IP and port; more lenient than net.SplitHostPort
+	var ip, port string
+	if idx := strings.LastIndex(r.RemoteAddr, ":"); idx > -1 {
+		ip = r.RemoteAddr[:idx]
+		port = r.RemoteAddr[idx+1:]
+	} else {
+		ip = r.RemoteAddr
+	}
+
+	// Remove [] from IPv6 addresses
+	ip = strings.Replace(ip, "[", "", 1)
+	ip = strings.Replace(ip, "]", "", 1)
+
+	// Split path in preparation for env variables.
+	// Previous rule.canSplit checks ensure this can never be -1.
+	splitPos := rule.splitPos(fpath)
+
+	// Request has the extension; path was split successfully
+	docURI := fpath[:splitPos+len(rule.SplitPath)]
+	pathInfo := fpath[splitPos+len(rule.SplitPath):]
+	scriptName := fpath
+	scriptFilename := absPath
+
+	// Strip PATH_INFO from SCRIPT_NAME
+	scriptName = strings.TrimSuffix(scriptName, pathInfo)
+
+	// Add vhost path prefix to scriptName. Otherwise, some PHP software will
+	// have difficulty discovering its URL.
+	pathPrefix, _ := r.Context().Value(caddy.CtxKey("path_prefix")).(string)
+	scriptName = path.Join(pathPrefix, scriptName)
+
+	// Get the request URI from context. The context stores the original URI in case
+	// it was changed by a middleware such as rewrite. By default, we pass the
+	// original URI in as the value of REQUEST_URI (the user can overwrite this
+	// if desired). Most PHP apps seem to want the original URI. Besides, this is
+	// how nginx defaults: http://stackoverflow.com/a/12485156/1048862
+	reqURL, _ := r.Context().Value(httpserver.OriginalURLCtxKey).(url.URL)
+
+	// Retrieve name of remote user that was set by some downstream middleware such as basicauth.
+	remoteUser, _ := r.Context().Value(httpserver.RemoteUserCtxKey).(string)
+
+	// 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,
+		"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":       remoteUser,
+		"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":   rule.Root,
+		"DOCUMENT_URI":    docURI,
+		"HTTP_HOST":       r.Host, // added here, since not always part of headers
+		"REQUEST_URI":     reqURL.RequestURI(),
+		"SCRIPT_FILENAME": scriptFilename,
+		"SCRIPT_NAME":     scriptName,
+	}
+
+	// compliance with the CGI specification requires that
+	// PATH_TRANSLATED should only exist if PATH_INFO is defined.
+	// Info: https://www.ietf.org/rfc/rfc3875 Page 14
+	if env["PATH_INFO"] != "" {
+		env["PATH_TRANSLATED"] = filepath.Join(rule.Root, pathInfo) // Info: http://www.oreilly.com/openbook/cgi/ch02_04.html
+	}
+
+	// Some web apps rely on knowing HTTPS or not
+	if r.TLS != nil {
+		env["HTTPS"] = "on"
+	}
+
+	// Add env variables from config (with support for placeholders in values)
+	replacer := httpserver.NewReplacer(r, nil, "")
+	for _, envVar := range rule.EnvVars {
+		env[envVar[0]] = replacer.Replace(envVar[1])
+	}
+
+	// Add all HTTP headers to env variables
+	for field, val := range r.Header {
+		header := strings.ToUpper(field)
+		header = headerNameReplacer.Replace(header)
+		env["HTTP_"+header] = strings.Join(val, ", ")
+	}
+	return env, nil
+}
+
+// Rule represents a FastCGI handling rule.
+// It is parsed from the fastcgi directive in the Caddyfile, see setup.go.
+type Rule struct {
+	// The base path to match. Required.
+	Path string
+
+	// upstream load balancer
+	balancer
+
+	// Always process files with this extension with fastcgi.
+	Ext string
+
+	// Use this directory as the fastcgi root directory. Defaults to the root
+	// directory of the parent virtual host.
+	Root 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 ends with '/' (which indicates a directory), these index
+	// files will be tried instead.
+	IndexFiles []string
+
+	// Environment Variables
+	EnvVars [][2]string
+
+	// Ignored paths
+	IgnoredSubPaths []string
+
+	// The duration used to set a deadline when connecting to an upstream.
+	ConnectTimeout time.Duration
+
+	// The duration used to set a deadline when reading from the FastCGI server.
+	ReadTimeout time.Duration
+
+	// The duration used to set a deadline when sending to the FastCGI server.
+	SendTimeout time.Duration
+}
+
+// balancer is a fastcgi upstream load balancer.
+type balancer interface {
+	// Address picks an upstream address from the
+	// underlying load balancer.
+	Address() (string, error)
+}
+
+// roundRobin is a round robin balancer for fastcgi upstreams.
+type roundRobin struct {
+	// Known Go bug: https://golang.org/pkg/sync/atomic/#pkg-note-BUG
+	// must be first field for 64 bit alignment
+	// on x86 and arm.
+	index     int64
+	addresses []string
+}
+
+func (r *roundRobin) Address() (string, error) {
+	index := atomic.AddInt64(&r.index, 1) % int64(len(r.addresses))
+	return r.addresses[index], nil
+}
+
+// srvResolver is a private interface used to abstract
+// the DNS resolver. It is mainly used to facilitate testing.
+type srvResolver interface {
+	LookupSRV(ctx context.Context, service, proto, name string) (string, []*net.SRV, error)
+}
+
+// srv is a service locator for fastcgi upstreams
+type srv struct {
+	resolver srvResolver
+	service  string
+}
+
+// Address looks up the service and returns the address:port
+// from first result in resolved list.
+// No explicit balancing is required because net.LookupSRV
+// sorts the results by priority and randomizes within priority.
+func (s *srv) Address() (string, error) {
+	_, addrs, err := s.resolver.LookupSRV(context.Background(), "", "", s.service)
+	if err != nil {
+		return "", err
+	}
+
+	return fmt.Sprintf("%s:%d", strings.TrimRight(addrs[0].Target, "."), addrs[0].Port), nil
+}
+
+// canSplit checks if path can split into two based on rule.SplitPath.
+func (r Rule) canSplit(path string) bool {
+	return r.splitPos(path) >= 0
+}
+
+// splitPos returns the index where path should be split
+// based on rule.SplitPath.
+func (r Rule) splitPos(path string) int {
+	if httpserver.CaseSensitivePath {
+		return strings.Index(path, r.SplitPath)
+	}
+	return strings.Index(strings.ToLower(path), strings.ToLower(r.SplitPath))
+}
+
+// AllowedPath checks if requestPath is not an ignored path.
+func (r Rule) AllowedPath(requestPath string) bool {
+	for _, ignoredSubPath := range r.IgnoredSubPaths {
+		if httpserver.Path(path.Clean(requestPath)).Matches(path.Join(r.Path, ignoredSubPath)) {
+			return false
+		}
+	}
+	return true
+}
+
+var (
+	headerNameReplacer = strings.NewReplacer(" ", "_", "-", "_")
+	// ErrIndexMissingSplit describes an index configuration error.
+	ErrIndexMissingSplit = errors.New("configured index file(s) must include split value")
+)
+
+// LogError is a non fatal error that allows requests to go through.
+type LogError string
+
+// Error satisfies error interface.
+func (l LogError) Error() string {
+	return string(l)
+}

caddyhttp/fastcgi/fastcgi_test.go

@@ -0,0 +1,388 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// 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
+
+import (
+	"context"
+	"net"
+	"net/http"
+	"net/http/fcgi"
+	"net/http/httptest"
+	"net/url"
+	"strconv"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/mholt/caddy"
+	"github.com/mholt/caddy/caddyhttp/httpserver"
+)
+
+func TestServeHTTP(t *testing.T) {
+	body := "This is some test body content"
+
+	bodyLenStr := strconv.Itoa(len(body))
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatalf("Unable to create listener for test: %v", err)
+	}
+	defer listener.Close()
+	go fcgi.Serve(listener, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Length", bodyLenStr)
+		w.Write([]byte(body))
+	}))
+
+	handler := Handler{
+		Next:  nil,
+		Rules: []Rule{{Path: "/", balancer: address(listener.Addr().String())}},
+	}
+	r, err := http.NewRequest("GET", "/", nil)
+	if err != nil {
+		t.Fatalf("Unable to create request: %v", err)
+	}
+	w := httptest.NewRecorder()
+
+	status, err := handler.ServeHTTP(w, r)
+
+	if got, want := status, 0; got != want {
+		t.Errorf("Expected returned status code to be %d, got %d", want, got)
+	}
+	if err != nil {
+		t.Errorf("Expected nil error, got: %v", err)
+	}
+	if got, want := w.Header().Get("Content-Length"), bodyLenStr; got != want {
+		t.Errorf("Expected Content-Length to be '%s', got: '%s'", want, got)
+	}
+	if got, want := w.Body.String(), body; got != want {
+		t.Errorf("Expected response body to be '%s', got: '%s'", want, got)
+	}
+}
+
+func TestRuleParseAddress(t *testing.T) {
+	getClientTestTable := []struct {
+		rule            *Rule
+		expectednetwork string
+		expectedaddress string
+	}{
+		{&Rule{balancer: address("tcp://172.17.0.1:9000")}, "tcp", "172.17.0.1:9000"},
+		{&Rule{balancer: address("fastcgi://localhost:9000")}, "tcp", "localhost:9000"},
+		{&Rule{balancer: address("172.17.0.15")}, "tcp", "172.17.0.15"},
+		{&Rule{balancer: address("/my/unix/socket")}, "unix", "/my/unix/socket"},
+		{&Rule{balancer: address("unix:/second/unix/socket")}, "unix", "/second/unix/socket"},
+	}
+
+	for _, entry := range getClientTestTable {
+		addr, err := entry.rule.Address()
+		if err != nil {
+			t.Errorf("Unexpected error in retrieving address: %s", err.Error())
+		}
+		if actualnetwork, _ := parseAddress(addr); actualnetwork != entry.expectednetwork {
+			t.Errorf("Unexpected network for address string %v. Got %v, expected %v", addr, actualnetwork, entry.expectednetwork)
+		}
+		if _, actualaddress := parseAddress(addr); actualaddress != entry.expectedaddress {
+			t.Errorf("Unexpected parsed address for address string %v. Got %v, expected %v", addr, actualaddress, entry.expectedaddress)
+		}
+	}
+}
+
+func TestRuleIgnoredPath(t *testing.T) {
+	rule := &Rule{
+		Path:            "/fastcgi",
+		IgnoredSubPaths: []string{"/download", "/static"},
+	}
+	tests := []struct {
+		url      string
+		expected bool
+	}{
+		{"/fastcgi", true},
+		{"/fastcgi/dl", true},
+		{"/fastcgi/download", false},
+		{"/fastcgi/download/static", false},
+		{"/fastcgi/static", false},
+		{"/fastcgi/static/download", false},
+		{"/fastcgi/something/download", true},
+		{"/fastcgi/something/static", true},
+		{"/fastcgi//static", false},
+		{"/fastcgi//static//download", false},
+		{"/fastcgi//download", false},
+	}
+
+	for i, test := range tests {
+		allowed := rule.AllowedPath(test.url)
+		if test.expected != allowed {
+			t.Errorf("Test %d: expected %v found %v", i, test.expected, allowed)
+		}
+	}
+}
+
+func TestBuildEnv(t *testing.T) {
+	testBuildEnv := func(r *http.Request, rule Rule, fpath string, envExpected map[string]string) {
+		var h Handler
+		env, err := h.buildEnv(r, rule, fpath)
+		if err != nil {
+			t.Error("Unexpected error:", err.Error())
+		}
+		for k, v := range envExpected {
+			if env[k] != v {
+				t.Errorf("Unexpected %v. Got %v, expected %v", k, env[k], v)
+			}
+		}
+	}
+
+	rule := Rule{
+		Ext:        ".php",
+		SplitPath:  ".php",
+		IndexFiles: []string{"index.php"},
+	}
+	url, err := url.Parse("http://localhost:2015/fgci_test.php?test=foobar")
+	if err != nil {
+		t.Error("Unexpected error:", err.Error())
+	}
+
+	var newReq = func() *http.Request {
+		r := http.Request{
+			Method:     "GET",
+			URL:        url,
+			Proto:      "HTTP/1.1",
+			ProtoMajor: 1,
+			ProtoMinor: 1,
+			Host:       "localhost:2015",
+			RemoteAddr: "[2b02:1810:4f2d:9400:70ab:f822:be8a:9093]:51688",
+			RequestURI: "/fgci_test.php",
+			Header: map[string][]string{
+				"Foo": {"Bar", "two"},
+			},
+		}
+		ctx := context.WithValue(r.Context(), httpserver.OriginalURLCtxKey, *r.URL)
+		return r.WithContext(ctx)
+	}
+
+	fpath := "/fgci_test.php"
+
+	var newEnv = func() map[string]string {
+		return map[string]string{
+			"REMOTE_ADDR":     "2b02:1810:4f2d:9400:70ab:f822:be8a:9093",
+			"REMOTE_PORT":     "51688",
+			"SERVER_PROTOCOL": "HTTP/1.1",
+			"QUERY_STRING":    "test=foobar",
+			"REQUEST_METHOD":  "GET",
+			"HTTP_HOST":       "localhost:2015",
+			"SCRIPT_NAME":     "/fgci_test.php",
+		}
+	}
+
+	// request
+	var r *http.Request
+
+	// expected environment variables
+	var envExpected map[string]string
+
+	// 1. Test for full canonical IPv6 address
+	r = newReq()
+	testBuildEnv(r, rule, fpath, envExpected)
+
+	// 2. Test for shorthand notation of IPv6 address
+	r = newReq()
+	r.RemoteAddr = "[::1]:51688"
+	envExpected = newEnv()
+	envExpected["REMOTE_ADDR"] = "::1"
+	testBuildEnv(r, rule, fpath, envExpected)
+
+	// 3. Test for IPv4 address
+	r = newReq()
+	r.RemoteAddr = "192.168.0.10:51688"
+	envExpected = newEnv()
+	envExpected["REMOTE_ADDR"] = "192.168.0.10"
+	testBuildEnv(r, rule, fpath, envExpected)
+
+	// 4. Test for environment variable
+	r = newReq()
+	rule.EnvVars = [][2]string{
+		{"HTTP_HOST", "localhost:2016"},
+		{"REQUEST_METHOD", "POST"},
+	}
+	envExpected = newEnv()
+	envExpected["HTTP_HOST"] = "localhost:2016"
+	envExpected["REQUEST_METHOD"] = "POST"
+	testBuildEnv(r, rule, fpath, envExpected)
+
+	// 5. Test for environment variable placeholders
+	r = newReq()
+	rule.EnvVars = [][2]string{
+		{"HTTP_HOST", "{host}"},
+		{"CUSTOM_URI", "custom_uri{uri}"},
+		{"CUSTOM_QUERY", "custom=true&{query}"},
+	}
+	envExpected = newEnv()
+	envExpected["HTTP_HOST"] = "localhost:2015"
+	envExpected["CUSTOM_URI"] = "custom_uri/fgci_test.php?test=foobar"
+	envExpected["CUSTOM_QUERY"] = "custom=true&test=foobar"
+	testBuildEnv(r, rule, fpath, envExpected)
+
+	// 6. Test SCRIPT_NAME includes path prefix
+	r = newReq()
+	ctx := context.WithValue(r.Context(), caddy.CtxKey("path_prefix"), "/test")
+	r = r.WithContext(ctx)
+	envExpected = newEnv()
+	envExpected["SCRIPT_NAME"] = "/test/fgci_test.php"
+	testBuildEnv(r, rule, fpath, envExpected)
+}
+
+func TestReadTimeout(t *testing.T) {
+	tests := []struct {
+		sleep       time.Duration
+		readTimeout time.Duration
+		shouldErr   bool
+	}{
+		{75 * time.Millisecond, 50 * time.Millisecond, true},
+		{0, -1 * time.Second, true},
+		{0, time.Minute, false},
+	}
+
+	var wg sync.WaitGroup
+
+	for i, test := range tests {
+		listener, err := net.Listen("tcp", "127.0.0.1:0")
+		if err != nil {
+			t.Fatalf("Test %d: Unable to create listener for test: %v", i, err)
+		}
+		defer listener.Close()
+
+		handler := Handler{
+			Next: nil,
+			Rules: []Rule{
+				{
+					Path:        "/",
+					balancer:    address(listener.Addr().String()),
+					ReadTimeout: test.readTimeout,
+				},
+			},
+		}
+		r, err := http.NewRequest("GET", "/", nil)
+		if err != nil {
+			t.Fatalf("Test %d: Unable to create request: %v", i, err)
+		}
+		w := httptest.NewRecorder()
+
+		wg.Add(1)
+		go fcgi.Serve(listener, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			time.Sleep(test.sleep)
+			w.WriteHeader(http.StatusOK)
+			wg.Done()
+		}))
+
+		got, err := handler.ServeHTTP(w, r)
+		if test.shouldErr {
+			if err == nil {
+				t.Errorf("Test %d: Expected i/o timeout error but had none", i)
+			} else if err, ok := err.(net.Error); !ok || !err.Timeout() {
+				t.Errorf("Test %d: Expected i/o timeout error, got: '%s'", i, err.Error())
+			}
+
+			want := http.StatusGatewayTimeout
+			if got != want {
+				t.Errorf("Test %d: Expected returned status code to be %d, got: %d",
+					i, want, got)
+			}
+		} else if err != nil {
+			t.Errorf("Test %d: Expected nil error, got: %v", i, err)
+		}
+
+		wg.Wait()
+	}
+}
+
+func TestSendTimeout(t *testing.T) {
+	tests := []struct {
+		sendTimeout time.Duration
+		shouldErr   bool
+	}{
+		{-1 * time.Second, true},
+		{time.Minute, false},
+	}
+
+	for i, test := range tests {
+		listener, err := net.Listen("tcp", "127.0.0.1:0")
+		if err != nil {
+			t.Fatalf("Test %d: Unable to create listener for test: %v", i, err)
+		}
+		defer listener.Close()
+
+		handler := Handler{
+			Next: nil,
+			Rules: []Rule{
+				{
+					Path:        "/",
+					balancer:    address(listener.Addr().String()),
+					SendTimeout: test.sendTimeout,
+				},
+			},
+		}
+		r, err := http.NewRequest("GET", "/", nil)
+		if err != nil {
+			t.Fatalf("Test %d: Unable to create request: %v", i, err)
+		}
+		w := httptest.NewRecorder()
+
+		go fcgi.Serve(listener, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.WriteHeader(http.StatusOK)
+		}))
+
+		got, err := handler.ServeHTTP(w, r)
+		if test.shouldErr {
+			if err == nil {
+				t.Errorf("Test %d: Expected i/o timeout error but had none", i)
+			} else if err, ok := err.(net.Error); !ok || !err.Timeout() {
+				t.Errorf("Test %d: Expected i/o timeout error, got: '%s'", i, err.Error())
+			}
+
+			want := http.StatusGatewayTimeout
+			if got != want {
+				t.Errorf("Test %d: Expected returned status code to be %d, got: %d",
+					i, want, got)
+			}
+		} else if err != nil {
+			t.Errorf("Test %d: Expected nil error, got: %v", i, err)
+		}
+	}
+}
+
+func TestBalancer(t *testing.T) {
+	tests := [][]string{
+		{"localhost", "host.local"},
+		{"localhost"},
+		{"localhost", "host.local", "example.com"},
+		{"localhost", "host.local", "example.com", "127.0.0.1"},
+	}
+	for i, test := range tests {
+		b := address(test...)
+		for _, host := range test {
+			a, err := b.Address()
+			if err != nil {
+				t.Errorf("Unexpected error in trying to retrieve address: %s", err.Error())
+			}
+			if a != host {
+				t.Errorf("Test %d: expected %s, found %s", i, host, a)
+			}
+		}
+	}
+}
+
+func address(addresses ...string) balancer {
+	return &roundRobin{
+		addresses: addresses,
+		index:     -1,
+	}
+}

caddyhttp/fastcgi/fcgi_test.php

@@ -0,0 +1,79 @@
+<?php
+
+ini_set("display_errors",1);
+
+echo "resp: start\n";//.print_r($GLOBALS,1)."\n".print_r($_SERVER,1)."\n";
+
+//echo print_r($_SERVER,1)."\n";
+
+$length = 0;
+$stat = "PASSED";
+
+$ret = "[";
+
+if (count($_POST) || count($_FILES)) {
+	foreach($_POST as $key => $val) {
+		$md5 = md5($val);
+		
+		if ($key != $md5) {
+			$stat = "FAILED";
+			echo "server:err ".$md5." != ".$key."\n";
+		}
+		
+		$length += strlen($key) + strlen($val);
+		
+		$ret .= $key."(".strlen($key).") ";
+	}
+	$ret .= "] [";
+	foreach ($_FILES as $k0 => $val) {
+
+		$error = $val["error"];
+		if ($error == UPLOAD_ERR_OK) {
+			$tmp_name = $val["tmp_name"];
+			$name = $val["name"];
+			$datafile = "/tmp/test.go";
+			move_uploaded_file($tmp_name, $datafile);
+			$md5 = md5_file($datafile);
+
+			if ($k0 != $md5) {
+				$stat = "FAILED";
+				echo "server:err ".$md5." != ".$key."\n";
+			}      
+			
+			$length += strlen($k0) + filesize($datafile);
+			
+			unlink($datafile);
+			$ret .= $k0."(".strlen($k0).") ";
+		}
+		else{
+			$stat = "FAILED";
+			echo "server:file err ".file_upload_error_message($error)."\n";
+		}
+	}
+	$ret .= "]";
+	echo "server:got data length " .$length."\n";
+}
+
+
+echo "-{$stat}-POST(".count($_POST).") FILE(".count($_FILES).")\n";
+
+function file_upload_error_message($error_code) {
+	switch ($error_code) { 
+		case UPLOAD_ERR_INI_SIZE: 
+		return 'The uploaded file exceeds the upload_max_filesize directive in php.ini'; 
+		case UPLOAD_ERR_FORM_SIZE: 
+		return 'The uploaded file exceeds the MAX_FILE_SIZE directive that was specified in the HTML form'; 
+		case UPLOAD_ERR_PARTIAL: 
+		return 'The uploaded file was only partially uploaded'; 
+		case UPLOAD_ERR_NO_FILE: 
+		return 'No file was uploaded'; 
+		case UPLOAD_ERR_NO_TMP_DIR: 
+		return 'Missing a temporary folder'; 
+		case UPLOAD_ERR_CANT_WRITE: 
+		return 'Failed to write file to disk'; 
+		case UPLOAD_ERR_EXTENSION: 
+		return 'File upload stopped by extension'; 
+		default: 
+		return 'Unknown upload error'; 
+	} 
+} 

caddyhttp/fastcgi/fcgiclient.go

@@ -1,4 +1,4 @@
-// Copyright 2015 Matthew Holt and The Caddy Authors
+// Copyright 2015 Light Code Labs, LLC
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -13,9 +13,10 @@
 // limitations under the License.
 
 // Forked Jan. 2015 from http://bitbucket.org/PinIdea/fcgi_client
-// (which is forked from https://code.google.com/p/go-fastcgi-client/).
+// (which is forked from https://code.google.com/p/go-fastcgi-client/)
+
 // This fork contains several fixes and improvements by Matt Holt and
-// other contributors to the Caddy project.
+// other contributors to this project.
 
 // Copyright 2012 Junqing Tan <ivan@mysqlab.net> and The Go Authors
 // Use of this source code is governed by a BSD-style
@@ -174,13 +175,15 @@ func (rec *record) read(r io.Reader) (buf []byte, err error) {
 // FCGIClient implements a FastCGI client, which is a standard for
 // interfacing external applications with Web servers.
 type FCGIClient struct {
-	mutex     sync.Mutex
-	rwc       io.ReadWriteCloser
-	h         header
-	buf       bytes.Buffer
-	stderr    bytes.Buffer
-	keepAlive bool
-	reqID     uint16
+	mutex       sync.Mutex
+	rwc         io.ReadWriteCloser
+	h           header
+	buf         bytes.Buffer
+	stderr      bytes.Buffer
+	keepAlive   bool
+	reqID       uint16
+	readTimeout time.Duration
+	sendTimeout time.Duration
 }
 
 // DialWithDialerContext connects to the fcgi responder at the specified network address, using custom net.Dialer
@@ -204,7 +207,6 @@ func DialWithDialerContext(ctx context.Context, network, address string, dialer
 
 // DialContext is like Dial but passes ctx to dialer.Dial.
 func DialContext(ctx context.Context, network, address string) (fcgi *FCGIClient, err error) {
-	// TODO: why not set timeout here?
 	return DialWithDialerContext(ctx, network, address, net.Dialer{})
 }
 
@@ -214,7 +216,7 @@ func Dial(network, address string) (fcgi *FCGIClient, err error) {
 	return DialContext(context.Background(), network, address)
 }
 
-// Close closes fcgi connection
+// Close closes fcgi connnection
 func (c *FCGIClient) Close() {
 	c.rwc.Close()
 }
@@ -242,6 +244,13 @@ func (c *FCGIClient) writeBeginRequest(role uint16, flags uint8) error {
 	return c.writeRecord(BeginRequest, b[:])
 }
 
+func (c *FCGIClient) writeEndRequest(appStatus int, protocolStatus uint8) error {
+	b := make([]byte, 8)
+	binary.BigEndian.PutUint32(b, uint32(appStatus))
+	b[4] = protocolStatus
+	return c.writeRecord(EndRequest, b)
+}
+
 func (c *FCGIClient) writePairs(recType uint8, pairs map[string]string) error {
 	w := newWriter(c, recType)
 	b := make([]byte, 8)
@@ -388,7 +397,7 @@ func (c *FCGIClient) Do(p map[string]string, req io.Reader) (r io.Reader, err er
 
 	body := newWriter(c, Stdin)
 	if req != nil {
-		_, _ = io.Copy(body, req)
+		io.Copy(body, req)
 	}
 	body.Close()
 
@@ -558,9 +567,9 @@ func (c *FCGIClient) SetReadTimeout(t time.Duration) error {
 	return nil
 }
 
-// SetWriteTimeout sets the write timeout for future calls that send data to
+// SetSendTimeout sets the read timeout for future calls that send data to
 // the fcgi responder. A zero value for t means no timeout will be set.
-func (c *FCGIClient) SetWriteTimeout(t time.Duration) error {
+func (c *FCGIClient) SetSendTimeout(t time.Duration) error {
 	if conn, ok := c.rwc.(net.Conn); ok && t != 0 {
 		return conn.SetWriteDeadline(time.Now().Add(t))
 	}

caddyhttp/fastcgi/fcgiclient_test.go

@@ -1,4 +1,4 @@
-// Copyright 2015 Matthew Holt and The Caddy Authors
+// Copyright 2015 Light Code Labs, LLC
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -44,7 +44,7 @@ import (
 // test fcgi protocol includes:
 // Get, Post, Post in multipart/form-data, and Post with files
 // each key should be the md5 of the value or the file uploaded
-// specify remote fcgi responder ip:port to test with php
+// sepicify remote fcgi responer ip:port to test with php
 // test failed if the remote fcgi(script) failed md5 verification
 // and output "FAILED" in response
 const (
@@ -59,9 +59,7 @@ type FastCGIServer struct{}
 
 func (s FastCGIServer) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
 
-	if err := req.ParseMultipartForm(100000000); err != nil {
-		log.Printf("[ERROR] failed to parse: %v", err)
-	}
+	req.ParseMultipartForm(100000000)
 
 	stat := "PASSED"
 	fmt.Fprintln(resp, "-")
@@ -70,15 +68,15 @@ func (s FastCGIServer) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
 		length := 0
 		for k0, v0 := range req.Form {
 			h := md5.New()
-			_, _ = io.WriteString(h, v0[0])
-			_md5 := fmt.Sprintf("%x", h.Sum(nil))
+			io.WriteString(h, v0[0])
+			md5 := fmt.Sprintf("%x", h.Sum(nil))
 
 			length += len(k0)
 			length += len(v0[0])
 
-			// echo error when key != _md5(val)
-			if _md5 != k0 {
-				fmt.Fprintln(resp, "server:err ", _md5, k0)
+			// echo error when key != md5(val)
+			if md5 != k0 {
+				fmt.Fprintln(resp, "server:err ", md5, k0)
 				stat = "FAILED"
 			}
 		}
@@ -199,12 +197,8 @@ func generateRandFile(size int) (p string, m string) {
 	for i := 0; i < size/16; i++ {
 		buf := make([]byte, 16)
 		binary.PutVarint(buf, rand.Int63())
-		if _, err := fo.Write(buf); err != nil {
-			log.Printf("[ERROR] failed to write buffer: %v\n", err)
-		}
-		if _, err := h.Write(buf); err != nil {
-			log.Printf("[ERROR] failed to write buffer: %v\n", err)
-		}
+		fo.Write(buf)
+		h.Write(buf)
 	}
 	m = fmt.Sprintf("%x", h.Sum(nil))
 	return
@@ -220,13 +214,12 @@ func DisabledTest(t *testing.T) {
 	go func() {
 		listener, err := net.Listen("tcp", ipPort)
 		if err != nil {
+			// handle error
 			log.Println("listener creation failed: ", err)
 		}
 
 		srv := new(FastCGIServer)
-		if err := fcgi.Serve(listener, srv); err != nil {
-			log.Print("[ERROR] failed to start server: ", err)
-		}
+		fcgi.Serve(listener, srv)
 	}()
 
 	time.Sleep(1 * time.Second)
@@ -249,9 +242,9 @@ func DisabledTest(t *testing.T) {
 	log.Println("test:", "post data (more than 60KB)")
 	data := ""
 	for i := 0x00; i < 0xff; i++ {
-		v0 := strings.Repeat(fmt.Sprint(i), 256)
+		v0 := strings.Repeat(string(i), 256)
 		h := md5.New()
-		_, _ = io.WriteString(h, v0)
+		io.WriteString(h, v0)
 		k0 := fmt.Sprintf("%x", h.Sum(nil))
 		data += k0 + "=" + url.QueryEscape(v0) + "&"
 	}
@@ -266,9 +259,9 @@ func DisabledTest(t *testing.T) {
 	log.Println("test:", "post forms (256 keys, more than 1MB)")
 	p1 := make(map[string]string, 1)
 	for i := 0x00; i < 0xff; i++ {
-		v0 := strings.Repeat(fmt.Sprint(i), 4096)
+		v0 := strings.Repeat(string(i), 4096)
 		h := md5.New()
-		_, _ = io.WriteString(h, v0)
+		io.WriteString(h, v0)
 		k0 := fmt.Sprintf("%x", h.Sum(nil))
 		p1[k0] = v0
 	}
@@ -292,10 +285,6 @@ func DisabledTest(t *testing.T) {
 	delete(f0, "m0")
 	sendFcgi(1, fcgiParams, nil, nil, f0)
 
-	if err := os.Remove(path0); err != nil {
-		log.Println("[ERROR] failed to remove path: ", err)
-	}
-	if err := os.Remove(path1); err != nil {
-		log.Println("[ERROR] failed to remove path: ", err)
-	}
+	os.Remove(path0)
+	os.Remove(path1)
 }

caddyhttp/fastcgi/setup.go

@@ -0,0 +1,215 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// 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
+
+import (
+	"errors"
+	"fmt"
+	"net"
+	"net/http"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/mholt/caddy"
+	"github.com/mholt/caddy/caddyhttp/httpserver"
+)
+
+func init() {
+	caddy.RegisterPlugin("fastcgi", caddy.Plugin{
+		ServerType: "http",
+		Action:     setup,
+	})
+}
+
+// setup configures a new FastCGI middleware instance.
+func setup(c *caddy.Controller) error {
+	cfg := httpserver.GetConfig(c)
+
+	rules, err := fastcgiParse(c)
+	if err != nil {
+		return err
+	}
+
+	cfg.AddMiddleware(func(next httpserver.Handler) httpserver.Handler {
+		return Handler{
+			Next:            next,
+			Rules:           rules,
+			Root:            cfg.Root,
+			FileSys:         http.Dir(cfg.Root),
+			SoftwareName:    caddy.AppName,
+			SoftwareVersion: caddy.AppVersion,
+			ServerName:      cfg.Addr.Host,
+			ServerPort:      cfg.Addr.Port,
+		}
+	})
+
+	return nil
+}
+
+func fastcgiParse(c *caddy.Controller) ([]Rule, error) {
+	var rules []Rule
+
+	cfg := httpserver.GetConfig(c)
+	absRoot, err := filepath.Abs(cfg.Root)
+	if err != nil {
+		return nil, err
+	}
+
+	for c.Next() {
+		args := c.RemainingArgs()
+
+		if len(args) < 2 || len(args) > 3 {
+			return rules, c.ArgErr()
+		}
+
+		rule := Rule{
+			Root: absRoot,
+			Path: args[0],
+		}
+
+		upstreams := []string{args[1]}
+
+		srvUpstream := false
+		if strings.HasPrefix(upstreams[0], "srv://") {
+			srvUpstream = true
+		}
+
+		if len(args) == 3 {
+			if err := fastcgiPreset(args[2], &rule); err != nil {
+				return rules, err
+			}
+		}
+
+		var err error
+
+		for c.NextBlock() {
+			switch c.Val() {
+			case "root":
+				if !c.NextArg() {
+					return rules, c.ArgErr()
+				}
+				rule.Root = 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":
+				args := c.RemainingArgs()
+				if len(args) == 0 {
+					return rules, c.ArgErr()
+				}
+				rule.IndexFiles = args
+
+			case "upstream":
+				if srvUpstream {
+					return rules, c.Err("additional upstreams are not supported with SRV upstream")
+				}
+
+				args := c.RemainingArgs()
+
+				if len(args) != 1 {
+					return rules, c.ArgErr()
+				}
+
+				upstreams = append(upstreams, args[0])
+			case "env":
+				envArgs := c.RemainingArgs()
+				if len(envArgs) < 2 {
+					return rules, c.ArgErr()
+				}
+				rule.EnvVars = append(rule.EnvVars, [2]string{envArgs[0], envArgs[1]})
+			case "except":
+				ignoredPaths := c.RemainingArgs()
+				if len(ignoredPaths) == 0 {
+					return rules, c.ArgErr()
+				}
+				rule.IgnoredSubPaths = ignoredPaths
+
+			case "connect_timeout":
+				if !c.NextArg() {
+					return rules, c.ArgErr()
+				}
+				rule.ConnectTimeout, err = time.ParseDuration(c.Val())
+				if err != nil {
+					return rules, err
+				}
+			case "read_timeout":
+				if !c.NextArg() {
+					return rules, c.ArgErr()
+				}
+				readTimeout, err := time.ParseDuration(c.Val())
+				if err != nil {
+					return rules, err
+				}
+				rule.ReadTimeout = readTimeout
+			case "send_timeout":
+				if !c.NextArg() {
+					return rules, c.ArgErr()
+				}
+				sendTimeout, err := time.ParseDuration(c.Val())
+				if err != nil {
+					return rules, err
+				}
+				rule.SendTimeout = sendTimeout
+			}
+		}
+
+		if srvUpstream {
+			balancer, err := parseSRV(upstreams[0])
+			if err != nil {
+				return rules, c.Err("malformed service locator string: " + err.Error())
+			}
+			rule.balancer = balancer
+		} else {
+			rule.balancer = &roundRobin{addresses: upstreams, index: -1}
+		}
+
+		rules = append(rules, rule)
+	}
+	return rules, nil
+}
+
+func parseSRV(locator string) (*srv, error) {
+	if locator[6:] == "" {
+		return nil, fmt.Errorf("%s does not include the host", locator)
+	}
+
+	return &srv{
+		service:  locator[6:],
+		resolver: &net.Resolver{},
+	}, nil
+}
+
+// fastcgiPreset configures rule according to name. It returns an error if
+// name is not a recognized preset name.
+func fastcgiPreset(name string, rule *Rule) error {
+	switch name {
+	case "php":
+		rule.Ext = ".php"
+		rule.SplitPath = ".php"
+		rule.IndexFiles = []string{"index.php"}
+	default:
+		return errors.New(name + " is not a valid preset name")
+	}
+	return nil
+}

caddyhttp/fastcgi/setup_test.go

@@ -0,0 +1,224 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// 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
+
+import (
+	"context"
+	"fmt"
+	"net"
+	"testing"
+
+	"github.com/mholt/caddy"
+	"github.com/mholt/caddy/caddyhttp/httpserver"
+)
+
+func TestSetup(t *testing.T) {
+	c := caddy.NewTestController("http", `fastcgi / 127.0.0.1:9000`)
+	err := setup(c)
+	if err != nil {
+		t.Errorf("Expected no errors, got: %v", err)
+	}
+	mids := httpserver.GetConfig(c).Middleware()
+	if len(mids) == 0 {
+		t.Fatal("Expected middleware, got 0 instead")
+	}
+
+	handler := mids[0](httpserver.EmptyNext)
+	myHandler, ok := handler.(Handler)
+
+	if !ok {
+		t.Fatalf("Expected handler to be type , got: %#v", handler)
+	}
+
+	if myHandler.Rules[0].Path != "/" {
+		t.Errorf("Expected / as the Path")
+	}
+	addr, err := myHandler.Rules[0].Address()
+	if err != nil {
+		t.Errorf("Unexpected error in trying to retrieve address: %s", err.Error())
+	}
+
+	if addr != "127.0.0.1:9000" {
+		t.Errorf("Expected 127.0.0.1:9000 as the Address")
+	}
+}
+
+func TestFastcgiParse(t *testing.T) {
+	tests := []struct {
+		inputFastcgiConfig    string
+		shouldErr             bool
+		expectedFastcgiConfig []Rule
+	}{
+
+		{`fastcgi /blog 127.0.0.1:9000 php`,
+			false, []Rule{{
+				Path:       "/blog",
+				balancer:   &roundRobin{addresses: []string{"127.0.0.1:9000"}},
+				Ext:        ".php",
+				SplitPath:  ".php",
+				IndexFiles: []string{"index.php"},
+			}}},
+		{`fastcgi / 127.0.0.1:9001 {
+	              split .html
+	              }`,
+			false, []Rule{{
+				Path:       "/",
+				balancer:   &roundRobin{addresses: []string{"127.0.0.1:9001"}},
+				Ext:        "",
+				SplitPath:  ".html",
+				IndexFiles: []string{},
+			}}},
+		{`fastcgi / 127.0.0.1:9001 {
+	              split .html
+	              except /admin /user
+	              }`,
+			false, []Rule{{
+				Path:            "/",
+				balancer:        &roundRobin{addresses: []string{"127.0.0.1:9001"}},
+				Ext:             "",
+				SplitPath:       ".html",
+				IndexFiles:      []string{},
+				IgnoredSubPaths: []string{"/admin", "/user"},
+			}}},
+	}
+	for i, test := range tests {
+		actualFastcgiConfigs, err := fastcgiParse(caddy.NewTestController("http", test.inputFastcgiConfig))
+
+		if err == nil && test.shouldErr {
+			t.Errorf("Test %d didn't error, but it should have", i)
+		} else if err != nil && !test.shouldErr {
+			t.Errorf("Test %d errored, but it shouldn't have; got '%v'", i, err)
+		}
+		if len(actualFastcgiConfigs) != len(test.expectedFastcgiConfig) {
+			t.Fatalf("Test %d expected %d no of FastCGI configs, but got %d ",
+				i, len(test.expectedFastcgiConfig), len(actualFastcgiConfigs))
+		}
+		for j, actualFastcgiConfig := range actualFastcgiConfigs {
+
+			if actualFastcgiConfig.Path != test.expectedFastcgiConfig[j].Path {
+				t.Errorf("Test %d expected %dth FastCGI Path to be  %s  , but got %s",
+					i, j, test.expectedFastcgiConfig[j].Path, actualFastcgiConfig.Path)
+			}
+
+			actualAddr, err := actualFastcgiConfig.Address()
+			if err != nil {
+				t.Errorf("Test %d unexpected error in trying to retrieve %dth actual address: %s", i, j, err.Error())
+			}
+
+			expectedAddr, err := test.expectedFastcgiConfig[j].Address()
+			if err != nil {
+				t.Errorf("Test %d unexpected error in trying to retrieve %dth expected address: %s", i, j, err.Error())
+			}
+
+			if actualAddr != expectedAddr {
+				t.Errorf("Test %d expected %dth FastCGI Address to be  %s  , but got %s",
+					i, j, expectedAddr, actualAddr)
+			}
+
+			if actualFastcgiConfig.Ext != test.expectedFastcgiConfig[j].Ext {
+				t.Errorf("Test %d expected %dth FastCGI Ext to be  %s  , but got %s",
+					i, j, test.expectedFastcgiConfig[j].Ext, actualFastcgiConfig.Ext)
+			}
+
+			if actualFastcgiConfig.SplitPath != test.expectedFastcgiConfig[j].SplitPath {
+				t.Errorf("Test %d expected %dth FastCGI SplitPath to be  %s  , but got %s",
+					i, j, test.expectedFastcgiConfig[j].SplitPath, actualFastcgiConfig.SplitPath)
+			}
+
+			if fmt.Sprint(actualFastcgiConfig.IndexFiles) != fmt.Sprint(test.expectedFastcgiConfig[j].IndexFiles) {
+				t.Errorf("Test %d expected %dth FastCGI IndexFiles to be  %s  , but got %s",
+					i, j, test.expectedFastcgiConfig[j].IndexFiles, actualFastcgiConfig.IndexFiles)
+			}
+
+			if fmt.Sprint(actualFastcgiConfig.IgnoredSubPaths) != fmt.Sprint(test.expectedFastcgiConfig[j].IgnoredSubPaths) {
+				t.Errorf("Test %d expected %dth FastCGI IgnoredSubPaths to be  %s  , but got %s",
+					i, j, test.expectedFastcgiConfig[j].IgnoredSubPaths, actualFastcgiConfig.IgnoredSubPaths)
+			}
+		}
+	}
+
+}
+
+func TestFastCGIResolveSRV(t *testing.T) {
+	tests := []struct {
+		inputFastcgiConfig string
+		locator            string
+		target             string
+		port               uint16
+		shouldErr          bool
+	}{
+		{
+			`fastcgi / srv://fpm.tcp.service.consul {
+				upstream yolo
+			}`,
+			"fpm.tcp.service.consul",
+			"127.0.0.1",
+			9000,
+			true,
+		},
+		{
+			`fastcgi / srv://fpm.tcp.service.consul`,
+			"fpm.tcp.service.consul",
+			"127.0.0.1",
+			9000,
+			false,
+		},
+	}
+
+	for i, test := range tests {
+		actualFastcgiConfigs, err := fastcgiParse(caddy.NewTestController("http", test.inputFastcgiConfig))
+
+		if err == nil && test.shouldErr {
+			t.Errorf("Test %d didn't error, but it should have", i)
+		} else if err != nil && !test.shouldErr {
+			t.Errorf("Test %d errored, but it shouldn't have; got '%v'", i, err)
+		}
+
+		for _, actualFastcgiConfig := range actualFastcgiConfigs {
+			resolver, ok := (actualFastcgiConfig.balancer).(*srv)
+			if !ok {
+				t.Errorf("Test %d upstream balancer is not srv", i)
+			}
+			resolver.resolver = buildTestResolver(test.target, test.port)
+
+			addr, err := actualFastcgiConfig.Address()
+			if err != nil {
+				t.Errorf("Test %d failed to retrieve upstream address. %s", i, err.Error())
+			}
+
+			expectedAddr := fmt.Sprintf("%s:%d", test.target, test.port)
+			if addr != expectedAddr {
+				t.Errorf("Test %d expected upstream address to be %s, got %s", i, expectedAddr, addr)
+			}
+		}
+	}
+}
+
+func buildTestResolver(target string, port uint16) srvResolver {
+	return &testSRVResolver{target, port}
+}
+
+type testSRVResolver struct {
+	target string
+	port   uint16
+}
+
+func (r *testSRVResolver) LookupSRV(ctx context.Context, service, proto, name string) (string, []*net.SRV, error) {
+	return "", []*net.SRV{
+		{Target: r.target,
+			Port:     r.port,
+			Priority: 1,
+			Weight:   1}}, nil
+}