readme: So much more ... what? Fixed cliffhanger

* chore: ci: fixing the step name that captures the pushed tag

* chrore: ci: exclude commits prefixed with `ci:` from changelog

.gitattributes

@@ -1,14 +0,0 @@
-# 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/workflows/ci.yml

@@ -0,0 +1,126 @@
+# Used as inspiration: https://github.com/mvdan/github-actions-golang
+
+name: Cross-Platform
+
+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-version: [ 1.14.x ]
+
+        # 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@v1
+      with:
+        go-version: ${{ matrix.go-version }}
+
+    - 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)"
+
+    - 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 -a -ldflags="-w -s" -v
+
+    - name: Publish Build Artifact
+      uses: actions/upload-artifact@v1
+      with:
+        name: caddy_v2_${{ runner.os }}_${{ 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
+
+  # From https://github.com/reviewdog/action-golangci-lint
+  golangci-lint:
+    name: runner / golangci-lint
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code into the Go module directory
+        uses: actions/checkout@v2
+
+      - name: Run golangci-lint
+        uses: reviewdog/action-golangci-lint@v1
+        # uses: docker://reviewdog/action-golangci-lint:v1 # pre-build docker image
+        with:
+          github_token: ${{ secrets.github_token }}

.github/workflows/fuzzing.yml

@@ -0,0 +1,75 @@
+name: Fuzzing
+
+on:
+  # Daily midnight fuzzing
+  schedule:
+    - cron: '0 0 * * *'
+
+jobs:
+  fuzzing:
+    name: Fuzzing
+
+    strategy:
+      matrix:
+        os: [ ubuntu-latest ]
+        go-version: [ 1.14.x ]
+    runs-on: ${{ matrix.os }}
+
+    steps:
+    - name: Install Go
+      uses: actions/setup-go@v1
+      with:
+        go-version: ${{ matrix.go-version }}
+
+    - name: Checkout code
+      uses: actions/checkout@v2
+
+    - name: Download go-fuzz tools and the Fuzzit CLI, move Fuzzit CLI to GOBIN
+      # If we decide we need to prevent this from running on forks, we can use this line:
+      # if: github.repository == 'caddyserver/caddy'
+      run: |
+
+        go get -v github.com/dvyukov/go-fuzz/go-fuzz github.com/dvyukov/go-fuzz/go-fuzz-build
+        wget -q -O fuzzit https://github.com/fuzzitdev/fuzzit/releases/download/v2.4.77/fuzzit_Linux_x86_64
+        chmod a+x fuzzit
+        mv fuzzit $(go env GOPATH)/bin
+        echo "::add-path::$(go env GOPATH)/bin"
+
+    - name: Generate fuzzers & submit them to Fuzzit
+      continue-on-error: true
+      env:
+        FUZZIT_API_KEY: ${{ secrets.FUZZIT_API_KEY }}
+        SYSTEM_PULLREQUEST_SOURCEBRANCH: ${{ github.ref }}
+        BUILD_SOURCEVERSION: ${{ github.sha }}
+      run: |
+        # debug
+        echo "PR Source Branch: $SYSTEM_PULLREQUEST_SOURCEBRANCH"
+        echo "Source version: $BUILD_SOURCEVERSION"
+
+        declare -A fuzzers_funcs=(\
+          ["./caddyconfig/httpcaddyfile/addresses_fuzz.go"]="FuzzParseAddress" \
+          ["./caddyconfig/caddyfile/parse_fuzz.go"]="FuzzParseCaddyfile" \
+          ["./listeners_fuzz.go"]="FuzzParseNetworkAddress" \
+          ["./replacer_fuzz.go"]="FuzzReplacer" \
+        )
+
+        declare -A fuzzers_targets=(\
+          ["./caddyconfig/httpcaddyfile/addresses_fuzz.go"]="parse-address" \
+          ["./caddyconfig/caddyfile/parse_fuzz.go"]="parse-caddyfile" \
+          ["./listeners_fuzz.go"]="parse-network-address" \
+          ["./replacer_fuzz.go"]="replacer" \
+        )
+
+        fuzz_type="fuzzing"
+
+        for f in $(find . -name \*_fuzz.go); do
+          FUZZER_DIRECTORY=$(dirname "$f")
+          
+          echo "go-fuzz-build func ${fuzzers_funcs[$f]} residing in $f"
+          
+          go-fuzz-build -func "${fuzzers_funcs[$f]}" -o "$FUZZER_DIRECTORY/${fuzzers_targets[$f]}.zip" "$FUZZER_DIRECTORY"
+          
+          fuzzit create job --engine go-fuzz caddyserver/"${fuzzers_targets[$f]}" "$FUZZER_DIRECTORY"/"${fuzzers_targets[$f]}.zip" --api-key "${FUZZIT_API_KEY}" --type "${fuzz_type}" --branch "${SYSTEM_PULLREQUEST_SOURCEBRANCH}" --revision "${BUILD_SOURCEVERSION}"
+          
+          echo "Completed $f"
+        done

.github/workflows/release.yml

@@ -0,0 +1,53 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - 'v*.*.*'
+
+jobs:
+  release:
+    name: Release
+    strategy:
+      matrix:
+        os: [ ubuntu-latest ]
+        go-version: [ 1.14.x ]
+    runs-on: ${{ matrix.os }}
+
+    steps:
+    - name: Install Go
+      uses: actions/setup-go@v1
+      with:
+        go-version: ${{ matrix.go-version }}
+
+    - name: Checkout code
+      uses: actions/checkout@v2
+
+    # So GoReleaser can generate the changelog properly
+    - name: Unshallowify the repo clone
+      run: git fetch --prune --unshallow
+
+    - 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
+    
+    # https://github.community/t5/GitHub-Actions/How-to-get-just-the-tag-name/m-p/32167/highlight/true#M1027
+    - name: Get the version
+      id: get_version
+      run: echo "::set-output name=version_tag::${GITHUB_REF/refs\/tags\//}"
+
+    # GoReleaser will take care of publishing those artifacts into the release
+    - name: Run GoReleaser
+      uses: goreleaser/goreleaser-action@v1
+      with:
+        version: latest
+        args: release --rm-dist
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        TAG: ${{ steps.get_version.outputs.version_tag }}

.gitignore

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

.golangci.yml

@@ -0,0 +1,49 @@
+linters-settings:
+  errcheck:
+    ignore: fmt:.*,io/ioutil:^Read.*,github.com/caddyserver/caddy/v2/caddyconfig:RegisterAdapter,github.com/caddyserver/caddy/v2:RegisterModule
+    ignoretests: true
+  misspell:
+    locale: US
+
+linters:
+  enable:
+    - bodyclose
+    - errcheck
+    - gofmt
+    - goimports
+    - gosec
+    - ineffassign
+    - misspell
+
+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

@@ -0,0 +1,67 @@
+before:
+  hooks:
+    - 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
+  - 386
+  - arm
+  - arm64
+  goarm:
+  - 6
+  - 7
+  ignore:
+    - goos: darwin
+      goarch: 386
+    - goos: darwin
+      goarch: arm
+  flags:
+  - -trimpath
+  ldflags:
+  - -s -w
+archives:
+  - format_overrides:
+      - goos: windows
+        format: zip
+    replacements:
+      darwin: macOS
+      linux: Linux
+      windows: Windows
+      386: i386
+      amd64: x86_64
+checksum:
+  algorithm: sha512
+release:
+  github:
+    owner: caddyserver
+    name: caddy
+  draft: true
+  prerelease: auto
+changelog:
+  sort: asc
+  filters:
+    exclude:
+    - '^ci:'
+    - '^docs:'
+    - '^test:'
+    - '^chore:'
+    - '^\w+\s+' # a hack to remove commit messages without colons thus don't correspond to a package

.travis.yml

@@ -1,33 +0,0 @@
-language: go
-
-go:
-  - 1.6.3
-  - 1.7.1
-  - 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/gordonklaus/ineffassign
-
-script:
-  - diff <(echo -n) <(gofmt -s -d .)
-  - ineffassign .
-  - go vet ./...
-  - go test -race ./...
-
-after_script:
-  - golint ./...

AUTHORS

@@ -0,0 +1,10 @@
+# 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>

CONTRIBUTING.md

@@ -1,115 +0,0 @@
-## Contributing to Caddy
-
-Welcome! Our community focuses on helping others and making Caddy the best it
-can be. We gladly accept contributions and encourage you to get involved!
-
-
-### Join us in the forum
-
-The [Caddy forum](https://forum.caddyserver.com) is the place for all discussion
-that doesn't belong in issues or pull requests. Feel free to participate with us!
-
-If you want to file a bug report or make an improvement to Caddy, however, you
-should submit an issue or pull request.
-
-
-### Bug reports
-
-Please [search this repository](https://github.com/mholt/caddy/search?q=&type=Issues&utf8=%E2%9C%93)
-with a variety of keywords to ensure your bug is not already reported.
-
-If unique, [open an issue](https://github.com/mholt/caddy/issues) and answer the
-questions so we can understand and reproduce the problematic behavior.
-
-The burden is on you to convince us that it is actually a bug in Caddy. This is
-easiest to do when you write clear, concise instructions so we can reproduce
-the behavior (even if it seems obvious). The more detailed and specific you are,
-the faster we will be able to help you. Check out
-[How to Report Bugs Effectively](http://www.chiark.greenend.org.uk/~sgtatham/bugs.html).
-
-Please be kind. :smile: Remember that Caddy comes at no cost to you, and you're
-getting free help. If we helped you, please consider
-[donating](https://caddyserver.com/donate) - it keeps us motivated!
-
-
-### Minor improvements and new tests
-
-Submit [pull requests](https://github.com/mholt/caddy/pulls) at any time for
-minor changes or new tests. Make sure to write tests to assert your change is
-working properly and is thoroughly covered. We'll ask most pull requests to be
-[squashed](http://gitready.com/advanced/2009/02/10/squashing-commits-with-rebase.html),
-especially with small commits.
-
-Your pull request may be thoroughly reviewed. This is because if we accept the
-PR, we also assume responsibility for it, although we would prefer you to
-help maintain your code after it gets merged. 
-
-
-### Proposals, suggestions, ideas, new features
-
-First, please [search](https://github.com/mholt/caddy/search?q=&type=Issues&utf8=%E2%9C%93)
-with a variety of keywords to ensure your suggestion/proposal is new.
-
-If so, you may open either an issue or a pull request for discussion and
-feedback.
-
-The advantage of issues is that you don't have to spend time implementing your
-idea, but you should still describe it thoroughly as if someone reading it would
-implement the whole thing starting from scratch.
-
-The advantage of pull requests is that we can immediately see the impact the
-change will have on the project, what the code will look like, and how to
-improve it. The disadvantage of pull requests is that they are unlikely to get
-accepted without significant changes first, or it may be rejected entirely.
-Don't worry, that won't happen without an open discussion first.
-
-If you are going to spend significant time writing code for a new pull request,
-best to open an issue to "claim" it and get feedback before you invest a lot of
-time. Not all pull requests are merged, and that's okay.
-[Read why.](https://github.com/turbolinks/turbolinks/pull/124#issuecomment-239826060)
-
-Remember: pull requests should always be thoroughly documented both via godoc
-and with at least a rough draft of documentation that might go on the website
-for users to read.
-
-
-### Collaborator status
-
-If your pull request is merged, congratulations! You're technically a
-collaborator. We may also grant you "Collaborator status" which means you can
-push to the repository and merge other pull requests. We hope that you will
-stay involved by reviewing pull requests, submitting more of your own, and
-resolving issues as you are able to. Thanks for making Caddy amazing!
-
-We ask that collaborators will conduct thorough code reviews and be nice to
-new contributors. Before merging a PR, it's best to get the approval of
-at least one or two other collaborators and/or the project owner. We prefer
-squashed commits instead of many little, semantically-unimportant commits. Also,
-CI and other post-commit hooks must pass before being merged except in certain
-unusual circumstances.
-
-Collaborator status may be removed for inactive users from time to time as
-we see fit; this is not an insult, just a basic security precaution in case
-the account becomes inactive or abandoned. Privileges can always be restored
-later.
-
-**Reviewing pull requests:** Please help submit and review pull requests as
-you are able! We would ask that every pull request be reviewed by at least
-one collaborator who did not open the pull request before merging. This will
-help ensure high code quality as new collaborators are added to the project.
-
-Read [CodeReviewComments](https://github.com/golang/go/wiki/CodeReviewComments)
-on the Go wiki for an idea of what we look for in good, clean Go code.
-
-
-
-### Vulnerabilities
-
-If you've found a vulnerability that is serious, please email me: Matthew dot 
-Holt at Gmail. If it's not a big deal, a pull request will probably be faster.
-
-
-## Thank you
-
-Thanks for your help! Caddy would not be what it is today without your
-contributions.

ISSUE_TEMPLATE

@@ -1,24 +0,0 @@
-(Are you asking for help with using Caddy? Please use our forum instead: https://forum.caddyserver.com. If you are filing a bug report, please answer the following questions. If your issue is not a bug report, you do not need to use this template. Either way, please consider donating if we've helped you. Thanks!)
-
-### 1. What version of Caddy are you running (`caddy -version`)?
-
-
-### 2. What are you trying to do?
-
-
-### 3. What is your entire Caddyfile?
-```text
-(Put Caddyfile here)
-```
-
-### 4. How did you run Caddy (give the full command and describe the execution environment)?
-
-
-### 5. What did you expect to see?
-
-
-### 6. What did you see instead (give full error messages and/or log)?
-
-
-### 7. How can someone who is starting from scratch reproduce this behavior as minimally as possible?
-

LICENSE

@@ -1,3 +1,4 @@
+
                                  Apache License
                            Version 2.0, January 2004
                         http://www.apache.org/licenses/
@@ -178,7 +179,7 @@
    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 "{}"
+      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
@@ -186,7 +187,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright {yyyy} {name of copyright owner}
+   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.

README.md

@@ -1,160 +1,152 @@
-<a href="https://caddyserver.com"><img src="https://caddyserver.com/resources/images/caddy-lower.png" alt="Caddy" width="350"></a>
-
-[![community](https://img.shields.io/badge/community-forum-ff69b4.svg?style=flat-square)](https://forum.caddyserver.com) [![twitter](https://img.shields.io/badge/twitter-@caddyserver-55acee.svg?style=flat-square)](https://twitter.com/caddyserver) [![Documentation](https://img.shields.io/badge/godoc-reference-blue.svg?style=flat-square)](https://godoc.org/github.com/mholt/caddy) [![Linux Build Status](https://img.shields.io/travis/mholt/caddy.svg?style=flat-square&label=linux+build)](https://travis-ci.org/mholt/caddy) [![Windows Build Status](https://img.shields.io/appveyor/ci/mholt/caddy.svg?style=flat-square&label=windows+build)](https://ci.appveyor.com/project/mholt/caddy)
-
-Caddy is a general-purpose web server for Windows, Mac, Linux, BSD, and
-[Android](https://github.com/mholt/caddy/wiki/Running-Caddy-on-Android). It is
-a capable but easier alternative to other popular web servers.
-
-[Releases](https://github.com/mholt/caddy/releases) ·
-[User Guide](https://caddyserver.com/docs) ·
-[Community](https://forum.caddyserver.com)
+<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>
+</p>
+<h3 align="center">Every site on HTTPS</h3>
+<p align="center">Caddy is an extensible server platform that uses TLS 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-blue.svg"></a>
+	<a href="https://app.fuzzit.dev/orgs/caddyserver-gh/dashboard"><img src="https://app.fuzzit.dev/badge?org_id=caddyserver-gh"></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>
+</p>
+<p align="center">
+	<a href="https://github.com/caddyserver/caddy/releases">Download</a> ·
+	<a href="https://caddyserver.com/docs/">Documentation</a> ·
+	<a href="https://caddy.community">Community</a>
+</p>
 
 
-## Menu
+
+### Menu
 
 - [Features](#features)
-- [Quick Start](#quick-start)
-- [Running from Source](#running-from-source)
-- [Running in Production](#running-in-production)
-- [Contributing](#contributing)
-- [About the Project](#about-the-project)
+- [Build from source](#build-from-source)
+	- [For development](#for-development)
+	- [With version information and/or plugins](#with-version-information-andor-plugins)
+- [Getting started](#getting-started)
+- [Overview](#overview)
+- [Full documentation](#full-documentation)
+- [Getting help](#getting-help)
+- [About](#about)
 
+<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
 
-- **Easy configuration** with Caddyfile
-- **Automatic HTTPS** via [Let's Encrypt](https://letsencrypt.org); Caddy
-obtains and manages all cryptographic assets for you
-- **HTTP/2** enabled by default (powered by Go standard library)
-- **Virtual hosting** for hundreds of sites per server instance, including TLS
-SNI
-- Experimental **QUIC support** for those that like speed
-- TLS session ticket **key rotation** for more secure connections
-- **Brilliant extensibility** so Caddy can be customized for your needs
+- **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/api)
+- [**Config adapters**](https://caddyserver.com/docs/config-adapters) if you don't like JSON
+- **Automatic HTTPS** by default
+	- [Let's Encrypt](https://letsencrypt.org) for public sites
+	- Fully-managed local CA for internal names & IPs
+	- Can coordinate with other Caddy instances in a cluster
+- **Stays up when other servers go down** due to TLS/OCSP/certificate-related issues
+- **HTTP/1.1, HTTP/2, and experimental HTTP/3** support
+- **Highly extensible** [modular architecture](https://caddyserver.com/docs/extending-caddy) lets Caddy do anything without bloat
 - **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
 
 
 
-## Quick Start
+## Build from source
 
-Caddy binaries have no dependencies and are available for every platform.
-Install Caddy any one of these ways:
+Requirements:
 
-- **[Download page](https://caddyserver.com/download)** allows you to
-customize your build in the browser
-- **[Latest release](https://github.com/mholt/caddy/releases/latest)** for
-pre-built binaries
-- **curl [getcaddy.com](https://getcaddy.com)** for auto install:
-`curl https://getcaddy.com | bash`
+- [Go 1.14 or newer](https://golang.org/dl/)
+- Do NOT disable [Go modules](https://github.com/golang/go/wiki/Modules) (`export GO111MODULE=on`)
 
-Once `caddy` is in your PATH, you can `cd` to your website's folder and run
-`caddy` to serve it. By default, Caddy serves the current directory at
-[localhost:2015](http://localhost:2015).
-
-To customize how your site is served, create a file named Caddyfile by your
-site and paste this into it:
-
-```plain
-localhost
-
-gzip
-browse
-websocket /echo cat
-ext    .html
-log    /var/log/access.log
-proxy  /api 127.0.0.1:7005
-header /api Access-Control-Allow-Origin *
+### For development
+ 
+```bash
+$ git clone "https://github.com/caddyserver/caddy.git"
+$ cd caddy/cmd/caddy/
+$ go build
 ```
 
-When you run `caddy` in that directory, it will automatically find and use
-that Caddyfile to configure itself.
+_**Note:** These steps [will not embed proper version information](https://github.com/golang/go/issues/29228). For that, please follow the instructions below._
 
-This simple file enables compression, allows directory browsing (for folders
-without an index file), hosts a WebSocket echo server at /echo, serves clean
-URLs, logs requests to 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.
+### With version information and/or plugins
 
-Wow! Caddy can do a lot with just a few lines.
+Using [our builder tool](https://github.com/caddyserver/xcaddy)...
 
-To host multiple sites and do more with the Caddyfile, please see the
-[Caddyfile documentation](https://caddyserver.com/docs/caddyfile).
+```
+$ xcaddy --version CADDY_VERSION
+```
 
-Note that production sites are served over
-[HTTPS by default](https://caddyserver.com/docs/automatic-https).
+...the following steps are automated:
 
-Caddy has a command line interface. Run `caddy -h` to view basic help or see
-the [CLI documentation](https://caddyserver.com/docs/cli) for details.
-
-**Running as root:** We advise against this. You can still listen on ports
-< 1024 using setcap like so: `sudo setcap cap_net_bind_service=+ep ./caddy`
+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. Pin Caddy version: `go get github.com/caddyserver/caddy/v2@TAG` replacing `TAG` with a git tag or commit. You can also pin any plugin versions similarly.
+6. Compile: `go build`
 
 
 
-## Running from Source
 
-Note: You will need **[Go 1.6](https://golang.org/dl/)** or newer.
+## Quick start
 
-1. `go get github.com/mholt/caddy/caddy`
-2. `cd` into your website's directory
-3. Run `caddy` (assuming `$GOPATH/bin` is in your `$PATH`)
+The [Caddy website](https://caddyserver.com/docs/) has documentation that includes tutorials, quick-start guides, reference, and more.
 
-Caddy's `main()` is in the caddy subfolder. To recompile Caddy, use
-`build.bash` found in that folder.
+**We recommend that all users do our [Getting Started](https://caddyserver.com/docs/getting-started) guide to become familiar with using Caddy.**
+
+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. 🙂
 
 
 
-## Running in Production
 
-The Caddy project does not officially maintain any system-specific
-integrations, 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.
+## Overview
 
-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.
+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 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.
+
+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 the [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
 
 
 
-## Contributing
+## Getting help
 
-**[Join our community](https://forum.caddyserver.com) where you can chat with
-other Caddy users and developers!**
+- 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.
 
-Please see our [contributing guidelines](https://github.com/mholt/caddy/blob/master/CONTRIBUTING.md)
-and check out the [developer wiki](https://github.com/mholt/caddy/wiki).
+- 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!
 
-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://forum.caddyserver.com)!
-
-If you want to contribute to the documentation, please submit pull requests to [caddyserver/caddyserver.com](https://github.com/caddyserver/caddyserver.com).
-
-Thanks for making Caddy -- and the Web -- better!
-
-Special thanks to
-[![DigitalOcean](https://i.imgur.com/sfGr0eY.png)](https://www.digitalocean.com)
-for hosting the Caddy project.
+Please use our [issue tracker](/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 Project
+## About
 
-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.
+**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 Light Code Labs, LLC.
 
-**The name "Caddy":** 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).
-
-*Author on Twitter: [@mholt6](https://twitter.com/mholt6)*
+- _Project on Twitter: [@caddyserver](https://twitter.com/caddyserver)_
+- _Author on Twitter: [@mholt6](https://twitter.com/mholt6)_

admin.go

@@ -0,0 +1,792 @@
+// 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"
+	"expvar"
+	"fmt"
+	"io"
+	"net/http"
+	"net/http/pprof"
+	"net/url"
+	"os"
+	"path"
+	"regexp"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"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 for API requests. Only used 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() (string, string, error) {
+	input := admin.Listen
+	if input == "" {
+		input = DefaultAdminListen
+	}
+	listenAddr, err := ParseNetworkAddress(input)
+	if err != nil {
+		return "", "", fmt.Errorf("parsing admin listener address: %v", err)
+	}
+	if listenAddr.PortRangeSize() != 1 {
+		return "", "", fmt.Errorf("admin endpoint must have exactly one address; cannot listen on %v", listenAddr)
+	}
+	return listenAddr.Network, listenAddr.JoinHostPort(0), 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(listenAddr string) adminHandler {
+	muxWrap := adminHandler{
+		enforceOrigin:  admin.EnforceOrigin,
+		allowedOrigins: admin.allowedOrigins(listenAddr),
+		mux:            http.NewServeMux(),
+	}
+
+	// addRoute just calls muxWrap.mux.Handle after
+	// wrapping the handler with error handling
+	addRoute := func(pattern string, h AdminHandler) {
+		wrapper := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			err := h.ServeHTTP(w, r)
+			muxWrap.handleError(w, r, err)
+		})
+		muxWrap.mux.Handle(pattern, wrapper)
+	}
+
+	// register standard config control endpoints
+	addRoute("/"+rawConfigKey+"/", AdminHandlerFunc(handleConfig))
+	addRoute("/id/", AdminHandlerFunc(handleConfigID))
+	addRoute("/stop", AdminHandlerFunc(handleStop))
+
+	// register debugging endpoints
+	muxWrap.mux.HandleFunc("/debug/pprof/", pprof.Index)
+	muxWrap.mux.HandleFunc("/debug/pprof/cmdline", pprof.Cmdline)
+	muxWrap.mux.HandleFunc("/debug/pprof/profile", pprof.Profile)
+	muxWrap.mux.HandleFunc("/debug/pprof/symbol", pprof.Symbol)
+	muxWrap.mux.HandleFunc("/debug/pprof/trace", pprof.Trace)
+	muxWrap.mux.Handle("/debug/vars", expvar.Handler())
+
+	// register third-party module endpoints
+	for _, m := range GetModules("admin.api") {
+		router := m.New().(AdminRouter)
+		for _, route := range router.Routes() {
+			addRoute(route.Pattern, 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, but whatever.
+func (admin AdminConfig) allowedOrigins(listen string) []string {
+	uniqueOrigins := make(map[string]struct{})
+	for _, o := range admin.Origins {
+		uniqueOrigins[o] = struct{}{}
+	}
+	if admin.Origins == nil {
+		uniqueOrigins[listen] = struct{}{}
+	}
+	var allowed []string
+	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
+	netw, addr, err := adminConfig.listenAddr()
+	if err != nil {
+		return err
+	}
+
+	handler := adminConfig.newAdminHandler(addr)
+
+	ln, err := Listen(netw, addr)
+	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,
+	}
+
+	go adminServer.Serve(ln)
+
+	Log().Named("admin").Info(
+		"admin endpoint started",
+		zap.String("address", addr),
+		zap.Bool("enforce_origin", adminConfig.EnforceOrigin),
+		zap.Strings("origins", handler.allowedOrigins),
+	)
+
+	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
+	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().Named("admin.api").Info("received request",
+		zap.String("method", r.Method),
+		zap.String("uri", r.RequestURI),
+		zap.String("remote_addr", r.RemoteAddr),
+		zap.Reflect("headers", r.Header),
+	)
+	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 h.enforceOrigin {
+		// DNS rebinding mitigation
+		err := h.checkHost(r)
+		if err != nil {
+			h.handleError(w, r, err)
+			return
+		}
+
+		// 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)
+	json.NewEncoder(w).Encode(apiErr)
+}
+
+// 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))
+	}
+	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"),
+		}
+	}
+	currentCfgMu.RLock()
+	hasCfg := currentCfg != nil
+	currentCfgMu.RUnlock()
+	if !hasCfg {
+		Log().Named("admin.api").Info("nothing to unload")
+		return nil
+	}
+	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,
+	}
+)
+
+// 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*,?`)
+
+const (
+	rawConfigKey = "config"
+	idKey        = "@id"
+)
+
+var bufPool = sync.Pool{
+	New: func() interface{} {
+		return new(bytes.Buffer)
+	},
+}
+
+var adminServer *http.Server

admin_test.go

@@ -0,0 +1,132 @@
+// 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

@@ -1,31 +0,0 @@
-version: "{build}"
-
-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.7.windows-amd64.zip
-  - 7z x go1.7.windows-amd64.zip -y -oC:\ > NUL
-  - go version
-  - go env
-  - go get -t ./...
-  - go get github.com/golang/lint/golint
-  - go get github.com/gordonklaus/ineffassign
-  - set PATH=%GOPATH%\bin;%PATH%
-
-build: off
-
-test_script:
-  - go vet ./...
-  - go test -race ./...
-  - ineffassign .
-
-after_test:
-  - golint ./...
-
-deploy: off

assets.go

@@ -1,34 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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)
-	}
-
-	os.Setenv("CADDYPATH", "testpath")
-	if actual, expected := AssetsPath(), "testpath"; actual != expected {
-		t.Errorf("Expected path to be %v, got: %v", expected, actual)
-	}
-	os.Setenv("CADDYPATH", "")
-}

caddy/build.bash

@@ -1,56 +0,0 @@
-#!/usr/bin/env bash
-#
-# Caddy build script. Automates proper versioning.
-#
-# Usage:
-#
-#     $ ./build.bash [output_filename] [git_repo]
-#
-# Outputs compiled program in current directory.
-# Default git repo is current directory.
-# Builds always take place from current directory.
-
-set -euo pipefail
-
-: ${output_filename:="${1:-}"}
-: ${output_filename:=""}
-
-: ${git_repo:="${2:-}"}
-: ${git_repo:="."}
-
-pkg=github.com/mholt/caddy/caddy/caddymain
-ldflags=()
-
-# Timestamp of build
-name="${pkg}.buildDate"
-value=$(date -u +"%a %b %d %H:%M:%S %Z %Y")
-ldflags+=("-X" "\"${name}=${value}\"")
-
-# Current tag, if HEAD is on a tag
-name="${pkg}.gitTag"
-set +e
-value="$(git -C "${git_repo}" describe --exact-match HEAD 2>/dev/null)"
-set -e
-ldflags+=("-X" "\"${name}=${value}\"")
-
-# Nearest tag on branch
-name="${pkg}.gitNearestTag"
-value="$(git -C "${git_repo}" describe --abbrev=0 --tags HEAD)"
-ldflags+=("-X" "\"${name}=${value}\"")
-
-# Commit SHA
-name="${pkg}.gitCommit"
-value="$(git -C "${git_repo}" rev-parse --short HEAD)"
-ldflags+=("-X" "\"${name}=${value}\"")
-
-# Summary of uncommitted changes
-name="${pkg}.gitShortStat"
-value="$(git -C "${git_repo}" diff-index --shortstat HEAD)"
-ldflags+=("-X" "\"${name}=${value}\"")
-
-# List of modified files
-name="${pkg}.gitFilesModified"
-value="$(git -C "${git_repo}" diff-index --name-only HEAD)"
-ldflags+=("-X" "\"${name}=${value}\"")
-
-go build -ldflags "${ldflags[*]}" -o "${output_filename}"

caddy/caddymain/run.go

@@ -1,290 +0,0 @@
-package caddymain
-
-import (
-	"errors"
-	"flag"
-	"fmt"
-	"io/ioutil"
-	"log"
-	"os"
-	"path/filepath"
-	"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.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")
-
-	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 {
-			log.Fatal(err)
-		}
-		fmt.Printf("Revoked certificate for %s\n", revoke)
-		os.Exit(0)
-	}
-	if version {
-		fmt.Printf("%s %s\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)
-	}
-
-	moveStorage() // TODO: This is temporary for the 0.9 release, or until most users upgrade to 0.9+
-
-	// Set CPU cap
-	err := setCPU(cpu)
-	if err != nil {
-		mustLogFatal(err)
-	}
-
-	// Get Caddyfile input
-	caddyfile, err := caddy.LoadCaddyfile(serverType)
-	if err != nil {
-		mustLogFatal(err)
-	}
-
-	// Start your engines
-	instance, err := caddy.Start(caddyfile)
-	if err != nil {
-		mustLogFatal(err)
-	}
-
-	// Twiddle your thumbs
-	instance.Wait()
-}
-
-// mustLogFatal wraps log.Fatal() 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 mustLogFatal(args ...interface{}) {
-	if !caddy.IsUpgrade() {
-		log.SetOutput(os.Stderr)
-	}
-	log.Fatal(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)
-	}
-
-	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
-}
-
-// moveStorage moves the old certificate storage location by
-// renaming the "letsencrypt" folder to the hostname of the
-// CA URL. This is TEMPORARY until most users have upgraded to 0.9+.
-func moveStorage() {
-	oldPath := filepath.Join(caddy.AssetsPath(), "letsencrypt")
-	_, err := os.Stat(oldPath)
-	if os.IsNotExist(err) {
-		return
-	}
-	// Just use a default config to get default (file) storage
-	fileStorage, err := new(caddytls.Config).StorageFor(caddytls.DefaultCAUrl)
-	if err != nil {
-		log.Fatalf("[ERROR] Unable to get new path for certificate storage: %v", err)
-	}
-	newPath := fileStorage.(*caddytls.FileStorage).Path
-	err = os.MkdirAll(string(newPath), 0700)
-	if err != nil {
-		log.Fatalf("[ERROR] Unable to make new certificate storage path: %v\n\nPlease follow instructions at:\nhttps://github.com/mholt/caddy/issues/902#issuecomment-228876011", err)
-	}
-	err = os.Rename(oldPath, string(newPath))
-	if err != nil {
-		log.Fatalf("[ERROR] Unable to migrate certificate storage: %v\n\nPlease follow instructions at:\nhttps://github.com/mholt/caddy/issues/902#issuecomment-228876011", err)
-	}
-	// convert mixed case folder and file names to lowercase
-	var done bool // walking is recursive and preloads the file names, so we must restart walk after a change until no changes
-	for !done {
-		done = true
-		filepath.Walk(string(newPath), func(path string, info os.FileInfo, err error) error {
-			// must be careful to only lowercase the base of the path, not the whole thing!!
-			base := filepath.Base(path)
-			if lowerBase := strings.ToLower(base); base != lowerBase {
-				lowerPath := filepath.Join(filepath.Dir(path), lowerBase)
-				err = os.Rename(path, lowerPath)
-				if err != nil {
-					log.Fatalf("[ERROR] Unable to lower-case: %v\n\nPlease follow instructions at:\nhttps://github.com/mholt/caddy/issues/902#issuecomment-228876011", err)
-				}
-				// terminate traversal and restart since Walk needs the updated file list with new file names
-				done = false
-				return errors.New("start over")
-			}
-			return 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 != ""
-
-	// 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%).
-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)
-	} 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
-)
-
-// 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

@@ -1,44 +0,0 @@
-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
-	} {
-		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,14 +0,0 @@
-// 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://forum.caddyserver.com/t/my-wish-for-0-9-go-gettable-custom-builds/59?u=matt
-
-package main
-
-import "github.com/mholt/caddy/caddy/caddymain"
-
-var run = caddymain.Run // replaced for tests
-
-func main() {
-	run()
-}

caddy/main_test.go

@@ -1,17 +0,0 @@
-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,58 +0,0 @@
-package caddy
-
-import "testing"
-
-/*
-// 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.Fatalf("Error starting, iteration %d: %v", i, err)
-		}
-
-		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)
-		}
-	}
-}

caddyconfig/caddyfile/adapter.go

@@ -0,0 +1,91 @@
+// 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

@@ -0,0 +1,384 @@
+// 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"
+	"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,
+	}
+}
+
+// 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/dispenser_test.go

@@ -1,6 +1,22 @@
+// 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 (
+	"io"
+	"log"
 	"reflect"
 	"strings"
 	"testing"
@@ -11,7 +27,7 @@ func TestDispenser_Val_Next(t *testing.T) {
 			  dir1 arg1
 			  dir2 arg2 arg3
 			  dir3`
-	d := NewDispenser("Testfile", strings.NewReader(input))
+	d := NewTestDispenser(input)
 
 	if val := d.Val(); val != "" {
 		t.Fatalf("Val(): Should return empty string when no token loaded; got '%s'", val)
@@ -49,7 +65,7 @@ func TestDispenser_NextArg(t *testing.T) {
 	input := `dir1 arg1
 			  dir2 arg2 arg3
 			  dir3`
-	d := NewDispenser("Testfile", strings.NewReader(input))
+	d := NewTestDispenser(input)
 
 	assertNext := func(shouldLoad bool, expectedVal string, expectedCursor int) {
 		if d.Next() != shouldLoad {
@@ -64,7 +80,7 @@ func TestDispenser_NextArg(t *testing.T) {
 	}
 
 	assertNextArg := func(expectedVal string, loadAnother bool, expectedCursor int) {
-		if d.NextArg() != true {
+		if !d.NextArg() {
 			t.Error("NextArg(): Should load next argument but got false instead")
 		}
 		if d.cursor != expectedCursor {
@@ -74,7 +90,7 @@ func TestDispenser_NextArg(t *testing.T) {
 			t.Errorf("Val(): Expected '%s' but got '%s'", expectedVal, val)
 		}
 		if !loadAnother {
-			if d.NextArg() != false {
+			if d.NextArg() {
 				t.Fatalf("NextArg(): Should NOT load another argument, but got true instead (val: '%s')", d.Val())
 			}
 			if d.cursor != expectedCursor {
@@ -96,7 +112,7 @@ func TestDispenser_NextLine(t *testing.T) {
 	input := `host:port
 			  dir1 arg1
 			  dir2 arg2 arg3`
-	d := NewDispenser("Testfile", strings.NewReader(input))
+	d := NewTestDispenser(input)
 
 	assertNextLine := func(shouldLoad bool, expectedVal string, expectedCursor int) {
 		if d.NextLine() != shouldLoad {
@@ -129,10 +145,10 @@ func TestDispenser_NextBlock(t *testing.T) {
 			  }
 			  foobar2 {
 			  }`
-	d := NewDispenser("Testfile", strings.NewReader(input))
+	d := NewTestDispenser(input)
 
 	assertNextBlock := func(shouldLoad bool, expectedCursor, expectedNesting int) {
-		if loaded := d.NextBlock(); loaded != shouldLoad {
+		if loaded := d.NextBlock(0); loaded != shouldLoad {
 			t.Errorf("NextBlock(): Should return %v but got %v", shouldLoad, loaded)
 		}
 		if d.cursor != expectedCursor {
@@ -159,7 +175,7 @@ func TestDispenser_Args(t *testing.T) {
 			  dir2 arg4 arg5
 			  dir3 arg6 arg7
 			  dir4`
-	d := NewDispenser("Testfile", strings.NewReader(input))
+	d := NewTestDispenser(input)
 
 	d.Next() // dir1
 
@@ -226,7 +242,7 @@ func TestDispenser_RemainingArgs(t *testing.T) {
 			  dir2 arg4 arg5
 			  dir3 arg6 { arg7
 			  dir4`
-	d := NewDispenser("Testfile", strings.NewReader(input))
+	d := NewTestDispenser(input)
 
 	d.Next() // dir1
 
@@ -263,7 +279,7 @@ func TestDispenser_ArgErr_Err(t *testing.T) {
 	input := `dir1 {
 			  }
 			  dir2 arg1 arg2`
-	d := NewDispenser("Testfile", strings.NewReader(input))
+	d := NewTestDispenser(input)
 
 	d.cursor = 1 // {
 
@@ -290,3 +306,13 @@ func TestDispenser_ArgErr_Err(t *testing.T) {
 		t.Errorf("Expected error message with custom message in it ('foobar'); got '%v'", err)
 	}
 }
+
+// NewTestDispenser parses input into tokens and creates a new
+// Disenser 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)
+}

caddyconfig/caddyfile/formatter.go

@@ -0,0 +1,216 @@
+// 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 == '#' {
+			if !spacePrior && !beginningOfLine {
+				write(' ')
+			}
+			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

@@ -0,0 +1,322 @@
+// 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`,
+		},
+	} {
+		// 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/lexer.go

@@ -1,3 +1,17 @@
+// 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 (
@@ -12,9 +26,10 @@ 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
+		reader       *bufio.Reader
+		token        Token
+		line         int
+		skippedLines int
 	}
 
 	// Token represents a single parsable unit.
@@ -77,27 +92,29 @@ func (l *lexer) next() bool {
 			panic(err)
 		}
 
+		if !escaped && ch == '\\' {
+			escaped = true
+			continue
+		}
+
 		if quoted {
-			if !escaped {
-				if ch == '\\' {
-					escaped = true
-					continue
-				} else if ch == '"' {
-					quoted = false
+			if escaped {
+				// all is literal in quoted area,
+				// so only escape quotes
+				if ch != '"' {
+					val = append(val, '\\')
+				}
+				escaped = false
+			} else {
+				if ch == '"' {
 					return makeToken()
 				}
 			}
 			if ch == '\n' {
-				l.line++
-			}
-			if escaped {
-				// only escape quotes
-				if ch != '"' {
-					val = append(val, '\\')
-				}
+				l.line += 1 + l.skippedLines
+				l.skippedLines = 0
 			}
 			val = append(val, ch)
-			escaped = false
 			continue
 		}
 
@@ -106,7 +123,13 @@ func (l *lexer) next() bool {
 				continue
 			}
 			if ch == '\n' {
-				l.line++
+				if escaped {
+					l.skippedLines++
+					escaped = false
+				} else {
+					l.line += 1 + l.skippedLines
+					l.skippedLines = 0
+				}
 				comment = false
 			}
 			if len(val) > 0 {
@@ -118,7 +141,6 @@ func (l *lexer) next() bool {
 		if ch == '#' {
 			comment = true
 		}
-
 		if comment {
 			continue
 		}
@@ -131,6 +153,11 @@ func (l *lexer) next() bool {
 			}
 		}
 
+		if escaped {
+			val = append(val, '\\')
+			escaped = false
+		}
+
 		val = append(val, ch)
 	}
 }

caddyconfig/caddyfile/lexer_test.go

@@ -1,6 +1,21 @@
+// 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 (
+	"log"
 	"strings"
 	"testing"
 )
@@ -80,6 +95,50 @@ func TestLexer(t *testing.T) {
 				{Line: 1, Text: "B"},
 			},
 		},
+		{
+			input: "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: "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: "line1\\\nescaped\nline2\nline3",
+			expected: []Token{
+				{Line: 1, Text: "line1"},
+				{Line: 1, Text: "escaped"},
+				{Line: 3, Text: "line2"},
+				{Line: 4, Text: "line3"},
+			},
+		},
+		{
+			input: "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: `"unescapable\ in quotes"`,
+			expected: []Token{
+				{Line: 1, Text: `unescapable\ in quotes`},
+			},
+		},
 		{
 			input: `"don't\escape"`,
 			expected: []Token{
@@ -92,6 +151,12 @@ func TestLexer(t *testing.T) {
 				{Line: 1, Text: `don't\\escape`},
 			},
 		},
+		{
+			input: `un\escapable`,
+			expected: []Token{
+				{Line: 1, Text: `un\escapable`},
+			},
+		},
 		{
 			input: `A "quoted value with line
 					break inside" {
@@ -144,7 +209,9 @@ func TestLexer(t *testing.T) {
 
 func tokenize(input string) (tokens []Token) {
 	l := lexer{}
-	l.load(strings.NewReader(input))
+	if err := l.load(strings.NewReader(input)); err != nil {
+		log.Printf("[ERROR] load failed: %v", err)
+	}
 	for l.next() {
 		tokens = append(tokens, l.token)
 	}

caddyconfig/caddyfile/parse.go

@@ -0,0 +1,536 @@
+// 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"
+	"io/ioutil"
+	"log"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// Parse parses the input just enough to group tokens, in
+// order, by server block. No further parsing is performed.
+// Server blocks are returned in the order in which they appear.
+// 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)}
+	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
+		envVarName := input[begin+len(spanOpen) : end]
+		if len(envVarName) == 0 {
+			offset = end + len(spanClose)
+			continue
+		}
+
+		// get the value of the environment variable
+		envVarValue := []byte(os.ExpandEnv(os.Getenv(string(envVarName))))
+
+		// splice in the value
+		input = append(input[:begin],
+			append(envVarValue, input[end+len(spanClose):]...)...)
+
+		// continue at the end of the replacement
+		offset = begin + len(envVarValue)
+	}
+	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)
+	if err != nil {
+		return nil, err
+	}
+	l := new(lexer)
+	err = l.load(bytes.NewReader(input))
+	if err != nil {
+		return nil, err
+	}
+	var tokens []Token
+	for l.next() {
+		l.token.File = filename
+		tokens = append(tokens, l.token)
+	}
+	return tokens, nil
+}
+
+type parser struct {
+	*Dispenser
+	block           ServerBlock // current server block being parsed
+	eof             bool        // if we encounter a valid EOF in a hard place
+	definedSnippets map[string][]Token
+	nesting         int
+}
+
+func (p *parser) parseAll() ([]ServerBlock, error) {
+	var blocks []ServerBlock
+
+	for p.Next() {
+		err := p.parseOne()
+		if err != nil {
+			return blocks, err
+		}
+		if len(p.block.Keys) > 0 || len(p.block.Segments) > 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{}
+	return p.begin()
+}
+
+func (p *parser) begin() error {
+	if len(p.tokens) == 0 {
+		return nil
+	}
+
+	err := p.addresses()
+
+	if err != nil {
+		return err
+	}
+
+	if p.eof {
+		// this happens if the Caddyfile consists of only
+		// a line of addresses and nothing else
+		return nil
+	}
+
+	if ok, name := p.isSnippet(); ok {
+		if p.definedSnippets == nil {
+			p.definedSnippets = map[string][]Token{}
+		}
+		if _, found := p.definedSnippets[name]; found {
+			return p.Errf("redeclaration of previously declared snippet %s", name)
+		}
+		// consume all tokens til matched close brace
+		tokens, err := p.snippetTokens()
+		if err != nil {
+			return err
+		}
+		p.definedSnippets[name] = tokens
+		// empty block keys so we don't save this block as a real server.
+		p.block.Keys = nil
+		return nil
+	}
+
+	return p.blockContents()
+}
+
+func (p *parser) addresses() error {
+	var expectingAnother bool
+
+	for {
+		tkn := p.Val()
+
+		// special case: import directive replaces tokens during parse-time
+		if tkn == "import" && p.isNewLine() {
+			err := p.doImport()
+			if err != nil {
+				return err
+			}
+			continue
+		}
+
+		// Open brace definitely indicates end of addresses
+		if tkn == "{" {
+			if expectingAnother {
+				return p.Errf("Expected another address but had '%s' - check for extra comma", tkn)
+			}
+			break
+		}
+
+		if tkn != "" { // empty token possible if user typed ""
+			// Trailing comma indicates another address will follow, which
+			// may possibly be on the next line
+			if tkn[len(tkn)-1] == ',' {
+				tkn = tkn[:len(tkn)-1]
+				expectingAnother = true
+			} else {
+				expectingAnother = false // but we may still see another one on this line
+			}
+
+			p.block.Keys = append(p.block.Keys, tkn)
+		}
+
+		// Advance token and possibly break out of loop or return error
+		hasNext := p.Next()
+		if expectingAnother && !hasNext {
+			return p.EOFErr()
+		}
+		if !hasNext {
+			p.eof = true
+			break // EOF
+		}
+		if !expectingAnother && p.isNewLine() {
+			break
+		}
+	}
+
+	return nil
+}
+
+func (p *parser) blockContents() error {
+	errOpenCurlyBrace := p.openCurlyBrace()
+	if errOpenCurlyBrace != nil {
+		// single-server configs don't need curly braces
+		p.cursor--
+	}
+
+	err := p.directives()
+	if err != nil {
+		return err
+	}
+
+	// only look for close curly brace if there was an opening
+	if errOpenCurlyBrace == nil {
+		err = p.closeCurlyBrace()
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// directives parses through all the lines for directives
+// and it expects the next token to be the first
+// directive. It goes until EOF or closing curly brace
+// which ends the server block.
+func (p *parser) directives() error {
+	for p.Next() {
+		// end of server block
+		if p.Val() == "}" {
+			// p.nesting has already been decremented
+			break
+		}
+
+		// special case: import directive replaces tokens during parse-time
+		if p.Val() == "import" {
+			err := p.doImport()
+			if err != nil {
+				return err
+			}
+			p.cursor-- // cursor is advanced when we continue, so roll back one more
+			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)
+		if err := p.directive(); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// doImport swaps out the import directive and its argument
+// (a total of 2 tokens) with the tokens in the specified file
+// or globbing pattern. When the function returns, the cursor
+// is on the token before where the import directive was. In
+// other words, call Next() to access the first token that was
+// imported.
+func (p *parser) doImport() error {
+	// syntax checks
+	if !p.NextArg() {
+		return p.ArgErr()
+	}
+	importPattern := p.Val()
+	if importPattern == "" {
+		return p.Err("Import requires a non-empty filepath")
+	}
+	if p.NextArg() {
+		return p.Err("Import takes only one argument (glob pattern or file)")
+	}
+	// 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
+
+	// first check snippets. That is a simple, non-recursive replacement
+	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())
+		if err != nil {
+			return p.Errf("Failed to get absolute path of file: %s: %v", p.Dispenser.File(), err)
+		}
+
+		var matches []string
+		var globPattern string
+		if !filepath.IsAbs(importPattern) {
+			globPattern = filepath.Join(filepath.Dir(absFile), importPattern)
+		} 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)
+			} else {
+				return p.Errf("File to import not found: %s", importPattern)
+			}
+		}
+
+		// collect all the imported tokens
+
+		for _, importFile := range matches {
+			newTokens, err := p.doSingleImport(importFile)
+			if err != nil {
+				return err
+			}
+			importedTokens = append(importedTokens, newTokens...)
+		}
+	}
+
+	// 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(importedTokens, tokensAfter...)...)
+	p.cursor--
+
+	return nil
+}
+
+// doSingleImport lexes the individual file at importFile and returns
+// its tokens or an error, if any.
+func (p *parser) doSingleImport(importFile string) ([]Token, error) {
+	file, err := os.Open(importFile)
+	if err != nil {
+		return nil, p.Errf("Could not import %s: %v", importFile, err)
+	}
+	defer file.Close()
+
+	if info, err := file.Stat(); err != nil {
+		return nil, p.Errf("Could not import %s: %v", importFile, err)
+	} else if info.IsDir() {
+		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)
+	if err != nil {
+		return nil, p.Errf("Could not read tokens while importing %s: %v", importFile, err)
+	}
+
+	// Tack the file path onto these tokens so errors show the imported file's name
+	// (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)
+	}
+	for i := 0; i < len(importedTokens); i++ {
+		importedTokens[i].File = filename
+	}
+
+	return importedTokens, nil
+}
+
+// directive collects tokens until the directive's scope
+// closes (either end of line or end of curly brace block).
+// It expects the currently-loaded token to be a directive
+// (or } that ends a server block). The collected tokens
+// are loaded into the current server block for later use
+// by directive setup functions.
+func (p *parser) directive() error {
+
+	// a segment is a list of tokens associated with this directive
+	var segment Segment
+
+	// the directive itself is appended as a relevant token
+	segment = append(segment, p.Token())
+
+	for p.Next() {
+		if p.Val() == "{" {
+			p.nesting++
+		} else if p.isNewLine() && p.nesting == 0 {
+			p.cursor-- // read too far
+			break
+		} else if p.Val() == "}" && p.nesting > 0 {
+			p.nesting--
+		} else if p.Val() == "}" && p.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.block.Segments = append(p.block.Segments, segment)
+
+	if p.nesting > 0 {
+		return p.EOFErr()
+	}
+
+	return nil
+}
+
+// openCurlyBrace expects the current token to be an
+// opening curly brace. This acts like an assertion
+// because it returns an error if the token is not
+// a opening curly brace. It does NOT advance the token.
+func (p *parser) openCurlyBrace() error {
+	if p.Val() != "{" {
+		return p.SyntaxErr("{")
+	}
+	return nil
+}
+
+// closeCurlyBrace expects the current token to be
+// a closing curly brace. This acts like an assertion
+// because it returns an error if the token is not
+// a closing curly brace. It does NOT advance the token.
+func (p *parser) closeCurlyBrace() error {
+	if p.Val() != "}" {
+		return p.SyntaxErr("}")
+	}
+	return nil
+}
+
+func (p *parser) isSnippet() (bool, string) {
+	keys := p.block.Keys
+	// A snippet block is a single key with parens. Nothing else qualifies.
+	if len(keys) == 1 && strings.HasPrefix(keys[0], "(") && strings.HasSuffix(keys[0], ")") {
+		return true, strings.TrimSuffix(keys[0][1:], ")")
+	}
+	return false, ""
+}
+
+// read and store everything in a block for later replay.
+func (p *parser) snippetTokens() ([]Token, error) {
+	// snippet must have curlies.
+	err := p.openCurlyBrace()
+	if err != nil {
+		return nil, err
+	}
+	nesting := 1 // count our own nesting in snippets
+	tokens := []Token{}
+	for p.Next() {
+		if p.Val() == "}" {
+			nesting--
+			if nesting == 0 {
+				break
+			}
+		}
+		if p.Val() == "{" {
+			nesting++
+		}
+		tokens = append(tokens, p.tokens[p.cursor])
+	}
+	// make sure we're matched up
+	if nesting != 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{'}'}

caddyconfig/caddyfile/parse_fuzz.go

@@ -0,0 +1,36 @@
+// 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.
+
+// +build gofuzz
+
+package caddyfile
+
+import "bytes"
+
+func FuzzParseCaddyfile(data []byte) (score int) {
+	if bytes.Contains(data, []byte("import")) {
+		return -1
+	}
+	sb, err := Parse("Caddyfile", data)
+	if err != nil {
+		// if both an error is received and some ServerBlocks,
+		// then the parse was able to parse partially. Mark this
+		// result as interesting to push the fuzzer further through the parser.
+		if sb != nil && len(sb) > 0 {
+			return 1
+		}
+		return 0
+	}
+	return 1
+}

caddyconfig/caddyfile/parse_test.go

@@ -0,0 +1,674 @@
+// 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"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestAllTokens(t *testing.T) {
+	input := []byte("a b c\nd e")
+	expected := []string{"a", "b", "c", "d", "e"}
+	tokens, err := allTokens("TestAllTokens", input)
+
+	if err != nil {
+		t.Fatalf("Expected no error, got %v", err)
+	}
+	if len(tokens) != len(expected) {
+		t.Fatalf("Expected %d tokens, got %d", len(expected), len(tokens))
+	}
+
+	for i, val := range expected {
+		if tokens[i].Text != val {
+			t.Errorf("Token %d should be '%s' but was '%s'", i, val, tokens[i].Text)
+		}
+	}
+}
+
+func TestParseOneAndImport(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
+	}
+
+	for i, test := range []struct {
+		input     string
+		shouldErr bool
+		keys      []string
+		numTokens []int // number of tokens to expect in each segment
+	}{
+		{`localhost`, false, []string{
+			"localhost",
+		}, []int{}},
+
+		{`localhost
+		  dir1`, false, []string{
+			"localhost",
+		}, []int{1}},
+
+		{`localhost:1234
+		  dir1 foo bar`, false, []string{
+			"localhost:1234",
+		}, []int{3},
+		},
+
+		{`localhost {
+		    dir1
+		  }`, false, []string{
+			"localhost",
+		}, []int{1}},
+
+		{`localhost:1234 {
+		    dir1 foo bar
+		    dir2
+		  }`, false, []string{
+			"localhost:1234",
+		}, []int{3, 1}},
+
+		{`http://localhost https://localhost
+		  dir1 foo bar`, false, []string{
+			"http://localhost",
+			"https://localhost",
+		}, []int{3}},
+
+		{`http://localhost https://localhost {
+		    dir1 foo bar
+		  }`, false, []string{
+			"http://localhost",
+			"https://localhost",
+		}, []int{3}},
+
+		{`http://localhost, https://localhost {
+		    dir1 foo bar
+		  }`, false, []string{
+			"http://localhost",
+			"https://localhost",
+		}, []int{3}},
+
+		{`http://localhost, {
+		  }`, true, []string{
+			"http://localhost",
+		}, []int{}},
+
+		{`host1:80, http://host2.com
+		  dir1 foo bar
+		  dir2 baz`, false, []string{
+			"host1:80",
+			"http://host2.com",
+		}, []int{3, 2}},
+
+		{`http://host1.com,
+		  http://host2.com,
+		  https://host3.com`, false, []string{
+			"http://host1.com",
+			"http://host2.com",
+			"https://host3.com",
+		}, []int{}},
+
+		{`http://host1.com:1234, https://host2.com
+		  dir1 foo {
+		    bar baz
+		  }
+		  dir2`, false, []string{
+			"http://host1.com:1234",
+			"https://host2.com",
+		}, []int{6, 1}},
+
+		{`127.0.0.1
+		  dir1 {
+		    bar baz
+		  }
+		  dir2 {
+		    foo bar
+		  }`, false, []string{
+			"127.0.0.1",
+		}, []int{5, 5}},
+
+		{`localhost
+		  dir1 {
+		    foo`, true, []string{
+			"localhost",
+		}, []int{3}},
+
+		{`localhost
+		  dir1 {
+		  }`, false, []string{
+			"localhost",
+		}, []int{3}},
+
+		{`localhost
+		  dir1 {
+		  } }`, true, []string{
+			"localhost",
+		}, []int{}},
+
+		{`localhost
+		  dir1 {
+		    nested {
+		      foo
+		    }
+		  }
+		  dir2 foo bar`, false, []string{
+			"localhost",
+		}, []int{7, 3}},
+
+		{``, false, []string{}, []int{}},
+
+		{`localhost
+		  dir1 arg1
+		  import testdata/import_test1.txt`, false, []string{
+			"localhost",
+		}, []int{2, 3, 1}},
+
+		{`import testdata/import_test2.txt`, false, []string{
+			"host1",
+		}, []int{1, 2}},
+
+		{`import testdata/import_test1.txt testdata/import_test2.txt`, true, []string{}, []int{}},
+
+		{`import testdata/not_found.txt`, true, []string{}, []int{}},
+
+		{`""`, false, []string{}, []int{}},
+
+		{``, false, []string{}, []int{}},
+
+		// 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{}},
+	} {
+		result, err := testParseOne(test.input)
+
+		if test.shouldErr && err == nil {
+			t.Errorf("Test %d: Expected an error, but didn't get one", i)
+		}
+		if !test.shouldErr && err != nil {
+			t.Errorf("Test %d: Expected no error, but got: %v", i, err)
+		}
+
+		if len(result.Keys) != len(test.keys) {
+			t.Errorf("Test %d: Expected %d keys, got %d",
+				i, len(test.keys), len(result.Keys))
+			continue
+		}
+		for j, addr := range result.Keys {
+			if addr != test.keys[j] {
+				t.Errorf("Test %d, key %d: Expected '%s', but was '%s'",
+					i, j, test.keys[j], addr)
+			}
+		}
+
+		if len(result.Segments) != len(test.numTokens) {
+			t.Errorf("Test %d: Expected %d segments, had %d",
+				i, len(test.numTokens), len(result.Segments))
+			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))
+				continue
+			}
+		}
+	}
+}
+
+func TestRecursiveImport(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]) != 2 {
+			t.Errorf("got unexpected tokens: %v", got.Segments)
+			return false
+		}
+		return true
+	}
+
+	recursiveFile1, err := filepath.Abs("testdata/recursive_import_test1")
+	if err != nil {
+		t.Fatal(err)
+	}
+	recursiveFile2, err := filepath.Abs("testdata/recursive_import_test2")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// test relative recursive import
+	err = ioutil.WriteFile(recursiveFile1, []byte(
+		`localhost
+		dir1
+		import recursive_import_test2`), 0644)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.Remove(recursiveFile1)
+
+	err = ioutil.WriteFile(recursiveFile2, []byte("dir2 1"), 0644)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.Remove(recursiveFile2)
+
+	// import absolute path
+	result, err := testParseOne("import " + recursiveFile1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !isExpected(result) {
+		t.Error("absolute+relative import failed")
+	}
+
+	// import relative path
+	result, err = testParseOne("import testdata/recursive_import_test1")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !isExpected(result) {
+		t.Error("relative+relative import failed")
+	}
+
+	// test absolute recursive import
+	err = ioutil.WriteFile(recursiveFile1, []byte(
+		`localhost
+		dir1
+		import `+recursiveFile2), 0644)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// import absolute path
+	result, err = testParseOne("import " + recursiveFile1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !isExpected(result) {
+		t.Error("absolute+absolute import failed")
+	}
+
+	// import relative path
+	result, err = testParseOne("import testdata/recursive_import_test1")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !isExpected(result) {
+		t.Error("relative+absolute import failed")
+	}
+}
+
+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
+		shouldErr bool
+		keys      [][]string // keys per server block, in order
+	}{
+		{`localhost`, false, [][]string{
+			{"localhost"},
+		}},
+
+		{`localhost:1234`, false, [][]string{
+			{"localhost:1234"},
+		}},
+
+		{`localhost:1234 {
+		  }
+		  localhost:2015 {
+		  }`, false, [][]string{
+			{"localhost:1234"},
+			{"localhost:2015"},
+		}},
+
+		{`localhost:1234, http://host2`, false, [][]string{
+			{"localhost:1234", "http://host2"},
+		}},
+
+		{`localhost:1234, http://host2,`, true, [][]string{}},
+
+		{`http://host1.com, http://host2.com {
+		  }
+		  https://host3.com, https://host4.com {
+		  }`, false, [][]string{
+			{"http://host1.com", "http://host2.com"},
+			{"https://host3.com", "https://host4.com"},
+		}},
+
+		{`import testdata/import_glob*.txt`, false, [][]string{
+			{"glob0.host0"},
+			{"glob0.host1"},
+			{"glob1.host0"},
+			{"glob2.host0"},
+		}},
+
+		{`import notfound/*`, false, [][]string{}},        // glob needn't error with no matches
+		{`import notfound/file.conf`, true, [][]string{}}, // but a specific file should
+	} {
+		p := testParser(test.input)
+		blocks, err := p.parseAll()
+
+		if test.shouldErr && err == nil {
+			t.Errorf("Test %d: Expected an error, but didn't get one", i)
+		}
+		if !test.shouldErr && err != nil {
+			t.Errorf("Test %d: Expected no error, but got: %v", i, err)
+		}
+
+		if len(blocks) != len(test.keys) {
+			t.Errorf("Test %d: Expected %d server blocks, got %d",
+				i, len(test.keys), len(blocks))
+			continue
+		}
+		for j, block := range blocks {
+			if len(block.Keys) != len(test.keys[j]) {
+				t.Errorf("Test %d: Expected %d keys in block %d, got %d",
+					i, len(test.keys[j]), j, len(block.Keys))
+				continue
+			}
+			for k, addr := range block.Keys {
+				if addr != test.keys[j][k] {
+					t.Errorf("Test %d, block %d, key %d: Expected '%s', but got '%s'",
+						i, j, k, test.keys[j][k], addr)
+				}
+			}
+		}
+	}
+}
+
+func TestEnvironmentReplacement(t *testing.T) {
+	os.Setenv("FOOBAR", "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:  "{$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)
+		}
+	}
+}
+
+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.Segments)
+	}
+	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) != 2 {
+		t.Fatalf("Server block should have tokens from import, got: %+v", blocks[0])
+	}
+	if actual, expected := blocks[0].Segments[0][0].Text, "gzip"; 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 {
+		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.
+	}
+	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)
+	}
+	for _, b := range blocks {
+		t.Log(b.Keys)
+		t.Log(b.Segments)
+	}
+	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)
+	}
+	for _, b := range blocks {
+		t.Log(b.Keys)
+		t.Log(b.Segments)
+	}
+	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 {
+		t.Errorf("Expected argument to be '%s' but was '%s'", expected, actual)
+	}
+}
+
+func testParser(input string) parser {
+	return parser{Dispenser: NewTestDispenser(input)}
+}

caddyconfig/configadapters.go

@@ -0,0 +1,136 @@
+// 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
+// and then adds a key to that object named fieldName with the value fieldVal.
+// This is useful for JSON-encoding module values where the module name has to
+// be described within the object by a certain key; for example,
+// "responder": "file_server" for a file server HTTP responder. The val must
+// encode into a map[string]interface{} (i.e. it must be a struct or map),
+// and any errors are converted into warnings, so this can be conveniently
+// used when filling a struct. For correct code, there should be no errors.
+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.
+func RegisterAdapter(name string, adapter Adapter) error {
+	if _, ok := configAdapters[name]; ok {
+		return fmt.Errorf("%s: already registered", name)
+	}
+	configAdapters[name] = adapter
+	return 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

@@ -0,0 +1,363 @@
+// 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"
+	"strconv"
+	"strings"
+
+	"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 {
+	var sbaddrs []sbAddrAssociation
+	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)
+	}
+	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
+	var lnHosts []string
+	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
+	var listenersList []string
+	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:   strings.ToLower(a.Scheme),
+		Host:     strings.ToLower(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
+}

caddyconfig/httpcaddyfile/addresses_fuzz.go

@@ -0,0 +1,28 @@
+// 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.
+
+// +build gofuzz
+
+package httpcaddyfile
+
+func FuzzParseAddress(data []byte) int {
+	addr, err := ParseAddress(string(data))
+	if err != nil {
+		if addr == (Address{}) {
+			return 1
+		}
+		return 0
+	}
+	return 1
+}

caddyconfig/httpcaddyfile/addresses_test.go

@@ -1,18 +1,16 @@
-package httpserver
+package httpcaddyfile
 
 import (
-	"strings"
 	"testing"
-
-	"github.com/mholt/caddy/caddyfile"
 )
 
-func TestStandardizeAddress(t *testing.T) {
+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},
@@ -22,43 +20,47 @@ func TestStandardizeAddress(t *testing.T) {
 		{`[::1]`, "", "::1", "", "", false},
 		{`[::1]:1234`, "", "::1", "1234", "", false},
 		{`:`, "", "", "", "", false},
-		{`localhost:http`, "http", "localhost", "80", "", false},
-		{`localhost:https`, "https", "localhost", "443", "", false},
-		{`:http`, "http", "", "80", "", false},
-		{`:https`, "https", "", "443", "", 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
-		{`http://localhost:443`, "", "", "", "", true},   // not conventional
-		{`https://localhost:80`, "", "", "", "", true},   // not conventional
-		{`http://localhost`, "http", "localhost", "80", "", false},
-		{`https://localhost`, "https", "localhost", "443", "", false},
-		{`http://127.0.0.1`, "http", "127.0.0.1", "80", "", false},
-		{`https://127.0.0.1`, "https", "127.0.0.1", "443", "", false},
-		{`http://[::1]`, "http", "::1", "80", "", false},
+		{`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", "", "", true},
-		{`localhost::`, "", "localhost::", "", "", true},
-		{`#$%@`, "", "", "", "", true},
+		{`::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", "80", "/", false},
-		{`//asdf`, "", "asdf", "", "", false},
+		{`http://host/`, "http", "host", "", "/", false},
+		{`//asdf`, "", "", "", "//asdf", false},
 		{`:1234/asdf`, "", "", "1234", "/asdf", false},
-		{`http://host/path`, "http", "host", "80", "/path", 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},
-		{`host:https/path`, "https", "host", "443", "/path", false},
 		{`/path`, "", "", "", "/path", false},
 	} {
-		actual, err := standardizeAddress(test.input)
+		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", i, test.input)
+			t.Errorf("Test %d (%s): Expected error, but had none (%#v)", i, test.input, actual)
 		}
 
 		if !test.shouldErr && actual.Original != test.input {
@@ -79,24 +81,6 @@ func TestStandardizeAddress(t *testing.T) {
 	}
 }
 
-func TestAddressVHost(t *testing.T) {
-	for i, test := range []struct {
-		addr     Address
-		expected string
-	}{
-		{Address{Original: "host:1234"}, "host:1234"},
-		{Address{Original: "host:1234/foo"}, "host:1234/foo"},
-		{Address{Original: "host/foo"}, "host/foo"},
-		{Address{Original: "http://host/foo"}, "host/foo"},
-		{Address{Original: "https://host/foo"}, "host/foo"},
-	} {
-		actual := test.addr.VHost()
-		if actual != test.expected {
-			t.Errorf("Test %d: expected '%s' but got '%s'", i, test.expected, actual)
-		}
-	}
-}
-
 func TestAddressString(t *testing.T) {
 	for i, test := range []struct {
 		addr     Address
@@ -119,41 +103,61 @@ func TestAddressString(t *testing.T) {
 	}
 }
 
-func TestInspectServerBlocksWithCustomDefaultPort(t *testing.T) {
-	Port = "9999"
-	filename := "Testfile"
-	ctx := newContext().(*httpContext)
-	input := strings.NewReader(`localhost`)
-	sblocks, err := caddyfile.Parse(filename, input, nil)
-	if err != nil {
-		t.Fatalf("Expected no error setting up test, got: %v", err)
+func TestKeyNormalization(t *testing.T) {
+	testCases := []struct {
+		input  string
+		expect string
+	}{
+		{
+			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:  ":80",
+			expect: ":80",
+		},
+		{
+			input:  ":443",
+			expect: ":443",
+		},
+		{
+			input:  ":1234",
+			expect: ":1234",
+		},
+		{
+			input:  "",
+			expect: "",
+		},
+		{
+			input:  ":",
+			expect: "",
+		},
+		{
+			input:  "[::]",
+			expect: "::",
+		},
 	}
-	_, err = ctx.InspectServerBlocks(filename, sblocks)
-	if err != nil {
-		t.Fatalf("Didn't expect an error, but got: %v", err)
-	}
-	addr := ctx.keysToSiteConfigs["localhost"].Addr
-	if addr.Port != Port {
-		t.Errorf("Expected the port on the address to be set, but got: %#v", addr)
-	}
-}
+	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: Normalized key for address '%s' was '%s' but expected '%s'", i, tc.input, actual, tc.expect)
+		}
 
-func TestDirectivesList(t *testing.T) {
-	for i, dir1 := range directives {
-		if dir1 == "" {
-			t.Errorf("directives[%d]: empty directive name", i)
-			continue
-		}
-		if got, want := dir1, strings.ToLower(dir1); got != want {
-			t.Errorf("directives[%d]: %s should be lower-cased", i, dir1)
-			continue
-		}
-		for j := i + 1; j < len(directives); j++ {
-			dir2 := directives[j]
-			if dir1 == dir2 {
-				t.Errorf("directives[%d] (%s) is a duplicate of directives[%d] (%s)",
-					j, dir2, i, dir1)
-			}
-		}
 	}
 }

caddyconfig/httpcaddyfile/builtins.go

@@ -0,0 +1,561 @@
+// 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"
+	"html"
+	"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"
+	"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...>
+//         alpn      <values...>
+//         load      <paths...>
+//         ca        <acme_ca_endpoint>
+//         ca_root   <pem_file>
+//         dns       <provider_name>
+//         on_demand
+//     }
+//
+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 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 h.NextBlock(0) {
+			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 "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 "dns":
+				if !h.Next() {
+					return nil, h.ArgErr()
+				}
+				if acmeIssuer == nil {
+					acmeIssuer = new(caddytls.ACMEIssuer)
+				}
+				provName := h.Val()
+				if acmeIssuer.Challenges == nil {
+					acmeIssuer.Challenges = new(caddytls.ChallengesConfig)
+				}
+				dnsProvModule, err := caddy.GetModule("tls.dns." + provName)
+				if err != nil {
+					return nil, h.Errf("getting DNS provider module named '%s': %v", provName, err)
+				}
+				acmeIssuer.Challenges.DNSRaw = caddyconfig.JSONModuleObject(dnsProvModule.New(), "provider", 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
+	var configVals []ConfigValue
+
+	// certificate loaders
+	if len(fileLoader) > 0 {
+		configVals = append(configVals, ConfigValue{
+			Class: "tls.certificate_loader",
+			Value: fileLoader,
+		})
+	}
+	if len(folderLoader) > 0 {
+		configVals = append(configVals, ConfigValue{
+			Class: "tls.certificate_loader",
+			Value: folderLoader,
+		})
+	}
+
+	// issuer
+	if acmeIssuer != nil && internalIssuer != nil {
+		// the logic to support this would be complex
+		return nil, h.Err("cannot use both ACME and internal issuers in same server block")
+	}
+	if acmeIssuer != nil {
+		// fill in global defaults, if configured
+		if email := h.Option("email"); email != nil && acmeIssuer.Email == "" {
+			acmeIssuer.Email = email.(string)
+		}
+		if acmeCA := h.Option("acme_ca"); acmeCA != nil && acmeIssuer.CA == "" {
+			acmeIssuer.CA = acmeCA.(string)
+		}
+		if caPemFile := h.Option("acme_ca_root"); caPemFile != nil {
+			acmeIssuer.TrustedRootsPEMFiles = append(acmeIssuer.TrustedRootsPEMFiles, caPemFile.(string))
+		}
+
+		configVals = append(configVals, ConfigValue{
+			Class: "tls.cert_issuer",
+			Value: acmeIssuer,
+		})
+	} else 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)
+
+	for h.Next() {
+		for nesting := h.Nesting(); h.NextBlock(nesting); {
+			dir := h.Val()
+
+			dirFunc, ok := registeredDirectives[dir]
+			if !ok {
+				return nil, h.Errf("unrecognized directive: %s", dir)
+			}
+
+			subHelper := h
+			subHelper.Dispenser = h.NewFromNextSegment()
+
+			results, err := dirFunc(subHelper)
+			if err != nil {
+				return nil, h.Errf("parsing caddyfile tokens for '%s': %v", dir, err)
+			}
+			for _, result := range results {
+				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)", dir, 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() {
+		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/directives.go

@@ -0,0 +1,449 @@
+// 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{
+	"root",
+
+	"header",
+
+	"redir",
+	"rewrite",
+
+	// URI manipulation
+	"uri",
+	"try_files",
+
+	// middleware handlers; some wrap responses
+	"basicauth",
+	"request_header",
+	"encode",
+	"templates",
+
+	// special routing directives
+	"handle",
+	"route",
+
+	// handlers that typically respond to requests
+	"respond",
+	"reverse_proxy",
+	"php_fastcgi",
+	"file_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, ok, err := h.MatcherToken()
+		if err != nil {
+			return nil, err
+		}
+		if ok {
+			// 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
+		val, err := setupFunc(h)
+		if err != nil {
+			return nil, err
+		}
+
+		return h.NewRoute(matcherSet, val), nil
+	})
+}
+
+// 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 {
+		h.Dispenser.Delete() // strip matcher token
+	}
+	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}}
+}
+
+// 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
+	}
+
+	// while we are sorting, we will need to decode a route's path matcher
+	// in order to sub-sort by path length; we can amortize this operation
+	// for efficiency by storing the decoded matchers in a slice
+	decodedMatchers := make([]caddyhttp.MatchPath, len(routes))
+
+	sort.SliceStable(routes, func(i, j int) bool {
+		iDir, jDir := routes[i].directive, routes[j].directive
+		if iDir == jDir {
+			// directives are the same; sub-sort by path matcher length
+			// if there's only one matcher set and one path (common case)
+			iRoute, ok := routes[i].Value.(caddyhttp.Route)
+			if !ok {
+				return false
+			}
+			jRoute, ok := routes[j].Value.(caddyhttp.Route)
+			if !ok {
+				return false
+			}
+
+			// use already-decoded matcher, or decode if it's the first time seeing it
+			iPM, jPM := decodedMatchers[i], decodedMatchers[j]
+			if iPM == nil && len(iRoute.MatcherSetsRaw) == 1 {
+				var pathMatcher caddyhttp.MatchPath
+				_ = json.Unmarshal(iRoute.MatcherSetsRaw[0]["path"], &pathMatcher)
+				decodedMatchers[i] = pathMatcher
+				iPM = pathMatcher
+			}
+			if jPM == nil && len(jRoute.MatcherSetsRaw) == 1 {
+				var pathMatcher caddyhttp.MatchPath
+				_ = json.Unmarshal(jRoute.MatcherSetsRaw[0]["path"], &pathMatcher)
+				decodedMatchers[j] = pathMatcher
+				jPM = pathMatcher
+			}
+
+			// sort by longer path (more specific) first; missing
+			// path matchers are treated as zero-length paths
+			var iPathLen, jPathLen int
+			if iPM != nil {
+				iPathLen = len(iPM[0])
+			}
+			if jPM != nil {
+				jPathLen = len(jPM[0])
+			}
+			return iPathLen > jPathLen
+		}
+
+		return dirPositions[iDir] < dirPositions[jDir]
+	})
+}
+
+// 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) {
+	var allResults []ConfigValue
+
+	for h.Next() {
+		// 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, seg := range segments {
+			if strings.HasPrefix(seg.Directive(), matcherPrefix) {
+				err := parseMatcherDefinitions(caddyfile.NewDispenser(seg), matcherDefs)
+				if err != nil {
+					return nil, err
+				}
+				segments = append(segments[:i], segments[i+1:]...)
+			}
+		}
+
+		// 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 buildSubroute(allResults, h.groupCounter)
+}
+
+// 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, unless allowEmpty is true, in which
+// case a key with no host (e.g. ":443") will be added to the list as an
+// empty string. Otherwise, if allowEmpty is false, and if sb has a key
+// that omits the hostname (i.e. is a catch-all/empty host), then the returned
+// list is empty, because the server block effectively matches ALL hosts.
+// The list may not be in a consistent order. If includePorts is true, then
+// any non-empty, non-standard ports will be included.
+func (sb serverBlock) hostsFromKeys(allowEmpty, includePorts bool) []string {
+	// first get each unique hostname
+	hostMap := make(map[string]struct{})
+	for _, addr := range sb.keys {
+		if addr.Host == "" && !allowEmpty {
+			// server block contains a key like ":443", i.e. the host portion
+			// is empty / catch-all, which means to match all hosts
+			return []string{}
+		}
+		if includePorts &&
+			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
+}
+
+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)
+)
+
+var registeredDirectives = make(map[string]UnmarshalFunc)

caddyconfig/httpcaddyfile/httptype_test.go

@@ -0,0 +1,149 @@
+package httpcaddyfile
+
+import (
+	"testing"
+
+	"github.com/caddyserver/caddy/v2/caddyconfig/caddyfile"
+)
+
+func TestServerType(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,
+		},
+	} {
+
+		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,
+		},
+	} {
+
+		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

@@ -0,0 +1,250 @@
+// 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"
+	"time"
+
+	"github.com/caddyserver/caddy/v2"
+	"github.com/caddyserver/caddy/v2/caddyconfig/caddyfile"
+	"github.com/caddyserver/caddy/v2/modules/caddytls"
+)
+
+func parseOptHTTPPort(d *caddyfile.Dispenser) (int, 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) (int, 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 parseOptExperimentalHTTP3(d *caddyfile.Dispenser) (bool, error) {
+	return true, nil
+}
+
+func parseOptOrder(d *caddyfile.Dispenser) ([]string, 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) (caddy.StorageConverter, error) {
+	if !d.Next() {
+		return nil, d.ArgErr()
+	}
+	args := d.RemainingArgs()
+	if len(args) != 1 {
+		return nil, d.ArgErr()
+	}
+	modName := args[0]
+	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 parseOptSingleString(d *caddyfile.Dispenser) (string, 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) (string, error) {
+	if d.Next() {
+		var listenAddress string
+		if !d.AllArgs(&listenAddress) {
+			return "", d.ArgErr()
+		}
+		if listenAddress == "" {
+			listenAddress = caddy.DefaultAdminListen
+		}
+		return listenAddress, nil
+	}
+	return "", nil
+}
+
+func parseOptOnDemand(d *caddyfile.Dispenser) (*caddytls.OnDemandConfig, 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 := time.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
+}

caddyconfig/httpcaddyfile/tlsapp.go

@@ -0,0 +1,372 @@
+// 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"
+	"fmt"
+	"reflect"
+	"sort"
+
+	"github.com/caddyserver/caddy/v2"
+	"github.com/caddyserver/caddy/v2/caddyconfig"
+	"github.com/caddyserver/caddy/v2/modules/caddytls"
+	"github.com/caddyserver/certmagic"
+)
+
+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
+
+	// count how many server blocks have a 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 serverBlocksWithHostlessKey int
+	hostsSharedWithHostlessKey := make(map[string]struct{})
+	for _, pair := range pairings {
+		for _, sb := range pair.serverBlocks {
+			for _, addr := range sb.keys {
+				if addr.Host == "" {
+					serverBlocksWithHostlessKey++
+					// 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[addr.Host] = struct{}{}
+						}
+					}
+					break
+				}
+			}
+		}
+	}
+
+	catchAllAP, err := newBaseAutomationPolicy(options, warnings, false)
+	if err != nil {
+		return nil, warnings, err
+	}
+
+	for _, p := range pairings {
+		for _, sblock := range p.serverBlocks {
+			// get values that populate an automation policy for this block
+			var ap *caddytls.AutomationPolicy
+
+			sblockHosts := sblock.hostsFromKeys(false, false)
+			if len(sblockHosts) == 0 {
+				ap = catchAllAP
+			}
+
+			// on-demand tls
+			if _, ok := sblock.pile["tls.on_demand"]; ok {
+				if ap == nil {
+					var err error
+					ap, err = newBaseAutomationPolicy(options, warnings, true)
+					if err != nil {
+						return nil, warnings, err
+					}
+				}
+				ap.OnDemand = true
+			}
+
+			// certificate issuers
+			if issuerVals, ok := sblock.pile["tls.cert_issuer"]; ok {
+				for _, issuerVal := range issuerVals {
+					issuer := issuerVal.Value.(certmagic.Issuer)
+					if ap == nil {
+						var err error
+						ap, err = newBaseAutomationPolicy(options, warnings, true)
+						if err != nil {
+							return nil, warnings, err
+						}
+					}
+					encoded := caddyconfig.JSONModuleObject(issuer, "module", issuer.(caddy.Module).CaddyModule().ID.Name(), &warnings)
+					if ap == catchAllAP && ap.IssuerRaw != nil && !bytes.Equal(ap.IssuerRaw, encoded) {
+						return nil, warnings, fmt.Errorf("conflicting issuer configuration: %s != %s", ap.IssuerRaw, encoded)
+					}
+					ap.IssuerRaw = encoded
+				}
+			}
+
+			if ap != nil {
+				// 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 serverBlocksWithHostlessKey > 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 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,
+				// unless, of course, the server block has a key with no hosts, in which
+				// case its automation policy becomes or blends with the default/global
+				// automation policy because, of necessity, it applies to all hostnames
+				// (i.e. it has no Subjects filter) -- in that case, we'll append it last
+				if ap != catchAllAP {
+					ap.Subjects = sblockHosts
+
+					// 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 ap.Issuer == nil {
+						var internal, external []string
+						for _, s := range ap.Subjects {
+							if certmagic.SubjectQualifiesForPublicCert(s) {
+								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.IssuerRaw = 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.certificate_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(reflect.Value(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 there is a global/catch-all automation policy, ensure it goes last
+	if catchAllAP != nil {
+		if tlsApp.Automation == nil {
+			tlsApp.Automation = new(caddytls.AutomationConfig)
+		}
+		tlsApp.Automation.Policies = append(tlsApp.Automation.Policies, catchAllAP)
+	}
+
+	// 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
+	var al caddytls.AutomateLoader
+	for h := range hostsSharedWithHostlessKey {
+		al = append(al, h)
+	}
+	if len(al) > 0 {
+		tlsApp.CertificatesRaw["automate"] = caddyconfig.JSON(al, &warnings)
+	}
+
+	// do a little verification & cleanup
+	if tlsApp.Automation != nil {
+		// 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{}{}
+			}
+		}
+
+		// consolidate automation policies that are the exact same
+		tlsApp.Automation.Policies = consolidateAutomationPolicies(tlsApp.Automation.Policies)
+	}
+
+	return tlsApp, warnings, 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) {
+	acmeCA, hasACMECA := options["acme_ca"]
+	acmeDNS, hasACMEDNS := options["acme_dns"]
+	acmeCARoot, hasACMECARoot := options["acme_ca_root"]
+	email, hasEmail := options["email"]
+	localCerts, hasLocalCerts := options["local_certs"]
+
+	hasGlobalAutomationOpts := hasACMECA || hasACMEDNS || hasACMECARoot || hasEmail || hasLocalCerts
+
+	// 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 localCerts != nil {
+		// internal issuer enabled trumps any ACME configurations; useful in testing
+		ap.IssuerRaw = caddyconfig.JSONModuleObject(caddytls.InternalIssuer{}, "module", "internal", &warnings)
+	} else {
+		if acmeCA == nil {
+			acmeCA = ""
+		}
+		if email == nil {
+			email = ""
+		}
+		mgr := caddytls.ACMEIssuer{
+			CA:    acmeCA.(string),
+			Email: email.(string),
+		}
+		if acmeDNS != nil {
+			provName := acmeDNS.(string)
+			dnsProvModule, err := caddy.GetModule("tls.dns." + provName)
+			if err != nil {
+				return nil, fmt.Errorf("getting DNS provider module named '%s': %v", provName, err)
+			}
+			mgr.Challenges = &caddytls.ChallengesConfig{
+				DNSRaw: caddyconfig.JSONModuleObject(dnsProvModule.New(), "provider", provName, &warnings),
+			}
+		}
+		if acmeCARoot != nil {
+			mgr.TrustedRootsPEMFiles = []string{acmeCARoot.(string)}
+		}
+		ap.IssuerRaw = caddyconfig.JSONModuleObject(mgr, "module", "acme", &warnings)
+	}
+
+	return ap, nil
+}
+
+// consolidateAutomationPolicies combines automation policies that are the same,
+// for a cleaner overall output.
+func consolidateAutomationPolicies(aps []*caddytls.AutomationPolicy) []*caddytls.AutomationPolicy {
+	for i := 0; i < len(aps); i++ {
+		for j := 0; j < len(aps); j++ {
+			if j == i {
+				continue
+			}
+
+			// 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 bytes.Equal(aps[i].IssuerRaw, aps[j].IssuerRaw) &&
+				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 {
+					aps = append(aps[:j], aps[j+1:]...)
+				} else if len(aps[i].Subjects) > 0 && len(aps[j].Subjects) == 0 {
+					aps = append(aps[:i], aps[i+1:]...)
+				} else {
+					aps[i].Subjects = append(aps[i].Subjects, aps[j].Subjects...)
+					aps = append(aps[:j], aps[j+1:]...)
+				}
+				i--
+				break
+			}
+		}
+	}
+
+	// ensure any catch-all policies go last
+	sort.SliceStable(aps, func(i, j int) bool {
+		return len(aps[i].Subjects) > len(aps[j].Subjects)
+	})
+
+	return aps
+}

caddyconfig/load.go

@@ -0,0 +1,153 @@
+// 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

@@ -1,252 +0,0 @@
-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
-}
-
-// IncrNest adds a level of nesting to the dispenser.
-func (d *Dispenser) IncrNest() {
-	d.nesting++
-	return
-}
-
-// 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 error with a message of msg.
-func (d *Dispenser) Err(msg string) error {
-	msg = fmt.Sprintf("%s:%d - Parse error: %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/json.go

@@ -1,184 +0,0 @@
-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

@@ -1,164 +0,0 @@
-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/parse.go

@@ -1,421 +0,0 @@
-package caddyfile
-
-import (
-	"io"
-	"os"
-	"path/filepath"
-	"strings"
-)
-
-// Parse parses the input just enough to group tokens, in
-// order, by server block. No further parsing is performed.
-// Server blocks are returned in the order in which they appear.
-// 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.
-func Parse(filename string, input io.Reader, validDirectives []string) ([]ServerBlock, error) {
-	p := parser{Dispenser: NewDispenser(filename, input), validDirectives: validDirectives}
-	blocks, err := p.parseAll()
-	return blocks, err
-}
-
-// allTokens lexes the entire input, but does not parse it.
-// It returns all the tokens from the input, unstructured
-// and in order.
-func allTokens(input io.Reader) ([]Token, error) {
-	l := new(lexer)
-	err := l.load(input)
-	if err != nil {
-		return nil, err
-	}
-	var tokens []Token
-	for l.next() {
-		tokens = append(tokens, l.token)
-	}
-	return tokens, nil
-}
-
-type parser struct {
-	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
-}
-
-func (p *parser) parseAll() ([]ServerBlock, error) {
-	var blocks []ServerBlock
-
-	for p.Next() {
-		err := p.parseOne()
-		if err != nil {
-			return blocks, err
-		}
-		if len(p.block.Keys) > 0 {
-			blocks = append(blocks, p.block)
-		}
-	}
-
-	return blocks, nil
-}
-
-func (p *parser) parseOne() error {
-	p.block = ServerBlock{Tokens: make(map[string][]Token)}
-
-	err := p.begin()
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (p *parser) begin() error {
-	if len(p.tokens) == 0 {
-		return nil
-	}
-
-	err := p.addresses()
-	if err != nil {
-		return err
-	}
-
-	if p.eof {
-		// this happens if the Caddyfile consists of only
-		// a line of addresses and nothing else
-		return nil
-	}
-
-	err = p.blockContents()
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (p *parser) addresses() error {
-	var expectingAnother bool
-
-	for {
-		tkn := replaceEnvVars(p.Val())
-
-		// special case: import directive replaces tokens during parse-time
-		if tkn == "import" && p.isNewLine() {
-			err := p.doImport()
-			if err != nil {
-				return err
-			}
-			continue
-		}
-
-		// Open brace definitely indicates end of addresses
-		if tkn == "{" {
-			if expectingAnother {
-				return p.Errf("Expected another address but had '%s' - check for extra comma", tkn)
-			}
-			break
-		}
-
-		if tkn != "" { // empty token possible if user typed ""
-			// Trailing comma indicates another address will follow, which
-			// may possibly be on the next line
-			if tkn[len(tkn)-1] == ',' {
-				tkn = tkn[:len(tkn)-1]
-				expectingAnother = true
-			} else {
-				expectingAnother = false // but we may still see another one on this line
-			}
-
-			p.block.Keys = append(p.block.Keys, tkn)
-		}
-
-		// Advance token and possibly break out of loop or return error
-		hasNext := p.Next()
-		if expectingAnother && !hasNext {
-			return p.EOFErr()
-		}
-		if !hasNext {
-			p.eof = true
-			break // EOF
-		}
-		if !expectingAnother && p.isNewLine() {
-			break
-		}
-	}
-
-	return nil
-}
-
-func (p *parser) blockContents() error {
-	errOpenCurlyBrace := p.openCurlyBrace()
-	if errOpenCurlyBrace != nil {
-		// single-server configs don't need curly braces
-		p.cursor--
-	}
-
-	err := p.directives()
-	if err != nil {
-		return err
-	}
-
-	// Only look for close curly brace if there was an opening
-	if errOpenCurlyBrace == nil {
-		err = p.closeCurlyBrace()
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-// directives parses through all the lines for directives
-// and it expects the next token to be the first
-// directive. It goes until EOF or closing curly brace
-// which ends the server block.
-func (p *parser) directives() error {
-	for p.Next() {
-		// end of server block
-		if p.Val() == "}" {
-			break
-		}
-
-		// special case: import directive replaces tokens during parse-time
-		if p.Val() == "import" {
-			err := p.doImport()
-			if err != nil {
-				return err
-			}
-			p.cursor-- // cursor is advanced when we continue, so roll back one more
-			continue
-		}
-
-		// normal case: parse a directive on this line
-		if err := p.directive(); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// doImport swaps out the import directive and its argument
-// (a total of 2 tokens) with the tokens in the specified file
-// or globbing pattern. When the function returns, the cursor
-// is on the token before where the import directive was. In
-// other words, call Next() to access the first token that was
-// imported.
-func (p *parser) doImport() error {
-	// syntax checks
-	if !p.NextArg() {
-		return p.ArgErr()
-	}
-	importPattern := replaceEnvVars(p.Val())
-	if importPattern == "" {
-		return p.Err("Import requires a non-empty filepath")
-	}
-	if p.NextArg() {
-		return p.Err("Import takes only one argument (glob pattern or 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", p.Dispenser.filename)
-	}
-
-	var matches []string
-	var globPattern string
-	if !filepath.IsAbs(importPattern) {
-		globPattern = filepath.Join(filepath.Dir(absFile), importPattern)
-	} else {
-		globPattern = importPattern
-	}
-	matches, err = filepath.Glob(globPattern)
-
-	if err != nil {
-		return p.Errf("Failed to use import pattern %s: %v", importPattern, err)
-	}
-	if len(matches) == 0 {
-		return p.Errf("No files matching import pattern %s", importPattern)
-	}
-
-	// splice out the import directive and its argument (2 tokens total)
-	tokensBefore := p.tokens[:p.cursor-1]
-	tokensAfter := p.tokens[p.cursor+1:]
-
-	// collect all the imported tokens
-	var importedTokens []Token
-	for _, importFile := range matches {
-		newTokens, err := p.doSingleImport(importFile)
-		if err != nil {
-			return err
-		}
-		var importLine int
-		importDir := filepath.Dir(importFile)
-		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(importDir, token.Text)
-				}
-				newTokens[i] = Token{
-					Text: abs,
-					Line: token.Line,
-					File: token.File,
-				}
-			}
-		}
-		importedTokens = append(importedTokens, newTokens...)
-	}
-
-	// 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(importedTokens, tokensAfter...)...)
-	p.cursor--
-
-	return nil
-}
-
-// doSingleImport lexes the individual file at importFile and returns
-// its tokens or an error, if any.
-func (p *parser) doSingleImport(importFile string) ([]Token, error) {
-	file, err := os.Open(importFile)
-	if err != nil {
-		return nil, p.Errf("Could not import %s: %v", importFile, err)
-	}
-	defer file.Close()
-
-	if info, err := file.Stat(); err != nil {
-		return nil, p.Errf("Could not import %s: %v", importFile, err)
-	} else if info.IsDir() {
-		return nil, p.Errf("Could not import %s: is a directory", importFile)
-	}
-
-	importedTokens, err := allTokens(file)
-	if err != nil {
-		return nil, p.Errf("Could not read tokens while importing %s: %v", importFile, err)
-	}
-
-	// Tack the filename onto these tokens so errors show the imported file's name
-	filename := filepath.Base(importFile)
-	for i := 0; i < len(importedTokens); i++ {
-		importedTokens[i].File = filename
-	}
-
-	return importedTokens, nil
-}
-
-// directive collects tokens until the directive's scope
-// closes (either end of line or end of curly brace block).
-// It expects the currently-loaded token to be a directive
-// (or } that ends a server block). The collected tokens
-// are loaded into the current server block for later use
-// by directive setup functions.
-func (p *parser) directive() error {
-	dir := p.Val()
-	nesting := 0
-
-	// 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
-	p.block.Tokens[dir] = append(p.block.Tokens[dir], p.tokens[p.cursor])
-
-	for p.Next() {
-		if p.Val() == "{" {
-			nesting++
-		} else if p.isNewLine() && nesting == 0 {
-			p.cursor-- // read too far
-			break
-		} else if p.Val() == "}" && nesting > 0 {
-			nesting--
-		} else if p.Val() == "}" && nesting == 0 {
-			return p.Err("Unexpected '}' because no matching opening brace")
-		}
-		p.tokens[p.cursor].Text = replaceEnvVars(p.tokens[p.cursor].Text)
-		p.block.Tokens[dir] = append(p.block.Tokens[dir], p.tokens[p.cursor])
-	}
-
-	if nesting > 0 {
-		return p.EOFErr()
-	}
-	return nil
-}
-
-// openCurlyBrace expects the current token to be an
-// opening curly brace. This acts like an assertion
-// because it returns an error if the token is not
-// a opening curly brace. It does NOT advance the token.
-func (p *parser) openCurlyBrace() error {
-	if p.Val() != "{" {
-		return p.SyntaxErr("{")
-	}
-	return nil
-}
-
-// closeCurlyBrace expects the current token to be
-// a closing curly brace. This acts like an assertion
-// because it returns an error if the token is not
-// a closing curly brace. It does NOT advance the token.
-func (p *parser) closeCurlyBrace() error {
-	if p.Val() != "}" {
-		return p.SyntaxErr("}")
-	}
-	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
-}

caddyfile/parse_test.go

@@ -1,499 +0,0 @@
-package caddyfile
-
-import (
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-func TestAllTokens(t *testing.T) {
-	input := strings.NewReader("a b c\nd e")
-	expected := []string{"a", "b", "c", "d", "e"}
-	tokens, err := allTokens(input)
-
-	if err != nil {
-		t.Fatalf("Expected no error, got %v", err)
-	}
-	if len(tokens) != len(expected) {
-		t.Fatalf("Expected %d tokens, got %d", len(expected), len(tokens))
-	}
-
-	for i, val := range expected {
-		if tokens[i].Text != val {
-			t.Errorf("Token %d should be '%s' but was '%s'", i, val, tokens[i].Text)
-		}
-	}
-}
-
-func TestParseOneAndImport(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
-	}
-
-	for i, test := range []struct {
-		input     string
-		shouldErr bool
-		keys      []string
-		tokens    map[string]int // map of directive name to number of tokens expected
-	}{
-		{`localhost`, false, []string{
-			"localhost",
-		}, map[string]int{}},
-
-		{`localhost
-		  dir1`, false, []string{
-			"localhost",
-		}, map[string]int{
-			"dir1": 1,
-		}},
-
-		{`localhost:1234
-		  dir1 foo bar`, false, []string{
-			"localhost:1234",
-		}, map[string]int{
-			"dir1": 3,
-		}},
-
-		{`localhost {
-		    dir1
-		  }`, false, []string{
-			"localhost",
-		}, map[string]int{
-			"dir1": 1,
-		}},
-
-		{`localhost:1234 {
-		    dir1 foo bar
-		    dir2
-		  }`, false, []string{
-			"localhost:1234",
-		}, map[string]int{
-			"dir1": 3,
-			"dir2": 1,
-		}},
-
-		{`http://localhost https://localhost
-		  dir1 foo bar`, false, []string{
-			"http://localhost",
-			"https://localhost",
-		}, map[string]int{
-			"dir1": 3,
-		}},
-
-		{`http://localhost https://localhost {
-		    dir1 foo bar
-		  }`, false, []string{
-			"http://localhost",
-			"https://localhost",
-		}, map[string]int{
-			"dir1": 3,
-		}},
-
-		{`http://localhost, https://localhost {
-		    dir1 foo bar
-		  }`, false, []string{
-			"http://localhost",
-			"https://localhost",
-		}, map[string]int{
-			"dir1": 3,
-		}},
-
-		{`http://localhost, {
-		  }`, true, []string{
-			"http://localhost",
-		}, map[string]int{}},
-
-		{`host1:80, http://host2.com
-		  dir1 foo bar
-		  dir2 baz`, false, []string{
-			"host1:80",
-			"http://host2.com",
-		}, map[string]int{
-			"dir1": 3,
-			"dir2": 2,
-		}},
-
-		{`http://host1.com,
-		  http://host2.com,
-		  https://host3.com`, false, []string{
-			"http://host1.com",
-			"http://host2.com",
-			"https://host3.com",
-		}, map[string]int{}},
-
-		{`http://host1.com:1234, https://host2.com
-		  dir1 foo {
-		    bar baz
-		  }
-		  dir2`, false, []string{
-			"http://host1.com:1234",
-			"https://host2.com",
-		}, map[string]int{
-			"dir1": 6,
-			"dir2": 1,
-		}},
-
-		{`127.0.0.1
-		  dir1 {
-		    bar baz
-		  }
-		  dir2 {
-		    foo bar
-		  }`, false, []string{
-			"127.0.0.1",
-		}, map[string]int{
-			"dir1": 5,
-			"dir2": 5,
-		}},
-
-		{`localhost
-		  dir1 {
-		    foo`, true, []string{
-			"localhost",
-		}, map[string]int{
-			"dir1": 3,
-		}},
-
-		{`localhost
-		  dir1 {
-		  }`, false, []string{
-			"localhost",
-		}, map[string]int{
-			"dir1": 3,
-		}},
-
-		{`localhost
-		  dir1 {
-		  } }`, true, []string{
-			"localhost",
-		}, map[string]int{
-			"dir1": 3,
-		}},
-
-		{`localhost
-		  dir1 {
-		    nested {
-		      foo
-		    }
-		  }
-		  dir2 foo bar`, false, []string{
-			"localhost",
-		}, map[string]int{
-			"dir1": 7,
-			"dir2": 3,
-		}},
-
-		{``, false, []string{}, map[string]int{}},
-
-		{`localhost
-		  dir1 arg1
-		  import testdata/import_test1.txt`, false, []string{
-			"localhost",
-		}, map[string]int{
-			"dir1": 2,
-			"dir2": 3,
-			"dir3": 1,
-		}},
-
-		{`import testdata/import_test2.txt`, false, []string{
-			"host1",
-		}, map[string]int{
-			"dir1": 1,
-			"dir2": 2,
-		}},
-
-		{`import testdata/import_test1.txt testdata/import_test2.txt`, true, []string{}, map[string]int{}},
-
-		{`import testdata/not_found.txt`, true, []string{}, map[string]int{}},
-
-		{`""`, false, []string{}, map[string]int{}},
-
-		{``, false, []string{}, map[string]int{}},
-	} {
-		result, err := testParseOne(test.input)
-
-		if test.shouldErr && err == nil {
-			t.Errorf("Test %d: Expected an error, but didn't get one", i)
-		}
-		if !test.shouldErr && err != nil {
-			t.Errorf("Test %d: Expected no error, but got: %v", i, err)
-		}
-
-		if len(result.Keys) != len(test.keys) {
-			t.Errorf("Test %d: Expected %d keys, got %d",
-				i, len(test.keys), len(result.Keys))
-			continue
-		}
-		for j, addr := range result.Keys {
-			if addr != test.keys[j] {
-				t.Errorf("Test %d, key %d: Expected '%s', but was '%s'",
-					i, j, test.keys[j], addr)
-			}
-		}
-
-		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 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
-			}
-		}
-	}
-}
-
-func TestRecursiveImport(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.Tokens) != 2 {
-			t.Errorf("got wrong number of tokens: expect 2, got %d", len(got.Tokens))
-			return false
-		}
-		if len(got.Tokens["dir1"]) != 1 || len(got.Tokens["dir2"]) != 2 {
-			t.Errorf("got unexpect tokens: %v", got.Tokens)
-			return false
-		}
-		return true
-	}
-
-	recursiveFile1, err := filepath.Abs("testdata/recursive_import_test1")
-	if err != nil {
-		t.Fatal(err)
-	}
-	recursiveFile2, err := filepath.Abs("testdata/recursive_import_test2")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// test relative recursive import
-	err = ioutil.WriteFile(recursiveFile1, []byte(
-		`localhost
-		dir1
-		import recursive_import_test2`), 0644)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.Remove(recursiveFile1)
-
-	err = ioutil.WriteFile(recursiveFile2, []byte("dir2 1"), 0644)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.Remove(recursiveFile2)
-
-	// import absolute path
-	result, err := testParseOne("import " + recursiveFile1)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !isExpected(result) {
-		t.Error("absolute+relative import failed")
-	}
-
-	// import relative path
-	result, err = testParseOne("import testdata/recursive_import_test1")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !isExpected(result) {
-		t.Error("relative+relative import failed")
-	}
-
-	// test absolute recursive import
-	err = ioutil.WriteFile(recursiveFile1, []byte(
-		`localhost
-		dir1
-		import `+recursiveFile2), 0644)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// import absolute path
-	result, err = testParseOne("import " + recursiveFile1)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !isExpected(result) {
-		t.Error("absolute+absolute import failed")
-	}
-
-	// import relative path
-	result, err = testParseOne("import testdata/recursive_import_test1")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !isExpected(result) {
-		t.Error("relative+absolute import failed")
-	}
-}
-
-func TestParseAll(t *testing.T) {
-	for i, test := range []struct {
-		input     string
-		shouldErr bool
-		keys      [][]string // keys per server block, in order
-	}{
-		{`localhost`, false, [][]string{
-			{"localhost"},
-		}},
-
-		{`localhost:1234`, false, [][]string{
-			{"localhost:1234"},
-		}},
-
-		{`localhost:1234 {
-		  }
-		  localhost:2015 {
-		  }`, false, [][]string{
-			{"localhost:1234"},
-			{"localhost:2015"},
-		}},
-
-		{`localhost:1234, http://host2`, false, [][]string{
-			{"localhost:1234", "http://host2"},
-		}},
-
-		{`localhost:1234, http://host2,`, true, [][]string{}},
-
-		{`http://host1.com, http://host2.com {
-		  }
-		  https://host3.com, https://host4.com {
-		  }`, false, [][]string{
-			{"http://host1.com", "http://host2.com"},
-			{"https://host3.com", "https://host4.com"},
-		}},
-
-		{`import testdata/import_glob*.txt`, false, [][]string{
-			{"glob0.host0"},
-			{"glob0.host1"},
-			{"glob1.host0"},
-			{"glob2.host0"},
-		}},
-	} {
-		p := testParser(test.input)
-		blocks, err := p.parseAll()
-
-		if test.shouldErr && err == nil {
-			t.Errorf("Test %d: Expected an error, but didn't get one", i)
-		}
-		if !test.shouldErr && err != nil {
-			t.Errorf("Test %d: Expected no error, but got: %v", i, err)
-		}
-
-		if len(blocks) != len(test.keys) {
-			t.Errorf("Test %d: Expected %d server blocks, got %d",
-				i, len(test.keys), len(blocks))
-			continue
-		}
-		for j, block := range blocks {
-			if len(block.Keys) != len(test.keys[j]) {
-				t.Errorf("Test %d: Expected %d keys in block %d, got %d",
-					i, len(test.keys[j]), j, len(block.Keys))
-				continue
-			}
-			for k, addr := range block.Keys {
-				if addr != test.keys[j][k] {
-					t.Errorf("Test %d, block %d, key %d: Expected '%s', but got '%s'",
-						i, j, k, test.keys[j][k], addr)
-				}
-			}
-		}
-	}
-}
-
-func TestEnvironmentReplacement(t *testing.T) {
-	os.Setenv("PORT", "8080")
-	os.Setenv("ADDRESS", "servername.com")
-	os.Setenv("FOOBAR", "foobar")
-
-	// 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)
-	}
-
-	// 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)
-	}
-
-	// 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)
-	}
-
-	// 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)
-	}
-
-	// 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].Tokens["dir1"][1].Text, "foobar"; expected != actual {
-		t.Errorf("Expected argument to be '%s' but was '%s'", 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)
-	}
-
-	// 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)
-	}
-
-	// 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)
-	}
-
-	// 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 {
-	buf := strings.NewReader(input)
-	p := parser{Dispenser: NewDispenser("Caddyfile", buf)}
-	return p
-}

caddyhttp/basicauth/basicauth.go

@@ -1,159 +0,0 @@
-// 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"
-	"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 hasAuth bool
-	var isAuthenticated bool
-
-	for _, rule := range a.Rules {
-		for _, res := range rule.Resources {
-			if !httpserver.Path(r.URL.Path).Matches(res) {
-				continue
-			}
-
-			// Path matches; parse auth header
-			username, password, ok := r.BasicAuth()
-			hasAuth = true
-
-			// Check credentials
-			if !ok ||
-				username != rule.Username ||
-				!rule.Password(password) {
-				continue
-			}
-
-			// Flag set only on successful authentication
-			isAuthenticated = true
-		}
-	}
-
-	if hasAuth {
-		if !isAuthenticated {
-			w.Header().Set("WWW-Authenticate", "Basic realm=\"Restricted\"")
-			return http.StatusUnauthorized, nil
-		}
-		// "It's an older code, sir, but it checks out. I was about to clear them."
-		return a.Next.ServeHTTP(w, r)
-	}
-
-	// 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
-}
-
-// 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

@@ -1,146 +0,0 @@
-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) {
-	rw := BasicAuth{
-		Next: httpserver.HandlerFunc(contentHandler),
-		Rules: []Rule{
-			{Username: "test", Password: PlainMatcher("ttest"), Resources: []string{"/testing"}},
-		},
-	}
-
-	tests := []struct {
-		from   string
-		result int
-		cred   string
-	}{
-		{"/testing", http.StatusUnauthorized, "ttest:test"},
-		{"/testing", http.StatusOK, "test:ttest"},
-		{"/testing", http.StatusUnauthorized, ""},
-	}
-
-	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)
-		}
-		if result == http.StatusUnauthorized {
-			headers := rec.Header()
-			if val, ok := headers["Www-Authenticate"]; ok {
-				if val[0] != "Basic realm=\"Restricted\"" {
-					t.Errorf("Test %d, Www-Authenticate should be %s provided %s", i, "Basic", val[0])
-				}
-			} else {
-				t.Errorf("Test %d, should provide a header Www-Authenticate", 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.Skipf("Error creating temp file (%v), 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

@@ -1,82 +0,0 @@
-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)
-			}
-
-			for c.NextBlock() {
-				rule.Resources = append(rule.Resources, c.Val())
-				if c.NextArg() {
-					return rules, c.Errf("Expecting only one resource per line (extra '%s')", c.Val())
-				}
-			}
-		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()
-		}
-
-		rules = append(rules, rule)
-	}
-
-	return rules, nil
-}
-
-func passwordMatcher(username, passw, siteRoot string) (PasswordMatcher, error) {
-	if !strings.HasPrefix(passw, "htpasswd=") {
-		return PlainMatcher(passw), nil
-	}
-	return GetHtpasswdMatcher(passw[9:], username, siteRoot)
-}

caddyhttp/basicauth/setup_test.go

@@ -1,132 +0,0 @@
-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 user pwd {
-			/resource1
-			/resource2
-		}`, false, "pwd", []Rule{
-			{Username: "user", Resources: []string{"/resource1", "/resource2"}},
-		}},
-		{`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 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,24 +0,0 @@
-package bind
-
-import (
-	"github.com/mholt/caddy"
-	"github.com/mholt/caddy/caddyhttp/httpserver"
-)
-
-func init() {
-	caddy.RegisterPlugin("bind", caddy.Plugin{
-		ServerType: "http",
-		Action:     setupBind,
-	})
-}
-
-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 nil
-}

caddyhttp/bind/bind_test.go

@@ -1,24 +0,0 @@
-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

@@ -1,432 +0,0 @@
-// 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"
-)
-
-// 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
-	Root      http.FileSystem
-	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
-}
-
-// BreadcrumbMap returns l.Path where every element is a map
-// of URLs and path segment names.
-func (l Listing) BreadcrumbMap() map[string]string {
-	result := map[string]string{}
-
-	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, part := range parts {
-		if i == 0 && part == "" {
-			// Leading slash (root)
-			result["/"] = "/"
-			continue
-		}
-		result[strings.Join(parts[:i+1], "/")] = part
-	}
-
-	return result
-}
-
-// FileInfo is the info about a particular file or directory
-type FileInfo struct {
-	IsDir   bool
-	Name    string
-	Size    int64
-	URL     string
-	ModTime time.Time
-	Mode    os.FileMode
-}
-
-// 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 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 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
-	if l.Items[i].IsDir {
-		iSize = directoryOffset + iSize
-	}
-	if l.Items[j].IsDir {
-		jSize = directoryOffset + jSize
-	}
-	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 "name":
-			sort.Sort(sort.Reverse(byName(l)))
-		case "size":
-			sort.Sort(sort.Reverse(bySize(l)))
-		case "time":
-			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 "name":
-			sort.Sort(byName(l))
-		case "size":
-			sort.Sort(bySize(l))
-		case "time":
-			sort.Sort(byTime(l))
-		default:
-			// If not one of the above, do nothing
-			return
-		}
-	}
-}
-
-func directoryListing(files []os.FileInfo, canGoUp bool, urlPath string) (Listing, bool) {
-	var (
-		fileinfos           []FileInfo
-		dirCount, fileCount int
-		hasIndexFile        bool
-	)
-
-	for _, f := range files {
-		name := f.Name()
-
-		for _, indexName := range staticfiles.IndexPages {
-			if name == indexName {
-				hasIndexFile = true
-				break
-			}
-		}
-
-		if f.IsDir() {
-			name += "/"
-			dirCount++
-		} else {
-			fileCount++
-		}
-
-		url := url.URL{Path: "./" + name} // prepend with "./" to fix paths with ':' in the name
-
-		fileinfos = append(fileinfos, FileInfo{
-			IsDir:   f.IsDir(),
-			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
-}
-
-// 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) {
-	var bc *Config
-	// See if there's a browse configuration to match the path
-	for i := range b.Configs {
-		if httpserver.Path(r.URL.Path).Matches(b.Configs[i].PathScope) {
-			bc = &b.Configs[i]
-			goto inScope
-		}
-	}
-	return b.Next.ServeHTTP(w, r)
-inScope:
-
-	// Browse works on existing directories; delegate everything else
-	requestedFilepath, err := bc.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)
-	if !strings.HasSuffix(r.URL.Path, "/") {
-		staticfiles.Redirect(w, r, r.URL.Path+"/", http.StatusTemporaryRedirect)
-		return 0, nil
-	}
-
-	return b.ServeListing(w, r, requestedFilepath, bc)
-}
-
-func (b Browse) loadDirectoryContents(requestedFilepath http.File, urlPath string) (*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)
-
-	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 = "name"
-		if sortCookie, sortErr := r.Cookie("sort"); sortErr == nil {
-			sort = sortCookie.Value
-		}
-	case "name", "size", "type":
-		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)
-	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.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

@@ -1,356 +0,0 @@
-package browse
-
-import (
-	"encoding/json"
-	"net/http"
-	"net/http/httptest"
-	"net/url"
-	"os"
-	"path/filepath"
-	"sort"
-	"testing"
-	"text/template"
-	"time"
-
-	"github.com/mholt/caddy/caddyhttp/httpserver"
-)
-
-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)
-	}
-
-	// 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)
-	}
-}
-
-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",
-				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)
-		}
-
-		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",
-				Root:      http.Dir("./testdata"),
-				Template:  tmpl,
-			},
-		},
-	}
-
-	req, err := http.NewRequest("GET", "/photos/", nil)
-	if err != nil {
-		t.Fatalf("Test: Could not create HTTP request: %v", err)
-	}
-
-	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="./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")
-			return 0, nil
-		}),
-		Configs: []Config{
-			{
-				PathScope: "/photos/",
-				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(),
-		})
-	}
-	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
-		{"/", "", "", -1, false, listing.Items},
-		//test case 2: limit is set to 1, orderBy and sortBy is default
-		{"/?limit=1", "", "", 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", "", "", 100000000, false, listing.Items},
-		//test case 4 : testing for negative limit
-		{"/?limit=-1", "", "", -1, false, listing.Items},
-		//test case 5 : testing with limit set to -1 and order set to descending
-		{"/?limit=-1&order=desc", "", "desc", -1, false, listing.Items},
-		//test case 6 : testing with limit set to 2 and order set to descending
-		{"/?limit=2&order=desc", "", "desc", 2, false, listing.Items},
-		//test case 7 : testing with limit set to 3 and order set to descending
-		{"/?limit=3&order=desc", "", "desc", 3, false, listing.Items},
-		//test case 8 : testing with limit set to 3 and order set to ascending
-		{"/?limit=3&order=asc", "", "asc", 3, false, listing.Items},
-		//test case 9 : testing with limit set to 1111111 and order set to ascending
-		{"/?limit=1111111&order=asc", "", "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", "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", "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", "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", "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", "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)
-		}
-
-		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
-}

caddyhttp/browse/setup.go

@@ -1,427 +0,0 @@
-package browse
-
-import (
-	"fmt"
-	"io/ioutil"
-	"net/http"
-	"text/template"
-
-	"github.com/mholt/caddy"
-	"github.com/mholt/caddy/caddyhttp/httpserver"
-)
-
-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.Root = http.Dir(cfg.Root)
-		theRoot, err := bc.Root.Open("/") // catch a missing path early
-		if err != nil {
-			return configs, err
-		}
-		defer theRoot.Close()
-		_, err = theRoot.Readdir(-1)
-		if err != nil {
-			return configs, err
-		}
-
-		// 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>{{.Name}}</title>
-		<meta name="viewport" content="width=device-width, initial-scale=1.0">
-<style>
-* { padding: 0; margin: 0; }
-
-body {
-	font-family: sans-serif;
-	text-rendering: optimizespeed;
-}
-
-a {
-	color: #006ed3;
-	text-decoration: none;
-}
-
-a:hover,
-h1 a:hover {
-	color: #319cff;
-}
-
-header,
-#summary {
-	padding-left: 5%;
-	padding-right: 5%;
-}
-
-th:first-child,
-td:first-child {
-	padding-left: 5%;
-}
-
-th:last-child,
-td:last-child {
-	padding-right: 5%;
-}
-
-header {
-	padding-top: 25px;
-	padding-bottom: 15px;
-	background-color: #f2f2f2;
-}
-
-h1 {
-	font-size: 20px;
-	font-weight: normal;
-	white-space: nowrap;
-	overflow-x: hidden;
-	text-overflow: ellipsis;
-}
-
-h1 a {
-	color: inherit;
-}
-
-h1 a:hover {
-	text-decoration: underline;
-}
-
-main {
-	display: block;
-}
-
-.meta {
-	font-size: 12px;
-	font-family: Verdana, sans-serif;
-	border-bottom: 1px solid #9C9C9C;
-	padding-top: 15px;
-	padding-bottom: 15px;
-}
-
-.meta-item {
-	margin-right: 1em;
-}
-
-table {
-	width: 100%;
-	border-collapse: collapse;
-}
-
-tr {
-	border-bottom: 1px dashed #dadada;
-}
-
-tbody tr:hover {
-	background-color: #ffffec;
-}
-
-th,
-td {
-	text-align: left;
-	padding: 10px 0;
-}
-
-th {
-	padding-top: 15px;
-	padding-bottom: 15px;
-	font-size: 16px;
-	white-space: nowrap;
-}
-
-th a {
-	color: black;
-}
-
-th svg {
-	vertical-align: middle;
-}
-
-td {
-	font-size: 14px;
-}
-
-td:first-child {
-	width: 50%;
-}
-
-th:last-child,
-td:last-child {
-	text-align: right;
-}
-
-td:first-child svg {
-	position: absolute;
-}
-
-td .name,
-td .goup {
-	margin-left: 1.75em;
-	word-break: break-all;
-	overflow-wrap: break-word;
-	white-space: pre-wrap;
-}
-
-footer {
-	padding: 40px 20px;
-	font-size: 12px;
-	text-align: center;
-}
-
-@media (max-width: 600px) {
-	.hideable {
-		display: none;
-	}
-
-	td:first-child {
-		width: auto;
-	}
-
-	th:nth-child(2),
-	td:nth-child(2) {
-		padding-right: 5%;
-		text-align: right;
-	}
-}
-</style>
-	</head>
-	<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 -->
-				<linearGradient id="f" y2="640" gradientUnits="userSpaceOnUse" x2="244.84" gradientTransform="matrix(.97319 0 0 1.0135 -.50695 -13.679)" y1="415.75" x1="244.84">
-					<stop stop-color="#b3ddfd" offset="0"/>
-					<stop stop-color="#69c" offset="1"/>
-				</linearGradient>
-				<linearGradient id="e" y2="571.06" gradientUnits="userSpaceOnUse" x2="238.03" gradientTransform="translate(0,2)" y1="346.05" x1="236.26">
-					<stop stop-color="#ace" offset="0"/>
-					<stop stop-color="#369" offset="1"/>
-				</linearGradient>
-				<g id="folder" transform="translate(-266.06 -193.36)">
-					<g transform="matrix(.066019 0 0 .066019 264.2 170.93)">
-						<g transform="matrix(1.4738 0 0 1.4738 -52.053 -166.93)">
-							<path fill="#69c" d="m98.424 343.78c-11.08 0-20 8.92-20 20v48.5 33.719 105.06c0 11.08 8.92 20 20 20h279.22c11.08 0 20-8.92 20-20v-138.78c0-11.08-8.92-20-20-20h-117.12c-7.5478-1.1844-9.7958-6.8483-10.375-11.312v-5.625-11.562c0-11.08-8.92-20-20-20h-131.72z"/>
-							<rect rx="12.885" ry="12.199" height="227.28" width="366.69" y="409.69" x="54.428" fill="#369"/>
-							<path fill="url(#e)" d="m98.424 345.78c-11.08 0-20 8.92-20 20v48.5 33.719 105.06c0 11.08 8.92 20 20 20h279.22c11.08 0 20-8.92 20-20v-138.78c0-11.08-8.92-20-20-20h-117.12c-7.5478-1.1844-9.7958-6.8483-10.375-11.312v-5.625-11.562c0-11.08-8.92-20-20-20h-131.72z"/>
-							<rect rx="12.885" ry="12.199" height="227.28" width="366.69" y="407.69" x="54.428" fill="url(#f)"/>
-						</g>
-					</g>
-				</g>
-
-				<!-- File -->
-				<linearGradient id="a">
-					<stop stop-color="#cbcbcb" offset="0"/>
-					<stop stop-color="#f0f0f0" offset=".34923"/>
-					<stop stop-color="#e2e2e2" offset="1"/>
-				</linearGradient>
-				<linearGradient id="d" y2="686.15" xlink:href="#a" gradientUnits="userSpaceOnUse" y1="207.83" gradientTransform="matrix(.28346 0 0 .31053 -608.52 485.11)" x2="380.1" x1="749.25"/>
-				<linearGradient id="c" y2="287.74" xlink:href="#a" gradientUnits="userSpaceOnUse" y1="169.44" gradientTransform="matrix(.28342 0 0 .31057 -608.52 485.11)" x2="622.33" x1="741.64"/>
-				<linearGradient id="b" y2="418.54" gradientUnits="userSpaceOnUse" y1="236.13" gradientTransform="matrix(.29343 0 0 .29999 -608.52 485.11)" x2="330.88" x1="687.96">
-					<stop stop-color="#fff" offset="0"/>
-					<stop stop-color="#fff" stop-opacity="0" offset="1"/>
-				</linearGradient>
-				<g id="file" transform="translate(-278.15 -216.59)">
-					<g fill-rule="evenodd" transform="matrix(.19775 0 0 .19775 381.05 112.68)">
-						<path d="m-520.17 525.5v36.739 36.739 36.739 36.739h33.528 33.528 33.528 33.528v-36.739-36.739-36.739l-33.528-36.739h-33.528-33.528-33.528z" stroke-opacity=".36478" stroke-width=".42649" fill="#fff"/>
-						<g>
-							<path d="m-520.11 525.68v36.739 36.739 36.739 36.739h33.528 33.528 33.528 33.528v-36.739-36.739-36.739l-33.528-36.739h-33.528-33.528-33.528z" stroke-opacity=".36478" stroke="#000" stroke-width=".42649" fill="url(#d)"/>
-							<path d="m-386 562.42c-10.108-2.9925-23.206-2.5682-33.101-0.86253 1.7084-10.962 1.922-24.701-0.4271-35.877l33.528 36.739z" stroke-width=".95407pt" fill="url(#c)"/>
-							<path d="m-519.13 537-0.60402 134.7h131.68l0.0755-33.296c-2.9446 1.1325-32.692-40.998-70.141-39.186-37.483 1.8137-27.785-56.777-61.006-62.214z" stroke-width="1pt" fill="url(#b)"/>
-						</g>
-					</g>
-				</g>
-
-				<!-- Up arrow -->
-				<g id="up-arrow" transform="translate(-279.22 -208.12)">
-					<path transform="matrix(.22413 0 0 .12089 335.67 164.35)" stroke-width="0" d="m-194.17 412.01h-28.827-28.827l14.414-24.965 14.414-24.965 14.414 24.965z"/>
-				</g>
-
-				<!-- Down arrow -->
-				<g id="down-arrow" transform="translate(-279.22 -208.12)">
-					<path transform="matrix(.22413 0 0 -.12089 335.67 257.93)" stroke-width="0" d="m-194.17 412.01h-28.827-28.827l14.414-24.965 14.414-24.965 14.414 24.965z"/>
-				</g>
-			</defs>
-		</svg>
-
-		<header>
-			<h1>
-				{{range $url, $name := .BreadcrumbMap}}<a href="{{$url}}">{{$name}}</a>{{if ne $url "/"}}/{{end}}{{end}}
-			</h1>
-		</header>
-		<main>
-			<div class="meta">
-				<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 .ItemsLimitedTo}}
-					<span class="meta-item">(of which only <b>{{.ItemsLimitedTo}}</b> are displayed)</span>
-					{{- end}}
-				</div>
-			</div>
-			<div class="listing">
-				<table aria-describedby="summary">
-					<thead>
-					<tr>
-						<th>
-							{{- if and (eq .Sort "name") (ne .Order "desc")}}
-							<a href="?sort=name&order=desc{{if ne 0 .ItemsLimitedTo}}&limit={{.ItemsLimitedTo}}{{end}}">Name <svg width="1em" height=".4em" 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 .ItemsLimitedTo}}&limit={{.ItemsLimitedTo}}{{end}}">Name <svg width="1em" height=".4em" 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 .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 .ItemsLimitedTo}}&limit={{.ItemsLimitedTo}}{{end}}">Size <svg width="1em" height=".4em" 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 .ItemsLimitedTo}}&limit={{.ItemsLimitedTo}}{{end}}">Size <svg width="1em" height=".4em" 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 .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 .ItemsLimitedTo}}&limit={{.ItemsLimitedTo}}{{end}}">Modified <svg width="1em" height=".4em" 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 .ItemsLimitedTo}}&limit={{.ItemsLimitedTo}}{{end}}">Modified <svg width="1em" height=".4em" 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 .ItemsLimitedTo}}&limit={{.ItemsLimitedTo}}{{end}}">Modified</a>
-							{{- end}}
-						</th>
-					</tr>
-					</thead>
-					<tbody>
-					{{- if .CanGoUp}}
-					<tr>
-						<td>
-							<a href="..">
-								<span class="goup">Go up</span>
-							</a>
-						</td>
-						<td>&mdash;</td>
-						<td class="hideable">&mdash;</td>
-					</tr>
-					{{- end}}
-					{{- range .Items}}
-					<tr>
-						<td>
-							<a href="{{.URL}}">
-								{{- if .IsDir}}
-								<svg width="1.5em" height="1em" version="1.1" viewBox="0 0 35.678803 28.527945"><use xlink:href="#folder"></use></svg>
-								{{- else}}
-								<svg width="1.5em" height="1em" version="1.1" viewBox="0 0 26.604381 29.144726"><use xlink:href="#file"></use></svg>
-								{{- end}}
-								<span class="name">{{.Name}}</span>
-							</a>
-						</td>
-						{{- if .IsDir}}
-						<td data-order="-1">&mdash;</td>
-						{{- else}}
-						<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>
-					</tr>
-					{{- end}}
-					</tbody>
-				</table>
-			</div>
-		</main>
-		<footer>
-			Served with <a rel="noopener noreferrer" href="https://caddyserver.com">Caddy</a>.
-		</footer>
-		<script type="text/javascript">
-			function localizeDatetime(e, index, ar) {
-				if (e.textContent === undefined) {
-					return;
-				}
-				var d = new Date(e.getAttribute('datetime'));
-				if (isNaN(d)) {
-					d = new Date(e.textContent);
-					if (isNaN(d)) {
-						return;
-					}
-				}
-				e.textContent = d.toLocaleString();
-			}
-			var timeList = Array.prototype.slice.call(document.getElementsByTagName("time"));
-			timeList.forEach(localizeDatetime);
-		</script>
-	</body>
-</html>`

caddyhttp/browse/setup_test.go

@@ -1,69 +0,0 @@
-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)
-	}
-	nonExistantDirPath := 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 . " + nonExistantDirPath, 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)
-			}
-		}
-	}
-}

caddyhttp/browse/testdata/header.html

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

caddyhttp/browse/testdata/photos.tpl

@@ -1,13 +0,0 @@
-<!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/test.html

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

caddyhttp/browse/testdata/photos/test2.html

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

caddyhttp/browse/testdata/photos/test3.html

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

caddyhttp/caddyhttp.go

@@ -1,30 +0,0 @@
-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/internalsrv"
-	_ "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/redirect"
-	_ "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/websocket"
-	_ "github.com/mholt/caddy/startupshutdown"
-)

caddyhttp/caddyhttp_test.go

@@ -1,19 +0,0 @@
-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 := 27 // 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

@@ -1,154 +0,0 @@
-// Package errors implements an HTTP error handling middleware.
-package errors
-
-import (
-	"fmt"
-	"io"
-	"log"
-	"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
-	LogFile          string
-	Log              *log.Logger
-	LogRoller        *httpserver.LogRoller
-	Debug            bool     // if true, errors are written out to client rather than to a log
-	file             *os.File // a log file to close when done
-}
-
-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

@@ -1,259 +0,0 @@
-package errors
-
-import (
-	"bytes"
-	"errors"
-	"fmt"
-	"log"
-	"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: log.New(&buf, "", 0),
-	}
-	_, 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: log.New(&buf, "", 0),
-	}
-
-	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

@@ -1,171 +0,0 @@
-package errors
-
-import (
-	"io"
-	"log"
-	"os"
-	"path/filepath"
-	"strconv"
-
-	"github.com/hashicorp/go-syslog"
-	"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
-	}
-
-	// Open the log file for writing when the server starts
-	c.OnStartup(func() error {
-		var err error
-		var writer io.Writer
-
-		switch handler.LogFile {
-		case "visible":
-			handler.Debug = true
-		case "stdout":
-			writer = os.Stdout
-		case "stderr":
-			writer = os.Stderr
-		case "syslog":
-			writer, err = gsyslog.NewLogger(gsyslog.LOG_ERR, "LOCAL0", "caddy")
-			if err != nil {
-				return err
-			}
-		default:
-			if handler.LogFile == "" {
-				writer = os.Stderr // default
-				break
-			}
-
-			var file *os.File
-			file, err = os.OpenFile(handler.LogFile, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0644)
-			if err != nil {
-				return err
-			}
-			if handler.LogRoller != nil {
-				file.Close()
-				handler.LogRoller.Filename = handler.LogFile
-				writer = handler.LogRoller.GetLogWriter()
-			} else {
-				handler.file = file
-				writer = file
-			}
-		}
-
-		handler.Log = log.New(writer, "", 0)
-		return nil
-	})
-
-	// When server stops, close any open log file
-	c.OnShutdown(func() error {
-		if handler.file != nil {
-			handler.file.Close()
-		}
-		return nil
-	})
-
-	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)}
-
-	cfg := httpserver.GetConfig(c)
-
-	optionalBlock := func() (bool, error) {
-		var hadBlock bool
-
-		for c.NextBlock() {
-			hadBlock = true
-
-			what := c.Val()
-			if !c.NextArg() {
-				return hadBlock, c.ArgErr()
-			}
-			where := c.Val()
-
-			if what == "log" {
-				if where == "visible" {
-					handler.Debug = true
-				} else {
-					handler.LogFile = where
-					if c.NextArg() {
-						if c.Val() == "{" {
-							c.IncrNest()
-							logRoller, err := httpserver.ParseRoller(c)
-							if err != nil {
-								return hadBlock, err
-							}
-							handler.LogRoller = logRoller
-						}
-					}
-				}
-			} else {
-				// Error page; ensure it exists
-				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 hadBlock, c.Errf("Duplicate status code entry: %s", what)
-					}
-					handler.GenericErrorPage = where
-				} else {
-					whatInt, err := strconv.Atoi(what)
-					if err != nil {
-						return hadBlock, c.Err("Expecting a numeric status code or '*', got '" + what + "'")
-					}
-
-					if _, exists := handler.ErrorPages[whatInt]; exists {
-						return hadBlock, c.Errf("Duplicate status code entry: %s", what)
-					}
-
-					handler.ErrorPages[whatInt] = where
-				}
-			}
-		}
-		return hadBlock, nil
-	}
-
-	for c.Next() {
-		// weird hack to avoid having the handler values overwritten.
-		if c.Val() == "}" {
-			continue
-		}
-		// Configuration may be in a block
-		hadBlock, err := optionalBlock()
-		if err != nil {
-			return handler, err
-		}
-
-		// Otherwise, the only argument would be an error log file name or 'visible'
-		if !hadBlock {
-			if c.NextArg() {
-				if c.Val() == "visible" {
-					handler.Debug = true
-				} else {
-					handler.LogFile = c.Val()
-				}
-			}
-		}
-	}
-
-	return handler, nil
-}

caddyhttp/errors/setup_test.go

@@ -1,182 +0,0 @@
-package errors
-
-import (
-	"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)
-	}
-
-	if myHandler.LogFile != "" {
-		t.Errorf("Expected '%s' as the default LogFile", "")
-	}
-	if myHandler.LogRoller != nil {
-		t.Errorf("Expected LogRoller to be nil, got: %v", *myHandler.LogRoller)
-	}
-	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) {
-	tests := []struct {
-		inputErrorsRules     string
-		shouldErr            bool
-		expectedErrorHandler ErrorHandler
-	}{
-		{`errors`, false, ErrorHandler{
-			LogFile: "",
-		}},
-		{`errors errors.txt`, false, ErrorHandler{
-			LogFile: "errors.txt",
-		}},
-		{`errors visible`, false, ErrorHandler{
-			LogFile: "",
-			Debug:   true,
-		}},
-		{`errors { log visible }`, false, ErrorHandler{
-			LogFile: "",
-			Debug:   true,
-		}},
-		{`errors { log errors.txt
-        404 404.html
-        500 500.html
-}`, false, ErrorHandler{
-			LogFile: "errors.txt",
-			ErrorPages: map[int]string{
-				404: "404.html",
-				500: "500.html",
-			},
-		}},
-		{`errors { log errors.txt { size 2 age 10 keep 3 } }`, false, ErrorHandler{
-			LogFile: "errors.txt",
-			LogRoller: &httpserver.LogRoller{
-				MaxSize:    2,
-				MaxAge:     10,
-				MaxBackups: 3,
-				LocalTime:  true,
-			},
-		}},
-		{`errors { log errors.txt {
-            size 3
-            age 11
-            keep 5
-        }
-        404 404.html
-        503 503.html
-}`, false, ErrorHandler{
-			LogFile: "errors.txt",
-			ErrorPages: map[int]string{
-				404: "404.html",
-				503: "503.html",
-			},
-			LogRoller: &httpserver.LogRoller{
-				MaxSize:    3,
-				MaxAge:     11,
-				MaxBackups: 5,
-				LocalTime:  true,
-			},
-		}},
-		{`errors { log errors.txt
-        * generic_error.html
-        404 404.html
-        503 503.html
-}`, false, ErrorHandler{
-			LogFile:          "errors.txt",
-			GenericErrorPage: "generic_error.html",
-			ErrorPages: map[int]string{
-				404: "404.html",
-				503: "503.html",
-			},
-		}},
-		// Next two test cases is the detection of duplicate status codes
-		{`errors {
-        503 503.html
-        503 503.html
-}`, true, ErrorHandler{}},
-		{`errors {
-        * generic_error.html
-        * generic_error.html
-}`, true, ErrorHandler{}},
-	}
-	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 actualErrorsRule.LogFile != test.expectedErrorHandler.LogFile {
-			t.Errorf("Test %d expected LogFile to be %s, but got %s",
-				i, test.expectedErrorHandler.LogFile, actualErrorsRule.LogFile)
-		}
-		if actualErrorsRule.Debug != test.expectedErrorHandler.Debug {
-			t.Errorf("Test %d expected Debug to be %v, but got %v",
-				i, test.expectedErrorHandler.Debug, actualErrorsRule.Debug)
-		}
-		if actualErrorsRule.LogRoller != nil && test.expectedErrorHandler.LogRoller == nil || actualErrorsRule.LogRoller == nil && test.expectedErrorHandler.LogRoller != nil {
-			t.Fatalf("Test %d expected LogRoller to be %v, but got %v",
-				i, test.expectedErrorHandler.LogRoller, actualErrorsRule.LogRoller)
-		}
-		if len(actualErrorsRule.ErrorPages) != len(test.expectedErrorHandler.ErrorPages) {
-			t.Fatalf("Test %d expected %d no of Error pages, but got %d ",
-				i, len(test.expectedErrorHandler.ErrorPages), len(actualErrorsRule.ErrorPages))
-		}
-		if actualErrorsRule.LogRoller != nil && test.expectedErrorHandler.LogRoller != nil {
-			if actualErrorsRule.LogRoller.Filename != test.expectedErrorHandler.LogRoller.Filename {
-				t.Fatalf("Test %d expected LogRoller Filename to be %s, but got %s",
-					i, test.expectedErrorHandler.LogRoller.Filename, actualErrorsRule.LogRoller.Filename)
-			}
-			if actualErrorsRule.LogRoller.MaxAge != test.expectedErrorHandler.LogRoller.MaxAge {
-				t.Fatalf("Test %d expected LogRoller MaxAge to be %d, but got %d",
-					i, test.expectedErrorHandler.LogRoller.MaxAge, actualErrorsRule.LogRoller.MaxAge)
-			}
-			if actualErrorsRule.LogRoller.MaxBackups != test.expectedErrorHandler.LogRoller.MaxBackups {
-				t.Fatalf("Test %d expected LogRoller MaxBackups to be %d, but got %d",
-					i, test.expectedErrorHandler.LogRoller.MaxBackups, actualErrorsRule.LogRoller.MaxBackups)
-			}
-			if actualErrorsRule.LogRoller.MaxSize != test.expectedErrorHandler.LogRoller.MaxSize {
-				t.Fatalf("Test %d expected LogRoller MaxSize to be %d, but got %d",
-					i, test.expectedErrorHandler.LogRoller.MaxSize, actualErrorsRule.LogRoller.MaxSize)
-			}
-			if actualErrorsRule.LogRoller.LocalTime != test.expectedErrorHandler.LogRoller.LocalTime {
-				t.Fatalf("Test %d expected LogRoller LocalTime to be %t, but got %t",
-					i, test.expectedErrorHandler.LogRoller.LocalTime, actualErrorsRule.LogRoller.LocalTime)
-			}
-		}
-		if actualErrorsRule.GenericErrorPage != test.expectedErrorHandler.GenericErrorPage {
-			t.Fatalf("Test %d expected GenericErrorPage to be %v, but got %v",
-				i, test.expectedErrorHandler.GenericErrorPage, actualErrorsRule.GenericErrorPage)
-		}
-	}
-
-}

caddyhttp/expvar/expvar.go

@@ -1,45 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,52 +0,0 @@
-// 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 path.Ext(urlpath) == "" && len(r.URL.Path) > 0 && r.URL.Path[len(r.URL.Path)-1] != '/' {
-		for _, ext := range e.Extensions {
-			if resourceExists(e.Root, urlpath+ext) {
-				r.URL.Path = urlpath + ext
-				break
-			}
-		}
-	}
-	return e.Next.ServeHTTP(w, r)
-}
-
-// resourceExists returns true if the file specified at
-// root + path exists; false otherwise.
-func resourceExists(root, path string) bool {
-	_, err := os.Stat(root + path)
-	// technically we should use os.IsNotExist(err)
-	// but we don't handle any other kinds of errors anyway
-	return err == nil
-}

caddyhttp/extensions/setup.go

@@ -1,53 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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

@@ -1,381 +0,0 @@
-// 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 (
-	"errors"
-	"io"
-	"net/http"
-	"os"
-	"path"
-	"path/filepath"
-	"strconv"
-	"strings"
-	"sync"
-
-	"github.com/mholt/caddy/caddyhttp/httpserver"
-)
-
-// persistent fastcgi connections
-
-type serialClient struct {
-	// for read/write serialisation
-	sync.Mutex
-	backend *FCGIClient
-}
-type concurrentPersistentConnectionsMap struct {
-	// for thread safe acces to the map
-	sync.Mutex
-	clientMap map[string]*serialClient
-}
-
-var persistentConnections = &(concurrentPersistentConnectionsMap{clientMap: make(map[string]*serialClient)})
-
-// UsePersistentFcgiConnections TODO: add an option in Caddyfile and pass it down to here
-var UsePersistentFcgiConnections = true
-
-// Handler is a middleware type that can handle requests as a FastCGI client.
-type Handler struct {
-	Next    httpserver.Handler
-	Rules   []Rule
-	Root    string
-	AbsRoot string // same as root, but absolute path
-	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 and the path must be allowed.
-		if !httpserver.Path(r.URL.Path).Matches(rule.Path) || !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
-			network, address := rule.parseAddress()
-
-			var fcgiBackend *FCGIClient
-			var client *serialClient
-			reuse := false
-			if UsePersistentFcgiConnections {
-				persistentConnections.Lock()
-				client, reuse = persistentConnections.clientMap[network+address]
-				persistentConnections.Unlock()
-			}
-
-			if reuse {
-				client.Lock()
-				defer client.Unlock()
-				fcgiBackend = client.backend
-			} else {
-				fcgiBackend, err = Dial(network, address)
-				if err != nil {
-					return http.StatusBadGateway, err
-				}
-			}
-
-			var resp *http.Response
-			contentLength, _ := strconv.Atoi(r.Header.Get("Content-Length"))
-			switch r.Method {
-			case "HEAD":
-				resp, err = fcgiBackend.Head(env)
-			case "GET":
-				resp, err = fcgiBackend.Get(env)
-			case "OPTIONS":
-				resp, err = fcgiBackend.Options(env)
-			default:
-				resp, err = fcgiBackend.Post(env, r.Method, r.Header.Get("Content-Type"), r.Body, contentLength)
-			}
-
-			if err != nil && err != io.EOF {
-				return http.StatusBadGateway, err
-			}
-
-			if UsePersistentFcgiConnections {
-				persistentConnections.Lock()
-				persistentConnections.clientMap[network+address] = &(serialClient{backend: fcgiBackend})
-				persistentConnections.Unlock()
-			} else {
-				defer fcgiBackend.Close()
-			}
-
-			// 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"))
-				persistentConnections.Lock()
-				delete(persistentConnections.clientMap, network+address)
-				persistentConnections.Unlock()
-				fcgiBackend.Close()
-			}
-
-			// 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 r.
-// The first string is the network, "tcp" or "unix", implied from the scheme and address.
-// The second string is r.Address, with scheme prefixes removed.
-// The two returned strings can be used as parameters to the Dial() function.
-func (r Rule) parseAddress() (string, string) {
-	// check if address has tcp scheme explicitly set
-	if strings.HasPrefix(r.Address, "tcp://") {
-		return "tcp", r.Address[len("tcp://"):]
-	}
-	// check if address has fastcgi scheme explicitly set
-	if strings.HasPrefix(r.Address, "fastcgi://") {
-		return "tcp", r.Address[len("fastcgi://"):]
-	}
-	// check if unix socket
-	if trim := strings.HasPrefix(r.Address, "unix"); strings.HasPrefix(r.Address, "/") || trim {
-		if trim {
-			return "unix", r.Address[len("unix:"):]
-		}
-		return "unix", r.Address
-	}
-	// default case, a plain tcp address with no scheme
-	return "tcp", r.Address
-}
-
-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(h.AbsRoot, 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)
-
-	// Get the request URI. The request URI might be as it came in over the wire,
-	// or it might have been rewritten internally by the rewrite middleware (see issue #256).
-	// If it was rewritten, there will be a header indicating the original URL,
-	// which is needed to get the correct RequestURI value for PHP apps.
-	const internalRewriteFieldName = "Caddy-Rewrite-Original-URI"
-	reqURI := r.URL.RequestURI()
-	if origURI := r.Header.Get(internalRewriteFieldName); origURI != "" {
-		reqURI = origURI
-		r.Header.Del(internalRewriteFieldName)
-	}
-
-	// 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":       "", // Not used
-		"REQUEST_METHOD":    r.Method,
-		"SERVER_NAME":       h.ServerName,
-		"SERVER_PORT":       h.ServerPort,
-		"SERVER_PROTOCOL":   r.Proto,
-		"SERVER_SOFTWARE":   h.SoftwareName + "/" + h.SoftwareVersion,
-
-		// Other variables
-		"DOCUMENT_ROOT":   h.AbsRoot,
-		"DOCUMENT_URI":    docURI,
-		"HTTP_HOST":       r.Host, // added here, since not always part of headers
-		"REQUEST_URI":     reqURI,
-		"SCRIPT_FILENAME": scriptFilename,
-		"SCRIPT_NAME":     scriptName,
-	}
-
-	// compliance with the CGI specification 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(h.AbsRoot, 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"
-	}
-
-	replacer := httpserver.NewReplacer(r, nil, "")
-	// Add env variables from config
-	for _, envVar := range rule.EnvVars {
-		// replace request placeholders in environment variables
-		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.
-type Rule struct {
-	// The base path to match. Required.
-	Path string
-
-	// The address of the FastCGI server. Required.
-	Address string
-
-	// Always process files with this extension with fastcgi.
-	Ext string
-
-	// The path in the URL will be split into two, with the first piece ending
-	// with the value of SplitPath. The first piece will be assumed as the
-	// actual resource (CGI script) name, and the second piece will be set to
-	// PATH_INFO for the CGI script to use.
-	SplitPath string
-
-	// If the URL ends with '/' (which indicates a directory), these index
-	// files will be tried instead.
-	IndexFiles []string
-
-	// Environment Variables
-	EnvVars [][2]string
-
-	// Ignored paths
-	IgnoredSubPaths []string
-}
-
-// 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

@@ -1,199 +0,0 @@
-package fastcgi
-
-import (
-	"net"
-	"net/http"
-	"net/http/fcgi"
-	"net/http/httptest"
-	"net/url"
-	"strconv"
-	"testing"
-)
-
-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: "/", 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{Address: "tcp://172.17.0.1:9000"}, "tcp", "172.17.0.1:9000"},
-		{&Rule{Address: "fastcgi://localhost:9000"}, "tcp", "localhost:9000"},
-		{&Rule{Address: "172.17.0.15"}, "tcp", "172.17.0.15"},
-		{&Rule{Address: "/my/unix/socket"}, "unix", "/my/unix/socket"},
-		{&Rule{Address: "unix:/second/unix/socket"}, "unix", "/second/unix/socket"},
-	}
-
-	for _, entry := range getClientTestTable {
-		if actualnetwork, _ := entry.rule.parseAddress(); actualnetwork != entry.expectednetwork {
-			t.Errorf("Unexpected network for address string %v. Got %v, expected %v", entry.rule.Address, actualnetwork, entry.expectednetwork)
-		}
-		if _, actualaddress := entry.rule.parseAddress(); actualaddress != entry.expectedaddress {
-			t.Errorf("Unexpected parsed address for address string %v. Got %v, expected %v", entry.rule.Address, 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{}
-	url, err := url.Parse("http://localhost:2015/fgci_test.php?test=blabla")
-	if err != nil {
-		t.Error("Unexpected error:", err.Error())
-	}
-
-	var newReq = func() *http.Request {
-		return &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",
-		}
-	}
-
-	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=blabla",
-			"REQUEST_METHOD":  "GET",
-			"HTTP_HOST":       "localhost:2015",
-		}
-	}
-
-	// 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=blabla"
-	envExpected["CUSTOM_QUERY"] = "custom=true&test=blabla"
-	testBuildEnv(r, rule, fpath, envExpected)
-}

caddyhttp/fastcgi/fcgi_test.php

@@ -1,79 +0,0 @@
-<?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/setup.go

@@ -1,126 +0,0 @@
-package fastcgi
-
-import (
-	"errors"
-	"net/http"
-	"path/filepath"
-
-	"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)
-	absRoot, err := filepath.Abs(cfg.Root)
-	if err != nil {
-		return err
-	}
-
-	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,
-			AbsRoot:         absRoot,
-			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
-
-	for c.Next() {
-		var rule Rule
-
-		args := c.RemainingArgs()
-
-		switch len(args) {
-		case 0:
-			return rules, c.ArgErr()
-		case 1:
-			rule.Path = "/"
-			rule.Address = args[0]
-		case 2:
-			rule.Path = args[0]
-			rule.Address = args[1]
-		case 3:
-			rule.Path = args[0]
-			rule.Address = args[1]
-			err := fastcgiPreset(args[2], &rule)
-			if err != nil {
-				return rules, c.Err("Invalid fastcgi rule preset '" + args[2] + "'")
-			}
-		}
-
-		for c.NextBlock() {
-			switch c.Val() {
-			case "ext":
-				if !c.NextArg() {
-					return rules, c.ArgErr()
-				}
-				rule.Ext = c.Val()
-			case "split":
-				if !c.NextArg() {
-					return rules, c.ArgErr()
-				}
-				rule.SplitPath = c.Val()
-			case "index":
-				args := c.RemainingArgs()
-				if len(args) == 0 {
-					return rules, c.ArgErr()
-				}
-				rule.IndexFiles = args
-			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
-			}
-		}
-
-		rules = append(rules, rule)
-	}
-
-	return rules, 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

@@ -1,122 +0,0 @@
-package fastcgi
-
-import (
-	"fmt"
-	"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")
-	}
-	if myHandler.Rules[0].Address != "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",
-				Address:    "127.0.0.1:9000",
-				Ext:        ".php",
-				SplitPath:  ".php",
-				IndexFiles: []string{"index.php"},
-			}}},
-		{`fastcgi / 127.0.0.1:9001 {
-	              split .html
-	              }`,
-			false, []Rule{{
-				Path:       "/",
-				Address:    "127.0.0.1:9001",
-				Ext:        "",
-				SplitPath:  ".html",
-				IndexFiles: []string{},
-			}}},
-		{`fastcgi / 127.0.0.1:9001 {
-	              split .html
-	              except /admin /user
-	              }`,
-			false, []Rule{{
-				Path:            "/",
-				Address:         "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)
-			}
-
-			if actualFastcgiConfig.Address != test.expectedFastcgiConfig[j].Address {
-				t.Errorf("Test %d expected %dth FastCGI Address to be  %s  , but got %s",
-					i, j, test.expectedFastcgiConfig[j].Address, actualFastcgiConfig.Address)
-			}
-
-			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)
-			}
-		}
-	}
-
-}

caddyhttp/gzip/gzip.go

@@ -1,167 +0,0 @@
-// Package gzip provides a middleware layer that performs
-// gzip compression on the response.
-package gzip
-
-import (
-	"bufio"
-	"compress/gzip"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"net"
-	"net/http"
-	"strings"
-
-	"github.com/mholt/caddy"
-	"github.com/mholt/caddy/caddyhttp/httpserver"
-)
-
-func init() {
-	caddy.RegisterPlugin("gzip", caddy.Plugin{
-		ServerType: "http",
-		Action:     setup,
-	})
-}
-
-// Gzip is a middleware type which gzips HTTP responses. It is
-// imperative that any handler which writes to a gzipped response
-// specifies the Content-Type, otherwise some clients will assume
-// application/x-gzip and try to download a file.
-type Gzip struct {
-	Next    httpserver.Handler
-	Configs []Config
-}
-
-// Config holds the configuration for Gzip middleware
-type Config struct {
-	RequestFilters  []RequestFilter
-	ResponseFilters []ResponseFilter
-	Level           int // Compression level
-}
-
-// ServeHTTP serves a gzipped response if the client supports it.
-func (g Gzip) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error) {
-	if !strings.Contains(r.Header.Get("Accept-Encoding"), "gzip") {
-		return g.Next.ServeHTTP(w, r)
-	}
-outer:
-	for _, c := range g.Configs {
-
-		// Check request filters to determine if gzipping is permitted for this request
-		for _, filter := range c.RequestFilters {
-			if !filter.ShouldCompress(r) {
-				continue outer
-			}
-		}
-
-		// Delete this header so gzipping is not repeated later in the chain
-		r.Header.Del("Accept-Encoding")
-
-		// gzipWriter modifies underlying writer at init,
-		// use a discard writer instead to leave ResponseWriter in
-		// original form.
-		gzipWriter, err := newWriter(c, ioutil.Discard)
-		if err != nil {
-			// should not happen
-			return http.StatusInternalServerError, err
-		}
-		defer gzipWriter.Close()
-		gz := &gzipResponseWriter{Writer: gzipWriter, ResponseWriter: w}
-
-		var rw http.ResponseWriter
-		// if no response filter is used
-		if len(c.ResponseFilters) == 0 {
-			// replace discard writer with ResponseWriter
-			gzipWriter.Reset(w)
-			rw = gz
-		} else {
-			// wrap gzip writer with ResponseFilterWriter
-			rw = NewResponseFilterWriter(c.ResponseFilters, gz)
-		}
-
-		// Any response in forward middleware will now be compressed
-		status, err := g.Next.ServeHTTP(rw, r)
-
-		// If there was an error that remained unhandled, we need
-		// to send something back before gzipWriter gets closed at
-		// the return of this method!
-		if status >= 400 {
-			httpserver.DefaultErrorFunc(w, r, status)
-			return 0, err
-		}
-		return status, err
-	}
-
-	// no matching filter
-	return g.Next.ServeHTTP(w, r)
-}
-
-// newWriter create a new Gzip Writer based on the compression level.
-// If the level is valid (i.e. between 1 and 9), it uses the level.
-// Otherwise, it uses default compression level.
-func newWriter(c Config, w io.Writer) (*gzip.Writer, error) {
-	if c.Level >= gzip.BestSpeed && c.Level <= gzip.BestCompression {
-		return gzip.NewWriterLevel(w, c.Level)
-	}
-	return gzip.NewWriter(w), nil
-}
-
-// gzipResponeWriter wraps the underlying Write method
-// with a gzip.Writer to compress the output.
-type gzipResponseWriter struct {
-	io.Writer
-	http.ResponseWriter
-	statusCodeWritten bool
-}
-
-// WriteHeader wraps the underlying WriteHeader method to prevent
-// problems with conflicting headers from proxied backends. For
-// example, a backend system that calculates Content-Length would
-// be wrong because it doesn't know it's being gzipped.
-func (w *gzipResponseWriter) WriteHeader(code int) {
-	w.Header().Del("Content-Length")
-	w.Header().Set("Content-Encoding", "gzip")
-	w.Header().Add("Vary", "Accept-Encoding")
-	w.ResponseWriter.WriteHeader(code)
-	w.statusCodeWritten = true
-}
-
-// Write wraps the underlying Write method to do compression.
-func (w *gzipResponseWriter) Write(b []byte) (int, error) {
-	if w.Header().Get("Content-Type") == "" {
-		w.Header().Set("Content-Type", http.DetectContentType(b))
-	}
-	if !w.statusCodeWritten {
-		w.WriteHeader(http.StatusOK)
-	}
-	n, err := w.Writer.Write(b)
-	return n, err
-}
-
-// Hijack implements http.Hijacker. It simply wraps the underlying
-// ResponseWriter's Hijack method if there is one, or returns an error.
-func (w *gzipResponseWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
-	if hj, ok := w.ResponseWriter.(http.Hijacker); ok {
-		return hj.Hijack()
-	}
-	return nil, nil, fmt.Errorf("not a Hijacker")
-}
-
-// Flush implements http.Flusher. It simply wraps the underlying
-// ResponseWriter's Flush method if there is one, or panics.
-func (w *gzipResponseWriter) Flush() {
-	if f, ok := w.ResponseWriter.(http.Flusher); ok {
-		f.Flush()
-	} else {
-		panic("not a Flusher") // should be recovered at the beginning of middleware stack
-	}
-}
-
-// CloseNotify implements http.CloseNotifier.
-// It just inherits the underlying ResponseWriter's CloseNotify method.
-func (w *gzipResponseWriter) CloseNotify() <-chan bool {
-	if cn, ok := w.ResponseWriter.(http.CloseNotifier); ok {
-		return cn.CloseNotify()
-	}
-	panic("not a CloseNotifier")
-}

caddyhttp/gzip/gzip_test.go

@@ -1,122 +0,0 @@
-package gzip
-
-import (
-	"fmt"
-	"io/ioutil"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-
-	"github.com/mholt/caddy/caddyhttp/httpserver"
-)
-
-func TestGzipHandler(t *testing.T) {
-	pathFilter := PathFilter{make(Set)}
-	badPaths := []string{"/bad", "/nogzip", "/nongzip"}
-	for _, p := range badPaths {
-		pathFilter.IgnoredPaths.Add(p)
-	}
-	extFilter := ExtFilter{make(Set)}
-	for _, e := range []string{".txt", ".html", ".css", ".md"} {
-		extFilter.Exts.Add(e)
-	}
-	gz := Gzip{Configs: []Config{
-		{RequestFilters: []RequestFilter{pathFilter, extFilter}},
-	}}
-
-	w := httptest.NewRecorder()
-	gz.Next = nextFunc(true)
-	var exts = []string{
-		".html", ".css", ".md",
-	}
-	for _, e := range exts {
-		url := "/file" + e
-		r, err := http.NewRequest("GET", url, nil)
-		if err != nil {
-			t.Error(err)
-		}
-		r.Header.Set("Accept-Encoding", "gzip")
-		_, err = gz.ServeHTTP(w, r)
-		if err != nil {
-			t.Error(err)
-		}
-	}
-
-	w = httptest.NewRecorder()
-	gz.Next = nextFunc(false)
-	for _, p := range badPaths {
-		for _, e := range exts {
-			url := p + "/file" + e
-			r, err := http.NewRequest("GET", url, nil)
-			if err != nil {
-				t.Error(err)
-			}
-			r.Header.Set("Accept-Encoding", "gzip")
-			_, err = gz.ServeHTTP(w, r)
-			if err != nil {
-				t.Error(err)
-			}
-		}
-	}
-
-	w = httptest.NewRecorder()
-	gz.Next = nextFunc(false)
-	exts = []string{
-		".htm1", ".abc", ".mdx",
-	}
-	for _, e := range exts {
-		url := "/file" + e
-		r, err := http.NewRequest("GET", url, nil)
-		if err != nil {
-			t.Error(err)
-		}
-		r.Header.Set("Accept-Encoding", "gzip")
-		_, err = gz.ServeHTTP(w, r)
-		if err != nil {
-			t.Error(err)
-		}
-	}
-}
-
-func nextFunc(shouldGzip bool) httpserver.Handler {
-	return httpserver.HandlerFunc(func(w http.ResponseWriter, r *http.Request) (int, error) {
-		// write a relatively large text file
-		b, err := ioutil.ReadFile("testdata/test.txt")
-		if err != nil {
-			return 500, err
-		}
-		if _, err := w.Write(b); err != nil {
-			return 500, err
-		}
-
-		if shouldGzip {
-			if r.Header.Get("Accept-Encoding") != "" {
-				return 0, fmt.Errorf("Accept-Encoding header not expected")
-			}
-			if w.Header().Get("Content-Encoding") != "gzip" {
-				return 0, fmt.Errorf("Content-Encoding must be gzip, found %v", r.Header.Get("Content-Encoding"))
-			}
-			if w.Header().Get("Vary") != "Accept-Encoding" {
-				return 0, fmt.Errorf("Vary must be Accept-Encoding, found %v", r.Header.Get("Vary"))
-			}
-			if _, ok := w.(*gzipResponseWriter); !ok {
-				return 0, fmt.Errorf("ResponseWriter should be gzipResponseWriter, found %T", w)
-			}
-			if strings.Contains(w.Header().Get("Content-Type"), "application/x-gzip") {
-				return 0, fmt.Errorf("Content type should not be gzip.")
-			}
-			return 0, nil
-		}
-		if r.Header.Get("Accept-Encoding") == "" {
-			return 0, fmt.Errorf("Accept-Encoding header expected")
-		}
-		if w.Header().Get("Content-Encoding") == "gzip" {
-			return 0, fmt.Errorf("Content-Encoding must not be gzip, found gzip")
-		}
-		if _, ok := w.(*gzipResponseWriter); ok {
-			return 0, fmt.Errorf("ResponseWriter should not be gzipResponseWriter")
-		}
-		return 0, nil
-	})
-}

caddyhttp/gzip/requestfilter.go

@@ -1,91 +0,0 @@
-package gzip
-
-import (
-	"net/http"
-	"path"
-
-	"github.com/mholt/caddy/caddyhttp/httpserver"
-)
-
-// RequestFilter determines if a request should be gzipped.
-type RequestFilter interface {
-	// ShouldCompress tells if gzip compression
-	// should be done on the request.
-	ShouldCompress(*http.Request) bool
-}
-
-// defaultExtensions is the list of default extensions for which to enable gzipping.
-var defaultExtensions = []string{"", ".txt", ".htm", ".html", ".css", ".php", ".js", ".json",
-	".md", ".mdown", ".xml", ".svg", ".go", ".cgi", ".py", ".pl", ".aspx", ".asp"}
-
-// DefaultExtFilter creates an ExtFilter with default extensions.
-func DefaultExtFilter() ExtFilter {
-	m := ExtFilter{Exts: make(Set)}
-	for _, extension := range defaultExtensions {
-		m.Exts.Add(extension)
-	}
-	return m
-}
-
-// ExtFilter is RequestFilter for file name extensions.
-type ExtFilter struct {
-	// Exts is the file name extensions to accept
-	Exts Set
-}
-
-// ExtWildCard is the wildcard for extensions.
-const ExtWildCard = "*"
-
-// ShouldCompress checks if the request file extension matches any
-// of the registered extensions. It returns true if the extension is
-// found and false otherwise.
-func (e ExtFilter) ShouldCompress(r *http.Request) bool {
-	ext := path.Ext(r.URL.Path)
-	return e.Exts.Contains(ExtWildCard) || e.Exts.Contains(ext)
-}
-
-// PathFilter is RequestFilter for request path.
-type PathFilter struct {
-	// IgnoredPaths is the paths to ignore
-	IgnoredPaths Set
-}
-
-// ShouldCompress checks if the request path matches any of the
-// registered paths to ignore. It returns false if an ignored path
-// is found and true otherwise.
-func (p PathFilter) ShouldCompress(r *http.Request) bool {
-	return !p.IgnoredPaths.ContainsFunc(func(value string) bool {
-		return httpserver.Path(r.URL.Path).Matches(value)
-	})
-}
-
-// Set stores distinct strings.
-type Set map[string]struct{}
-
-// Add adds an element to the set.
-func (s Set) Add(value string) {
-	s[value] = struct{}{}
-}
-
-// Remove removes an element from the set.
-func (s Set) Remove(value string) {
-	delete(s, value)
-}
-
-// Contains check if the set contains value.
-func (s Set) Contains(value string) bool {
-	_, ok := s[value]
-	return ok
-}
-
-// ContainsFunc is similar to Contains. It iterates all the
-// elements in the set and passes each to f. It returns true
-// on the first call to f that returns true and false otherwise.
-func (s Set) ContainsFunc(f func(string) bool) bool {
-	for k := range s {
-		if f(k) {
-			return true
-		}
-	}
-	return false
-}

caddyhttp/gzip/requestfilter_test.go

@@ -1,113 +0,0 @@
-package gzip
-
-import (
-	"net/http"
-	"testing"
-)
-
-func TestSet(t *testing.T) {
-	set := make(Set)
-	set.Add("a")
-	if len(set) != 1 {
-		t.Errorf("Expected 1 found %v", len(set))
-	}
-	set.Add("a")
-	if len(set) != 1 {
-		t.Errorf("Expected 1 found %v", len(set))
-	}
-	set.Add("b")
-	if len(set) != 2 {
-		t.Errorf("Expected 2 found %v", len(set))
-	}
-	if !set.Contains("a") {
-		t.Errorf("Set should contain a")
-	}
-	if !set.Contains("b") {
-		t.Errorf("Set should contain a")
-	}
-	set.Add("c")
-	if len(set) != 3 {
-		t.Errorf("Expected 3 found %v", len(set))
-	}
-	if !set.Contains("c") {
-		t.Errorf("Set should contain c")
-	}
-	set.Remove("a")
-	if len(set) != 2 {
-		t.Errorf("Expected 2 found %v", len(set))
-	}
-	if set.Contains("a") {
-		t.Errorf("Set should not contain a")
-	}
-	if !set.ContainsFunc(func(v string) bool {
-		return v == "c"
-	}) {
-		t.Errorf("ContainsFunc should return true")
-	}
-}
-
-func TestExtFilter(t *testing.T) {
-	var filter RequestFilter = ExtFilter{make(Set)}
-	for _, e := range []string{".txt", ".html", ".css", ".md"} {
-		filter.(ExtFilter).Exts.Add(e)
-	}
-	r := urlRequest("file.txt")
-	if !filter.ShouldCompress(r) {
-		t.Errorf("Should be valid filter")
-	}
-	var exts = []string{
-		".html", ".css", ".md",
-	}
-	for i, e := range exts {
-		r := urlRequest("file" + e)
-		if !filter.ShouldCompress(r) {
-			t.Errorf("Test %v: Should be valid filter", i)
-		}
-	}
-	exts = []string{
-		".htm1", ".abc", ".mdx",
-	}
-	for i, e := range exts {
-		r := urlRequest("file" + e)
-		if filter.ShouldCompress(r) {
-			t.Errorf("Test %v: Should not be valid filter", i)
-		}
-	}
-	filter.(ExtFilter).Exts.Add(ExtWildCard)
-	for i, e := range exts {
-		r := urlRequest("file" + e)
-		if !filter.ShouldCompress(r) {
-			t.Errorf("Test %v: Should be valid filter. Wildcard used.", i)
-		}
-	}
-}
-
-func TestPathFilter(t *testing.T) {
-	paths := []string{
-		"/a", "/b", "/c", "/de",
-	}
-	var filter RequestFilter = PathFilter{make(Set)}
-	for _, p := range paths {
-		filter.(PathFilter).IgnoredPaths.Add(p)
-	}
-	for i, p := range paths {
-		r := urlRequest(p)
-		if filter.ShouldCompress(r) {
-			t.Errorf("Test %v: Should not be valid filter", i)
-		}
-	}
-	paths = []string{
-		"/f", "/g", "/h", "/ed",
-	}
-	for i, p := range paths {
-		r := urlRequest(p)
-		if !filter.ShouldCompress(r) {
-			t.Errorf("Test %v: Should be valid filter", i)
-		}
-	}
-}
-
-func urlRequest(url string) *http.Request {
-	r, _ := http.NewRequest("GET", url, nil)
-	return r
-}

caddyhttp/gzip/responsefilter.go

@@ -1,79 +0,0 @@
-package gzip
-
-import (
-	"compress/gzip"
-	"net/http"
-	"strconv"
-)
-
-// ResponseFilter determines if the response should be gzipped.
-type ResponseFilter interface {
-	ShouldCompress(http.ResponseWriter) bool
-}
-
-// LengthFilter is ResponseFilter for minimum content length.
-type LengthFilter int64
-
-// ShouldCompress returns if content length is greater than or
-// equals to minimum length.
-func (l LengthFilter) ShouldCompress(w http.ResponseWriter) bool {
-	contentLength := w.Header().Get("Content-Length")
-	length, err := strconv.ParseInt(contentLength, 10, 64)
-	if err != nil || length == 0 {
-		return false
-	}
-	return l != 0 && int64(l) <= length
-}
-
-// ResponseFilterWriter validates ResponseFilters. It writes
-// gzip compressed data if ResponseFilters are satisfied or
-// uncompressed data otherwise.
-type ResponseFilterWriter struct {
-	filters           []ResponseFilter
-	shouldCompress    bool
-	statusCodeWritten bool
-	*gzipResponseWriter
-}
-
-// NewResponseFilterWriter creates and initializes a new ResponseFilterWriter.
-func NewResponseFilterWriter(filters []ResponseFilter, gz *gzipResponseWriter) *ResponseFilterWriter {
-	return &ResponseFilterWriter{filters: filters, gzipResponseWriter: gz}
-}
-
-// WriteHeader wraps underlying WriteHeader method and
-// compresses if filters are satisfied.
-func (r *ResponseFilterWriter) WriteHeader(code int) {
-	// Determine if compression should be used or not.
-	r.shouldCompress = true
-	for _, filter := range r.filters {
-		if !filter.ShouldCompress(r) {
-			r.shouldCompress = false
-			break
-		}
-	}
-
-	if r.shouldCompress {
-		// replace discard writer with ResponseWriter
-		if gzWriter, ok := r.gzipResponseWriter.Writer.(*gzip.Writer); ok {
-			gzWriter.Reset(r.ResponseWriter)
-		}
-		// use gzip WriteHeader to include and delete
-		// necessary headers
-		r.gzipResponseWriter.WriteHeader(code)
-	} else {
-		r.ResponseWriter.WriteHeader(code)
-	}
-	r.statusCodeWritten = true
-}
-
-// Write wraps underlying Write method and compresses if filters
-// are satisfied
-func (r *ResponseFilterWriter) Write(b []byte) (int, error) {
-	if !r.statusCodeWritten {
-		r.WriteHeader(http.StatusOK)
-	}
-	if r.shouldCompress {
-		return r.gzipResponseWriter.Write(b)
-	}
-	return r.ResponseWriter.Write(b)
-}

caddyhttp/gzip/responsefilter_test.go

@@ -1,89 +0,0 @@
-package gzip
-
-import (
-	"compress/gzip"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	"github.com/mholt/caddy/caddyhttp/httpserver"
-)
-
-func TestLengthFilter(t *testing.T) {
-	var filters = []ResponseFilter{
-		LengthFilter(100),
-		LengthFilter(1000),
-		LengthFilter(0),
-	}
-
-	var tests = []struct {
-		length         int64
-		shouldCompress [3]bool
-	}{
-		{20, [3]bool{false, false, false}},
-		{50, [3]bool{false, false, false}},
-		{100, [3]bool{true, false, false}},
-		{500, [3]bool{true, false, false}},
-		{1000, [3]bool{true, true, false}},
-		{1500, [3]bool{true, true, false}},
-	}
-
-	for i, ts := range tests {
-		for j, filter := range filters {
-			r := httptest.NewRecorder()
-			r.Header().Set("Content-Length", fmt.Sprint(ts.length))
-			wWriter := NewResponseFilterWriter([]ResponseFilter{filter}, &gzipResponseWriter{gzip.NewWriter(r), r, false})
-			if filter.ShouldCompress(wWriter) != ts.shouldCompress[j] {
-				t.Errorf("Test %v: Expected %v found %v", i, ts.shouldCompress[j], filter.ShouldCompress(r))
-			}
-		}
-	}
-}
-
-func TestResponseFilterWriter(t *testing.T) {
-	tests := []struct {
-		body           string
-		shouldCompress bool
-	}{
-		{"Hello\t\t\t\n", false},
-		{"Hello the \t\t\t world is\n\n\n great", true},
-		{"Hello \t\t\nfrom gzip", true},
-		{"Hello gzip\n", false},
-	}
-
-	filters := []ResponseFilter{
-		LengthFilter(15),
-	}
-
-	server := Gzip{Configs: []Config{
-		{ResponseFilters: filters},
-	}}
-
-	for i, ts := range tests {
-		server.Next = httpserver.HandlerFunc(func(w http.ResponseWriter, r *http.Request) (int, error) {
-			w.Header().Set("Content-Length", fmt.Sprint(len(ts.body)))
-			w.Write([]byte(ts.body))
-			return 200, nil
-		})
-
-		r := urlRequest("/")
-		r.Header.Set("Accept-Encoding", "gzip")
-
-		w := httptest.NewRecorder()
-
-		server.ServeHTTP(w, r)
-
-		resp := w.Body.String()
-
-		if !ts.shouldCompress {
-			if resp != ts.body {
-				t.Errorf("Test %v: No compression expected, found %v", i, resp)
-			}
-		} else {
-			if resp == ts.body {
-				t.Errorf("Test %v: Compression expected, found %v", i, resp)
-			}
-		}
-	}
-}

caddyhttp/gzip/setup.go

@@ -1,119 +0,0 @@
-package gzip
-
-import (
-	"fmt"
-	"strconv"
-	"strings"
-
-	"github.com/mholt/caddy"
-	"github.com/mholt/caddy/caddyhttp/httpserver"
-)
-
-// setup configures a new gzip middleware instance.
-func setup(c *caddy.Controller) error {
-	configs, err := gzipParse(c)
-	if err != nil {
-		return err
-	}
-
-	httpserver.GetConfig(c).AddMiddleware(func(next httpserver.Handler) httpserver.Handler {
-		return Gzip{Next: next, Configs: configs}
-	})
-
-	return nil
-}
-
-func gzipParse(c *caddy.Controller) ([]Config, error) {
-	var configs []Config
-
-	for c.Next() {
-		config := Config{}
-
-		// Request Filters
-		pathFilter := PathFilter{IgnoredPaths: make(Set)}
-		extFilter := ExtFilter{Exts: make(Set)}
-
-		// Response Filters
-		lengthFilter := LengthFilter(0)
-
-		// No extra args expected
-		if len(c.RemainingArgs()) > 0 {
-			return configs, c.ArgErr()
-		}
-
-		for c.NextBlock() {
-			switch c.Val() {
-			case "ext":
-				exts := c.RemainingArgs()
-				if len(exts) == 0 {
-					return configs, c.ArgErr()
-				}
-				for _, e := range exts {
-					if !strings.HasPrefix(e, ".") && e != ExtWildCard && e != "" {
-						return configs, fmt.Errorf(`gzip: invalid extension "%v" (must start with dot)`, e)
-					}
-					extFilter.Exts.Add(e)
-				}
-			case "not":
-				paths := c.RemainingArgs()
-				if len(paths) == 0 {
-					return configs, c.ArgErr()
-				}
-				for _, p := range paths {
-					if p == "/" {
-						return configs, fmt.Errorf(`gzip: cannot exclude path "/" - remove directive entirely instead`)
-					}
-					if !strings.HasPrefix(p, "/") {
-						return configs, fmt.Errorf(`gzip: invalid path "%v" (must start with /)`, p)
-					}
-					pathFilter.IgnoredPaths.Add(p)
-				}
-			case "level":
-				if !c.NextArg() {
-					return configs, c.ArgErr()
-				}
-				level, _ := strconv.Atoi(c.Val())
-				config.Level = level
-			case "min_length":
-				if !c.NextArg() {
-					return configs, c.ArgErr()
-				}
-				length, err := strconv.ParseInt(c.Val(), 10, 64)
-				if err != nil {
-					return configs, err
-				} else if length == 0 {
-					return configs, fmt.Errorf(`gzip: min_length must be greater than 0`)
-				}
-				lengthFilter = LengthFilter(length)
-			default:
-				return configs, c.ArgErr()
-			}
-		}
-
-		// Request Filters
-		config.RequestFilters = []RequestFilter{}
-
-		// If ignored paths are specified, put in front to filter with path first
-		if len(pathFilter.IgnoredPaths) > 0 {
-			config.RequestFilters = []RequestFilter{pathFilter}
-		}
-
-		// Then, if extensions are specified, use those to filter.
-		// Otherwise, use default extensions filter.
-		if len(extFilter.Exts) > 0 {
-			config.RequestFilters = append(config.RequestFilters, extFilter)
-		} else {
-			config.RequestFilters = append(config.RequestFilters, DefaultExtFilter())
-		}
-
-		// Response Filters
-		// If min_length is specified, use it.
-		if int64(lengthFilter) != 0 {
-			config.ResponseFilters = append(config.ResponseFilters, lengthFilter)
-		}
-
-		configs = append(configs, config)
-	}
-
-	return configs, nil
-}

caddyhttp/gzip/setup_test.go

@@ -1,101 +0,0 @@
-package gzip
-
-import (
-	"testing"
-
-	"github.com/mholt/caddy"
-	"github.com/mholt/caddy/caddyhttp/httpserver"
-)
-
-func TestSetup(t *testing.T) {
-	c := caddy.NewTestController("http", `gzip`)
-	err := setup(c)
-	if err != nil {
-		t.Errorf("Expected no errors, but got: %v", err)
-	}
-	mids := httpserver.GetConfig(c).Middleware()
-	if mids == nil {
-		t.Fatal("Expected middleware, was nil instead")
-	}
-
-	handler := mids[0](httpserver.EmptyNext)
-	myHandler, ok := handler.(Gzip)
-	if !ok {
-		t.Fatalf("Expected handler to be type Gzip, got: %#v", handler)
-	}
-
-	if !httpserver.SameNext(myHandler.Next, httpserver.EmptyNext) {
-		t.Error("'Next' field of handler was not set properly")
-	}
-
-	tests := []struct {
-		input     string
-		shouldErr bool
-	}{
-		{`gzip {`, true},
-		{`gzip {}`, true},
-		{`gzip a b`, true},
-		{`gzip a {`, true},
-		{`gzip { not f } `, true},
-		{`gzip { not } `, true},
-		{`gzip { not /file
-		 ext .html
-		 level 1
-		} `, false},
-		{`gzip { level 9 } `, false},
-		{`gzip { ext } `, true},
-		{`gzip { ext /f
-		} `, true},
-		{`gzip { not /file
-		 ext .html
-		 level 1
-		}
-		gzip`, false},
-		{`gzip {
-		 ext ""
-		}`, false},
-		{`gzip { not /file
-		 ext .html
-		 level 1
-		}
-		gzip { not /file1
-		 ext .htm
-		 level 3
-		}
-		`, false},
-		{`gzip { not /file
-		 ext .html
-		 level 1
-		}
-		gzip { not /file1
-		 ext .htm
-		 level 3
-		}
-		`, false},
-		{`gzip { not /file
-		 ext *
-		 level 1
-		}
-		`, false},
-		{`gzip { not /file
-		 ext *
-		 level 1
-		 min_length ab
-		}
-		`, true},
-		{`gzip { not /file
-		 ext *
-		 level 1
-		 min_length 1000
-		}
-		`, false},
-	}
-	for i, test := range tests {
-		_, err := gzipParse(caddy.NewTestController("http", test.input))
-		if test.shouldErr && err == nil {
-			t.Errorf("Test %v: Expected error but found nil", i)
-		} else if !test.shouldErr && err != nil {
-			t.Errorf("Test %v: Expected no error but found error: %v", i, err)
-		}
-	}
-}

caddyhttp/gzip/testdata/test.txt

@@ -1,199 +0,0 @@
-Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vivamus mattis, dolor et feugiat suscipit, nisi urna consectetur enim, et porta libero dui eget dolor. Sed ac enim aliquet, ornare ipsum a, aliquet augue. Fusce faucibus id mi at porta. Donec scelerisque consectetur rutrum. In aliquam est vel quam molestie porttitor. Sed eget nunc blandit, commodo dui ac, tempus mi. Nulla ac est ac leo hendrerit rhoncus. Etiam id finibus neque. In ultrices diam orci, eu tempor neque bibendum sed. Fusce facilisis mauris in finibus elementum. Pellentesque tristique bibendum diam, nec molestie velit facilisis quis. Nulla facilisi. Morbi nec velit eget massa blandit consequat sed hendrerit velit. Ut euismod elit sit amet dui venenatis, a luctus tortor vestibulum.
-
-Aliquam consequat rutrum sagittis. Donec eros felis, ultricies quis elementum nec, consequat et ex. Nullam feugiat eu sapien nec mollis. Quisque porttitor tortor ipsum, quis aliquam diam tincidunt a. Praesent tortor lorem, finibus sit amet tempor ac, iaculis et nunc. Duis enim justo, gravida in pharetra id, rhoncus id nisi. Maecenas dui risus, accumsan ut nisi vitae, placerat dignissim risus. Quisque orci lectus, sodales a lacus sit amet, bibendum gravida odio. Duis consectetur, ante et vulputate convallis, augue augue mollis ligula, sed tincidunt nunc ligula vel enim. Donec faucibus pulvinar consectetur. Nam laoreet, dolor ac elementum vestibulum, eros justo fringilla leo, pretium fringilla sem nunc non sem. Proin at nisl eget leo hendrerit lacinia.
-
-Aliquam id lacus mauris. Morbi et justo urna. Vestibulum venenatis pharetra lectus in pharetra. Fusce feugiat nisl nec enim rutrum finibus. Etiam a nunc metus. Phasellus non dignissim eros, non feugiat quam. Nunc velit ante, commodo at ex eu, fringilla semper tellus.
-
-Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; Etiam rhoncus ultricies nisl, id vestibulum dolor eleifend id. Quisque condimentum condimentum nisi, at dapibus sapien pharetra ut. Suspendisse a sodales odio, sit amet facilisis risus. Vestibulum varius pretium pellentesque. Nunc sit amet sollicitudin sapien, eu finibus mi. Aenean justo arcu, ornare id massa et, auctor dictum dui. Morbi et aliquet velit.
-
-Curabitur leo ligula, congue non tincidunt vel, consectetur at erat. In scelerisque orci in cursus molestie. Duis erat erat, vehicula sed sollicitudin eget, suscipit in erat. Quisque sed quam in ante dictum hendrerit. Aenean elementum mattis ipsum, sollicitudin luctus felis. Duis fringilla varius mattis. Integer dapibus efficitur blandit.
-
-Vivamus placerat enim vel est feugiat, cursus pretium ante aliquam. Curabitur hendrerit iaculis odio, in tristique nisl rutrum non. Aenean varius luctus ipsum quis interdum. Nam suscipit purus et lacus accumsan, a rutrum turpis mattis. Sed non bibendum mi. Pellentesque pulvinar ligula eget massa feugiat pharetra. Sed malesuada sem metus, sit amet feugiat purus pretium vel. Fusce magna est, fermentum vitae mauris vel, elementum pharetra est. In blandit faucibus tortor in elementum. Maecenas vitae ornare dui, quis commodo orci. Pellentesque sed scelerisque dolor. Aliquam eget libero in risus tempor efficitur vitae sit amet libero. Sed sed eros dapibus, consectetur mauris eget, auctor mauris.
-
-Quisque sed efficitur dui. Suspendisse tempor maximus varius. Vivamus tristique volutpat orci, sed placerat ligula condimentum in. Aliquam sodales mi interdum diam semper pulvinar. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Vestibulum faucibus facilisis leo, eget suscipit urna luctus nec. Integer posuere gravida nibh in imperdiet. Nunc ultrices in lorem vel volutpat. Morbi laoreet augue id dapibus porta. Pellentesque ac convallis lectus. Proin placerat lorem sed lacus blandit rhoncus.
-
-Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nam mattis in nunc id scelerisque. Donec et elit ac odio blandit euismod. Mauris enim risus, fermentum ac accumsan in, rhoncus sed erat. Donec sed laoreet eros. In ut purus sed nunc consequat pretium sit amet in nibh. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Aenean at semper nisl. Quisque vel lectus ut felis pellentesque imperdiet.
-
-Maecenas eget lacinia mi. Vivamus eget sollicitudin tortor. Pellentesque molestie, massa in bibendum ultrices, nunc mauris finibus ex, non porttitor enim leo ac dolor. Vivamus dapibus nisl dui, sit amet convallis ipsum dictum ac. Nulla facilisi. Curabitur laoreet auctor sapien, at porttitor urna scelerisque sit amet. Ut placerat neque congue vulputate ullamcorper. Nunc ut sem tristique, volutpat sem at, commodo augue. Ut facilisis pulvinar vestibulum.
-
-Duis volutpat eros laoreet, fringilla nulla eu, congue lorem. Fusce vestibulum bibendum ornare. Donec venenatis nisi at augue suscipit, vel cursus massa bibendum. Fusce facilisis nisl ut volutpat tempus. Fusce porttitor ante mauris, et bibendum sapien tincidunt non. In rhoncus tincidunt fermentum. Morbi id venenatis nunc. Maecenas blandit suscipit porta. Proin porttitor molestie nibh. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae;
-
-Phasellus sed nulla nisi. Proin mollis hendrerit felis, ultricies sollicitudin mi semper eget. Fusce at neque at justo vehicula rhoncus a gravida lectus. Cras tristique eget arcu nec fringilla. Nam sit amet dolor mollis, fermentum lorem at, faucibus erat. Morbi eu urna laoreet, faucibus purus et, accumsan neque. Maecenas eget velit lorem. Sed eu est elementum, sagittis elit id, scelerisque elit. Nunc elementum fermentum sem, id viverra mauris viverra at. Sed molestie mi sed velit vestibulum, sit amet porttitor tellus dictum. Fusce rhoncus felis et molestie iaculis. Cras ornare eget urna non pulvinar. Pellentesque ultricies leo quis dignissim sollicitudin. Nunc elit mi, bibendum eu tellus quis, pellentesque dapibus erat.
-
-Morbi blandit sit amet sem sed fringilla. Ut quis augue egestas, pharetra sapien at, tincidunt neque. Aliquam sodales, justo et tincidunt posuere, nunc lacus tincidunt lectus, non iaculis sem arcu nec diam. Nullam lobortis lorem at quam euismod, non elementum eros vulputate. Vivamus gravida non libero ac tristique. Morbi sit amet lectus elementum, malesuada diam a, pharetra odio. Phasellus non erat ipsum. Phasellus ullamcorper feugiat nunc, ut porta mauris feugiat eu. Ut egestas ligula dolor, ac mollis massa rhoncus at. Donec maximus pulvinar est non eleifend. Quisque vulputate turpis sed ligula accumsan tincidunt. Cras tortor augue, aliquam sed pretium vel, semper sit amet nisi. Pellentesque gravida dapibus libero porta viverra. Donec lacinia, ante et porta mollis, lorem est feugiat odio, vitae sollicitudin augue ipsum ac mi. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas.
-
-Phasellus non mauris consequat, congue metus at, sodales quam. Phasellus imperdiet et elit quis rhoncus. Phasellus aliquet euismod ligula quis elementum. Etiam sed nibh arcu. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed enim sem, pulvinar quis elit non, dignissim rhoncus mi. Quisque vitae ullamcorper enim, vitae varius lacus. Nunc hendrerit augue quis volutpat bibendum. Nulla ultricies justo sit amet lorem dignissim interdum. Duis congue, mauris vel posuere ornare, lacus justo accumsan ex, a malesuada arcu orci sit amet risus. Sed at nisl non massa sollicitudin convallis at in erat. Ut imperdiet, eros at hendrerit maximus, lacus orci molestie dolor, vitae aliquam ligula lacus eget mi. Sed massa purus, sagittis sed sollicitudin nec, condimentum eget metus. Sed commodo nunc in nibh auctor, a pellentesque nisl pretium. Vivamus ac ex sit amet libero posuere malesuada. Interdum et malesuada fames ac ante ipsum primis in faucibus.
-
-Praesent molestie est et pulvinar placerat. Sed tincidunt sapien eu justo vulputate rutrum. Donec vel ultrices erat. Morbi quis rhoncus metus. Cras pellentesque augue quis auctor eleifend. Suspendisse quis commodo quam. Etiam dapibus metus nec tortor pharetra lobortis. Quisque pharetra lectus ac velit commodo, nec blandit nisl viverra. Pellentesque aliquet tincidunt molestie. Vestibulum ullamcorper, eros eu posuere varius, metus enim rutrum elit, quis fringilla orci tellus at odio. Ut malesuada, justo vitae lobortis porta, nisi magna dictum metus, sed porta arcu turpis vitae tortor. Morbi in elit sapien.
-
-Maecenas quis feugiat augue. Integer sollicitudin dolor sit amet mi dictum, non consequat turpis scelerisque. Aliquam erat volutpat. Aliquam venenatis mollis orci, nec sollicitudin elit convallis quis. Vivamus varius, libero a sagittis lobortis, massa massa suscipit neque, lacinia lacinia ante justo non massa. Quisque ut erat ac purus euismod consequat. Phasellus malesuada elementum ipsum sed rutrum. Vivamus scelerisque erat vel nisl tempus euismod id eget arcu.
-
-Ut fermentum dapibus finibus. Praesent aliquam magna tellus, et pulvinar ipsum dignissim volutpat. Ut mollis diam eros, lacinia euismod lectus venenatis in. Sed lobortis eros massa, at vulputate ipsum hendrerit ac. Aenean id commodo sapien, id suscipit metus. Ut fringilla quam laoreet posuere pretium. Donec vel dapibus nibh. Donec non neque felis. Sed consequat efficitur semper. In ac porta mi. Fusce non elit urna. Aenean pharetra urna laoreet enim malesuada, vitae feugiat nibh molestie. Nam varius porta arcu non convallis. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Etiam tempus ex et quam accumsan sodales. Aliquam eget metus ac est accumsan ultrices.
-
-Nullam eleifend mauris ac maximus scelerisque. Integer nec sapien massa. Ut laoreet, nibh non egestas congue, enim metus mollis mi, sit amet sodales dolor diam sed augue. Vestibulum dignissim metus at felis faucibus faucibus. Pellentesque molestie nisi viverra quam tincidunt, ut molestie est feugiat. Sed nulla tortor, gravida quis varius sed, commodo sit amet arcu. Curabitur viverra, lacus at placerat vestibulum, ligula orci semper ipsum, et mollis mi erat a ligula. Pellentesque ornare urna eu lorem blandit vestibulum. Mauris quis rutrum justo. Vivamus non sollicitudin odio. Curabitur ornare ante vitae justo mollis efficitur.
-
-Suspendisse interdum bibendum lobortis. Etiam commodo gravida sollicitudin. Curabitur interdum vel nisi a auctor. Nunc varius dui in aliquam porttitor. Nam consequat mi enim, sed tempor eros scelerisque eu. Proin auctor, enim nec imperdiet mollis, dui magna blandit tellus, non elementum orci lorem vitae odio. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec laoreet cursus risus. Curabitur porta massa vitae lorem posuere, non tristique mauris lacinia. Ut ligula nisl, pulvinar eget ligula eu, suscipit hendrerit ligula.
-
-Maecenas elementum justo quis odio vestibulum ullamcorper. Quisque commodo non odio quis vehicula. Ut vel ornare erat. Duis quis tristique tellus. Suspendisse dignissim aliquet purus sed consectetur. Cras in sollicitudin lectus. Donec posuere venenatis efficitur. Nullam ac pellentesque mi.
-
-Etiam malesuada ut tellus nec sodales. Cras malesuada eu arcu quis tincidunt. Sed consequat malesuada eleifend. Aenean accumsan vel ligula efficitur elementum. Sed elementum sapien nec magna iaculis pharetra. Interdum et malesuada fames ac ante ipsum primis in faucibus. Sed in augue sit amet sem malesuada facilisis at ac risus. Aliquam aliquam dignissim mauris vel pharetra. In hac habitasse platea dictumst. Phasellus varius risus id urna pretium, fermentum tristique lorem condimentum. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; Vestibulum tincidunt eu dolor at vehicula. Proin pulvinar ex non gravida venenatis. Donec lacinia, ipsum in congue hendrerit, risus turpis elementum elit, eget tempor purus lorem ut sapien. Maecenas dapibus eros eget viverra imperdiet. Donec ullamcorper nulla hendrerit molestie rutrum.
-
-Duis maximus molestie pellentesque. Duis mattis hendrerit dolor, et vulputate turpis pretium ut. Aliquam porta elit in pretium faucibus. Vivamus tortor nunc, elementum nec cursus facilisis, consequat ac elit. Suspendisse porttitor lobortis sollicitudin. Curabitur auctor velit ac gravida feugiat. Praesent convallis tempor nulla, id sodales eros ullamcorper eget. Praesent blandit massa quis placerat molestie. Integer elementum lacinia fermentum. Phasellus ullamcorper mattis finibus. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Curabitur diam quam, egestas nec arcu vitae, efficitur pellentesque nisl. Curabitur a dui vitae metus vehicula condimentum vel sit amet dolor. Vestibulum vehicula dictum semper. Sed vitae aliquet odio.
-
-Etiam quis purus molestie, finibus nisi aliquam, venenatis nunc. Phasellus tempor id erat sed mattis. Praesent at facilisis diam. In tortor turpis, eleifend vitae facilisis sit amet, ultrices ut nibh. Cras placerat mollis risus, nec accumsan massa aliquam eu. Aliquam erat volutpat. Aliquam tincidunt, leo in laoreet viverra, metus sapien convallis justo, ut pellentesque massa est sit amet ligula. Suspendisse et arcu justo. Quisque at luctus urna. Vestibulum elit eros, dapibus at faucibus sit amet, dapibus a sem. Donec nec mi pulvinar, luctus nisi quis, sollicitudin mauris. Phasellus id velit a enim vehicula eleifend.
-
-Sed volutpat vel eros sit amet efficitur. Nullam ut neque lobortis, rutrum dui at, blandit massa. Vivamus quis commodo mi. Praesent ultrices lacinia consectetur. Phasellus nec imperdiet augue, eget eleifend arcu. Morbi viverra a sapien vel eleifend. Pellentesque in volutpat sapien. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Pellentesque facilisis metus a nulla fermentum sollicitudin. Nam hendrerit risus eget purus bibendum ultricies eu commodo leo. Nulla placerat feugiat massa nec efficitur. Nam quis mattis erat, vel porta ex.
-
-Fusce ullamcorper nibh velit. Praesent porttitor dignissim eros, nec fermentum tellus pellentesque sit amet. Suspendisse potenti. Suspendisse eget quam in lorem sollicitudin porttitor sed a arcu. Cras eget ligula venenatis, posuere sem ac, semper leo. Nam dictum ipsum at leo convallis finibus. Nam a lorem consectetur, ullamcorper nulla ut, posuere sapien. Quisque quis vulputate enim, sit amet consectetur tellus. Integer in massa sed diam mattis imperdiet non a velit. Maecenas consectetur posuere erat, sed cursus dui pretium sed. Etiam at pellentesque mi. Aliquam pharetra rutrum rhoncus.
-
-Proin finibus luctus leo, at iaculis arcu. Pellentesque ullamcorper ligula sapien, quis tempor velit bibendum ac. Fusce vestibulum posuere purus, quis efficitur diam venenatis quis. Sed posuere arcu ut diam varius laoreet. Integer non eros id odio finibus eleifend. Mauris vulputate arcu non sem placerat, vel sodales dolor accumsan. Phasellus felis elit, viverra nec congue ac, pretium in ante. Fusce ut ex eu massa rutrum dictum id sit amet lectus. Duis venenatis ligula erat, eu congue enim gravida suscipit. Pellentesque luctus eget sem eu luctus. Interdum et malesuada fames ac ante ipsum primis in faucibus. Aenean dignissim suscipit hendrerit.
-
-Vivamus vel dui ac leo maximus efficitur eget iaculis nisl. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Praesent et elit ultrices, aliquet diam sed, placerat lorem. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Sed lectus ex, elementum pretium sem nec, tincidunt tincidunt felis. Ut viverra neque mi, vitae convallis dolor tempor vel. Nam eleifend non erat id cursus.
-
-In euismod scelerisque auctor. Fusce ligula nunc, dictum non euismod nec, ultricies eget sapien. Fusce ultrices in ipsum non vehicula. Nunc a elit a mauris dapibus ullamcorper quis ac neque. Integer vel commodo eros, nec tincidunt mi. Maecenas mi augue, congue a condimentum a, gravida non tellus. Pellentesque tortor eros, fermentum in nunc non, placerat cursus tortor. Donec malesuada eleifend sem, ac consectetur neque ultricies dictum.
-
-Pellentesque mattis nulla sed bibendum viverra. Phasellus maximus dolor justo, et aliquam felis ultricies vel. Curabitur aliquet pulvinar elit vitae pulvinar. Praesent sed gravida turpis. Praesent ipsum ipsum, lacinia nec bibendum in, sagittis id felis. Donec nibh neque, aliquet non porttitor vitae, maximus id urna. Pellentesque est libero, placerat in libero et, cursus consectetur felis.
-
-Donec eget ipsum eu nisl aliquam pharetra. Suspendisse consequat enim mi, lacinia ullamcorper nisi vulputate id. Aliquam finibus ligula tortor, eget varius erat convallis a. Donec sollicitudin rutrum rutrum. Aenean mollis lacinia dictum. Morbi ac tempus arcu, sit amet auctor nunc. Nulla sed est dignissim, dictum sem vitae, tincidunt dolor. Pellentesque nunc ipsum, semper quis eros ut, luctus hendrerit velit. Maecenas risus ipsum, posuere et molestie id, tempor a elit. Etiam aliquam turpis sit amet accumsan vestibulum. Curabitur consectetur erat vel magna sodales, sit amet aliquet metus scelerisque. Proin pretium lacus in commodo efficitur. Pellentesque congue aliquam neque at imperdiet. Suspendisse faucibus, ex quis varius consectetur, sem magna congue ligula, sed fringilla urna ligula a libero. Nullam ut sapien at erat ullamcorper venenatis sit amet eu mauris.
-
-Praesent ante massa, laoreet eu tortor ut, molestie tristique risus. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; Curabitur fermentum vulputate mauris eget sodales. Nunc eleifend leo ac dui efficitur, sit amet volutpat enim semper. Morbi lorem diam, dictum nec felis sed, lobortis tempor nunc. Curabitur dapibus volutpat arcu, eget lacinia ipsum ultricies sed. Fusce hendrerit erat nunc, nec tempus risus pulvinar in. Suspendisse fringilla sagittis ante vel molestie. Suspendisse vulputate sagittis congue. Quisque gravida metus sit amet risus rutrum bibendum. Nullam id ex risus. Aliquam erat volutpat. Nunc vitae tellus id purus scelerisque efficitur. Quisque nulla dui, tempor sed sollicitudin vitae, hendrerit dapibus enim. Nullam tincidunt non est ut lobortis.
-
-Nunc molestie nisi non vestibulum maximus. Phasellus tincidunt maximus fringilla. Donec justo sem, viverra vel ligula in, ullamcorper mattis odio. Duis commodo urna nec pharetra mollis. Sed vehicula metus et nibh laoreet congue. In tincidunt, metus sit amet pulvinar placerat, arcu quam vestibulum lorem, vel efficitur elit mi at dui. Etiam id congue urna, sit amet tincidunt tellus. Vestibulum euismod magna eget orci semper, in placerat quam congue. Suspendisse eget turpis quis sapien imperdiet sollicitudin. Nullam sodales gravida justo at iaculis. Nunc iaculis leo at orci viverra, in facilisis neque ultricies. Integer gravida neque ut ex sodales posuere. Nullam odio mauris, consectetur ut ultrices eget, porttitor eu tortor. Proin ut risus quis erat tristique ornare non ut est. Nulla dignissim sed ipsum ut sagittis. Curabitur facilisis mattis nunc eget molestie.
-
-Nam ultrices vitae velit sollicitudin volutpat. Aenean sagittis diam aliquet pretium imperdiet. Donec ultricies nisl a nisi porttitor iaculis. Donec quis tempus purus, in suscipit nibh. Nulla dignissim tristique vulputate. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Praesent egestas sit amet enim at porttitor. Vivamus nec tortor lobortis mauris tempus varius non sed ante. Praesent lorem nisl, blandit ac rutrum at, faucibus eu sem. Nunc arcu nulla, mollis nec eros eget, hendrerit cursus ex. Praesent ut pretium dolor. Vestibulum varius sapien et eleifend commodo. Fusce auctor ut orci a consectetur. Praesent condimentum sit amet elit sit amet sollicitudin.
-
-In luctus, diam eu ultrices maximus, urna nibh ullamcorper orci, id tempor nibh arcu eu mauris. Phasellus lacus nunc, fringilla eu turpis sed, pharetra ultricies diam. Etiam nisi enim, sagittis et erat non, finibus rhoncus ex. Cras maximus ullamcorper magna, vel tempor lacus venenatis quis. Vivamus fringilla tincidunt purus et maximus. Quisque commodo ullamcorper tellus, eget accumsan massa maximus nec. Curabitur in imperdiet mi. Proin lorem est, pellentesque quis hendrerit at, condimentum non mi. Nulla id ante placerat, dapibus metus nec, hendrerit justo. Praesent pretium, est quis eleifend aliquam, nunc odio convallis mi, vitae dapibus enim sem quis quam. Nulla facilisi.
-
-Quisque ornare, erat non egestas vulputate, odio massa consequat ex, nec convallis ligula dui at urna. Pellentesque lacinia, est a ornare facilisis, mi leo malesuada nunc, sed tristique ex augue sed magna. Mauris imperdiet pharetra blandit. Etiam eget nisl id massa elementum imperdiet. Nullam tortor leo, volutpat ac nulla id, feugiat pulvinar eros. Pellentesque tempus bibendum felis et luctus. Duis non imperdiet nibh. Sed blandit ex a odio feugiat maximus. Maecenas elementum odio sit amet purus fermentum, ut mattis enim maximus. Proin efficitur lectus enim, nec fringilla velit pharetra quis. Aliquam ligula massa, tincidunt venenatis dolor sit amet, condimentum suscipit nisi. Cras a velit mi. Curabitur id ligula vestibulum, semper erat ut, tincidunt lacus. Nunc egestas urna et velit hendrerit, eu posuere libero sollicitudin. Suspendisse vitae fringilla nunc. Aenean eros ipsum, scelerisque at laoreet sed, mollis vel eros.
-
-Proin ac placerat nulla. Proin sollicitudin eget dolor eu luctus. Maecenas sit amet ante volutpat, molestie metus sit amet, tempus justo. Cras tellus odio, accumsan vitae urna eget, tempor eleifend turpis. Nulla venenatis posuere lacus congue convallis. Fusce suscipit egestas aliquet. Vivamus condimentum massa eget lacinia finibus. Morbi vitae leo ut eros consequat dapibus.
-
-Sed vel arcu a lorem posuere placerat in quis purus. Aliquam dapibus libero dui. Etiam in ex diam. Morbi nec nibh ut purus posuere euismod. Sed lobortis neque mauris, ac efficitur arcu venenatis ac. Donec orci purus, accumsan cursus ligula eu, mollis fermentum metus. Donec placerat diam et lorem dignissim, vel varius odio sagittis. Suspendisse potenti. Nam et erat facilisis ex maximus ultricies. Sed non magna nec turpis malesuada vulputate ac in massa.
-
-Cras ac dignissim purus, quis vehicula tortor. Maecenas vulputate, nisl vel egestas dignissim, nibh elit commodo elit, et maximus elit est vel massa. Vestibulum fermentum, dolor sed pellentesque scelerisque, ligula mauris lacinia lorem, ac commodo elit turpis rhoncus velit. Donec a enim in metus eleifend pharetra et ac elit. Morbi sed pellentesque leo. Nullam fringilla ultricies ante, nec pellentesque massa convallis nec. Maecenas elementum, mi a congue ullamcorper, arcu enim hendrerit enim, vitae fermentum sapien tellus ac sem. Nunc et tempus est. Aliquam lacinia, quam non tempor consequat, lorem lectus mollis nisl, id tempor nisl turpis eu purus. Sed eget maximus diam, convallis hendrerit neque.
-
-Donec venenatis odio ipsum, in consectetur dui tristique sit amet. Duis placerat neque nec lorem laoreet, et fermentum sapien rutrum. Quisque et diam odio. Phasellus ultrices nibh nec dolor laoreet fringilla. Nulla facilisi. Curabitur pretium erat quam, id facilisis nunc euismod ac. Duis condimentum risus ut vestibulum dapibus. Suspendisse lorem nunc, aliquet quis commodo eu, sagittis a neque. In sodales augue mattis odio sagittis scelerisque. Sed sem purus, commodo nec ornare non, dapibus id enim.
-
-Mauris urna nisl, consectetur vitae blandit a, posuere a dui. Praesent ut nisl accumsan, vehicula erat a, mattis ligula. Nam metus neque, blandit vel diam a, finibus sagittis orci. Sed metus lorem, congue in tincidunt quis, varius ut lectus. In ultrices augue nec sem bibendum ultricies. Cras a tellus at est gravida tempor vel id risus. Nullam erat nulla, fringilla nec nunc sit amet, placerat ultricies turpis. Sed interdum mi vitae ullamcorper posuere. Proin eu faucibus urna. Mauris maximus, quam a accumsan commodo, justo diam mollis nunc, ac laoreet lacus magna quis nisl. Quisque tincidunt lacus ipsum, ut sagittis elit mattis in. Donec elementum vitae purus ut tristique. Fusce lobortis orci ante, ut bibendum risus imperdiet at.
-
-Donec dignissim tristique tincidunt. Sed vitae felis justo. Curabitur tincidunt, enim non finibus luctus, elit nunc consectetur libero, sit amet tincidunt odio purus eget quam. Nam tincidunt id metus malesuada feugiat. Vivamus metus quam, posuere quis quam sollicitudin, tincidunt placerat nisi. Aenean nec enim elementum, varius augue id, iaculis urna. Mauris nec risus eu arcu elementum tristique. Nullam ultrices diam eget lorem porta iaculis. Donec fringilla nibh mi, vel auctor enim maximus sed. Vestibulum metus erat, sollicitudin nec pharetra at, sodales vel tellus.
-
-Phasellus sed erat ac velit faucibus semper ut ut justo. Proin commodo porttitor magna dapibus rutrum. Maecenas placerat neque ac aliquet maximus. Praesent rutrum, felis quis venenatis placerat, tortor ligula porta ipsum, eu dapibus mi urna eget nisl. Proin ultrices vitae ipsum non tristique. Donec convallis massa metus, id mollis felis sollicitudin eu. Nulla gravida nunc id dui bibendum blandit. Suspendisse ut venenatis quam, vitae tempus massa. Quisque tincidunt mi eget erat congue, ac volutpat nunc posuere. Aenean aliquet eros id sapien rhoncus, ac hendrerit urna tincidunt. Morbi vitae euismod nisl, ut accumsan diam. Sed ultricies, tellus nec mollis rhoncus, lacus tellus feugiat est, eu ullamcorper arcu eros nec nulla.
-
-Donec pretium arcu eget justo efficitur mollis. Vivamus id arcu sit amet mauris congue vulputate sit amet in tellus. Vivamus commodo est libero, et vulputate lorem convallis in. Donec cursus arcu et nibh congue porta. Suspendisse laoreet neque sit amet magna ultrices, consequat scelerisque velit fermentum. Curabitur faucibus lorem faucibus, condimentum sem id, volutpat velit. Donec sed odio dolor. Fusce sodales ligula sit amet pretium hendrerit.
-
-Mauris ultrices vehicula metus, sed finibus lectus tristique et. Morbi id egestas lacus. Nulla volutpat, lectus et molestie elementum, urna nulla semper massa, at feugiat enim magna quis lacus. Phasellus vitae erat vitae turpis mattis tempus et sed dui. Ut vitae cursus orci. Etiam in massa lectus. Donec purus augue, bibendum sit amet feugiat et, lacinia vitae velit.
-
-Nulla ac enim tempus, accumsan nunc quis, malesuada quam. Etiam cursus nisi ut aliquam dapibus. Ut vulputate pulvinar ante, id condimentum dui euismod a. Maecenas arcu velit, ornare in nibh eu, feugiat volutpat augue. Duis a diam vitae orci tristique auctor id auctor nisi. Curabitur tincidunt, leo viverra elementum auctor, mi ex efficitur libero, vel aliquet eros mauris sed odio. Nulla consectetur, metus non ullamcorper rutrum, quam eros egestas lacus, vitae luctus odio neque hendrerit nulla. Suspendisse ullamcorper orci massa, non pretium libero dignissim id. Aenean scelerisque justo sapien, quis convallis augue dapibus ut. Aenean ut tincidunt justo. Aenean a lacus lectus.
-
-Interdum et malesuada fames ac ante ipsum primis in faucibus. Sed sit amet magna eleifend, dictum risus non, dictum turpis. Nam ut quam malesuada, accumsan magna rhoncus, malesuada arcu. In id egestas purus. Nunc nec arcu vel elit vulputate dignissim accumsan sed quam. Suspendisse lacinia ex mattis mi ornare, et maximus ex rhoncus. Morbi ac posuere ligula, eu imperdiet mi. Fusce a dapibus turpis. Duis vel odio elementum, laoreet ipsum sit amet, blandit tellus. Vestibulum eleifend condimentum enim, fermentum vehicula nisi tincidunt nec. Aenean at maximus ante. Maecenas iaculis enim ac tortor feugiat, ac ultricies metus mollis. Nam posuere et turpis vitae egestas.
-
-Proin vitae eros vel quam tristique ullamcorper. In nec feugiat diam. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; Aenean dui elit, dictum sit amet mi non, dignissim laoreet nisi. Nulla eget congue ipsum. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Duis vitae libero sed nulla sagittis placerat nec sed lorem. Phasellus accumsan suscipit nunc a ultricies. Sed dapibus et elit a hendrerit. Ut fermentum quis velit vel dignissim. Etiam vel odio justo. In aliquet eros ut ultrices imperdiet. Aliquam erat volutpat. Phasellus quis dolor aliquam, lacinia mauris ut, blandit elit. Proin risus ipsum, laoreet nec gravida ut, condimentum at nisl.
-
-Nam eu ipsum vel sem semper consectetur porttitor ut sem. Pellentesque ac leo ultricies, ornare risus pulvinar, elementum ipsum. Maecenas a turpis et lorem auctor sagittis. Pellentesque porttitor eu erat non maximus. Duis tristique in orci sed facilisis. Nulla orci justo, facilisis eu libero et, consequat varius lectus. Fusce quis quam et mauris tristique condimentum at vitae urna. Proin tristique ex ut mauris eleifend, sed dapibus felis semper. Aenean placerat sollicitudin sollicitudin. Ut elementum tincidunt neque in feugiat. Aliquam rhoncus ligula id hendrerit dapibus. Nulla ac ex dolor. Phasellus ex nisi, viverra sit amet faucibus nec, malesuada nec nisl. Aliquam erat volutpat. Ut consequat egestas odio, pretium ullamcorper massa viverra at.
-
-Pellentesque blandit sit amet est a auctor. Nullam et arcu et risus tempus eleifend. Nunc tristique lectus est, quis rutrum magna sagittis eget. Etiam iaculis tellus eget metus laoreet faucibus vel vel nisi. Fusce et posuere enim. Morbi nec interdum nisl. Donec diam est, semper vel hendrerit at, rutrum sed eros. Nunc eu dapibus sem, eget ultricies elit. Nam condimentum ex pharetra turpis ornare, at pretium orci vehicula. Proin in tristique est, eu mollis ante. Sed tortor nisl, tincidunt et maximus quis, porta vitae elit. Quisque bibendum condimentum sodales. Vivamus fermentum posuere molestie. Morbi pharetra elit eget turpis vulputate, eget laoreet metus rutrum.
-
-Suspendisse at diam ac nisl vestibulum facilisis. Quisque non sollicitudin urna, sed lacinia tortor. Duis ultrices ut mauris at aliquet. Vestibulum eu mauris dapibus, dictum nibh rhoncus, bibendum magna. Suspendisse rutrum ligula eu posuere efficitur. Nullam in egestas arcu. Proin a urna ac felis tempor sagittis egestas nec tortor. Donec ac feugiat leo. Ut ac tempor sapien, ac lacinia dolor. In placerat sagittis libero, sit amet varius massa auctor sit amet. Fusce pellentesque finibus odio vel scelerisque. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Vivamus euismod nisi nisi, ac luctus sapien venenatis nec.
-
-Quisque sit amet metus et turpis laoreet pulvinar. Sed at accumsan ex. Aliquam eu tempus odio. Fusce consectetur dolor ut magna fringilla venenatis. Pellentesque rhoncus libero elementum, placerat eros et, laoreet eros. Nulla sit amet ligula viverra, aliquam felis accumsan, blandit eros. Vestibulum porta volutpat magna vel malesuada.
-
-Duis semper aliquam nisi, vel finibus tellus pretium mollis. Vivamus nec libero vitae neque blandit finibus. Aliquam maximus, libero ut tristique cursus, magna risus placerat dui, sit amet semper odio metus vel mauris. Aenean porta ut nisi in aliquet. Vivamus in felis eu odio porttitor finibus. Phasellus placerat urna non leo congue, at placerat magna volutpat. Etiam ut fermentum ligula. Sed nunc lectus, posuere et tellus sed, rutrum pulvinar ex. Nulla ullamcorper at mauris at efficitur. Vivamus ultrices, odio sit amet congue porttitor, purus ante mattis justo, quis dapibus sem tellus sit amet dui. Morbi nec neque efficitur, scelerisque erat in, posuere diam. Nam faucibus nunc eget condimentum pulvinar. Praesent rutrum nisi et mauris fermentum sagittis. Cras imperdiet elit in eros mollis, ut pulvinar lacus tincidunt.
-
-Vestibulum vel convallis ante. Duis et varius nibh. Praesent sodales purus at efficitur lacinia. In eget lacus odio. Vivamus eros nisi, lobortis non quam et, sollicitudin congue nulla. Pellentesque vestibulum turpis non purus pharetra egestas. Quisque accumsan vestibulum fermentum. Nam eu hendrerit neque. Proin ut aliquet lorem, id suscipit massa. Sed volutpat viverra magna, vel faucibus felis convallis in. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras a hendrerit odio, ac facilisis purus.
-
-Nam a nulla ultricies tellus porttitor feugiat. Morbi et urna suscipit, accumsan massa id, semper nisl. Nam eros nibh, eleifend semper erat vitae, vehicula cursus mauris. Nam semper pulvinar augue eu auctor. Morbi eget laoreet magna. Proin porta, nulla egestas commodo ultrices, risus felis efficitur eros, et mollis augue nisl in neque. Nullam dignissim dui eget tellus gravida, non congue nisl elementum. Nulla ac eros hendrerit, sollicitudin mauris vitae, tristique turpis. Maecenas id laoreet erat.
-
-Nullam vestibulum in felis euismod aliquam. Sed sit amet magna in mauris feugiat scelerisque et fermentum lorem. Aenean scelerisque eget mauris vel molestie. Sed vel ipsum non magna eleifend tristique. Phasellus viverra nulla justo, sed maximus neque sollicitudin hendrerit. Mauris facilisis sem vel elit mattis iaculis. Vivamus ac dapibus sem. Sed quis egestas sapien, eu volutpat augue. Vestibulum molestie suscipit est, ut fermentum diam rhoncus eu. Maecenas accumsan massa sed sapien viverra commodo. Duis eget lacus a urna accumsan mattis at sed orci. Aenean at scelerisque felis. Sed magna lectus, lacinia eu pharetra ac, pharetra at ex. Vestibulum vel tortor a sem luctus placerat. Maecenas efficitur, est sed auctor vehicula, ante lorem finibus dolor, tristique efficitur lacus risus eget ex. Pellentesque maximus velit eu ipsum lobortis blandit.
-
-Maecenas aliquam sollicitudin tellus, consequat ultricies lacus. Proin pretium nibh fermentum, malesuada quam sit amet, luctus orci. Curabitur sodales varius tortor, eu rutrum nisi blandit eu. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Quisque nec lectus quis nisi mattis dapibus. Donec dapibus leo ac nibh elementum pharetra. Aliquam lobortis ante a risus facilisis condimentum. Sed mauris enim, tristique sed viverra eu, varius vel lorem. Vivamus non ex mi. Etiam sed pellentesque ante. Ut leo ipsum, mattis a eleifend sed, tincidunt pharetra nibh. Nam vel tellus nunc.
-
-Nullam libero urna, euismod at consequat quis, fringilla eu turpis. Aliquam tellus leo, posuere elementum risus vel, pulvinar tincidunt quam. Interdum et malesuada fames ac ante ipsum primis in faucibus. Ut non nibh id massa bibendum porta a sed ante. Donec commodo accumsan orci, quis volutpat sem tincidunt id. Nulla mollis, lacus id pretium cursus, nisi nulla rhoncus quam, non maximus leo ligula consequat metus. In fringilla et est quis tristique. Nullam vestibulum urna leo, non molestie ipsum dignissim at. Donec tristique erat vitae interdum gravida. Vestibulum tincidunt nec nunc eget blandit. Vestibulum at laoreet arcu, sed ultrices orci. Nam vitae sapien bibendum, aliquam massa quis, convallis mauris. Morbi eu mi ultrices, aliquam tortor sit amet, elementum diam. Sed pulvinar lorem eget urna consequat consectetur. Integer hendrerit tortor quis ipsum suscipit, eget vulputate neque semper. Duis pulvinar hendrerit nisi sed pretium.
-
-Ut imperdiet tempor convallis. Nullam vehicula sem id ligula hendrerit consectetur. Nunc a ornare justo. Donec elementum eros id mi sagittis, sit amet consectetur nisi semper. Maecenas varius gravida turpis, quis dapibus ex consectetur sed. Cras tortor neque, lacinia et neque scelerisque, hendrerit semper est. In ultricies blandit nisl ut finibus.
-
-In sapien ante, euismod non molestie vel, venenatis eu tortor. Pellentesque nec tortor sed ante posuere faucibus. Morbi sed euismod urna, vel dictum neque. Aenean ultrices in eros a lobortis. Suspendisse lacinia est eu lacus porttitor ornare. Donec vitae sapien diam. Integer vitae pellentesque ex. Maecenas iaculis purus id felis hendrerit suscipit vitae non tortor. Pellentesque rhoncus facilisis orci, at ultrices nibh egestas nec.
-
-Quisque eu quam eros. Nam venenatis pharetra augue. Donec ut mauris maximus, rutrum nulla id, dignissim purus. Curabitur nec sem id risus mollis bibendum nec sit amet ipsum. Nam dignissim hendrerit ullamcorper. Suspendisse eu risus scelerisque, dapibus nibh vitae, pellentesque eros. Proin finibus sapien id cursus consequat. Quisque augue mi, imperdiet vitae dignissim eget, lacinia id lectus. Etiam at augue non lectus iaculis fermentum vel in arcu. Suspendisse et nunc sodales, auctor arcu in, faucibus est. Ut quis neque vitae leo placerat luctus sed quis velit. Suspendisse vehicula, erat vel dictum posuere, ligula sapien tristique velit, vel tincidunt orci leo at enim. Quisque non ullamcorper lectus.
-
-Aliquam dapibus mattis purus eu euismod. Maecenas sagittis mi quis tellus sodales hendrerit. Phasellus at sem egestas, condimentum purus in, cursus quam. Praesent nec suscipit diam, at laoreet ex. Suspendisse cursus lectus eu erat convallis accumsan et nec orci. Pellentesque finibus hendrerit tellus, at rutrum enim rhoncus eget. Etiam id hendrerit nulla. Phasellus tempus urna a lorem ullamcorper accumsan. Proin sit amet orci ante.
-
-Aenean pulvinar sem quis ligula dignissim tincidunt. Maecenas eu odio ut tortor venenatis elementum. Aenean a purus nunc. Suspendisse ut hendrerit elit. Phasellus ac lectus in tellus ullamcorper tincidunt. Aliquam ac pellentesque leo. Nam dignissim semper quam a efficitur. Suspendisse finibus pretium risus non lacinia. Phasellus consectetur porta pellentesque. Integer ac facilisis libero. Quisque pellentesque imperdiet tortor. Fusce porta mi nec consequat sagittis. Aliquam turpis sem, finibus ut tellus at, efficitur tincidunt velit. Nullam vitae diam sit amet quam malesuada lacinia.
-
-Proin in hendrerit nisi. Interdum et malesuada fames ac ante ipsum primis in faucibus. Aenean elementum tortor libero, ac volutpat eros euismod quis. Ut malesuada convallis tortor a consectetur. Curabitur urna sem, consectetur in elit at, mollis dictum elit. Nulla rhoncus libero id purus fermentum faucibus. Curabitur finibus auctor suscipit. Ut sed molestie elit. In ut sem non sapien varius commodo. Duis nec facilisis erat. Donec sollicitudin mollis ex, in dapibus erat commodo eget. Vestibulum lorem sapien, consequat sed commodo ac, maximus vitae nunc. Pellentesque interdum interdum nulla, id facilisis magna viverra at. Donec porttitor ante id congue dignissim. Aliquam dignissim eget diam pellentesque accumsan.
-
-Donec a efficitur neque. Integer iaculis sit amet augue sed pharetra. Nulla dignissim dolor a orci maximus ullamcorper. Morbi varius enim ut posuere molestie. Donec volutpat magna ut suscipit interdum. Cras magna dolor, rutrum eget nisi quis, ornare fringilla libero. Nullam tempor tempor erat eget condimentum. Vivamus egestas ex ac tellus finibus maximus. Donec eget vehicula purus, a venenatis neque. Duis mollis quam sit amet lectus ullamcorper tempus. Etiam eget sapien in orci porta pharetra. Phasellus et viverra dolor, vitae placerat urna. Nullam vel porttitor tellus. Aenean dictum imperdiet lobortis.
-
-Suspendisse auctor metus ut aliquam ullamcorper. Morbi ac aliquet massa, a porta lorem. Etiam luctus dignissim erat. Etiam eu mi eu nisi convallis bibendum vel a nisi. Aenean condimentum enim et magna placerat, dictum aliquet tellus bibendum. Nam interdum mauris at facilisis porta. Morbi sodales sollicitudin tempus.
-
-Nam quis aliquam tellus. Vestibulum placerat nisi eget tempus egestas. Etiam congue diam ut leo blandit fermentum. Curabitur eu dui quis mauris sodales imperdiet ac ac urna. Integer at nisl cursus, suscipit odio vel, consequat neque. Suspendisse in lectus turpis. Nullam dui odio, tempus ut feugiat at, suscipit a justo. Phasellus mauris augue, aliquet efficitur cursus eu, finibus sit amet ipsum. Vestibulum urna mauris, mollis sit amet ex at, cursus imperdiet nulla. Donec velit justo, viverra et erat in, hendrerit hendrerit turpis. Proin pharetra nunc aliquam neque congue eleifend.
-
-Praesent vel egestas metus. Sed dui mi, laoreet a euismod ac, ullamcorper in orci. Aenean eu risus pulvinar, aliquet ex ac, ornare ex. Mauris lectus purus, placerat ut lacus ac, pellentesque sollicitudin sem. Proin sed volutpat sapien. Ut posuere ex ac odio eleifend, ac ultrices ligula ultricies. Vestibulum nec nunc a leo volutpat convallis eget vel turpis. Suspendisse ut dapibus enim, at scelerisque ligula. Mauris vestibulum nec tellus a porta. Quisque ac placerat sapien, nec maximus nunc. Vivamus mollis tincidunt risus in auctor. In laoreet elit et eleifend facilisis. Integer facilisis tortor quam, sed tristique purus mattis id. Etiam faucibus leo augue.
-
-Sed tristique efficitur nulla, et rutrum mauris euismod non. Praesent ac leo luctus dui rutrum dictum a vel ipsum. Vestibulum faucibus risus vitae imperdiet rhoncus. Nunc volutpat viverra nisl. Nunc sit amet urna sed purus iaculis egestas. Nam pretium dui eget ante ullamcorper tempus. Pellentesque gravida, dui non cursus tempus, nisl lorem viverra diam, in condimentum metus neque eu justo. In malesuada tortor sagittis posuere finibus. Nunc ac nisi lacus. Interdum et malesuada fames ac ante ipsum primis in faucibus. Proin nec nibh nec orci sagittis venenatis sed et justo. Vestibulum et nisl vitae ex mattis efficitur. Interdum et malesuada fames ac ante ipsum primis in faucibus.
-
-Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Suspendisse hendrerit nibh nec ex consequat tempor. Suspendisse vestibulum urna in blandit iaculis. Aenean lacinia odio ex, eget tempor nulla condimentum sed. Proin suscipit, est eget sollicitudin feugiat, nisl felis ultrices massa, non finibus justo risus quis lectus. Mauris ipsum tellus, suscipit nec gravida sed, aliquet non sem. Ut suscipit sodales ante, vitae feugiat quam scelerisque in. Curabitur id luctus dui, eget interdum dui. Maecenas sagittis quis nisi et laoreet. Cras maximus in leo et feugiat. Proin aliquam egestas consequat. Suspendisse sit amet arcu auctor eros imperdiet rhoncus sed in lorem. Sed porttitor at elit laoreet mattis. Donec dui eros, dictum sit amet massa at, facilisis consequat nisi. Phasellus arcu est, viverra vel lacus id, efficitur sodales ligula.
-
-Nam ultrices dignissim mi vel vestibulum. Mauris a euismod lorem, in scelerisque enim. Pellentesque molestie fermentum purus, nec semper nunc placerat sit amet. Aenean ullamcorper sollicitudin faucibus. Curabitur a hendrerit leo. Donec congue massa nulla, vitae sodales ex posuere non. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Cras pharetra risus eu consequat commodo. Donec iaculis lorem vitae diam mollis feugiat.
-
-Nulla molestie dui quis blandit pretium. Curabitur et tempus nisi. Aliquam luctus interdum libero a varius. Morbi nec volutpat odio. Quisque elementum velit vitae mi hendrerit, nec aliquet arcu tempus. Aenean ullamcorper, tortor sit amet rutrum dapibus, metus dui sagittis nisl, id volutpat velit lorem sodales erat. Quisque vel justo sed massa rutrum accumsan eget non elit. Fusce luctus felis mi, id aliquet massa commodo sit amet. Morbi blandit et est ac faucibus. Quisque eget malesuada nibh, sit amet venenatis purus. Proin risus eros, ullamcorper nec posuere a, hendrerit eu dolor. Nunc a mattis dolor. Fusce ultricies arcu eu lectus consequat elementum. Phasellus euismod nunc sapien, eget lobortis urna efficitur vitae. Phasellus sed ligula rhoncus, imperdiet neque eget, luctus est. Praesent aliquam aliquet turpis, quis ornare lacus sagittis ut.
-
-Quisque rhoncus velit in suscipit commodo. Donec massa turpis, posuere ut vulputate vitae, ultrices gravida velit. Aenean lectus nulla, hendrerit vitae laoreet imperdiet, ultrices a ipsum. Morbi a tincidunt odio, et lacinia nisi. In in pulvinar nibh. Vestibulum vehicula tellus quis est mollis efficitur. Maecenas non pellentesque dui, et sagittis erat. Sed sed diam blandit diam convallis euismod sit amet sit amet arcu.
-
-Proin ullamcorper maximus suscipit. Aenean non volutpat quam. Vivamus ex justo, aliquam vitae vulputate eu, porttitor ut leo. Sed lorem mauris, finibus in feugiat sit amet, tincidunt ac risus. Duis accumsan lectus at purus dapibus ultricies. Ut ac sagittis velit. In vel enim eu neque imperdiet interdum eget eget massa. Aliquam varius sagittis pulvinar. Etiam fermentum sit amet mi finibus tempor. Aliquam varius risus erat, ac commodo sapien euismod et. Proin pretium mattis turpis et aliquet. Suspendisse facilisis ut mi ut maximus. Donec dictum dapibus feugiat.
-
-Proin tempor diam vestibulum odio elementum aliquam. Integer nunc urna, dictum id tortor eget, efficitur accumsan elit. Quisque lobortis ante ac mollis dignissim. Integer vel nunc rutrum, malesuada metus a, vestibulum neque. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; Donec ac erat ut mi fermentum consequat. Praesent tempor, erat id porttitor tempor, erat mauris semper massa, ac vulputate lacus justo ac ligula. Sed ligula neque, tincidunt ut tortor sed, volutpat sollicitudin diam. Pellentesque ligula purus, volutpat nec velit non, vulputate euismod arcu. Aenean quis purus volutpat, placerat sem vitae, sollicitudin nunc. Cras laoreet semper ipsum quis finibus. Fusce pellentesque purus at nibh mattis, et consequat dui viverra. Proin eu tellus sit amet sapien volutpat dictum. Curabitur luctus feugiat massa ac vehicula. Nullam eu lacus tempus, hendrerit lectus ac, posuere odio. Donec eu dui metus.
-
-Quisque molestie turpis eget dolor iaculis cursus. Suspendisse facilisis tristique enim at efficitur. Quisque sit amet nunc nisl. Nam placerat interdum fringilla. Aliquam vulputate, risus et euismod vulputate, ante dolor consequat odio, at finibus diam ante quis sem. Nulla accumsan quam id neque aliquam maximus. Proin sed convallis eros. Phasellus imperdiet in quam a ultrices. Fusce et imperdiet elit. Sed et hendrerit ipsum. Fusce arcu odio, rutrum vitae posuere vitae, facilisis lacinia nibh.
-
-Fusce nec tincidunt sem. Morbi tempus, nisi quis malesuada ornare, turpis neque condimentum justo, bibendum bibendum justo ex eu nulla. Pellentesque laoreet tincidunt dolor nec venenatis. Morbi eros risus, venenatis ac luctus ut, luctus quis sapien. Etiam et tellus massa. Aenean sit amet libero massa. Fusce venenatis elit vitae tellus commodo hendrerit. Curabitur ipsum tellus, dignissim nec lacus non, suscipit efficitur magna.
-
-Integer et erat tortor. Ut elementum pharetra scelerisque. Pellentesque mollis, urna quis faucibus cursus, arcu orci mattis lorem, varius maximus magna justo quis massa. Donec id scelerisque metus. Fusce sit amet ex a lectus ornare mollis. Donec ut metus nisl. Sed at turpis turpis. Suspendisse ut nibh nunc. Duis eget viverra nisi.
-
-In massa velit, ultricies sit amet elementum vel, sollicitudin ac tellus. Ut euismod nisl non leo porta varius. Phasellus sapien velit, auctor quis pulvinar nec, venenatis in urna. Aliquam elementum, eros vitae dignissim condimentum, enim lacus suscipit nibh, eget imperdiet nibh metus ac arcu. Quisque condimentum, ligula in luctus pharetra, elit tortor lacinia neque, et aliquam ex velit sed ipsum. Maecenas convallis ante odio, finibus egestas dolor porta non. Nunc fringilla erat diam, nec lobortis est scelerisque eget. Cras dictum lectus rhoncus, rhoncus dui at, bibendum risus. Aenean eget tristique nunc. Etiam eget elementum urna. Nulla facilisi.
-
-Aliquam porta magna id est fermentum, sit amet iaculis mi viverra. Nullam pharetra, ex non ultricies fringilla, dui ligula cursus ipsum, vitae iaculis eros quam vel sem. Sed lacinia vestibulum tellus at sodales. Quisque vulputate, quam eu porta convallis, lectus lacus viverra metus, quis tincidunt augue libero nec tellus. Curabitur et fermentum turpis. Praesent urna neque, fermentum ac magna vitae, convallis fermentum enim. Nam ut nulla at dui viverra faucibus vel at justo. Praesent feugiat commodo ante et dictum. Nullam quis gravida diam. Curabitur nec nisl ac elit luctus bibendum a sed augue. Mauris nec dolor eget eros ullamcorper condimentum.
-
-In leo mauris, sagittis id rhoncus vel, aliquet non augue. Pellentesque ornare vitae nibh luctus pulvinar. Proin eu lacinia neque, ut faucibus lorem. Curabitur quis justo porttitor, tincidunt mauris id, porta turpis. Sed id leo elit. Morbi auctor nisi eget augue feugiat consequat. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Sed ut purus felis.
-
-Ut pretium, purus eget ultricies condimentum, diam quam finibus lacus, non scelerisque leo nisi at arcu. Vestibulum consectetur quam ac dapibus dignissim. Cras et lacus sit amet nisl sodales dignissim non eu tortor. Nam ultrices enim quam, vitae lobortis est varius in. Sed tincidunt tincidunt eros eget semper. Etiam accumsan efficitur suscipit. Donec at facilisis purus, et egestas ex. Vivamus dapibus iaculis sapien. Sed fermentum dui sit amet est blandit scelerisque non vitae neque. Vivamus a placerat ex. Mauris feugiat ultrices turpis, id luctus nulla rhoncus mattis. Curabitur accumsan eleifend ligula id viverra.
-
-Aliquam molestie maximus nisl, vitae fermentum odio hendrerit quis. Fusce varius quis velit at sagittis. Morbi eu magna aliquet, scelerisque risus sit amet, sollicitudin ante. Mauris scelerisque pellentesque lacinia. Duis quis ligula nec mauris pretium lacinia. Nulla imperdiet lorem est, nec laoreet ante commodo et. Suspendisse et sollicitudin turpis, ut luctus nibh.
-
-Ut id libero nec purus condimentum pharetra eget ac mauris. Vivamus finibus dignissim lacus, at porta leo sodales sit amet. Nunc augue leo, eleifend eu ultricies eget, posuere et tellus. Maecenas porta, nibh in rutrum semper, ex eros fringilla nisl, eu ultricies sem nunc sit amet magna. Aenean nec pharetra odio. Pellentesque quis diam quam. Fusce tincidunt justo enim, in condimentum erat euismod id. Etiam varius dui ut turpis placerat efficitur non id nulla. Nunc in velit magna. Sed posuere enim enim, sed semper urna auctor at. Nam scelerisque, est sed accumsan convallis, ipsum ligula imperdiet purus, eget malesuada urna nisi at nisl. Donec massa purus, venenatis at ex in, lobortis porttitor erat. In hac habitasse platea dictumst.
-
-Mauris varius mattis fringilla. Ut pretium leo turpis. Etiam nec scelerisque sem. Donec velit elit, suscipit in dolor scelerisque, sagittis dignissim justo. Morbi egestas sit amet turpis vitae elementum. Integer maximus justo ac elit tempus faucibus. Donec consequat elementum dui consequat lobortis. Etiam eget est nec nibh pulvinar maximus. Integer egestas pulvinar leo vitae luctus. Nullam enim justo, vestibulum ac bibendum et, pharetra eleifend mauris. In ut ligula nec risus eleifend blandit.
-
-Mauris sagittis arcu quis magna pulvinar, quis interdum leo semper. Aenean viverra turpis eget erat molestie, sit amet malesuada ipsum maximus. Duis eros metus, consequat vel metus quis, ullamcorper ullamcorper tortor. Duis condimentum, metus non molestie mollis, ante augue eleifend elit, nec porttitor nunc ex id purus. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Nullam nisi velit, placerat et dictum sed, vulputate et mauris. Sed bibendum porttitor tellus vel vehicula.
-
-Nam non gravida sapien, et euismod nulla. Pellentesque dapibus tristique lectus, sed finibus turpis accumsan ut. Pellentesque ultricies diam eu felis iaculis, vitae egestas nulla tempus. Ut pharetra, sem ac feugiat lobortis, ex nisl congue libero, vel pellentesque leo nibh eu elit. Etiam vehicula non metus at ornare. Aliquam orci leo, eleifend a fermentum condimentum, eleifend at lectus. Ut sit amet iaculis elit. Nullam molestie mattis leo a aliquet. Vestibulum convallis commodo rhoncus. Vestibulum at eros leo. Nam tempus urna sit amet nunc sagittis blandit. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Nam condimentum, felis sit amet ultricies consectetur, velit ex ultrices ipsum, sit amet condimentum enim dui pulvinar risus. Vivamus euismod a quam et sagittis. Fusce posuere at sem non egestas. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas.
-
-Maecenas urna felis, condimentum vitae pretium vel, consequat id ligula. Proin eget ante eget tellus luctus maximus vitae sit amet libero. Donec at risus eget tellus feugiat vulputate. Aliquam laoreet sapien at pellentesque vehicula. In egestas laoreet lobortis. Duis ultrices molestie urna sit amet dapibus. Fusce ultricies mauris lectus, in luctus est facilisis sit amet. Nunc sed faucibus orci. Fusce fringilla est a dictum commodo. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Aliquam aliquam lacus a eros tincidunt maximus.
-
-Aenean vestibulum, metus vel interdum lacinia, libero metus consectetur tellus, non sollicitudin ante ipsum ut velit. Donec accumsan laoreet justo hendrerit venenatis. Mauris hendrerit tincidunt diam eu accumsan. Suspendisse egestas non orci at vulputate. Praesent sollicitudin congue magna egestas aliquet. Mauris at molestie mi. Mauris vel magna viverra, mattis velit at, fringilla elit. Cras porta lorem leo, ut tincidunt velit pharetra non.
-
-Praesent commodo turpis et ligula vulputate, non ullamcorper ante faucibus. Phasellus cursus magna quis est mollis, id suscipit libero mattis. Nam felis lectus, accumsan vitae sollicitudin eu, facilisis nec velit. Nam sollicitudin odio ut sapien vulputate, quis commodo diam convallis. Aliquam fringilla est quis lacus elementum lobortis. Mauris pulvinar enim justo, ut sollicitudin eros pulvinar sit amet. Sed lobortis vestibulum eleifend. Morbi at mattis elit. In sit amet porttitor lacus, eget pharetra sapien. Proin elit metus, varius in dictum sed, ornare vel odio.
-
-Suspendisse luctus viverra mollis. Vivamus est ante, egestas nec dignissim egestas, varius a libero. Phasellus id lacinia tellus. Sed pellentesque porttitor rutrum. Duis a mi sollicitudin, mollis purus et, fermentum ante. Nullam non metus et lacus vehicula ultricies eget non risus. Aenean ipsum dui, venenatis ut leo sed, ultricies volutpat tellus. Praesent consectetur id felis maximus suscipit. Nulla vel ipsum vel massa convallis ornare a vel felis. Aliquam convallis vestibulum ante.
-
-Quisque eu pretium libero. Morbi volutpat velit ut est finibus, eu condimentum dui tristique. Cras dignissim tempus risus id gravida. Donec vitae lorem dolor. Aliquam et cursus lorem. Sed molestie dui nibh, et bibendum turpis elementum quis. Nunc consequat diam et tortor consectetur, eget sollicitudin urna mollis.
-
-Cras vel est posuere ipsum viverra mollis. In lacus elit, interdum eget pretium non, dictum vitae dolor. Nulla arcu neque, sollicitudin varius iaculis in, gravida id justo. Phasellus ut condimentum justo. Aenean consectetur vitae sem quis rhoncus. Nam id nulla sit amet mauris ultricies bibendum et vitae quam. Mauris blandit metus in egestas egestas. Aenean erat ligula, consectetur nec elementum in, elementum quis quam. Quisque est arcu, auctor sed est eget, bibendum tristique mauris. Aliquam a varius purus, sit amet faucibus augue. Vestibulum a mattis lacus. Mauris eleifend, tortor sit amet fermentum lobortis, libero risus feugiat erat, sodales imperdiet magna nibh ut elit. In porta sapien urna, eget viverra magna egestas ut. Aliquam ac eleifend ligula. Morbi dignissim magna id varius pulvinar. Ut pulvinar commodo placerat.
-
-In iaculis tortor id molestie scelerisque. Quisque congue tristique nisi bibendum efficitur. Proin rutrum ultrices tincidunt. Praesent faucibus, mauris in dictum tincidunt, quam ligula suscipit nisi, nec efficitur ligula mi sit amet purus. Donec porta, velit convallis elementum posuere, sem nibh ornare dui, eget semper purus erat dictum diam. Mauris congue eros tellus, eget bibendum purus blandit sit amet. Sed faucibus ipsum vel velit maximus, vitae lobortis lectus luctus. Morbi tempor lacus sit amet hendrerit auctor. Aliquam auctor maximus laoreet. Nulla viverra massa eu tortor porta molestie. Fusce quis nisi arcu. Duis sit amet vestibulum quam, in posuere nunc. Nulla non placerat tortor. Curabitur malesuada eget metus ac auctor. Interdum et malesuada fames ac ante ipsum primis in faucibus.
-
-Donec bibendum libero nisl, eu varius est imperdiet id. Morbi sed arcu rhoncus, maximus libero eleifend, facilisis lacus. Sed sollicitudin, odio suscipit congue malesuada, justo magna finibus mauris, sed faucibus ipsum ligula ac augue. Sed sodales nulla mauris, efficitur bibendum sapien sagittis sit amet. Fusce consectetur justo diam, eu consequat nunc lacinia at. Curabitur ex ante, tempus at elementum non, maximus id lacus. Pellentesque in urna turpis. Proin tristique consequat lacus tincidunt faucibus. Proin ac tortor metus. Maecenas mollis blandit arcu, sit amet aliquam mauris laoreet sit amet. Nullam vulputate erat ac magna convallis efficitur. Proin cursus sodales est non suscipit. Nunc commodo lorem aliquet, commodo felis sit amet, dapibus orci. Nulla a enim vel ex facilisis laoreet. Donec malesuada laoreet turpis vel interdum. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos.
-
-Donec venenatis lectus eu tortor lobortis cursus. Quisque sit amet scelerisque quam, quis imperdiet ex. Morbi lacus purus, interdum non fringilla ut, ornare eget nisl. Morbi eleifend justo magna. Ut rutrum, nisl quis ultrices euismod, ligula arcu auctor quam, vel mattis ipsum lectus sit amet felis. Pellentesque vitae sagittis lorem. Morbi blandit finibus purus, quis commodo velit ultrices venenatis. Pellentesque eu erat enim. Fusce sollicitudin nunc nisi, non viverra neque aliquet at.
-
-Curabitur bibendum vel augue eget viverra. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; Phasellus id hendrerit quam, id tempor ex. Fusce quis sem dapibus, ornare leo ut, fringilla metus. Praesent molestie posuere scelerisque. Praesent ut libero vitae nisi iaculis venenatis maximus in leo. Donec sed ipsum massa. Aenean id purus tellus.
-
-Maecenas varius pharetra dignissim. Nulla iaculis in elit a facilisis. Nam ipsum enim, tristique nec feugiat ut, tristique vel felis. Donec tincidunt suscipit justo, at dictum ante sollicitudin sed. Mauris nisi ipsum, faucibus id sollicitudin at, consequat eu nibh. Duis lorem lectus, vestibulum vel eros eget, efficitur semper ligula. Quisque tristique tortor eu eros fringilla scelerisque. Aenean nisl nisi, mollis non dolor in, sagittis blandit metus. Cras tellus turpis, volutpat in varius non, semper eget magna. Pellentesque finibus augue id fringilla cursus.
-
-Fusce id est elit. Aliquam sit amet nunc finibus mi consectetur hendrerit in sit amet leo. Nunc posuere lectus ut est pellentesque, eu mollis tortor efficitur. Aliquam tincidunt placerat mauris non aliquam. Sed finibus dapibus tortor, sit amet fringilla libero tincidunt ut. Morbi at lectus volutpat, congue turpis sit amet, dignissim quam. Sed suscipit dolor vel nibh facilisis porta. Donec ut purus a leo volutpat pellentesque.
-
-Mauris vitae ipsum bibendum, interdum metus nec, pharetra purus. Nulla facilisi. Donec dolor ligula, iaculis vitae tempor quis, euismod non tortor. Phasellus condimentum accumsan augue, vel hendrerit nisi dictum id. Nullam eget ante sit amet turpis tempus finibus. Morbi a dolor sollicitudin, sollicitudin sem a, placerat massa. Aenean consectetur elit non aliquet lacinia. Maecenas lobortis ex turpis, vel sollicitudin dolor elementum in. Sed sit amet facilisis elit. Duis iaculis faucibus ante, ac bibendum ex placerat id. Nulla facilisi. Praesent sollicitudin ut velit at interdum. Nulla viverra volutpat lorem. Sed mattis gravida auctor. Nam pharetra erat id convallis luctus. Vestibulum congue est lorem, eget fermentum magna consequat eu.
-
-Sed ac luctus lectus, egestas gravida lorem. Suspendisse a tortor et velit mattis efficitur. Integer ornare accumsan justo nec molestie. Donec leo nunc, ultrices a consequat ut, bibendum at nisl. Mauris varius sem ac malesuada pharetra. Quisque bibendum diam at interdum molestie. Mauris ac ante sapien. Integer ultricies vitae justo eu dictum. Nulla facilisi. Etiam aliquet tellus id dignissim pharetra.
-
-Nam sed nibh ex. Phasellus faucibus ante sapien, sit amet tristique elit posuere mattis. Proin porta vitae enim sed auctor. Vestibulum quis ex euismod, imperdiet ante iaculis, vehicula mi. Vivamus convallis augue pellentesque commodo bibendum. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Integer gravida vitae leo vel varius. Aenean porta vehicula lorem, vitae commodo turpis sagittis eu. Aenean mattis elit et mi sagittis vulputate. Morbi vitae nisi quis mauris malesuada scelerisque. Morbi id efficitur quam. Ut id elit quam. Fusce at nisi fringilla, pharetra diam ut, suscipit erat.

caddyhttp/header/header.go

@@ -1,55 +0,0 @@
-// Package header provides middleware that appends headers to
-// requests based on a set of configuration rules that define
-// which routes receive which headers.
-package header
-
-import (
-	"net/http"
-	"strings"
-
-	"github.com/mholt/caddy/caddyhttp/httpserver"
-)
-
-// Headers is middleware that adds headers to the responses
-// for requests matching a certain path.
-type Headers struct {
-	Next  httpserver.Handler
-	Rules []Rule
-}
-
-// ServeHTTP implements the httpserver.Handler interface and serves requests,
-// setting headers on the response according to the configured rules.
-func (h Headers) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error) {
-	replacer := httpserver.NewReplacer(r, nil, "")
-	for _, rule := range h.Rules {
-		if httpserver.Path(r.URL.Path).Matches(rule.Path) {
-			for _, header := range rule.Headers {
-				// One can either delete a header, add multiple values to a header, or simply
-				// set a header.
-				if strings.HasPrefix(header.Name, "-") {
-					w.Header().Del(strings.TrimLeft(header.Name, "-"))
-				} else if strings.HasPrefix(header.Name, "+") {
-					w.Header().Add(strings.TrimLeft(header.Name, "+"), replacer.Replace(header.Value))
-				} else {
-					w.Header().Set(header.Name, replacer.Replace(header.Value))
-				}
-			}
-		}
-	}
-	return h.Next.ServeHTTP(w, r)
-}
-
-type (
-	// Rule groups a slice of HTTP headers by a URL pattern.
-	// TODO: use http.Header type instead?
-	Rule struct {
-		Path    string
-		Headers []Header
-	}
-
-	// Header represents a single HTTP header, simply a name and value.
-	Header struct {
-		Name  string
-		Value string
-	}
-)

caddyhttp/header/header_test.go

@@ -1,89 +0,0 @@
-package header
-
-import (
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"reflect"
-	"sort"
-	"testing"
-
-	"github.com/mholt/caddy/caddyhttp/httpserver"
-)
-
-func TestHeader(t *testing.T) {
-	hostname, err := os.Hostname()
-	if err != nil {
-		t.Fatalf("Could not determine hostname: %v", err)
-	}
-	for i, test := range []struct {
-		from  string
-		name  string
-		value string
-	}{
-		{"/a", "Foo", "Bar"},
-		{"/a", "Bar", ""},
-		{"/a", "Baz", ""},
-		{"/a", "ServerName", hostname},
-		{"/b", "Foo", ""},
-		{"/b", "Bar", "Removed in /a"},
-	} {
-		he := Headers{
-			Next: httpserver.HandlerFunc(func(w http.ResponseWriter, r *http.Request) (int, error) {
-				return 0, nil
-			}),
-			Rules: []Rule{
-				{Path: "/a", Headers: []Header{
-					{Name: "Foo", Value: "Bar"},
-					{Name: "ServerName", Value: "{hostname}"},
-					{Name: "-Bar"},
-				}},
-			},
-		}
-
-		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()
-		rec.Header().Set("Bar", "Removed in /a")
-
-		he.ServeHTTP(rec, req)
-
-		if got := rec.Header().Get(test.name); got != test.value {
-			t.Errorf("Test %d: Expected %s header to be %q but was %q",
-				i, test.name, test.value, got)
-		}
-	}
-}
-
-func TestMultipleHeaders(t *testing.T) {
-	he := Headers{
-		Next: httpserver.HandlerFunc(func(w http.ResponseWriter, r *http.Request) (int, error) {
-			return 0, nil
-		}),
-		Rules: []Rule{
-			{Path: "/a", Headers: []Header{
-				{Name: "+Link", Value: "</images/image.png>; rel=preload"},
-				{Name: "+Link", Value: "</css/main.css>; rel=preload"},
-			}},
-		},
-	}
-
-	req, err := http.NewRequest("GET", "/a", nil)
-	if err != nil {
-		t.Fatalf("Could not create HTTP request: %v", err)
-	}
-
-	rec := httptest.NewRecorder()
-	he.ServeHTTP(rec, req)
-
-	desiredHeaders := []string{"</css/main.css>; rel=preload", "</images/image.png>; rel=preload"}
-	actualHeaders := rec.HeaderMap[http.CanonicalHeaderKey("Link")]
-	sort.Strings(actualHeaders)
-
-	if !reflect.DeepEqual(desiredHeaders, actualHeaders) {
-		t.Errorf("Expected header to contain: %v but got: %v", desiredHeaders, actualHeaders)
-	}
-}