templates: Change functions, add front matter support, better markdown

These will be used in the new automated documentation system

.gitattributes

@@ -1,21 +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
-go.mod    text eol=lf
-go.sum    text eol=lf
-
-*.txt     text eol=lf core.whitespace whitespace=tab-in-indent,trailing-space,tabwidth=2
-*.tpl     text eol=lf core.whitespace whitespace=tab-in-indent,trailing-space,tabwidth=2
-*.htm     text eol=lf core.whitespace whitespace=tab-in-indent,trailing-space,tabwidth=2
-*.html    text eol=lf core.whitespace whitespace=tab-in-indent,trailing-space,tabwidth=2
-*.md      text eol=lf core.whitespace whitespace=tab-in-indent,trailing-space,tabwidth=2
-*.yml     text eol=lf core.whitespace whitespace=tab-in-indent,trailing-space,tabwidth=2
-.git*     text eol=auto core.whitespace whitespace=trailing-space

.github/CONTRIBUTING.md

@@ -1,160 +0,0 @@
-Contributing to Caddy
-=====================
-
-Welcome! Thank you for choosing to be a part of our community. Caddy wouldn't be great without your involvement!
-
-For starters, we invite you to join [the Caddy forum](https://caddy.community) where you can hang out with other Caddy users and developers.
-
-## Common Tasks
-
-- [Contributing code](#contributing-code)
-- [Writing a plugin](#writing-a-plugin)
-- [Asking or answering questions for help using Caddy](#getting-help-using-caddy)
-- [Reporting a bug](#reporting-bugs)
-- [Suggesting an enhancement or a new feature](#suggesting-features)
-- [Improving documentation](#improving-documentation)
-
-Other menu items:
-
-- [Values](#values)
-- [Responsible Disclosure](#responsible-disclosure)
-- [Thank You](#thank-you)
-
-
-### Contributing code
-
-You can have a direct impact on the project by helping with its code. To contribute code to Caddy, open a [pull request](https://github.com/caddyserver/caddy/pulls) (PR). If you're new to our community, that's okay: **we gladly welcome pull requests from anyone, regardless of your native language or coding experience.** You can get familiar with Caddy's code base by using [code search at Sourcegraph](https://sourcegraph.com/github.com/caddyserver/caddy/-/search).
-
-We hold contributions to a high standard for quality :bowtie:, so don't be surprised if we ask for revisions—even if it seems small or insignificant. Please don't take it personally. :wink: If your change is on the right track, we can guide you to make it mergable.
-
-Here are some of the expectations we have of contributors:
-
-- If your change is more than just a minor alteration, **open an issue to propose your change first.** This way we can avoid confusion, coordinate what everyone is working on, and ensure that changes are in-line with the project's goals and the best interests of its users. If there's already an issue about it, comment on the existing issue to claim it.
-
-- **Keep pull requests small.** Smaller PRs are more likely to be merged because they are easier to review! We might ask you to break up large PRs into smaller ones. [An example of what we DON'T do.](https://twitter.com/iamdevloper/status/397664295875805184)
-
-- **Keep related commits together in a PR.** We do want pull requests to be small, but you should also keep multiple related commits in the same PR if they rely on each other.
-
-- **Write tests.** Tests are essential! Written properly, they ensure your change works, and that other changes in the future won't break your change. CI checks should pass.
-
-- **Benchmarks should be included for optimizations.** Optimizations sometimes make code harder to read or have changes that are less than obvious. They should be proven with benchmarks or profiling.
-
-- **[Squash](http://gitready.com/advanced/2009/02/10/squashing-commits-with-rebase.html) insignificant commits.** Every commit should be significant. Commits which merely rewrite a comment or fix a typo can be combined into another commit that has more substance. Interactive rebase can do this, or a simpler way is `git reset --soft <diverging-commit>` then `git commit -s`.
-
-- **Own your contributions.** Caddy is a growing project, and it's much better when individual contributors help maintain their change after it is merged.
-
-- **Use comments properly.** We expect good godoc comments for package-level functions, types, and values. Comments are also useful whenever the purpose for a line of code is not obvious.
-
-We often grant [collaborator status](#collaborator-instructions) to contributors who author one or more significant, high-quality PRs that are merged into the code base!
-
-
-#### HOW TO MAKE A PULL REQUEST TO CADDY
-
-Contributing to Go projects on GitHub is fun and easy. We recommend the following workflow:
-
-1. [Fork this repo](https://github.com/caddyserver/caddy). This makes a copy of the code you can write to.
-
-2. If you don't already have this repo (caddyserver/caddy.git) repo on your computer, get it with `go get github.com/caddyserver/caddy/caddy`.
-
-3. Tell git that it can push the caddyserver/caddy.git repo to your fork by adding a remote: `git remote add myfork https://github.com/you/caddy.git`
-
-4. Make your changes in the caddyserver/caddy.git repo on your computer.
-
-5. Push your changes to your fork: `git push myfork`
-
-6. [Create a pull request](https://github.com/caddyserver/caddy/pull/new/master) to merge your changes into caddyserver/caddy @ master. (Click "compare across forks" and change the head fork.)
-
-This workflow is nice because you don't have to change import paths. You can get fancier by using different branches if you want.
-
-
-### Writing a plugin
-
-Caddy can do more with plugins! Anyone can write a plugin. Plugins are Go libraries that get compiled into Caddy, extending its feature set. They can add directives to the Caddyfile, change how the Caddyfile is loaded, and even implement new server types (e.g. HTTP, DNS). When it's ready, you can submit your plugin to the Caddy website so others can download it.
-
-[Learn how to write and submit a plugin](https://github.com/caddyserver/caddy/wiki) on the wiki. You should also share and discuss your plugin idea [on the forums](https://caddy.community) to have people test it out. We don't use the Caddy issue tracker for plugins.
-
-
-### Getting help using Caddy
-
-If you have a question about using Caddy, [ask on our forum](https://caddy.community)! There will be more people there who can help you than just the Caddy developers who follow our issue tracker. Issues are not the place for usage questions.
-
-Many people on the forums could benefit from your experience and expertise, too. Once you've been helped, consider giving back by answering other people's questions and participating in other discussions.
-
-
-### Reporting bugs
-
-Like every software, Caddy has its flaws. If you find one, [search the issues](https://github.com/caddyserver/caddy/issues) to see if it has already been reported. If not, [open a new issue](https://github.com/caddyserver/caddy/issues/new) and describe the bug, and somebody will look into it! (This repository is only for Caddy, not plugins.)
-
-**You can help stop bugs in their tracks!** Speed up the patch by identifying the bug in the code. This can sometimes be done by adding `fmt.Println()` statements (or similar) in relevant code paths to narrow down where the problem may be. It's a good way to [introduce yourself to the Go language](https://tour.golang.org), too.
-
-Please follow the issue template so we have all the needed information. Unredacted&mdash;yes, actual values matter. We need to be able to repeat the bug using your instructions. Please simplify the issue as much as possible. 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!
-
-We suggest reading [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 support when we fix your issues. If we helped you, please consider helping someone else!
-
-
-### Suggesting features
-
-First, [search to see if your feature has already been requested](https://github.com/caddyserver/caddy/issues). If it has, you can add a :+1: reaction to vote for it. If your feature idea is new, open an issue to request the feature. You don't have to follow the bug template for feature requests. Please describe your idea thoroughly so that we know how to implement it! Really vague requests may not be helpful or actionable and without clarification will have to be closed.
-
-While we really do value your requests and implement many of them, not all features are a good fit for Caddy. Most of those [make good plugins](https://github.com/caddyserver/caddy/wiki), though, which can be made by anyone! But if a feature is not in the best interest of the Caddy project or its users in general, we may politely decline to implement it into Caddy core.
-
-
-### Improving documentation
-
-Caddy's documentation is available at [https://caddyserver.com/docs](https://caddyserver.com/docs). If you would like to make a fix to the docs, please submit an issue here describing the change to make.
-
-Note that plugin documentation is not hosted by the Caddy website, other than basic usage examples. They are managed by the individual plugin authors, and you will have to contact them to change their documentation.
-
-
-
-## Collaborator Instructions
-
-Collaborators have push rights to the repository. We grant this permission after one or more successful, high-quality PRs are merged! We thank them for their help.The expectations we have of collaborators are:
-
-- **Help review pull requests.** Be meticulous, but also kind. We love our contributors, but we critique the contribution to make it better. Multiple, thorough reviews make for the best contributions! Here are some questions to consider:
-	- Can the change be made more elegant?
-	- Is this a maintenance burden?
-	- What assumptions does the code make?
-	- Is it well-tested?
-	- Is the change a good fit for the project?
-	- Does it actually fix the problem or is it creating a special case instead?
-	- Does the change incur any new dependencies? (Avoid these!)
-
-- **Answer issues.** If every collaborator helped out with issues, we could count the number of open issues on two hands. This means getting involved in the discussion, investigating the code, and yes, debugging it. It's fun. Really! :smile: Please, please help with open issues. Granted, some issues need to be done before others. And of course some are larger than others: you don't have to do it all yourself. Work with other collaborators as a team!
-
-- **Do not merge pull requests until they have been approved by one or two other collaborators.** If a project owner approves the PR, it can be merged (as long as the conversation has finished too).
-
-- **Prefer squashed commits over a messy merge.** If there are many little commits, please [squash the commits](https://stackoverflow.com/a/11732910/1048862) so we don't clutter the commit history.
-
-- **Don't accept new dependencies lightly.** Dependencies can make the world crash and burn, but they are sometimes necessary. Choose carefully. Extremely small dependencies (a few lines of code) can be inlined. The rest may not be needed. For those that are, Caddy vendors all dependencies with the help of [gvt](https://github.com/FiloSottile/gvt). All external dependencies must be vendored, and _Caddy must not export any types defined by those dependencies_. Check this diligently!
-
-- **Be extra careful in some areas of the code.** There are some critical areas in the Caddy code base that we review extra meticulously: the `caddy` and `caddytls` packages especially.
-
-- **Make sure tests test the actual thing.** Double-check that the tests fail without the change, and pass with it. It's important that they assert what they're purported to assert.
-
-- **Recommended reading**
-	- [CodeReviewComments](https://github.com/golang/go/wiki/CodeReviewComments) for an idea of what we look for in good, clean Go code
-	- [Linus Torvalds describes a good commit message](https://gist.github.com/matthewhudson/1475276)
-	- [Best Practices for Maintainers](https://opensource.guide/best-practices/)
-	- [Shrinking Code Review](https://alexgaynor.net/2015/dec/29/shrinking-code-review/)
-
-
-
-## Values
-
-- A person is always more important than code. People don't like being handled "efficiently". But we can still process issues and pull requests efficiently while being kind, patient, and considerate.
-
-- The ends justify the means, if the means are good. A good tree won't produce bad fruit. But if we cut corners or are hasty in our process, the end result will not be good.
-
-
-## Responsible Disclosure
-
-If you've found a security vulnerability, please email me, the author, directly: Matthew dot Holt at Gmail. I'll need enough information to verify the bug and make a patch. It will speed things up if you suggest a working patch. If your report is valid and a patch is released, we will not reveal your identity by default. If you wish to be credited, please give me the name to use. Thanks for responsibly helping Caddy&mdash;and thousands of websites&mdash;be more secure!
-
-
-## Thank you
-
-Thanks for your help! Caddy would not be what it is today without your
-contributions.

.github/FUNDING.yml

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

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,83 +0,0 @@
----
-name: Bug report
-about: For behaviors which violate documentation or cause incorrect results
-title: ''
-labels: ''
-assignees: ''
----
-
-<!--
-This template is for bug reports. The lack of a feature is not a bug; to request a feature, please switch templates.
-
-Are you asking for help with using Caddy? Please ask on our forum: https://caddy.community
-
-Please do not skip relevant questions; this will slow down the debugging process and your issue may be closed.
--->
-
-## 1. Which version of Caddy are you using (`caddy -version`)?
-<!-- If there is no version information, please paste commit SHA instead. -->
-
-
-
-
-## 2. What are you trying to do?
-<!-- Please clearly describe what you are trying to do thoroughly enough so that a reader with no background information can repeat it. -->
-
-
-
-
-## 3. What is your Caddyfile?
-```text
-paste entire Caddyfile here - DO NOT REDACT ANYTHING (except credentials)
-```
-<!-- Changing or hiding parts of your Caddyfile only slows things down and may result in your report being closed.
-For more information, see https://caddy.community/t/how-to-get-help-with-caddy-more-effectively/5222 -->
-<!-- If you are unable to post this publicly, we offer private support: https://caddyserver.com/products/support -->
-
-
-
-
-## 4. How did you run Caddy (give the full command and describe the execution environment)?
-<!-- IMPORTANT: Please eliminate Docker, systemd, reverse proxies, upstream dependencies, caches, firewalls, and other unnecessary, external factors from your setup first. This will help prove that this is a bug in Caddy and not a misconfiguration of your environment. We may close issues that are too complex to replicate. Thank you! -->
-
-
-
-
-## 5. Please paste any relevant HTTP request(s) here.
-<!-- Paste curl command, or full HTTP request including headers and body. You may skip this if the bug does not require HTTP requests. -->
-
-
-
-
-## 6. What did you expect to see?
-<!-- Describe your expected results as precisely as possible. -->
-
-
-
-
-## 7. What did you see instead (give full error messages and/or log)?
-<!-- Please run Caddy with the -log flag, and use the log and errors directives as needed. DO NOT REDACT INFORMATION except for credentials. See https://caddy.community/t/how-to-get-help-with-caddy-more-effectively/5222 -->
-
-
-
-
-## 8. Why is this a bug, and how do you think this should be fixed?
-<!-- Help us understand why it is a bug; it is not always obvious. You can help us get this resolved faster by thinking about the problem and describing possible solutions! -->
-
-
-
-
-## 9. What are you doing to work around the problem in the meantime?
-<!-- This can help others who encounter the same problem, until we implement a fix. -->
-
-
-
-
-## 10. Please link to any related issues, pull requests, and/or discussion.
-<!-- This can add crucial context to your report. -->
-
-
-
-
-## Bonus: What do you use Caddy for? Why did you choose Caddy?
-<!-- We'd like to know! -->

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,35 +0,0 @@
----
-name: Feature request
-about: Suggest an idea for this project
-title: ''
-labels: feature request
-assignees: ''
----
-
-<!--
-This template is for feature requests. If you are reporting a bug instead, please switch templates.
-
-Are you asking for help with using Caddy? Please ask on our forum: https://caddy.community
--->
-
-
-## 1. What would you like to have changed?
-<!-- Fully describe the feature or enhancement you are requesting; examples can be helpful too -->
-
-
-
-
-## 2. Why is this feature a useful, necessary, and/or important addition to this project?
-<!-- Please justify why this change adds value to the project, considering the added maintenance burden and complexity the change introduces -->
-
-
-
-
-## 3. What alternatives are there, or what are you doing in the meantime to work around the lack of this feature?
-<!-- We want to get an idea of what is being done in practice, or how other projects support your feature -->
-
-
-
-
-## 4. Please link to any relevant issues, pull requests, or other discussions.
-<!-- This adds crucial context to your feature request and can speed things up -->

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,40 +0,0 @@
----
-name: Pull request
-about: Propose changes to the code
-title: ''
-labels: ''
-assignees: ''
----
-
-<!--
-Thank you for contributing to Caddy! Please fill this out to help us make the most of your pull request.
-
-Was this change discussed in an issue first? That can help save time in case the change is not a good fit for the project. Not all pull requests get merged.
-
-It is not uncommon for pull requests to go through several, iterative reviews. Please be patient with us! Every reviewer is a volunteer, and each has their own style.
--->
-
-## 1. What does this change do, exactly?
-<!-- Please be specific. Motivate the problem, and justify why this is the best solution. -->
-
-
-
-
-## 2. Please link to the relevant issues.
-<!-- This adds crucial context to your change. -->
-
-
-
-
-## 3. Which documentation changes (if any) need to be made because of this PR?
-<!-- Reviewers will often reference this first in order to know what to expect from the change. Please be specific enough so that they can paste your wording into the documentation directly. -->
-
-
-
-
-## 4. Checklist
-
-- [ ] I have written tests and verified that they fail without my change
-- [ ] I have squashed any insignificant commits
-- [ ] This change has comments explaining package types, values, functions, and non-obvious lines of code
-- [ ] I am willing to help maintain this change if there are issues with it later

.gitignore

@@ -1,22 +1,18 @@
-.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
 
-.vscode/
+# build artifacts
+cmd/caddy/caddy
+cmd/caddy/caddy.exe
 
-*.bat
+# mac specific
+.DS_Store
+
+# go modules
+vendor

.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

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>

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,225 +1,384 @@
-<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 <!-- Serve Confidently --></h3>
-<p align="center">Caddy is a general-purpose HTTP/2 web server that serves HTTPS by default.</p>
-<p align="center">
-	<a href="https://dev.azure.com/mholt-dev/Caddy/_build?definitionId=5"><img src="https://img.shields.io/azure-devops/build/mholt-dev/afec6074-9842-457f-98cf-69df6adbbf2e/5/master.svg?label=cross-platform%20tests"></a>
-	<a href="https://godoc.org/github.com/caddyserver/caddy"><img src="https://img.shields.io/badge/godoc-reference-blue.svg"></a>
-	<a href="https://goreportcard.com/report/caddyserver/caddy"><img src="https://goreportcard.com/badge/github.com/caddyserver/caddy"></a>
-	<br>
-	<a href="https://twitter.com/caddyserver" title="@caddyserver on Twitter"><img src="https://img.shields.io/badge/twitter-@caddyserver-55acee.svg" alt="@caddyserver on Twitter"></a>
-	<a href="https://caddy.community" title="Caddy Forum"><img src="https://img.shields.io/badge/community-forum-ff69b4.svg" alt="Caddy Forum"></a>
-	<a href="https://sourcegraph.com/github.com/caddyserver/caddy?badge" title="Caddy on Sourcegraph"><img src="https://sourcegraph.com/github.com/caddyserver/caddy/-/badge.svg" alt="Caddy on Sourcegraph"></a>
-</p>
-<p align="center">
-	<a href="https://caddyserver.com/download">Download</a> ·
-	<a href="https://caddyserver.com/docs">Documentation</a> ·
-	<a href="https://caddy.community">Community</a>
-</p>
+Caddy 2 Development Branch
+===========================
 
----
+[![Build Status](https://dev.azure.com/mholt-dev/Caddy/_apis/build/status/Multiplatform%20Tests?branchName=v2)](https://dev.azure.com/mholt-dev/Caddy/_build/latest?definitionId=5&branchName=v2)
+[![fuzzit](https://app.fuzzit.dev/badge?org_id=caddyserver-gh)](https://app.fuzzit.dev/orgs/caddyserver-gh/dashboard)
 
-Caddy is a **production-ready** open-source web server that is fast, easy to use, and makes you more productive.
+This is the development branch for Caddy 2. This code (version 2) is not yet feature-complete or production-ready, but is already being used in production, and we encourage you to deploy it today on sites that are not very visible or important so that it can obtain crucial experience in the field.
 
-Available for Windows, Mac, Linux, BSD, Solaris, and [Android](https://github.com/caddyserver/caddy/wiki/Running-Caddy-on-Android).
+Please file issues to propose new features and report bugs, and after the bug or feature has been discussed, submit a pull request! We need your help to build this web server into what you want it to be. (Caddy 2 issues and pull requests receive priority over Caddy 1 issues and pull requests.)
 
-<p align="center">
-	<b>Thanks to our special sponsor:</b>
-	<br><br>
-	<a href="https://relicabackup.com"><img src="https://caddyserver.com/resources/images/sponsors/relica.png" width="220" alt="Relica - Cross-platform file backup to the cloud, local disks, or other computers"></a>
-</p>
+**Caddy 2 is the web server of the Go community.** We are looking for maintainers to represent the community! Please become involved (issues, PRs, [our forum](https://caddy.community) etc.) and express interest if you are committed to being a collaborator on the Caddy project.
 
-## Menu
 
-- [Features](#features)
-- [Install](#install)
+### Menu
+
+- [Build from source](#build-from-source)
 - [Quick Start](#quick-start)
-- [Running in Production](#running-in-production)
-- [Contributing](#contributing)
-- [Donors](#donors)
-- [About the Project](#about-the-project)
-
-## Features
-
-- **Easy configuration** with the Caddyfile
-- **Automatic HTTPS** on by default (via [Let's Encrypt](https://letsencrypt.org))
-- **HTTP/2** by default
-- **Virtual hosting** so multiple sites just work
-- Experimental **QUIC support** for cutting-edge transmissions
-- TLS session ticket **key rotation** for more secure connections
-- **Extensible with plugins** because a convenient web server is a helpful one
-- **Runs anywhere** with **no external dependencies** (not even libc)
-
-[See a more complete list of features built into Caddy.](https://caddyserver.com/features) On top of all those, Caddy does even more with plugins: choose which plugins you want at [download](https://caddyserver.com/download).
-
-Altogether, Caddy can do things other web servers simply cannot do. Its features and plugins save you time and mistakes, and will cheer you up. Your Caddy instance takes care of the details for you!
+- [Configuration](#configuration)
+- [Full Documentation](#full-documentation)
+- [List of Improvements](#list-of-improvements)
+- [FAQ](#faq)
 
 
-<p align="center">
-	<b>Powered by</b>
-	<br>
-	<a href="https://github.com/mholt/certmagic"><img src="https://user-images.githubusercontent.com/1128849/49704830-49d37200-fbd5-11e8-8385-767e0cd033c3.png" alt="CertMagic" width="250"></a>
-</p>
+## Build from source
 
+Requirements:
 
-## Install
+- [Go 1.13 or newer](https://golang.org/dl/)
+- Do NOT disable [Go modules](https://github.com/golang/go/wiki/Modules) (`export GO111MODULE=auto`)
 
-Caddy binaries have no dependencies and are available for every platform. Get Caddy any of these ways:
+Download the `v2` source code:
 
-- **[Download page](https://caddyserver.com/download)** (RECOMMENDED) allows you to customize your build in the browser
-- **[Latest release](https://github.com/caddyserver/caddy/releases/latest)** for pre-built, vanilla binaries
-- **[AWS Marketplace](https://aws.amazon.com/marketplace/pp/B07J1WNK75?qid=1539015041932&sr=0-1&ref_=srh_res_product_title&cl_spe=C)** makes it easy to deploy directly to your cloud environment. <a href="https://aws.amazon.com/marketplace/pp/B07J1WNK75?qid=1539015041932&sr=0-1&ref_=srh_res_product_title&cl_spe=C" target="_blank">
-<img src="https://s3.amazonaws.com/cloudformation-examples/cloudformation-launch-stack.png" alt="Get Caddy on the AWS Marketplace" height="25"/></a>
-
-
-## Build
-
-To build from source you need **[Git](https://git-scm.com/downloads)** and **[Go](https://golang.org/doc/install)** (1.13 or newer).
-
-**To build Caddy without plugins:**
-
-<!-- TODO: This env variable will not be required starting with Go 1.13 -->
-1. Set the transitional environment variable for Go modules: `export GO111MODULE=on`
-2. Run `go get github.com/caddyserver/caddy/caddy`
-
-Caddy will be installed to your `$GOPATH/bin` folder.
-
-With these instructions, the binary will not have embedded version information (see [golang/go#29228](https://github.com/golang/go/issues/29228)), but it is fine for a quick start.
-
-**To build Caddy with plugins (and with version information):**
-
-There is no need to modify the Caddy code to build it with plugins. We will create a simple Go module with our own `main()` that you can use to make custom Caddy builds.
-
-<!-- TODO: This env variable will not be required starting with Go 1.13 -->
-1. Set the transitional environment variable for Go modules: `export GO111MODULE=on`
-2. Create a new folder anywhere and within create a Go file (with an extension of `.go`, such as `main.go`) with the contents below, adjusting to import the plugins you want to include:
-```go
-package main
-
-import (
-	"github.com/caddyserver/caddy/caddy/caddymain"
-	
-	// plug in plugins here, for example:
-	// _ "import/path/here"
-)
-
-func main() {
-	// optional: disable telemetry
-	// caddymain.EnableTelemetry = false
-	caddymain.Run()
-}
+```bash
+$ git clone -b v2 "https://github.com/caddyserver/caddy.git"
 ```
-3. `go mod init caddy`
-4. Run `go get github.com/caddyserver/caddy`
-5. `go install` will then create your binary at `$GOPATH/bin`, or `go build` will put it in the current directory.
 
-**To install Caddy's source code for development:**
+Build:
 
-<!-- TODO: This env variable will not be required starting with Go 1.13 -->
-1. Set the transitional environment variable for Go modules: `export GO111MODULE=on`
-2. Run `git clone https://github.com/caddyserver/caddy.git` in any folder (doesn't have to be in GOPATH).
+```bash
+$ cd caddy/cmd/caddy/
+$ go build
+```
 
-You can make changes to the source code from that clone and checkout any commit or tag you wish to develop on.
+That will put a `caddy(.exe)` binary into the current directory. You can move it into your PATH or use `go install` to do that automatically (assuming `$GOPATH/bin` is already in your PATH). You can also use `go run main.go` for quick, temporary builds while developing.
 
-When building from source, telemetry is enabled by default. You can disable it by changing `caddymain.EnableTelemetry = false` in run.go, or use the `-disabled-metrics` flag at runtime to disable only certain metrics.
+The initial build may be slow as dependencies are downloaded. Subsequent builds should be very fast. If you encounter any Go-module-related errors, try clearing your Go module cache (`$GOPATH/pkg/mod`) and Go package cache (`$GOPATH/pkg`) and read [the Go wiki page about modules for help](https://github.com/golang/go/wiki/Modules). If you have issues with Go modules, please consult the Go community for help. But if there is an actual error in Caddy, please report it to us.
 
 
 ## Quick Start
 
-To serve static files from the current working directory, run:
+(Until the stable 2.0 release, there may be breaking changes in v2, please be aware!)
 
-```
-caddy
+These instructions assume an executable build of Caddy 2 is named `caddy` in the current folder. If it's in your PATH, you may omit the path to the binary (`./`).
+
+Start Caddy:
+
+```bash
+$ ./caddy start
 ```
 
-Caddy's default port is 2015, so open your browser to [http://localhost:2015](http://localhost:2015).
+There are no config files with Caddy 2. Instead, you POST configuration to it:
 
-### Go from 0 to HTTPS in 5 seconds
-
-If the `caddy` binary has permission to bind to low ports and your domain name's DNS records point to the machine you're on:
-
-```
-caddy -host example.com
+```bash
+$ curl -X POST "http://localhost:2019/load" \
+    -H "Content-Type: application/json" \
+    -d @- << EOF
+    {
+        "apps": {
+            "http": {
+                "servers": {
+                    "example": {
+                        "listen": ["127.0.0.1:2080"],
+                        "routes": [
+                            {
+                                "handle": [{
+                                    "handler": "file_server",
+                                    "browse": {}
+                                }]
+                            }
+                        ]
+                    }
+                }
+            }
+        }
+    }
+EOF
 ```
 
-This command serves static files from the current directory over HTTPS. Certificates are automatically obtained and renewed for you! Caddy is also automatically configuring ports 80 and 443 for you, and redirecting HTTP to HTTPS. Cool, huh?
+Now visit http://localhost:2080 in your browser and you will see the contents of the current directory displayed.
 
-### Customizing your site
+To change Caddy's configuration, simply POST a new payload to that endpoint. Config changes are extremely lightweight and efficient, and should be graceful on all platforms -- _even Windows_.
 
-To customize how your site is served, create a file named Caddyfile by your site and paste this into it:
+Updating configuration using heredoc can be tedious, so you can still use a config file if you prefer. Put your configuration in any file (`caddy.json` for example) and then POST that instead:
+
+```bash
+$ curl -X POST "http://localhost:2019/load" \
+    -H "Content-Type: application/json" \
+    -d @caddy.json
+```
+
+Or you can tell Caddy to load its configuration from a file in the first place (this simply does the work of the above curl command for you):
+
+```bash
+$ ./caddy start --config caddy.json
+```
+
+To stop Caddy:
+
+```bash
+$ ./caddy stop
+```
+
+Note that this will stop any process named the same as `os.Args[0]`.
+
+For other commands, please see [the Caddy 2 documentation](https://github.com/caddyserver/caddy/wiki/v2:-Documentation).
+
+### Caddyfile
+
+Caddy 2 can be configured with a Caddyfile, much like in v1, for example:
 
 ```plain
-localhost
+example.com
 
-push
-browse
-websocket /echo cat
-ext    .html
-log    /var/log/access.log
-proxy  /api 127.0.0.1:7005
-header /api Access-Control-Allow-Origin *
+try_files {path}.html {path}
+encode gzip zstd
+reverse_proxy /api  localhost:9005
+php_fastcgi   /blog unix//path/to/socket
+file_server
 ```
 
-When you run `caddy` in that directory, it will automatically find and use that Caddyfile.
+Instead of being its primary mode of configuration, an internal _config adapter_ adapts the Caddyfile to Caddy's native JSON structure. You can see it in action with the [`adapt` command](https://github.com/caddyserver/caddy/wiki/v2:-Documentation#adapt):
 
-This simple file enables server push (via Link headers), allows directory browsing (for folders without an index file), hosts a WebSocket echo server at /echo, serves clean URLs, logs requests to an access log, proxies all API requests to a backend on port 7005, and adds the coveted  `Access-Control-Allow-Origin: *` header for all responses from the API.
+```bash
+$ ./caddy adapt --config path/to/Caddyfile --adapter caddyfile --pretty
+```
 
-Wow! Caddy can do a lot with just a few lines.
+If you just want to run Caddy with your Caddyfile directly, the CLI wraps this up for you nicely. Either of the following commands:
 
-### Doing more with Caddy
+```bash
+$ ./caddy start
+$ ./caddy run
+```
 
-To host multiple sites and do more with the Caddyfile, please see the [Caddyfile tutorial](https://caddyserver.com/tutorial/caddyfile).
+will use your Caddyfile if it is called `Caddyfile` in the current directory.
 
-Sites with qualifying hostnames are served over [HTTPS by default](https://caddyserver.com/docs/automatic-https).
+If your Caddyfile is somewhere else, you can still use it:
 
-Caddy has a nice little command line interface. Run `caddy -h` to view basic help or see the [CLI documentation](https://caddyserver.com/docs/cli) for details.
+```bash
+$ ./caddy start|run --config path/to/Caddyfile --adapter caddyfile
+```
+
+[Learn more about the Caddyfile in v2.](https://github.com/caddyserver/caddy/wiki/v2:-Documentation#caddyfile-adapter)
 
 
-## Running in Production
+## Configuration
 
-Caddy is production-ready if you find it to be a good fit for your site and workflow.
+Caddy 2 exposes an unprecedented level of control compared to any web server in existence. In Caddy 2, 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 2 is also ridiculously extensible, with a module system that makes vast improvements over Caddy 1's plugin system.
 
-**Running as root:** We advise against this. You can still listen on ports < 1024 on Linux using setcap like so: `sudo setcap cap_net_bind_service=+ep ./caddy`
+Nearly all of Caddy 2's configuration is contained in a single config document, rather than being spread across CLI flags and env variables and a configuration file as with other web servers (and Caddy 1).
 
-The Caddy project does not officially maintain any system-specific integrations nor suggest how to administer your own system. But your download file includes [unofficial resources](https://github.com/caddyserver/caddy/tree/master/dist/init) contributed by the community that you may find helpful for running Caddy in production.
+To wield the power of this design, you need to know how the config document is structured. Please see the [the Caddy 2 documentation in our wiki](https://github.com/caddyserver/caddy/wiki/v2:-Documentation) for details about Caddy's config structure.
 
-How you choose to run Caddy is up to you. Many users are satisfied with `nohup caddy &`. Others use `screen`. Users who need Caddy to come back up after reboots either do so in the script that caused the reboot, add a command to an init script, or configure a service with their OS.
-
-If you have questions or concerns about Caddy' underlying crypto implementations, consult Go's [crypto packages](https://golang.org/pkg/crypto), starting with their documentation, then issues, then the code itself; as Caddy uses mainly those libraries.
+Configuration is normally given to Caddy through an API endpoint, which is likewise documented in the wiki pages. However, you can also use config files of various formats with [config adapters](https://github.com/caddyserver/caddy/wiki/v2:-Documentation#config-adapters).
 
 
-## Contributing
+## Full Documentation
 
-**[Join our forum](https://caddy.community) where you can chat with other Caddy users and developers!** To get familiar with the code base, try [Caddy code search on Sourcegraph](https://sourcegraph.com/github.com/caddyserver/caddy/)!
+Caddy 2 is very much in development, so the documentation is an ongoing WIP, but the latest will be in our wiki for now:
 
-Please see our [contributing guidelines](https://github.com/caddyserver/caddy/blob/master/.github/CONTRIBUTING.md) for instructions. If you want to write a plugin, check out the [developer wiki](https://github.com/caddyserver/caddy/wiki).
+**https://github.com/caddyserver/caddy/wiki/v2:-Documentation**
 
-We use GitHub issues and pull requests only for discussing bug reports and the development of specific changes. We welcome all other topics on the [forum](https://caddy.community)!
-
-If you want to contribute to the documentation, please [submit an issue](https://github.com/caddyserver/caddy/issues/new) describing the change that should be made.
-
-### Good First Issue
-
-If you are looking for somewhere to start and would like to help out by working on an existing issue, take a look at our [`Good First Issue`](https://github.com/caddyserver/caddy/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22) tag 
-
-Thanks for making Caddy -- and the Web -- better!
+Note that breaking changes are expected until the stable 2.0 release.
 
 
-## Donors
+## List of Improvements
 
-- [DigitalOcean](https://m.do.co/c/6d7bdafccf96) is hosting the Caddy project.
-- [DNSimple](https://dnsimple.link/resolving-caddy) provides DNS services for Caddy's sites.
-- [DNS Spy](https://dnsspy.io) keeps an eye on Caddy's DNS properties.
+The following is a non-comprehensive list of significant improvements over Caddy 1. Not everything in this list is finished yet, but they will be finished or at least will be possible with Caddy 2:
 
-We thank them for their services. **If you want to help keep Caddy free, please [become a sponsor](https://caddyserver.com/pricing)!**
+- Centralized configuration. No more disparate use of environment variables, config files (potentially multiple!), CLI flags, etc.
+- REST API. Control Caddy with HTTP requests to an administration endpoint. Changes are applied immediately and efficiently.
+- Dynamic configuration. Any and all specific config values can be modified directly through the admin API with a REST endpoint.
+    - Change only specific configuration settings instead of needing to specify the whole config each time. This makes it safe and easy to change Caddy's config with manually-crafted curl commands, for example.
+- No configuration files. Except optionally to bootstrap its configuration at startup. You can still use config files if you wish, and we expect that most people will.
+- Export the current Caddy configuration with an API GET request.
+- Silky-smooth graceful reloads. Update the configuration up to dozens of times per second with no dropped requests and very little memory cost. Our unique graceful reload technology is lighter and faster **and works on all platforms, including Windows**.
+- An embedded scripting language! Caddy2 has native Starlark integration. Do things you never thought possible with higher performance than Lua, JavaScript, and other VMs. Starlark is expressive, familiar (dialect of Python), _almost_ Turing-complete, and highly efficient. (We're still improving performance here.)
+- Using [XDG standards](https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html#variables) instead of dumping all assets in `$HOME/.caddy`.
+- Caddy plugins are now called "Caddy modules" (although the terms "plugin" and "module" may be used interchangeably). Caddy modules are a concept unrelated [Go modules](https://github.com/golang/go/wiki/Modules), except that Caddy modules may be implemented by Go modules. Caddy modules are centrally-registered, properly namespaced, and generically loaded & configured, as opposed to how scattered and unorganized Caddy 1-era plugins are.
+- Modules are easier to write, since they do not have to both deserialize their own configuration from a configuration DSL and provision themselves like plugins did. Modules are initialized pre-configured and have the ability to validate the configuration and perform provisioning steps if necessary.
+- Can specify different storage mechanisms in different parts of the configuration, if more than one is needed.
+- "Top-level" Caddy modules are simply called "apps" because literally any long-lived application can be served by Caddy 2.
+- Even more of Caddy is made of modules, allowing for unparalleled extensibility, flexibility, and control. Caddy 2 is arguably the most flexible, extensible, programmable web server ever made.
+- TLS improvements!
+	- TLS configuration is now centralized and decoupled from specific sites
+	- A single certificate cache is used process-wide, reducing duplication and improving memory use
+	- Customize how to manage each certificate ("automation policies") based on the hostname
+	- Automation policy doesn't have to be limited to just ACME - could be any way to manage certificates
+	- Fine-grained control over TLS handshakes
+	- If an ACME challenge fails, other enabled challenges will be tried (no other web server does this)
+    - TLS Session Ticket Ephemeral Keys (STEKs) can be rotated in a cluster for increased performance (no other web server does this either!)
+    - Ability to select a specific certificate per ClientHello given multiple qualifying certificates
+    - Provide TLS certificates without persisting them to disk; keep private keys entirely in memory
+	- Certificate management at startup is now asynchronous and much easier to use through machine reboots and in unsupervised settings
+- All-new HTTP server core
+	- Listeners can be configured for any network type, address, and port range
+	- Customizable TLS connection policies
+	- HTTP handlers are configured by "routes" which consist of matcher and handler components. Match matches an HTTP request, and handle defines the list of handlers to invoke as a result of the match.
+	- Some matchers are regular expressions, which expose capture groups to placeholders.
+	- New matchers include negation and matching based on remote IP address / CIDR ranges.
+    - Placeholders are vastly improved generally
+	- Placeholders (variables) are more properly namespaced.
+	- Multiple routes may match an HTTP request, creating a "composite route" quickly on the fly.
+	- The actual handler for any given request is its composite route.
+	- User defines the order of middlewares (careful! easy to break things).
+	- Adding middlewares no longer requires changes to Caddy's code base (there is no authoritative list).
+	- Routes may be marked as terminal, meaning no more routes will be matched.
+	- Routes may be grouped so that only the first matching route in a group is applied.
+	- Requests may be "re-handled" if they are modified and need to be sent through the chain again (internal redirect).
+	- Vastly more powerful static file server, with native content-negotiation abilities
+    - Done away with URL-rewriting hacks often needed in Caddy 1
+	- Highly descriptive/traceable errors
+	- Very flexible error handling, with the ability to specify a whole list of routes just for error cases
+	- The proxy has numerous improvements, including dynamic backends and more configurable health checks
+	- FastCGI support integrated with the reverse proxy
+	- More control over automatic HTTPS: disable entirely, disable only HTTP->HTTPS redirects, disable only cert management, and for certain names, etc.
+    - Use Starlark to build custom, dynamic HTTP handlers at request-time
+        - We are finding that -- on average -- Caddy 2's Starlark handlers are ~1.25-2x faster than NGINX+Lua.
+
+And a few major features still being worked on:
+
+- Logging
+- Kubernetes ingress controller (mostly done, just polishing it -- and it's amazing)
+- More config adapters. Caddy's native JSON config structure is powerful and complex. Config adapters upsample various formats to Caddy's native config. There are already adapters for Caddyfile, JSON 5, and JSON-C. Planned are NGINX config, YAML, and TOML. The community might be interested in building Traefik and Apache config adapters!
 
 
-## About the Project
 
-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.
+## FAQ
 
-**The name "Caddy" is trademarked:** The name of the software is "Caddy", not "Caddy Server" or "CaddyServer". Please call it "Caddy" or, if you wish to clarify, "the Caddy web server". See [brand guidelines](https://caddyserver.com/brand). Caddy is a registered trademark of Light Code Labs, LLC.
+### How do I configure Caddy 2?
 
-*Author on Twitter: [@mholt6](https://twitter.com/mholt6)*
+Caddy's primary mode of configuration is a REST API, which accepts a JSON document. The JSON structure is described [in the wiki](https://github.com/caddyserver/caddy/wiki/v2:-Documentation). The advantages of exposing this low-level structure are 1) it has near-parity with actual memory initialization, 2) it allows us to offer wrappers over this configuration to any degree of convenience that is needed, and 3) it performs very well under rapid config changes.
+
+Basically, you will [start Caddy](https://github.com/caddyserver/caddy/wiki/v2:-Documentation#start), then [POST a JSON config to its API endpoint](https://github.com/caddyserver/caddy/wiki/v2:-Documentation#post-load).
+
+Although this makes Caddy 2 highly programmable, not everyone will want to configure Caddy via JSON with an API. Sometimes we just want to give Caddy a simple, static config file and have it do its thing. That's what **[config adapters](https://github.com/caddyserver/caddy/wiki/v2:-Documentation#config-adapters)** are for! You can configure Caddy more ways than one, depending on your needs and preferences. See the next questions that explain this more.
+
+### Caddy 2 feels harder to use. How is this an improvement over Caddy 1?
+
+Caddy's ease of use is one of the main reasons it is special. We are not taking that away in Caddy 2, but first we had to be sure to tackle the fundamental design limitations with Caddy 1. Usability can then be layered on top. This approach has several advantages which we discuss in the next question.
+
+### What about the Caddyfile; are there easier ways to configure Caddy 2?
+
+Yes! Caddy's native JSON configuration via API is nice when you are automating config changes at scale, but if you just have a simple, static configuration in a file, you can do that too with the [Caddyfile](https://github.com/caddyserver/caddy/wiki/v2:-Documentation#caddyfile-adapter).
+
+The v2 Caddyfile is very similar to the v1 Caddyfile, but they are not compatible. Several improvements have been made to request matching and directives in v2, giving you more power with less complexity and fewer inconsistencies.
+
+Caddy's default _config adapter_ is the Caddyfile adapter. This takes a Caddyfile as input and [outputs the JSON config](https://github.com/caddyserver/caddy/wiki/v2:-Documentation#adapt). You can even run Caddy directly without having to see or think about the underlying JSON config.
+
+The following _config adapters_ are already being built or plan to be built:
+
+- Caddyfile
+- JSON 5
+- JSON-C
+- nginx
+- YAML
+- TOML
+- any others that the community would like to contribute
+
+Config adapters allow you to configure Caddy not just one way but _any_ of these ways. For example, you'll be able to bring your existing NGINX config to Caddy and it will spit out the Caddy config JSON you need (to the best of its ability). How cool is that! You can then easily tweak the resulting config by hand, if necessary.
+
+All config adapters vary in their theoretical expressiveness; that is, if you need more advanced configuration you'll have to drop down to the JSON config, because the Caddyfile or an nginx config may not be expressive enough.
+
+However, we expect that most users will be able to use the Caddyfile (or another easy config adapter) exclusively for their sites.
+
+### Why JSON for configuration? Why not _&lt;any other serialization format&gt;_?
+
+We know there might be strong opinions on this one. Regardless, for Caddy 2, we've decided to go with JSON. If that proves to be a fatal mistake, then Caddy 3 probably won't use JSON.
+
+JSON may not be the fastest, the most compact, the easiest to write, serialization format that exists. But those aren't our goals. It has withstood the test of time and checks all our boxes.
+
+- It is almost entirely ubiquitous. JSON works natively in web browsers and has mature libraries in pretty much every language.
+- It is human-readable (as opposed to a binary format).
+- It is easy to tweak by hand. Although composing raw JSON by hand is not awesome, this will not be mainstream once our config adapters are done.
+- It is generally easy to convert other serializations or config formats into JSON, as opposed to the other way around.
+- Even though JSON deserialization is not fast per-se, that kind of performance is not really a concern since config reloads are not the server's hottest path like HTTP request handling or TLS handshakes are. Even with JSON, Caddy 2 can handle dozens of config changes per second, which is probably plenty for now.
+- It maps almost 1:1 to the actual, in-memory values that power your HTTP handlers and other parts of the server (no need to parse a config file with some arbitrary DSL and do a bunch of extra pre-processing).
+
+Ultimately, we think all these properties are appropriate -- if not ideal -- for a web server configuration.
+
+If you're still not happy with the choice of JSON, feel free to contribute a config adapter of your own choice!
+
+Or just use YAML or TOML, which seamlessly translate to JSON.
+
+### JSON is declarative; what if I need more programmability (i.e. imperative syntax)?
+
+NGINX also realized the need for imperative logic in declarative configs, so they tried "if" statements, [but it was a bad idea](https://www.nginx.com/resources/wiki/start/topics/depth/ifisevil/).
+
+We have good news. Caddy 2 can give you the power of imperative logic without the perils of mixing declarative and imperative config such as befell NGINX. We do this by allowing embedded imperative syntax awithin the Caddy's declarative config.
+
+Caddy 2's configuration is declarative because configuration is very much declarative in nature. Configuration is a tricky medium, as it is read and written by both computers and humans. Computers use it, but humans constantly refer to it and update it. Declarative syntaxes are fairly straightforward to make sense of, whereas it is difficult to reason about imperative logic.
+
+However, sometimes computation is useful, and in some cases, the only way to express what you need. This can be illustrated really well in the simple case of trying to decide whether a particular HTTP middleware should be invoked as part of an HTTP request. A lot of the time, such logic is as simple as: "GET requests for any path starting with /foo/bar", which can be expressed declaratively in JSON:
+
+```json
+{
+	"method": "GET",
+	"path": "/foo/bar"
+}
+```
+
+But what if you need to match /foo/bar OR /topaz? How do you express that OR clause? Maybe an array:
+
+```json
+{
+	"method": ["GET"],
+	"path": ["/foo/bar", "/topaz"]
+}
+```
+
+Now what if you need add a NOT or AND clause? JSON quickly tires out. As you learn about Caddy 2's request matching, you will see how we handled this. Caddy 2's JSON gives you the ability to express moderately-complex logic such as:
+
+```js
+// this is not actual Caddy config, just logic pseudocode
+IF (Host = "example.com")
+	OR (Host = "sub.example.com" AND Path != "/foo/bar")
+```
+
+Already, this is more expressive power than most web servers offer with their native config, yet Caddy 2 offers this in JSON.
+
+But in most web servers, to make logic this complex feasible, you'll generally call out to Lua or some extra DSL. For example, in NGINX you could use a Lua module to express this logic. Traefik 2.0 has [yet another kind of clunky-looking custom DSL](https://blog.containo.us/back-to-traefik-2-0-2f9aa17be305#d22e) just for this.
+
+Caddy 2 solves this in a novel way with [Starlark expressions](https://godoc.org/go.starlark.net/starlark#Eval). Starlark is a familiar dialect of Python! So, no new DSLs to learn and no VMs to slow things down:
+
+```python
+req.host == 'example.com' ||
+	(req.host == 'sub.example.com' && req.path != '/foo/bar')
+```
+
+Starlark performs at least as well as NGINX+Lua (more performance tests ongoing, as well as optimizations to make it even faster!) and because it's basically Python, it's familiar and easy to use.
+
+In summary: Caddy 2 config is declarative, but can be imperative where that is useful.
+
+### What is Caddy 2 licensed as?
+
+Caddy 2 is licensed under the Apache 2.0 open source license. There are no official Caddy 2 distributions that are proprietary.
+
+### Does Caddy 2 have telemetry?
+
+No. There was not enough academic interest to continue supporting it. If telemetry does get added later, it will not be on by default or will be vastly reduced in its scope.
+
+## Does Caddy 2 use HTTPS by default?
+
+Yes. HTTPS is automatic and enabled by default when possible, just like in Caddy 1. Basically, if your HTTP routes specify a `host` matcher with qualifying domain names, those names will be enabled for automatic HTTPS. Automatic HTTPS is disabled for domains which match certificates that are manually loaded by your config.
+
+## How do I avoid Let's Encrypt rate limits with Caddy 2?
+
+As you are testing and developing with Caddy 2, you should use test ("staging") certificates from Let's Encrypt to avoid rate limits. By default, Caddy 2 uses Let's Encrypt's production endpoint to get real certificates for your domains, but their [rate limits](https://letsencrypt.org/docs/rate-limits/) forbid testing and development use of this endpoint for good reasons. You can switch to their [staging endpoint](https://letsencrypt.org/docs/staging-environment/) by adding the staging CA to your automation policy in the `tls` app:
+
+```json
+"tls": {
+	"automation": {
+		"policies": [
+			{
+				"management": {
+					"module": "acme",
+					"ca": "https://acme-staging-v02.api.letsencrypt.org/directory"
+				}
+			}
+		]
+	}
+}
+```
+
+Or with the Caddyfile, using a global options block at the top:
+
+```
+{
+	acme_ca https://acme-staging-v02.api.letsencrypt.org/directory
+}
+```
+
+## Can we get some access controls on the admin endpoint?
+
+Yeah, that's coming. For now, you can use a permissioned unix socket for some basic security.

admin.go

@@ -0,0 +1,861 @@
+// 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"
+	"mime"
+	"net/http"
+	"net/http/pprof"
+	"net/url"
+	"os"
+	"path"
+	"regexp"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/caddyserver/caddy/v2/caddyconfig"
+	"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"`
+}
+
+// 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("/load", AdminHandlerFunc(handleLoad))
+	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 handleLoad(w http.ResponseWriter, r *http.Request) error {
+	if r.Method != http.MethodPost {
+		return 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 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 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 APIError{
+					Code: http.StatusBadRequest,
+					Err:  fmt.Errorf("malformed Content-Type"),
+				}
+			}
+			adapterName := ct[slashIdx+1:]
+			cfgAdapter := caddyconfig.GetAdapter(adapterName)
+			if cfgAdapter == nil {
+				return APIError{
+					Code: http.StatusBadRequest,
+					Err:  fmt.Errorf("unrecognized config adapter '%s'", adapterName),
+				}
+			}
+			result, warnings, err := cfgAdapter.Adapt(body, nil)
+			if err != nil {
+				return 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 {
+					Log().Named("admin.api.load").Error(err.Error())
+				}
+				w.Write(respBody)
+			}
+			body = result
+		}
+	}
+
+	forceReload := r.Header.Get("Cache-Control") == "must-revalidate"
+
+	err = Load(body, forceReload)
+	if err != nil {
+		return APIError{
+			Code: http.StatusBadRequest,
+			Err:  fmt.Errorf("loading config: %v", err),
+		}
+	}
+
+	Log().Named("admin.api").Info("load complete")
+
+	return nil
+}
+
+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.
+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?(-?[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)
+	}
+}

assets.go

@@ -1,48 +0,0 @@
-// Copyright 2015 Light Code Labs, LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package caddy
-
-import (
-	"os"
-	"path/filepath"
-	"runtime"
-)
-
-// AssetsPath returns the path to the folder
-// where the application may store data. If
-// CADDYPATH env variable is set, that value
-// is used. Otherwise, the path is the result
-// of evaluating "$HOME/.caddy".
-func AssetsPath() string {
-	if caddyPath := os.Getenv("CADDYPATH"); caddyPath != "" {
-		return caddyPath
-	}
-	return filepath.Join(userHomeDir(), ".caddy")
-}
-
-// userHomeDir returns the user's home directory according to
-// environment variables.
-//
-// Credit: http://stackoverflow.com/a/7922977/1048862
-func userHomeDir() string {
-	if runtime.GOOS == "windows" {
-		home := os.Getenv("HOMEDRIVE") + os.Getenv("HOMEPATH")
-		if home == "" {
-			home = os.Getenv("USERPROFILE")
-		}
-		return home
-	}
-	return os.Getenv("HOME")
-}

assets_test.go

@@ -1,39 +0,0 @@
-// Copyright 2015 Light Code Labs, LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package caddy
-
-import (
-	"os"
-	"strings"
-	"testing"
-)
-
-func TestAssetsPath(t *testing.T) {
-	if actual := AssetsPath(); !strings.HasSuffix(actual, ".caddy") {
-		t.Errorf("Expected path to be a .caddy folder, got: %v", actual)
-	}
-
-	err := os.Setenv("CADDYPATH", "testpath")
-	if err != nil {
-		t.Error("Could not set CADDYPATH")
-	}
-	if actual, expected := AssetsPath(), "testpath"; actual != expected {
-		t.Errorf("Expected path to be %v, got: %v", expected, actual)
-	}
-	err = os.Setenv("CADDYPATH", "")
-	if err != nil {
-		t.Error("Could not set CADDYPATH")
-	}
-}

azure-pipelines.yml

@@ -2,87 +2,239 @@
 # https://docs.microsoft.com/azure/devops/pipelines/languages/go
 
 trigger:
-- master
+  - v2
 
-strategy:
-  matrix:
-    linux:
-      imageName: ubuntu-16.04
-      gorootDir: /usr/local
-    mac:
-      imageName: macos-10.13
-      gorootDir: /usr/local
-    windows:
-      imageName: windows-2019
-      gorootDir: C:\
-
-pool:
-  vmImage: $(imageName)
+schedules:
+- cron: "0 0 * * *"
+  displayName: Daily midnight fuzzing
+  branches:
+    include:
+    - v2
+  always: true
 
 variables:
   GOROOT: $(gorootDir)/go
   GOPATH: $(system.defaultWorkingDirectory)/gopath
   GOBIN:  $(GOPATH)/bin
   modulePath: '$(GOPATH)/src/github.com/$(build.repository.name)'
-  # TODO: modules should be the default in Go 1.13, so this won't be needed
+  # TODO: Remove once it's enabled by default
   GO111MODULE: on
 
-steps:
-- bash: |
-    latestGo=$(curl "https://golang.org/VERSION?m=text")
-    echo "##vso[task.setvariable variable=LATEST_GO]$latestGo"
-    echo "Latest Go version: $latestGo"
-  displayName: "Get latest Go version"
+jobs:
+- job: crossPlatformTest
+  displayName: "Cross-Platform Tests"
+  strategy:
+    matrix:
+      linux:
+        imageName: ubuntu-16.04
+        gorootDir: /usr/local
+      mac:
+        imageName: macos-10.13
+        gorootDir: /usr/local
+      windows:
+        imageName: windows-2019
+        gorootDir: C:\
+  pool:
+    vmImage: $(imageName)
+  
+  steps:
+  - bash: |
+      latestGo=$(curl "https://golang.org/VERSION?m=text")
+      echo "##vso[task.setvariable variable=LATEST_GO]$latestGo"
+      echo "Latest Go version: $latestGo"
+    displayName: "Get latest Go version"
 
-- bash: |
-    sudo rm -f $(which go)
-    echo '##vso[task.prependpath]$(GOBIN)'
-    echo '##vso[task.prependpath]$(GOROOT)/bin'
-    mkdir -p '$(modulePath)'
-    shopt -s extglob
-    shopt -s dotglob
-    mv !(gopath) '$(modulePath)'
-  displayName: Remove old Go, set GOBIN/GOROOT, and move project into GOPATH
+  - bash: |
+      sudo rm -f $(which go)
+      echo '##vso[task.prependpath]$(GOBIN)'
+      echo '##vso[task.prependpath]$(GOROOT)/bin'
+      mkdir -p '$(modulePath)'
+      shopt -s extglob
+      shopt -s dotglob
+      mv !(gopath) '$(modulePath)'
+    displayName: Remove old Go, set GOBIN/GOROOT, and move project into GOPATH
 
-# Install Go (this varies by platform)
+  # Install Go (this varies by platform)
+  - bash: |
+      wget "https://dl.google.com/go/$(LATEST_GO).linux-amd64.tar.gz"
+      sudo tar -C $(gorootDir) -xzf "$(LATEST_GO).linux-amd64.tar.gz"
+    condition: eq( variables['Agent.OS'], 'Linux' )
+    displayName: Install Go on Linux
 
-- bash: |
-    wget "https://dl.google.com/go/$(LATEST_GO).linux-amd64.tar.gz"
-    sudo tar -C $(gorootDir) -xzf "$(LATEST_GO).linux-amd64.tar.gz"
-  condition: eq( variables['Agent.OS'], 'Linux' )
-  displayName: Install Go on Linux
+  - bash: |
+      wget "https://dl.google.com/go/$(LATEST_GO).darwin-amd64.tar.gz"
+      sudo tar -C $(gorootDir) -xzf "$(LATEST_GO).darwin-amd64.tar.gz"
+    condition: eq( variables['Agent.OS'], 'Darwin' )
+    displayName: Install Go on macOS
 
-- bash: |
-    wget "https://dl.google.com/go/$(LATEST_GO).darwin-amd64.tar.gz"
-    sudo tar -C $(gorootDir) -xzf "$(LATEST_GO).darwin-amd64.tar.gz"
-  condition: eq( variables['Agent.OS'], 'Darwin' )
-  displayName: Install Go on macOS
+  # The low performance is partly due to PowerShell's attempt to update the progress bar. Disabling it speeds up the process.
+  # Reference: https://github.com/PowerShell/PowerShell/issues/2138
+  - powershell: |
+      $ProgressPreference = 'SilentlyContinue'
+      Write-Host "Downloading Go..."
+      (New-Object System.Net.WebClient).DownloadFile("https://dl.google.com/go/$(LATEST_GO).windows-amd64.zip", "$(LATEST_GO).windows-amd64.zip")
+      Write-Host "Extracting Go... (I'm slow too)"
+      7z x "$(LATEST_GO).windows-amd64.zip" -o"$(gorootDir)"
+    condition: eq( variables['Agent.OS'], 'Windows_NT' )
+    displayName: Install Go on Windows
 
-- powershell: |
-    Write-Host "Downloading Go... (please be patient, I am very slow)"
-    (New-Object System.Net.WebClient).DownloadFile("https://dl.google.com/go/$(LATEST_GO).windows-amd64.zip", "$(LATEST_GO).windows-amd64.zip")
-    Write-Host "Extracting Go... (I'm slow too)"
-    Expand-Archive "$(LATEST_GO).windows-amd64.zip" -DestinationPath "$(gorootDir)"
-  condition: eq( variables['Agent.OS'], 'Windows_NT' )
-  displayName: Install Go on Windows
+  - bash: curl -sfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b $(go env GOPATH)/bin v1.19.1
+    displayName: Install golangci-lint
 
-# TODO: When this issue is fixed, replace with installer script:
-# https://github.com/golangci/golangci-lint/issues/472
-- script: go get -v github.com/golangci/golangci-lint/cmd/golangci-lint
-  displayName: Install golangci-lint
+  - script: |
+      go get github.com/axw/gocov/gocov
+      go get github.com/AlekSi/gocov-xml
+      go get -u github.com/jstemmer/go-junit-report
+    displayName: Install test and coverage analysis tools
 
-- bash: |
-    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
-  displayName: Print Go version and environment
+  - bash: |
+      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
+    displayName: Print Go version and environment
 
-- script: |
-    go get -v -t -d ./...
-    golangci-lint run -E gofmt -E goimports -E misspell
-    go test -race ./...
-  workingDirectory: '$(modulePath)'
-  displayName: Run tests
+  - script: |
+      go get -v -t -d ./...
+      mkdir test-results
+    workingDirectory: '$(modulePath)'
+    displayName: Get dependencies
+
+  # its behavior is governed by .golangci.yml
+  - script: |
+      (golangci-lint run --out-format junit-xml) > test-results/lint-result.xml
+      exit 0
+    workingDirectory: '$(modulePath)'
+    continueOnError: true
+    displayName: Run lint check
+
+  - script: |
+      (go test -v -coverprofile=cover-profile.out -race ./... 2>&1) > test-results/test-result.out
+    workingDirectory: '$(modulePath)'
+    continueOnError: true
+    displayName: Run tests
+
+  - script: |
+      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 
+    workingDirectory: '$(modulePath)'
+    displayName: Prepare coverage reports
+
+  - script: |
+      (cat ./test-results/test-result.out | go-junit-report) > test-results/test-result.xml
+    workingDirectory: '$(modulePath)'
+    displayName: Prepare test report
+
+  - task: PublishCodeCoverageResults@1
+    displayName: Publish test coverage report
+    inputs:
+      codeCoverageTool: Cobertura 
+      summaryFileLocation: $(modulePath)/coverage/coverage.xml
+
+  - task: PublishTestResults@2
+    displayName: Publish unit test
+    inputs:
+      testResultsFormat: 'JUnit'
+      testResultsFiles: $(modulePath)/test-results/test-result.xml
+      testRunTitle: $(agent.OS) Unit Test
+      mergeTestResults: false
+
+  - task: PublishTestResults@2
+    displayName: Publish lint results
+    inputs:
+      testResultsFormat: 'JUnit'
+      testResultsFiles: $(modulePath)/test-results/lint-result.xml
+      testRunTitle: $(agent.OS) Lint
+      mergeTestResults: false
+
+  - bash: |
+      exit 1
+    condition: eq(variables['Agent.JobStatus'], 'SucceededWithIssues')
+    displayName: Coerce correct build result
+
+- job: fuzzing
+  displayName: 'Fuzzing'
+  # Only run this job on schedules or PRs for non-forks.
+  condition: or(eq(variables['System.PullRequest.IsFork'], 'False'), eq(variables['Build.Reason'], 'Schedule') )
+  strategy:
+    matrix:
+      linux:
+        imageName: ubuntu-16.04
+        gorootDir: /usr/local
+  pool:
+    vmImage: $(imageName)
+
+  steps:
+  - bash: |
+      latestGo=$(curl "https://golang.org/VERSION?m=text")
+      echo "##vso[task.setvariable variable=LATEST_GO]$latestGo"
+      echo "Latest Go version: $latestGo"
+    displayName: "Get latest Go version"
+
+  - bash: |
+      sudo rm -f $(which go)
+      echo '##vso[task.prependpath]$(GOBIN)'
+      echo '##vso[task.prependpath]$(GOROOT)/bin'
+      mkdir -p '$(modulePath)'
+      shopt -s extglob
+      shopt -s dotglob
+      mv !(gopath) '$(modulePath)'
+    displayName: Remove old Go, set GOBIN/GOROOT, and move project into GOPATH
+
+  - bash: |
+      wget "https://dl.google.com/go/$(LATEST_GO).linux-amd64.tar.gz"
+      sudo tar -C $(gorootDir) -xzf "$(LATEST_GO).linux-amd64.tar.gz"
+    condition: eq( variables['Agent.OS'], 'Linux' )
+    displayName: Install Go on Linux
+
+  - bash: |
+      # Install Clang-7.0 because other versions seem to be missing the file libclang_rt.fuzzer-x86_64.a
+      sudo add-apt-repository "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-7 main"
+      wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
+      sudo apt update && sudo apt install -y clang-7 lldb-7 lld-7
+
+      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.74/fuzzit_Linux_x86_64
+      chmod a+x fuzzit
+      mv fuzzit $(GOBIN)
+    displayName: Download go-fuzz tools and the Fuzzit CLI, and move Fuzzit CLI to GOBIN
+    condition: and(eq(variables['System.PullRequest.IsFork'], 'False') , eq( variables['Agent.OS'], 'Linux' ))
+
+  - bash: |
+      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="local-regression"
+      if [[ $(Build.Reason) == "Schedule" ]]; then
+        fuzz_type="fuzzing"
+      fi
+      echo "Fuzzing type: $fuzz_type"
+
+      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]}" -libfuzzer -o "$FUZZER_DIRECTORY/${fuzzers_targets[$f]}.a" $FUZZER_DIRECTORY
+        echo "Generating fuzzer binary of func ${fuzzers_funcs[$f]} which resides in $f"
+        clang-7 -fsanitize=fuzzer "$FUZZER_DIRECTORY/${fuzzers_targets[$f]}.a" -o "$FUZZER_DIRECTORY/${fuzzers_targets[$f]}"
+        fuzzit create job caddyserver/${fuzzers_targets[$f]} $FUZZER_DIRECTORY/${fuzzers_targets[$f]} --api-key ${FUZZIT_API_KEY} --type "${fuzz_type}" --branch "${SYSTEM_PULLREQUEST_SOURCEBRANCH}" --revision "${BUILD_SOURCEVERSION}"
+        echo "Completed $f"
+      done
+    env:
+      FUZZIT_API_KEY: $(FUZZIT_API_KEY)
+    workingDirectory: '$(modulePath)'
+    displayName: Generate fuzzers & submit them to Fuzzit

caddy/caddymain/run.go

@@ -1,612 +0,0 @@
-// Copyright 2015 Light Code Labs, LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package caddymain
-
-import (
-	"bufio"
-	"errors"
-	"flag"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"log"
-	"os"
-	"path/filepath"
-	"runtime"
-	"runtime/debug"
-	"strconv"
-	"strings"
-
-	"github.com/caddyserver/caddy"
-	"github.com/caddyserver/caddy/caddyfile"
-	"github.com/caddyserver/caddy/caddytls"
-	"github.com/caddyserver/caddy/telemetry"
-	"github.com/google/uuid"
-	"github.com/klauspost/cpuid"
-	"github.com/mholt/certmagic"
-	lumberjack "gopkg.in/natefinch/lumberjack.v2"
-
-	_ "github.com/caddyserver/caddy/caddyhttp" // plug in the HTTP server type
-	// This is where other plugins get plugged in (imported)
-)
-
-func init() {
-	caddy.TrapSignals()
-
-	flag.BoolVar(&certmagic.Default.Agreed, "agree", false, "Agree to the CA's Subscriber Agreement")
-	flag.StringVar(&certmagic.Default.CA, "ca", certmagic.Default.CA, "URL to certificate authority's ACME server directory")
-	flag.StringVar(&certmagic.Default.DefaultServerName, "default-sni", certmagic.Default.DefaultServerName, "If a ClientHello ServerName is empty, use this ServerName to choose a TLS certificate")
-	flag.BoolVar(&certmagic.Default.DisableHTTPChallenge, "disable-http-challenge", certmagic.Default.DisableHTTPChallenge, "Disable the ACME HTTP challenge")
-	flag.BoolVar(&certmagic.Default.DisableTLSALPNChallenge, "disable-tls-alpn-challenge", certmagic.Default.DisableTLSALPNChallenge, "Disable the ACME TLS-ALPN challenge")
-	flag.StringVar(&disabledMetrics, "disabled-metrics", "", "Comma-separated list of telemetry metrics to disable")
-	flag.StringVar(&conf, "conf", "", "Caddyfile to load (default \""+caddy.DefaultConfigFile+"\")")
-	flag.StringVar(&cpu, "cpu", "100%", "CPU cap")
-	flag.BoolVar(&printEnv, "env", false, "Enable to print environment variables")
-	flag.StringVar(&envFile, "envfile", "", "Path to file with environment variables to load in KEY=VALUE format")
-	flag.BoolVar(&fromJSON, "json-to-caddyfile", false, "From JSON stdin to Caddyfile stdout")
-	flag.BoolVar(&plugins, "plugins", false, "List installed plugins")
-	flag.StringVar(&certmagic.Default.Email, "email", "", "Default ACME CA account email address")
-	flag.DurationVar(&certmagic.HTTPTimeout, "catimeout", certmagic.HTTPTimeout, "Default ACME CA HTTP timeout")
-	flag.StringVar(&logfile, "log", "", "Process log file")
-	flag.BoolVar(&logTimestamps, "log-timestamps", true, "Enable timestamps for the process log")
-	flag.IntVar(&logRollMB, "log-roll-mb", 100, "Roll process log when it reaches this many megabytes (0 to disable rolling)")
-	flag.BoolVar(&logRollCompress, "log-roll-compress", true, "Gzip-compress rolled process log files")
-	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(&toJSON, "caddyfile-to-json", false, "From Caddyfile stdin to JSON stdout")
-	flag.BoolVar(&version, "version", false, "Show version")
-	flag.BoolVar(&validate, "validate", false, "Parse the Caddyfile but do not start the server")
-
-	caddy.RegisterCaddyfileLoader("flag", caddy.LoaderFunc(confLoader))
-	caddy.SetDefaultCaddyfileLoader("default", caddy.LoaderFunc(defaultLoader))
-}
-
-// Run is Caddy's main() function.
-func Run() {
-	flag.Parse()
-
-	module := getBuildModule()
-	cleanModVersion := strings.TrimPrefix(module.Version, "v")
-
-	caddy.AppName = appName
-	caddy.AppVersion = module.Version
-	caddy.OnProcessExit = append(caddy.OnProcessExit, certmagic.CleanUpOwnLocks)
-	certmagic.UserAgent = appName + "/" + cleanModVersion
-
-	if !logTimestamps {
-		// Disable timestamps for logging
-		log.SetFlags(0)
-	}
-
-	// 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:
-		if logRollMB > 0 {
-			log.SetOutput(&lumberjack.Logger{
-				Filename:   logfile,
-				MaxSize:    logRollMB,
-				MaxAge:     14,
-				MaxBackups: 10,
-				Compress:   logRollCompress,
-			})
-		} else {
-			err := os.MkdirAll(filepath.Dir(logfile), 0755)
-			if err != nil {
-				mustLogFatalf("%v", err)
-			}
-			f, err := os.OpenFile(logfile, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
-			if err != nil {
-				mustLogFatalf("%v", err)
-			}
-			// don't close file; log should be writeable for duration of process
-			log.SetOutput(f)
-		}
-	}
-
-	// load all additional envs as soon as possible
-	if err := LoadEnvFromFile(envFile); err != nil {
-		mustLogFatalf("%v", err)
-	}
-
-	if printEnv {
-		for _, v := range os.Environ() {
-			fmt.Println(v)
-		}
-	}
-
-	// initialize telemetry client
-	if EnableTelemetry {
-		err := initTelemetry()
-		if err != nil {
-			mustLogFatalf("[ERROR] Initializing telemetry: %v", err)
-		}
-	} else if disabledMetrics != "" {
-		mustLogFatalf("[ERROR] Cannot disable specific metrics because telemetry is disabled")
-	}
-
-	// Check for one-time actions
-	if revoke != "" {
-		err := caddytls.Revoke(revoke)
-		if err != nil {
-			mustLogFatalf("%v", err)
-		}
-		fmt.Printf("Revoked certificate for %s\n", revoke)
-		os.Exit(0)
-	}
-	if version {
-		if module.Sum != "" {
-			// a build with a known version will also have a checksum
-			fmt.Printf("Caddy %s (%s)\n", module.Version, module.Sum)
-		} else {
-			fmt.Println(module.Version)
-		}
-		os.Exit(0)
-	}
-	if plugins {
-		fmt.Println(caddy.DescribePlugins())
-		os.Exit(0)
-	}
-
-	// Check if we just need to do a Caddyfile Convert and exit
-	checkJSONCaddyfile()
-
-	// Set CPU cap
-	err := setCPU(cpu)
-	if err != nil {
-		mustLogFatalf("%v", err)
-	}
-
-	// Executes Startup events
-	caddy.EmitEvent(caddy.StartupEvent, nil)
-
-	// Get Caddyfile input
-	caddyfileinput, err := caddy.LoadCaddyfile(serverType)
-	if err != nil {
-		mustLogFatalf("%v", err)
-	}
-
-	if validate {
-		err := caddy.ValidateAndExecuteDirectives(caddyfileinput, nil, true)
-		if err != nil {
-			mustLogFatalf("%v", err)
-		}
-		msg := "Caddyfile is valid"
-		fmt.Println(msg)
-		log.Printf("[INFO] %s", msg)
-		os.Exit(0)
-	}
-
-	// Log Caddy version before start
-	log.Printf("[INFO] Caddy version: %s", module.Version)
-
-	// Start your engines
-	instance, err := caddy.Start(caddyfileinput)
-	if err != nil {
-		mustLogFatalf("%v", err)
-	}
-
-	// Begin telemetry (these are no-ops if telemetry disabled)
-	telemetry.Set("caddy_version", module.Version)
-	telemetry.Set("num_listeners", len(instance.Servers()))
-	telemetry.Set("server_type", serverType)
-	telemetry.Set("os", runtime.GOOS)
-	telemetry.Set("arch", runtime.GOARCH)
-	telemetry.Set("cpu", struct {
-		BrandName  string `json:"brand_name,omitempty"`
-		NumLogical int    `json:"num_logical,omitempty"`
-		AESNI      bool   `json:"aes_ni,omitempty"`
-	}{
-		BrandName:  cpuid.CPU.BrandName,
-		NumLogical: runtime.NumCPU(),
-		AESNI:      cpuid.CPU.AesNi(),
-	})
-	if containerized := detectContainer(); containerized {
-		telemetry.Set("container", containerized)
-	}
-	telemetry.StartEmitting()
-
-	// Twiddle your thumbs
-	instance.Wait()
-}
-
-// mustLogFatalf wraps log.Fatalf() in a way that ensures the
-// output is always printed to stderr so the user can see it
-// if the user is still there, even if the process log was not
-// enabled. If this process is an upgrade, however, and the user
-// might not be there anymore, this just logs to the process
-// log and exits.
-func mustLogFatalf(format string, args ...interface{}) {
-	if !caddy.IsUpgrade() {
-		log.SetOutput(os.Stderr)
-	}
-	log.Fatalf(format, args...)
-}
-
-// confLoader loads the Caddyfile using the -conf flag.
-func confLoader(serverType string) (caddy.Input, error) {
-	if conf == "" {
-		return nil, nil
-	}
-
-	if conf == "stdin" {
-		return caddy.CaddyfileFromPipe(os.Stdin, serverType)
-	}
-
-	var contents []byte
-	if strings.Contains(conf, "*") {
-		// Let caddyfile.doImport logic handle the globbed path
-		contents = []byte("import " + conf)
-	} else {
-		var err error
-		contents, err = ioutil.ReadFile(conf)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	return caddy.CaddyfileInput{
-		Contents:       contents,
-		Filepath:       conf,
-		ServerTypeName: serverType,
-	}, nil
-}
-
-// defaultLoader loads the Caddyfile from the current working directory.
-func defaultLoader(serverType string) (caddy.Input, error) {
-	contents, err := ioutil.ReadFile(caddy.DefaultConfigFile)
-	if err != nil {
-		if os.IsNotExist(err) {
-			return nil, nil
-		}
-		return nil, err
-	}
-	return caddy.CaddyfileInput{
-		Contents:       contents,
-		Filepath:       caddy.DefaultConfigFile,
-		ServerTypeName: serverType,
-	}, nil
-}
-
-// getBuildModule returns the build info of Caddy
-// from debug.BuildInfo (requires Go modules). If
-// no version information is available, a non-nil
-// value will still be returned, but with an
-// unknown version.
-func getBuildModule() *debug.Module {
-	bi, ok := debug.ReadBuildInfo()
-	if ok {
-		// The recommended way to build Caddy involves
-		// creating a separate main module, which
-		// preserves caddy a read-only dependency
-		// TODO: track related Go issue: https://github.com/golang/go/issues/29228
-		for _, mod := range bi.Deps {
-			if mod.Path == "github.com/caddyserver/caddy" {
-				return mod
-			}
-		}
-	}
-	return &debug.Module{Version: "unknown"}
-}
-
-func checkJSONCaddyfile() {
-	if fromJSON {
-		jsonBytes, err := ioutil.ReadAll(os.Stdin)
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "Read stdin failed: %v", err)
-			os.Exit(1)
-		}
-		caddyfileBytes, err := caddyfile.FromJSON(jsonBytes)
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "Converting from JSON failed: %v", err)
-			os.Exit(2)
-		}
-		fmt.Println(string(caddyfileBytes))
-		os.Exit(0)
-	}
-	if toJSON {
-		caddyfileBytes, err := ioutil.ReadAll(os.Stdin)
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "Read stdin failed: %v", err)
-			os.Exit(1)
-		}
-		jsonBytes, err := caddyfile.ToJSON(caddyfileBytes)
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "Converting to JSON failed: %v", err)
-			os.Exit(2)
-		}
-		fmt.Println(string(jsonBytes))
-		os.Exit(0)
-	}
-}
-
-// setCPU parses string cpu and sets GOMAXPROCS
-// according to its value. It accepts either
-// a number (e.g. 3) or a percent (e.g. 50%).
-// If the percent resolves to less than a single
-// GOMAXPROCS, it rounds it up to GOMAXPROCS=1.
-func setCPU(cpu string) error {
-	var numCPU int
-
-	availCPU := runtime.NumCPU()
-
-	if strings.HasSuffix(cpu, "%") {
-		// Percent
-		var percent float32
-		pctStr := cpu[:len(cpu)-1]
-		pctInt, err := strconv.Atoi(pctStr)
-		if err != nil || pctInt < 1 || pctInt > 100 {
-			return errors.New("invalid CPU value: percentage must be between 1-100")
-		}
-		percent = float32(pctInt) / 100
-		numCPU = int(float32(availCPU) * percent)
-		if numCPU < 1 {
-			numCPU = 1
-		}
-	} else {
-		// Number
-		num, err := strconv.Atoi(cpu)
-		if err != nil || num < 1 {
-			return errors.New("invalid CPU value: provide a number or percent greater than 0")
-		}
-		numCPU = num
-	}
-
-	if numCPU > availCPU {
-		numCPU = availCPU
-	}
-
-	runtime.GOMAXPROCS(numCPU)
-	return nil
-}
-
-// detectContainer attempts to determine whether the process is
-// being run inside a container. References:
-// https://tuhrig.de/how-to-know-you-are-inside-a-docker-container/
-// https://stackoverflow.com/a/20012536/1048862
-// https://gist.github.com/anantkamath/623ce7f5432680749e087cf8cfba9b69
-func detectContainer() bool {
-	if runtime.GOOS != "linux" {
-		return false
-	}
-
-	file, err := os.Open("/proc/1/cgroup")
-	if err != nil {
-		return false
-	}
-	defer file.Close()
-
-	i := 0
-	scanner := bufio.NewScanner(file)
-	for scanner.Scan() {
-		i++
-		if i > 1000 {
-			return false
-		}
-
-		line := scanner.Text()
-		parts := strings.SplitN(line, ":", 3)
-		if len(parts) < 3 {
-			continue
-		}
-
-		if strings.Contains(parts[2], "docker") ||
-			strings.Contains(parts[2], "lxc") ||
-			strings.Contains(parts[2], "moby") {
-			return true
-		}
-	}
-
-	return false
-}
-
-// initTelemetry initializes the telemetry engine.
-func initTelemetry() error {
-	uuidFilename := filepath.Join(caddy.AssetsPath(), "uuid")
-	if customUUIDFile := os.Getenv("CADDY_UUID_FILE"); customUUIDFile != "" {
-		uuidFilename = customUUIDFile
-	}
-
-	newUUID := func() uuid.UUID {
-		id := uuid.New()
-		err := os.MkdirAll(caddy.AssetsPath(), 0700)
-		if err != nil {
-			log.Printf("[ERROR] Persisting instance UUID: %v", err)
-			return id
-		}
-		err = ioutil.WriteFile(uuidFilename, []byte(id.String()), 0600) // human-readable as a string
-		if err != nil {
-			log.Printf("[ERROR] Persisting instance UUID: %v", err)
-		}
-		return id
-	}
-
-	var id uuid.UUID
-
-	// load UUID from storage, or create one if we don't have one
-	if uuidFile, err := os.Open(uuidFilename); os.IsNotExist(err) {
-		// no UUID exists yet; create a new one and persist it
-		id = newUUID()
-	} else if err != nil {
-		log.Printf("[ERROR] Loading persistent UUID: %v", err)
-		id = newUUID()
-	} else {
-		defer uuidFile.Close()
-		uuidBytes, err := ioutil.ReadAll(uuidFile)
-		if err != nil {
-			log.Printf("[ERROR] Reading persistent UUID: %v", err)
-			id = newUUID()
-		} else {
-			id, err = uuid.ParseBytes(uuidBytes)
-			if err != nil {
-				log.Printf("[ERROR] Parsing UUID: %v", err)
-				id = newUUID()
-			}
-		}
-	}
-
-	// parse and check the list of disabled metrics
-	var disabledMetricsSlice []string
-	if len(disabledMetrics) > 0 {
-		if len(disabledMetrics) > 1024 {
-			// mitigate disk space exhaustion at the collection endpoint
-			return fmt.Errorf("too many metrics to disable")
-		}
-		disabledMetricsSlice = splitTrim(disabledMetrics, ",")
-		for _, metric := range disabledMetricsSlice {
-			if metric == "instance_id" || metric == "timestamp" || metric == "disabled_metrics" {
-				return fmt.Errorf("instance_id, timestamp, and disabled_metrics cannot be disabled")
-			}
-		}
-	}
-
-	// initialize telemetry
-	telemetry.Init(id, disabledMetricsSlice)
-
-	// if any metrics were disabled, report which ones (so we know how representative the data is)
-	if len(disabledMetricsSlice) > 0 {
-		telemetry.Set("disabled_metrics", disabledMetricsSlice)
-		log.Printf("[NOTICE] The following telemetry metrics are disabled: %s", disabledMetrics)
-	}
-
-	return nil
-}
-
-// Split string s into all substrings separated by sep and returns a slice of
-// the substrings between those separators.
-//
-// If s does not contain sep and sep is not empty, Split returns a
-// slice of length 1 whose only element is s.
-//
-// If sep is empty, Split splits after each UTF-8 sequence. If both s
-// and sep are empty, Split returns an empty slice.
-//
-// Each item that in result is trim space and not empty string
-func splitTrim(s string, sep string) []string {
-	splitItems := strings.Split(s, sep)
-	trimItems := make([]string, 0, len(splitItems))
-	for _, item := range splitItems {
-		if item = strings.TrimSpace(item); item != "" {
-			trimItems = append(trimItems, item)
-		}
-	}
-	return trimItems
-}
-
-// LoadEnvFromFile loads additional envs if file provided and exists
-// Envs in file should be in KEY=VALUE format
-func LoadEnvFromFile(envFile string) error {
-	if envFile == "" {
-		return nil
-	}
-
-	file, err := os.Open(envFile)
-	if err != nil {
-		return err
-	}
-	defer file.Close()
-
-	envMap, err := ParseEnvFile(file)
-	if err != nil {
-		return err
-	}
-
-	for k, v := range envMap {
-		if err := os.Setenv(k, v); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-// ParseEnvFile implements parse logic for environment files
-func ParseEnvFile(envInput io.Reader) (map[string]string, error) {
-	envMap := make(map[string]string)
-
-	scanner := bufio.NewScanner(envInput)
-	var line string
-	lineNumber := 0
-
-	for scanner.Scan() {
-		line = strings.TrimSpace(scanner.Text())
-		lineNumber++
-
-		// skip lines starting with comment
-		if strings.HasPrefix(line, "#") {
-			continue
-		}
-
-		// skip empty line
-		if len(line) == 0 {
-			continue
-		}
-
-		fields := strings.SplitN(line, "=", 2)
-		if len(fields) != 2 {
-			return nil, fmt.Errorf("Can't parse line %d; line should be in KEY=VALUE format", lineNumber)
-		}
-
-		if strings.Contains(fields[0], " ") {
-			return nil, fmt.Errorf("Can't parse line %d; KEY contains whitespace", lineNumber)
-		}
-
-		key := fields[0]
-		val := fields[1]
-
-		if key == "" {
-			return nil, fmt.Errorf("Can't parse line %d; KEY can't be empty string", lineNumber)
-		}
-		envMap[key] = val
-	}
-
-	if err := scanner.Err(); err != nil {
-		return nil, err
-	}
-
-	return envMap, nil
-}
-
-const appName = "Caddy"
-
-// Flags that control program flow or startup
-var (
-	serverType      string
-	conf            string
-	cpu             string
-	envFile         string
-	fromJSON        bool
-	logfile         string
-	logTimestamps   bool
-	logRollMB       int
-	logRollCompress bool
-	revoke          string
-	toJSON          bool
-	version         bool
-	plugins         bool
-	printEnv        bool
-	validate        bool
-	disabledMetrics string
-)
-
-// EnableTelemetry defines whether telemetry is enabled in Run.
-var EnableTelemetry = true

caddy/caddymain/run_test.go

@@ -1,118 +0,0 @@
-// Copyright 2015 Light Code Labs, LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package caddymain
-
-import (
-	"reflect"
-	"runtime"
-	"strings"
-	"testing"
-)
-
-func TestSetCPU(t *testing.T) {
-	currentCPU := runtime.GOMAXPROCS(-1)
-	maxCPU := runtime.NumCPU()
-	halfCPU := int(0.5 * float32(maxCPU))
-	if halfCPU < 1 {
-		halfCPU = 1
-	}
-	for i, test := range []struct {
-		input     string
-		output    int
-		shouldErr bool
-	}{
-		{"1", 1, false},
-		{"-1", currentCPU, true},
-		{"0", currentCPU, true},
-		{"100%", maxCPU, false},
-		{"50%", halfCPU, false},
-		{"110%", currentCPU, true},
-		{"-10%", currentCPU, true},
-		{"invalid input", currentCPU, true},
-		{"invalid input%", currentCPU, true},
-		{"9999", maxCPU, false}, // over available CPU
-		{"1%", 1, false},        // under a single CPU; assume maxCPU < 100
-	} {
-		err := setCPU(test.input)
-		if test.shouldErr && err == nil {
-			t.Errorf("Test %d: Expected error, but there wasn't any", i)
-		}
-		if !test.shouldErr && err != nil {
-			t.Errorf("Test %d: Expected no error, but there was one: %v", i, err)
-		}
-		if actual, expected := runtime.GOMAXPROCS(-1), test.output; actual != expected {
-			t.Errorf("Test %d: GOMAXPROCS was %d but expected %d", i, actual, expected)
-		}
-		// teardown
-		runtime.GOMAXPROCS(currentCPU)
-	}
-}
-
-func TestSplitTrim(t *testing.T) {
-	for i, test := range []struct {
-		input  string
-		output []string
-		sep    string
-	}{
-		{"os,arch,cpu,caddy_version", []string{"os", "arch", "cpu", "caddy_version"}, ","},
-		{"os,arch,cpu,caddy_version,", []string{"os", "arch", "cpu", "caddy_version"}, ","},
-		{"os,,, arch, cpu, caddy_version,", []string{"os", "arch", "cpu", "caddy_version"}, ","},
-		{", , os, arch, cpu , caddy_version,, ,", []string{"os", "arch", "cpu", "caddy_version"}, ","},
-		{"os, ,, arch, cpu , caddy_version,, ,", []string{"os", "arch", "cpu", "caddy_version"}, ","},
-	} {
-		got := splitTrim(test.input, test.sep)
-		if len(got) != len(test.output) {
-			t.Errorf("Test %d: spliteTrim() = %v, want %v", i, got, test.output)
-			continue
-		}
-		for j, item := range test.output {
-			if item != got[j] {
-				t.Errorf("Test %d: spliteTrim() = %v, want %v", i, got, test.output)
-				break
-			}
-		}
-	}
-}
-
-func TestParseEnvFile(t *testing.T) {
-	tests := []struct {
-		name    string
-		input   string
-		want    map[string]string
-		wantErr bool
-	}{
-		{"parsing KEY=VALUE", "PORT=4096", map[string]string{"PORT": "4096"}, false},
-		{"empty KEY", "=4096", nil, true},
-		{"one value", "test", nil, true},
-		{"comments skipped", "#TEST=1\nPORT=8888", map[string]string{"PORT": "8888"}, false},
-		{"empty line", "\nPORT=7777", map[string]string{"PORT": "7777"}, false},
-		{"comments with space skipped", "  #TEST=1", map[string]string{}, false},
-		{"KEY with space", "PORT =8888", nil, true},
-		{"only spaces", "   ", map[string]string{}, false},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			reader := strings.NewReader(tt.input)
-			got, err := ParseEnvFile(reader)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("ParseEnvFile() error = %v, wantErr %v", err, tt.wantErr)
-				return
-			}
-			if !reflect.DeepEqual(got, tt.want) {
-				t.Errorf("ParseEnvFile() = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}

caddy_test.go

@@ -1,212 +0,0 @@
-// Copyright 2015 Light Code Labs, LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package caddy
-
-import (
-	"fmt"
-	"log"
-	"reflect"
-	"sync"
-	"testing"
-
-	"github.com/caddyserver/caddy/caddyfile"
-)
-
-/*
-// 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)
-		}
-	}
-}
-*/
-
-// CallbackTestContext implements Context interface
-type CallbackTestContext struct {
-	// If MakeServersFail is set to true then MakeServers returns an error
-	MakeServersFail bool
-}
-
-func (h *CallbackTestContext) InspectServerBlocks(name string, sblock []caddyfile.ServerBlock) ([]caddyfile.ServerBlock, error) {
-	return sblock, nil
-}
-func (h *CallbackTestContext) MakeServers() ([]Server, error) {
-	if h.MakeServersFail {
-		return make([]Server, 0), fmt.Errorf("MakeServers failed")
-	}
-	return make([]Server, 0), nil
-}
-
-func TestCaddyRestartCallbacks(t *testing.T) {
-	for i, test := range []struct {
-		restartFail   bool
-		expectedCalls []string
-	}{
-		{false, []string{"OnRestart", "OnShutdown"}},
-		{true, []string{"OnRestart", "OnRestartFailed"}},
-	} {
-		serverName := fmt.Sprintf("%v", i)
-		// RegisterServerType to make successful restart possible
-		RegisterServerType(serverName, ServerType{
-			Directives: func() []string { return []string{} },
-			// If MakeServersFail is true then the restart will fail due to context failure
-			NewContext: func(inst *Instance) Context { return &CallbackTestContext{MakeServersFail: test.restartFail} },
-		})
-		c := NewTestController(serverName, "")
-		c.instance = &Instance{
-			serverType: serverName,
-			wg:         new(sync.WaitGroup),
-		}
-
-		// Register callbacks which save the calls order
-		calls := make([]string, 0)
-		c.OnRestart(func() error {
-			calls = append(calls, "OnRestart")
-			return nil
-		})
-		c.OnRestartFailed(func() error {
-			calls = append(calls, "OnRestartFailed")
-			return nil
-		})
-		c.OnShutdown(func() error {
-			calls = append(calls, "OnShutdown")
-			return nil
-		})
-
-		_, err := c.instance.Restart(CaddyfileInput{Contents: []byte(""), ServerTypeName: serverName})
-		if err != nil {
-			log.Printf("[ERROR] Restart failed: %v", err)
-		}
-
-		if !reflect.DeepEqual(calls, test.expectedCalls) {
-			t.Errorf("Test %d: Callbacks expected: %v, got: %v", i, test.expectedCalls, calls)
-		}
-
-		err = c.instance.Stop()
-		if err != nil {
-			log.Printf("[ERROR] Stop failed: %v", err)
-		}
-
-		c.instance.Wait()
-	}
-
-}
-
-func TestIsLoopback(t *testing.T) {
-	for i, test := range []struct {
-		input  string
-		expect bool
-	}{
-		{"example.com", false},
-		{"localhost", true},
-		{"localhost:1234", true},
-		{"localhost:", true},
-		{"127.0.0.1", true},
-		{"127.0.0.1:443", true},
-		{"127.0.1.5", true},
-		{"10.0.0.5", false},
-		{"12.7.0.1", false},
-		{"[::1]", true},
-		{"[::1]:1234", true},
-		{"::1", true},
-		{"::", false},
-		{"[::]", false},
-		{"local", false},
-	} {
-		if got, want := IsLoopback(test.input), test.expect; got != want {
-			t.Errorf("Test %d (%s): expected %v but was %v", i, test.input, want, got)
-		}
-	}
-}
-
-func TestIsInternal(t *testing.T) {
-	for i, test := range []struct {
-		input  string
-		expect bool
-	}{
-		{"9.255.255.255", false},
-		{"10.0.0.0", true},
-		{"10.0.0.1", true},
-		{"10.255.255.254", true},
-		{"10.255.255.255", true},
-		{"11.0.0.0", false},
-		{"10.0.0.5:1234", true},
-		{"11.0.0.5:1234", false},
-
-		{"172.15.255.255", false},
-		{"172.16.0.0", true},
-		{"172.16.0.1", true},
-		{"172.31.255.254", true},
-		{"172.31.255.255", true},
-		{"172.32.0.0", false},
-		{"172.16.0.1:1234", true},
-
-		{"192.167.255.255", false},
-		{"192.168.0.0", true},
-		{"192.168.0.1", true},
-		{"192.168.255.254", true},
-		{"192.168.255.255", true},
-		{"192.169.0.0", false},
-		{"192.168.0.1:1234", true},
-
-		{"fbff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", false},
-		{"fc00::", true},
-		{"fc00::1", true},
-		{"[fc00::1]", true},
-		{"[fc00::1]:8888", true},
-		{"fdff:ffff:ffff:ffff:ffff:ffff:ffff:fffe", true},
-		{"fdff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", true},
-		{"fe00::", false},
-		{"fd12:3456:789a:1::1:1234", true},
-
-		{"example.com", false},
-		{"localhost", false},
-		{"localhost:1234", false},
-		{"localhost:", false},
-		{"127.0.0.1", false},
-		{"127.0.0.1:443", false},
-		{"127.0.1.5", false},
-		{"12.7.0.1", false},
-		{"[::1]", false},
-		{"[::1]:1234", false},
-		{"::1", false},
-		{"::", false},
-		{"[::]", false},
-		{"local", false},
-	} {
-		if got, want := IsInternal(test.input), test.expect; got != want {
-			t.Errorf("Test %d (%s): expected %v but was %v", i, test.input, want, got)
-		}
-	}
-}

caddyconfig/caddyfile/adapter.go

@@ -0,0 +1,87 @@
+// 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"
+	"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, bytes.NewReader(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.
+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,371 @@
+// 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.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
+}
+
+// NewFromNextTokens 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) NewFromNextTokens() *Dispenser {
+	tkns := []Token{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 to include
+			// all the tokens including surrounding curly braces
+			// for a new dispenser to have
+			d.Prev()
+			tkns = append(tkns, d.Token())
+			d.Next()
+			openedBlock = true
+		}
+		tkns = append(tkns, d.Token())
+	}
+	if openedBlock {
+		// include closing brace accordingly
+		tkns = append(tkns, d.Token())
+	}
+	return NewDispenser(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,4 +1,4 @@
-// Copyright 2015 Light Code Labs, LLC
+// 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.
@@ -15,6 +15,8 @@
 package caddyfile
 
 import (
+	"io"
+	"log"
 	"reflect"
 	"strings"
 	"testing"
@@ -25,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)
@@ -63,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 {
@@ -110,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 {
@@ -143,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 {
@@ -173,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
 
@@ -240,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
 
@@ -277,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 // {
 
@@ -304,3 +306,11 @@ func TestDispenser_ArgErr_Err(t *testing.T) {
 		t.Errorf("Expected error message with custom message in it ('foobar'); got '%v'", err)
 	}
 }
+
+func newTestDispenser(input string) *Dispenser {
+	tokens, err := allTokens("Testfile", strings.NewReader(input))
+	if err != nil && err != io.EOF {
+		log.Fatalf("getting all tokens from input: %v", err)
+	}
+	return NewDispenser(tokens)
+}

caddyconfig/caddyfile/lexer.go

@@ -26,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.
@@ -91,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
 		}
 
@@ -120,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 {
@@ -132,7 +141,6 @@ func (l *lexer) next() bool {
 		if ch == '#' {
 			comment = true
 		}
-
 		if comment {
 			continue
 		}
@@ -145,6 +153,11 @@ func (l *lexer) next() bool {
 			}
 		}
 
+		if escaped {
+			val = append(val, '\\')
+			escaped = false
+		}
+
 		val = append(val, ch)
 	}
 }

caddyconfig/caddyfile/lexer_test.go

@@ -95,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{
@@ -107,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" {

caddyconfig/caddyfile/parse.go

@@ -28,15 +28,19 @@ import (
 // Directives that do not appear in validDirectives will cause
 // an error. If you do not want to check for valid directives,
 // pass in nil instead.
-func Parse(filename string, input io.Reader, validDirectives []string) ([]ServerBlock, error) {
-	p := parser{Dispenser: NewDispenser(filename, input), validDirectives: validDirectives}
+func Parse(filename string, input io.Reader) ([]ServerBlock, error) {
+	tokens, err := allTokens(filename, input)
+	if err != nil {
+		return nil, err
+	}
+	p := parser{Dispenser: NewDispenser(tokens)}
 	return p.parseAll()
 }
 
 // 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) {
+func allTokens(filename string, input io.Reader) ([]Token, error) {
 	l := new(lexer)
 	err := l.load(input)
 	if err != nil {
@@ -44,17 +48,18 @@ func allTokens(input io.Reader) ([]Token, error) {
 	}
 	var tokens []Token
 	for l.next() {
+		l.token.File = filename
 		tokens = append(tokens, l.token)
 	}
 	return tokens, nil
 }
 
 type parser struct {
-	Dispenser
+	*Dispenser
 	block           ServerBlock // current server block being parsed
-	validDirectives []string    // a directive must be valid or it's an error
 	eof             bool        // if we encounter a valid EOF in a hard place
 	definedSnippets map[string][]Token
+	nesting         int
 }
 
 func (p *parser) parseAll() ([]ServerBlock, error) {
@@ -65,17 +70,19 @@ func (p *parser) parseAll() ([]ServerBlock, error) {
 		if err != nil {
 			return blocks, err
 		}
-		if len(p.block.Keys) > 0 {
+		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{Tokens: make(map[string][]Token)}
-
+	p.block = ServerBlock{}
 	return p.begin()
 }
 
@@ -182,7 +189,7 @@ func (p *parser) blockContents() error {
 		return err
 	}
 
-	// Only look for close curly brace if there was an opening
+	// only look for close curly brace if there was an opening
 	if errOpenCurlyBrace == nil {
 		err = p.closeCurlyBrace()
 		if err != nil {
@@ -201,6 +208,7 @@ func (p *parser) directives() error {
 	for p.Next() {
 		// end of server block
 		if p.Val() == "}" {
+			// p.nesting has already been decremented
 			break
 		}
 
@@ -214,11 +222,15 @@ func (p *parser) directives() error {
 			continue
 		}
 
-		// normal case: parse a directive on this line
+		// 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
 }
 
@@ -254,7 +266,7 @@ func (p *parser) doImport() error {
 		// 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.filename, err)
+			return p.Errf("Failed to get absolute path of file: %s: %v", p.Dispenser.File(), err)
 		}
 
 		var matches []string
@@ -316,7 +328,7 @@ func (p *parser) doSingleImport(importFile string) ([]Token, error) {
 		return nil, p.Errf("Could not import %s: is a directory", importFile)
 	}
 
-	importedTokens, err := allTokens(file)
+	importedTokens, err := allTokens(importFile, file)
 	if err != nil {
 		return nil, p.Errf("Could not read tokens while importing %s: %v", importFile, err)
 	}
@@ -325,7 +337,7 @@ func (p *parser) doSingleImport(importFile string) ([]Token, error) {
 	// (we use full, absolute path to avoid bugs: issue #1892)
 	filename, err := filepath.Abs(importFile)
 	if err != nil {
-		return nil, p.Errf("Failed to get absolute path of file: %s: %v", p.Dispenser.filename, err)
+		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
@@ -341,26 +353,24 @@ func (p *parser) doSingleImport(importFile string) ([]Token, error) {
 // are loaded into the current server block for later use
 // by directive setup functions.
 func (p *parser) directive() error {
-	dir := replaceEnvVars(p.Val())
-	nesting := 0
+	// evaluate any env vars in directive token
+	p.tokens[p.cursor].Text = replaceEnvVars(p.tokens[p.cursor].Text)
 
-	// 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)
-	}
+	// a segment is a list of tokens associated with this directive
+	var segment Segment
 
-	// The directive itself is appended as a relevant token
-	p.block.Tokens[dir] = append(p.block.Tokens[dir], p.tokens[p.cursor])
+	// the directive itself is appended as a relevant token
+	segment = append(segment, p.Token())
 
 	for p.Next() {
 		if p.Val() == "{" {
-			nesting++
-		} else if p.isNewLine() && nesting == 0 {
+			p.nesting++
+		} else if p.isNewLine() && p.nesting == 0 {
 			p.cursor-- // read too far
 			break
-		} else if p.Val() == "}" && nesting > 0 {
-			nesting--
-		} else if p.Val() == "}" && nesting == 0 {
+		} 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 {
@@ -370,12 +380,15 @@ func (p *parser) directive() error {
 			continue
 		}
 		p.tokens[p.cursor].Text = replaceEnvVars(p.tokens[p.cursor].Text)
-		p.block.Tokens[dir] = append(p.block.Tokens[dir], p.tokens[p.cursor])
+		segment = append(segment, p.Token())
 	}
 
-	if nesting > 0 {
+	p.block.Segments = append(p.block.Segments, segment)
+
+	if p.nesting > 0 {
 		return p.EOFErr()
 	}
+
 	return nil
 }
 
@@ -401,19 +414,6 @@ func (p *parser) closeCurlyBrace() error {
 	return nil
 }
 
-// validDirective returns true if dir is in p.validDirectives.
-func (p *parser) validDirective(dir string) bool {
-	if p.validDirectives == nil {
-		return true
-	}
-	for _, d := range p.validDirectives {
-		if d == dir {
-			return true
-		}
-	}
-	return false
-}
-
 // replaceEnvVars replaces environment variables that appear in the token
 // and understands both the $UNIX and %WINDOWS% syntaxes.
 func replaceEnvVars(s string) string {
@@ -444,13 +444,6 @@ func replaceEnvReferences(s, refStart, refEnd string) string {
 	return s
 }
 
-// ServerBlock associates any number of keys (usually addresses
-// of some sort) with tokens (grouped by directive name).
-type ServerBlock struct {
-	Keys   []string
-	Tokens map[string][]Token
-}
-
 func (p *parser) isSnippet() (bool, string) {
 	keys := p.block.Keys
 	// A snippet block is a single key with parens. Nothing else qualifies.
@@ -462,29 +455,62 @@ func (p *parser) isSnippet() (bool, string) {
 
 // read and store everything in a block for later replay.
 func (p *parser) snippetTokens() ([]Token, error) {
-	// TODO: disallow imports in snippets for simplicity at import time
 	// snippet must have curlies.
 	err := p.openCurlyBrace()
 	if err != nil {
 		return nil, err
 	}
-	count := 1
+	nesting := 1 // count our own nesting in snippets
 	tokens := []Token{}
 	for p.Next() {
 		if p.Val() == "}" {
-			count--
-			if count == 0 {
+			nesting--
+			if nesting == 0 {
 				break
 			}
 		}
 		if p.Val() == "{" {
-			count++
+			nesting++
 		}
 		tokens = append(tokens, p.tokens[p.cursor])
 	}
 	// make sure we're matched up
-	if count != 0 {
+	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 ""
+}

caddyconfig/caddyfile/parse_fuzz.go

@@ -1,4 +1,4 @@
-// Copyright 2015 Light Code Labs, LLC
+// 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.
@@ -12,27 +12,25 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package bind
+// +build gofuzz
+// +build gofuzz_libfuzzer
+
+package caddyfile
 
 import (
-	"github.com/caddyserver/caddy"
-	"github.com/caddyserver/caddy/caddyhttp/httpserver"
+	"bytes"
 )
 
-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()
+func FuzzParseCaddyfile(data []byte) (score int) {
+	sb, err := Parse("Caddyfile", bytes.NewReader(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
 		}
-		config.TLS.Manager.ListenHost = config.ListenHost // necessary for ACME challenges, see issue #309
+		return 0
 	}
-	return nil
+	return 1
 }

caddyconfig/caddyfile/parse_test.go

@@ -25,7 +25,7 @@ import (
 func TestAllTokens(t *testing.T) {
 	input := strings.NewReader("a b c\nd e")
 	expected := []string{"a", "b", "c", "d", "e"}
-	tokens, err := allTokens(input)
+	tokens, err := allTokens("TestAllTokens", input)
 
 	if err != nil {
 		t.Fatalf("Expected no error, got %v", err)
@@ -53,84 +53,67 @@ func TestParseOneAndImport(t *testing.T) {
 		input     string
 		shouldErr bool
 		keys      []string
-		tokens    map[string]int // map of directive name to number of tokens expected
+		numTokens []int // number of tokens to expect in each segment
 	}{
 		{`localhost`, false, []string{
 			"localhost",
-		}, map[string]int{}},
+		}, []int{}},
 
 		{`localhost
 		  dir1`, false, []string{
 			"localhost",
-		}, map[string]int{
-			"dir1": 1,
-		}},
+		}, []int{1}},
 
 		{`localhost:1234
 		  dir1 foo bar`, false, []string{
 			"localhost:1234",
-		}, map[string]int{
-			"dir1": 3,
-		}},
+		}, []int{3},
+		},
 
 		{`localhost {
 		    dir1
 		  }`, false, []string{
 			"localhost",
-		}, map[string]int{
-			"dir1": 1,
-		}},
+		}, []int{1}},
 
 		{`localhost:1234 {
 		    dir1 foo bar
 		    dir2
 		  }`, false, []string{
 			"localhost:1234",
-		}, map[string]int{
-			"dir1": 3,
-			"dir2": 1,
-		}},
+		}, []int{3, 1}},
 
 		{`http://localhost https://localhost
 		  dir1 foo bar`, false, []string{
 			"http://localhost",
 			"https://localhost",
-		}, map[string]int{
-			"dir1": 3,
-		}},
+		}, []int{3}},
 
 		{`http://localhost https://localhost {
 		    dir1 foo bar
 		  }`, false, []string{
 			"http://localhost",
 			"https://localhost",
-		}, map[string]int{
-			"dir1": 3,
-		}},
+		}, []int{3}},
 
 		{`http://localhost, https://localhost {
 		    dir1 foo bar
 		  }`, false, []string{
 			"http://localhost",
 			"https://localhost",
-		}, map[string]int{
-			"dir1": 3,
-		}},
+		}, []int{3}},
 
 		{`http://localhost, {
 		  }`, true, []string{
 			"http://localhost",
-		}, map[string]int{}},
+		}, []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,
-		}},
+		}, []int{3, 2}},
 
 		{`http://host1.com,
 		  http://host2.com,
@@ -138,7 +121,7 @@ func TestParseOneAndImport(t *testing.T) {
 			"http://host1.com",
 			"http://host2.com",
 			"https://host3.com",
-		}, map[string]int{}},
+		}, []int{}},
 
 		{`http://host1.com:1234, https://host2.com
 		  dir1 foo {
@@ -147,10 +130,7 @@ func TestParseOneAndImport(t *testing.T) {
 		  dir2`, false, []string{
 			"http://host1.com:1234",
 			"https://host2.com",
-		}, map[string]int{
-			"dir1": 6,
-			"dir2": 1,
-		}},
+		}, []int{6, 1}},
 
 		{`127.0.0.1
 		  dir1 {
@@ -160,34 +140,25 @@ func TestParseOneAndImport(t *testing.T) {
 		    foo bar
 		  }`, false, []string{
 			"127.0.0.1",
-		}, map[string]int{
-			"dir1": 5,
-			"dir2": 5,
-		}},
+		}, []int{5, 5}},
 
 		{`localhost
 		  dir1 {
 		    foo`, true, []string{
 			"localhost",
-		}, map[string]int{
-			"dir1": 3,
-		}},
+		}, []int{3}},
 
 		{`localhost
 		  dir1 {
 		  }`, false, []string{
 			"localhost",
-		}, map[string]int{
-			"dir1": 3,
-		}},
+		}, []int{3}},
 
 		{`localhost
 		  dir1 {
 		  } }`, true, []string{
 			"localhost",
-		}, map[string]int{
-			"dir1": 3,
-		}},
+		}, []int{}},
 
 		{`localhost
 		  dir1 {
@@ -197,48 +168,38 @@ func TestParseOneAndImport(t *testing.T) {
 		  }
 		  dir2 foo bar`, false, []string{
 			"localhost",
-		}, map[string]int{
-			"dir1": 7,
-			"dir2": 3,
-		}},
+		}, []int{7, 3}},
 
-		{``, false, []string{}, map[string]int{}},
+		{``, false, []string{}, []int{}},
 
 		{`localhost
 		  dir1 arg1
 		  import testdata/import_test1.txt`, false, []string{
 			"localhost",
-		}, map[string]int{
-			"dir1": 2,
-			"dir2": 3,
-			"dir3": 1,
-		}},
+		}, []int{2, 3, 1}},
 
 		{`import testdata/import_test2.txt`, false, []string{
 			"host1",
-		}, map[string]int{
-			"dir1": 1,
-			"dir2": 2,
-		}},
+		}, []int{1, 2}},
 
-		{`import testdata/import_test1.txt testdata/import_test2.txt`, true, []string{}, map[string]int{}},
+		{`import testdata/import_test1.txt testdata/import_test2.txt`, true, []string{}, []int{}},
 
-		{`import testdata/not_found.txt`, true, []string{}, map[string]int{}},
+		{`import testdata/not_found.txt`, true, []string{}, []int{}},
 
-		{`""`, false, []string{}, map[string]int{}},
+		{`""`, false, []string{}, []int{}},
 
-		{``, false, []string{}, map[string]int{}},
+		{``, false, []string{}, []int{}},
 
 		// test cases found by fuzzing!
-		{`import }{$"`, true, []string{}, map[string]int{}},
-		{`import /*/*.txt`, true, []string{}, map[string]int{}},
-		{`import /???/?*?o`, true, []string{}, map[string]int{}},
-		{`import /??`, true, []string{}, map[string]int{}},
-		{`import /[a-z]`, true, []string{}, map[string]int{}},
-		{`import {$}`, true, []string{}, map[string]int{}},
-		{`import {%}`, true, []string{}, map[string]int{}},
-		{`import {$$}`, true, []string{}, map[string]int{}},
-		{`import {%%}`, true, []string{}, map[string]int{}},
+		{`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)
 
@@ -261,15 +222,16 @@ func TestParseOneAndImport(t *testing.T) {
 			}
 		}
 
-		if len(result.Tokens) != len(test.tokens) {
-			t.Errorf("Test %d: Expected %d directives, had %d",
-				i, len(test.tokens), len(result.Tokens))
+		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 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))
+
+		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
 			}
 		}
@@ -289,12 +251,12 @@ func TestRecursiveImport(t *testing.T) {
 			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))
+		if len(got.Segments) != 2 {
+			t.Errorf("got wrong number of segments: expect 2, got %d", len(got.Segments))
 			return false
 		}
-		if len(got.Tokens["dir1"]) != 1 || len(got.Tokens["dir2"]) != 2 {
-			t.Errorf("got unexpect tokens: %v", got.Tokens)
+		if len(got.Segments[0]) != 1 || len(got.Segments[1]) != 2 {
+			t.Errorf("got unexpect tokens: %v", got.Segments)
 			return false
 		}
 		return true
@@ -384,12 +346,12 @@ func TestDirectiveImport(t *testing.T) {
 			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))
+		if len(got.Segments) != 2 {
+			t.Errorf("got wrong number of segments: expect 2, got %d", len(got.Segments))
 			return false
 		}
-		if len(got.Tokens["dir1"]) != 1 || len(got.Tokens["proxy"]) != 8 {
-			t.Errorf("got unexpect tokens: %v", got.Tokens)
+		if len(got.Segments[0]) != 1 || len(got.Segments[1]) != 8 {
+			t.Errorf("got unexpect tokens: %v", got.Segments)
 			return false
 		}
 		return true
@@ -557,21 +519,21 @@ func TestEnvironmentReplacement(t *testing.T) {
 	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 {
+	if actual, expected := blocks[0].Segments[0][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 {
+	if actual, expected := blocks[0].Segments[0][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 {
+	if actual, expected := blocks[0].Segments[0][1].Text, "{%ADDRESS}"; expected != actual {
 		t.Errorf("Expected host to be '%s' but was '%s'", expected, actual)
 	}
 
@@ -585,24 +547,18 @@ func TestEnvironmentReplacement(t *testing.T) {
 	// 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 {
+	if actual, expected := blocks[0].Segments[0][1].Text, "Test foobar test"; expected != actual {
 		t.Errorf("Expected argument to be '%s' but was '%s'", expected, actual)
 	}
 
 	// after end token
 	p = testParser(":1234\nanswer \"{{ .Name }} {$FOOBAR}\"")
 	blocks, _ = p.parseAll()
-	if actual, expected := blocks[0].Tokens["answer"][1].Text, "{{ .Name }} foobar"; expected != actual {
+	if actual, expected := blocks[0].Segments[0][1].Text, "{{ .Name }} foobar"; 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
-}
-
 func TestSnippets(t *testing.T) {
 	p := testParser(`
 		(common) {
@@ -619,7 +575,7 @@ func TestSnippets(t *testing.T) {
 	}
 	for _, b := range blocks {
 		t.Log(b.Keys)
-		t.Log(b.Tokens)
+		t.Log(b.Segments)
 	}
 	if len(blocks) != 1 {
 		t.Fatalf("Expect exactly one server block. Got %d.", len(blocks))
@@ -627,16 +583,15 @@ func TestSnippets(t *testing.T) {
 	if actual, expected := blocks[0].Keys[0], "http://example.com"; expected != actual {
 		t.Errorf("Expected server name to be '%s' but was '%s'", expected, actual)
 	}
-	if len(blocks[0].Tokens) != 2 {
-		t.Fatalf("Server block should have tokens from import")
+	if len(blocks[0].Segments) != 2 {
+		t.Fatalf("Server block should have tokens from import, got: %+v", blocks[0])
 	}
-	if actual, expected := blocks[0].Tokens["gzip"][0].Text, "gzip"; expected != actual {
+	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].Tokens["errors"][1].Text, "stderr"; 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) {
@@ -668,9 +623,9 @@ func TestImportedFilesIgnoreNonDirectiveImportTokens(t *testing.T) {
 	}
 	for _, b := range blocks {
 		t.Log(b.Keys)
-		t.Log(b.Tokens)
+		t.Log(b.Segments)
 	}
-	auth := blocks[0].Tokens["basicauth"]
+	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:
@@ -703,7 +658,7 @@ func TestSnippetAcrossMultipleFiles(t *testing.T) {
 	}
 	for _, b := range blocks {
 		t.Log(b.Keys)
-		t.Log(b.Tokens)
+		t.Log(b.Segments)
 	}
 	if len(blocks) != 1 {
 		t.Fatalf("Expect exactly one server block. Got %d.", len(blocks))
@@ -711,10 +666,14 @@ func TestSnippetAcrossMultipleFiles(t *testing.T) {
 	if actual, expected := blocks[0].Keys[0], "http://example.com"; expected != actual {
 		t.Errorf("Expected server name to be '%s' but was '%s'", expected, actual)
 	}
-	if len(blocks[0].Tokens) != 1 {
+	if len(blocks[0].Segments) != 1 {
 		t.Fatalf("Server block should have tokens from import")
 	}
-	if actual, expected := blocks[0].Tokens["gzip"][0].Text, "gzip"; expected != actual {
+	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,117 @@
+// 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"
+)
+
+// 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 nil
+}
+
+// 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]
+}
+
+var configAdapters = make(map[string]Adapter)

caddyconfig/httpcaddyfile/addresses.go

@@ -0,0 +1,334 @@
+// 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"
+	"net/url"
+	"reflect"
+	"strconv"
+	"strings"
+
+	"github.com/caddyserver/caddy/v2/caddyconfig/caddyfile"
+	"github.com/caddyserver/caddy/v2/modules/caddyhttp"
+	"github.com/mholt/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
+// beceause 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) (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)
+			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 {
+			sbmap[addr] = append(sbmap[addr], serverBlock{
+				block: caddyfile.ServerBlock{
+					Keys:     keys,
+					Segments: sblock.block.Segments,
+				},
+				pile: sblock.pile,
+			})
+		}
+	}
+
+	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) ([]string, error) {
+	addr, err := ParseAddress(key)
+	if err != nil {
+		return nil, fmt.Errorf("parsing key: %v", err)
+	}
+	addr = addr.Normalize()
+
+	lnPort := DefaultPort
+	if addr.Port != "" {
+		// port explicitly defined
+		lnPort = addr.Port
+	} else if certmagic.HostQualifies(addr.Host) {
+		// automatic HTTPS
+		lnPort = strconv.Itoa(certmagic.HTTPSPort)
+	}
+
+	// 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 {
+		listeners[net.JoinHostPort(host, lnPort)] = struct{}{}
+	}
+
+	// now turn map into list
+	var listenersList []string
+	for lnStr := range listeners {
+		listenersList = append(listenersList, lnStr)
+	}
+	// sort.Strings(listenersList) // TODO: is sorting necessary?
+
+	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) {
+	httpPort, httpsPort := strconv.Itoa(certmagic.HTTPPort), strconv.Itoa(certmagic.HTTPSPort)
+
+	input := str
+
+	// Split input into components (prepend with // to force host portion by default)
+	if !strings.Contains(str, "//") && !strings.HasPrefix(str, "/") {
+		str = "//" + str
+	}
+
+	u, err := url.Parse(str)
+	if err != nil {
+		return Address{}, err
+	}
+
+	// separate host and port
+	host, port, err := net.SplitHostPort(u.Host)
+	if err != nil {
+		host, port, err = net.SplitHostPort(u.Host + ":")
+		if err != nil {
+			host = u.Host
+		}
+	}
+
+	// see if we can set port based off scheme
+	if port == "" {
+		if u.Scheme == "http" {
+			port = httpPort
+		} else if u.Scheme == "https" {
+			port = httpsPort
+		}
+	}
+
+	// error if scheme and port combination violate convention
+	if (u.Scheme == "http" && port == httpsPort) || (u.Scheme == "https" && port == httpPort) {
+		return Address{}, fmt.Errorf("[%s] scheme and port violate convention", input)
+	}
+
+	return Address{Original: input, Scheme: u.Scheme, Host: host, Port: port, Path: u.Path}, err
+}
+
+// TODO: which of the methods on Address are even used?
+
+// 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
+	if !caseSensitivePath {
+		path = strings.ToLower(path)
+	}
+
+	// ensure host is normalized if it's an IP address
+	host := 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
+}
+
+const (
+	// DefaultPort is the default port to use.
+	DefaultPort = "2015"
+
+	caseSensitivePath = false // TODO: Used?
+)

caddyconfig/httpcaddyfile/addresses_fuzz.go

@@ -1,4 +1,4 @@
-// Copyright 2015 Light Code Labs, LLC
+// 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.
@@ -12,14 +12,18 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package summary
+// +build gofuzz
+// +build gofuzz_libfuzzer
 
-import "testing"
+package httpcaddyfile
 
-func TestMarkdown(t *testing.T) {
-	input := []byte(`Testing with just a few words.`)
-	got := string(Markdown(input, 3))
-	if want := "Testing with just"; want != got {
-		t.Errorf("Expected '%s' but got '%s'", want, got)
+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

@@ -0,0 +1,166 @@
+package httpcaddyfile
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestParseAddress(t *testing.T) {
+	for i, test := range []struct {
+		input                    string
+		scheme, host, port, path string
+		shouldErr                bool
+	}{
+		{`localhost`, "", "localhost", "", "", false},
+		{`localhost:1234`, "", "localhost", "1234", "", false},
+		{`localhost:`, "", "localhost", "", "", false},
+		{`0.0.0.0`, "", "0.0.0.0", "", "", false},
+		{`127.0.0.1:1234`, "", "127.0.0.1", "1234", "", false},
+		{`:1234`, "", "", "1234", "", false},
+		{`[::1]`, "", "::1", "", "", false},
+		{`[::1]:1234`, "", "::1", "1234", "", false},
+		{`:`, "", "", "", "", false},
+		{`:http`, "", "", "", "", true},
+		{`:https`, "", "", "", "", true},
+		{`localhost:http`, "", "", "", "", true}, // using service name in port is verboten, as of Go 1.12.8
+		{`localhost:https`, "", "", "", "", true},
+		{`http://localhost:https`, "", "", "", "", true}, // conflict
+		{`http://localhost:http`, "", "", "", "", true},  // repeated scheme
+		{`host:https/path`, "", "", "", "", true},
+		{`http://localhost:443`, "", "", "", "", 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},
+		{`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},
+		{`host/path`, "", "host", "", "/path", false},
+		{`http://host/`, "http", "host", "80", "/", false},
+		{`//asdf`, "", "asdf", "", "", false},
+		{`:1234/asdf`, "", "", "1234", "/asdf", false},
+		{`http://host/path`, "http", "host", "80", "/path", false},
+		{`https://host:443/path/foo`, "https", "host", "443", "/path/foo", false},
+		{`host:80/path`, "", "host", "80", "/path", false},
+		{`/path`, "", "", "", "/path", false},
+	} {
+		actual, err := ParseAddress(test.input)
+
+		if err != nil && !test.shouldErr {
+			t.Errorf("Test %d (%s): Expected no error, but had error: %v", i, test.input, err)
+		}
+		if err == nil && test.shouldErr {
+			t.Errorf("Test %d (%s): Expected error, but had none", i, test.input)
+		}
+
+		if !test.shouldErr && actual.Original != test.input {
+			t.Errorf("Test %d (%s): Expected original '%s', got '%s'", i, test.input, test.input, actual.Original)
+		}
+		if actual.Scheme != test.scheme {
+			t.Errorf("Test %d (%s): Expected scheme '%s', got '%s'", i, test.input, test.scheme, actual.Scheme)
+		}
+		if actual.Host != test.host {
+			t.Errorf("Test %d (%s): Expected host '%s', got '%s'", i, test.input, test.host, actual.Host)
+		}
+		if actual.Port != test.port {
+			t.Errorf("Test %d (%s): Expected port '%s', got '%s'", i, test.input, test.port, actual.Port)
+		}
+		if actual.Path != test.path {
+			t.Errorf("Test %d (%s): Expected path '%s', got '%s'", i, test.input, test.path, actual.Path)
+		}
+	}
+}
+
+func TestAddressString(t *testing.T) {
+	for i, test := range []struct {
+		addr     Address
+		expected string
+	}{
+		{Address{Scheme: "http", Host: "host", Port: "1234", Path: "/path"}, "http://host:1234/path"},
+		{Address{Scheme: "", Host: "host", Port: "", Path: ""}, "http://host"},
+		{Address{Scheme: "", Host: "host", Port: "80", Path: ""}, "http://host"},
+		{Address{Scheme: "", Host: "host", Port: "443", Path: ""}, "https://host"},
+		{Address{Scheme: "https", Host: "host", Port: "443", Path: ""}, "https://host"},
+		{Address{Scheme: "https", Host: "host", Port: "", Path: ""}, "https://host"},
+		{Address{Scheme: "", Host: "host", Port: "80", Path: "/path"}, "http://host/path"},
+		{Address{Scheme: "http", Host: "", Port: "1234", Path: ""}, "http://:1234"},
+		{Address{Scheme: "", Host: "", Port: "", Path: ""}, ""},
+	} {
+		actual := test.addr.String()
+		if actual != test.expected {
+			t.Errorf("Test %d: expected '%s' but got '%s'", i, test.expected, actual)
+		}
+	}
+}
+
+func TestKeyNormalization(t *testing.T) {
+	testCases := []struct {
+		input  string
+		expect string
+	}{
+		{
+			input:  "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: "::",
+		},
+	}
+	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
+		}
+		expect := tc.expect
+		if !caseSensitivePath {
+			// every other part of the address should be lowercased when normalized,
+			// so simply lower-case the whole thing to do case-insensitive comparison
+			// of the path as well
+			expect = strings.ToLower(expect)
+		}
+		if actual := addr.Normalize().Key(); actual != expect {
+			t.Errorf("Test %d: Normalized key for address '%s' was '%s' but expected '%s'", i, tc.input, actual, expect)
+		}
+
+	}
+}

caddyconfig/httpcaddyfile/builtins.go

@@ -0,0 +1,299 @@
+// Copyright 2015 Matthew Holt and The Caddy Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package httpcaddyfile
+
+import (
+	"encoding/json"
+	"fmt"
+	"html"
+	"net/http"
+	"reflect"
+
+	"github.com/caddyserver/caddy/v2"
+	"github.com/caddyserver/caddy/v2/caddyconfig"
+	"github.com/caddyserver/caddy/v2/modules/caddyhttp"
+	"github.com/caddyserver/caddy/v2/modules/caddytls"
+)
+
+func init() {
+	RegisterDirective("bind", parseBind)
+	RegisterDirective("root", parseRoot)
+	RegisterDirective("tls", parseTLS)
+	RegisterHandlerDirective("redir", parseRedir)
+	RegisterHandlerDirective("respond", parseRespond)
+}
+
+func parseBind(h Helper) ([]ConfigValue, error) {
+	var lnHosts []string
+	for h.Next() {
+		lnHosts = append(lnHosts, h.RemainingArgs()...)
+	}
+	return h.NewBindAddresses(lnHosts), nil
+}
+
+func parseRoot(h Helper) ([]ConfigValue, error) {
+	if !h.Next() {
+		return nil, h.ArgErr()
+	}
+
+	matcherSet, ok, err := h.MatcherToken()
+	if err != nil {
+		return nil, err
+	}
+	if !ok {
+		// no matcher token; oops
+		h.Dispenser.Prev()
+	}
+
+	if !h.NextArg() {
+		return nil, h.ArgErr()
+	}
+	root := h.Val()
+	if h.NextArg() {
+		return nil, h.ArgErr()
+	}
+
+	varsHandler := caddyhttp.VarsMiddleware{"root": root}
+	route := caddyhttp.Route{
+		HandlersRaw: []json.RawMessage{
+			caddyconfig.JSONModuleObject(varsHandler, "handler", "vars", nil),
+		},
+	}
+	if matcherSet != nil {
+		route.MatcherSetsRaw = []caddy.ModuleMap{matcherSet}
+	}
+
+	return h.NewVarsRoute(route), nil
+}
+
+func parseTLS(h Helper) ([]ConfigValue, error) {
+	var configVals []ConfigValue
+
+	var cp *caddytls.ConnectionPolicy
+	var fileLoader caddytls.FileLoader
+	var folderLoader caddytls.FolderLoader
+	var mgr caddytls.ACMEManagerMaker
+	var off bool
+
+	// fill in global defaults, if configured
+	if email := h.Option("email"); email != nil {
+		mgr.Email = email.(string)
+	}
+	if acmeCA := h.Option("acme_ca"); acmeCA != nil {
+		mgr.CA = acmeCA.(string)
+	}
+
+	for h.Next() {
+		// file certificate loader
+		firstLine := h.RemainingArgs()
+		switch len(firstLine) {
+		case 0:
+		case 1:
+			if firstLine[0] == "off" {
+				off = true
+			} else {
+				mgr.Email = firstLine[0]
+			}
+		case 2:
+			fileLoader = append(fileLoader, caddytls.CertKeyFilePair{
+				Certificate: firstLine[0],
+				Key:         firstLine[1],
+				// TODO: add tags, for enterprise module's certificate selection
+			})
+		default:
+			return nil, h.ArgErr()
+		}
+
+		var hasBlock bool
+		for h.NextBlock(0) {
+			hasBlock = true
+
+			switch h.Val() {
+			// connection policy
+			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])
+					}
+					if cp == nil {
+						cp = new(caddytls.ConnectionPolicy)
+					}
+					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])
+					}
+					if cp == nil {
+						cp = new(caddytls.ConnectionPolicy)
+					}
+					cp.ProtocolMax = args[1]
+				}
+			case "ciphers":
+				for h.NextArg() {
+					if _, ok := caddytls.SupportedCipherSuites[h.Val()]; !ok {
+						return nil, h.Errf("Wrong cipher suite name or cipher suite not supported: '%s'", h.Val())
+					}
+					if cp == nil {
+						cp = new(caddytls.ConnectionPolicy)
+					}
+					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())
+					}
+					if cp == nil {
+						cp = new(caddytls.ConnectionPolicy)
+					}
+					cp.Curves = append(cp.Curves, h.Val())
+				}
+			case "alpn":
+				args := h.RemainingArgs()
+				if len(args) == 0 {
+					return nil, h.ArgErr()
+				}
+				if cp == nil {
+					cp = new(caddytls.ConnectionPolicy)
+				}
+				cp.ALPN = args
+
+			// certificate folder loader
+			case "load":
+				folderLoader = append(folderLoader, h.RemainingArgs()...)
+
+			// automation policy
+			case "ca":
+				arg := h.RemainingArgs()
+				if len(arg) != 1 {
+					return nil, h.ArgErr()
+				}
+				mgr.CA = arg[0]
+
+			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()
+		}
+	}
+
+	// certificate loaders
+	if len(fileLoader) > 0 {
+		configVals = append(configVals, ConfigValue{
+			Class: "tls.certificate_loader",
+			Value: fileLoader,
+		})
+		// ensure server uses HTTPS by setting non-nil conn policy
+		if cp == nil {
+			cp = new(caddytls.ConnectionPolicy)
+		}
+	}
+	if len(folderLoader) > 0 {
+		configVals = append(configVals, ConfigValue{
+			Class: "tls.certificate_loader",
+			Value: folderLoader,
+		})
+		// ensure server uses HTTPS by setting non-nil conn policy
+		if cp == nil {
+			cp = new(caddytls.ConnectionPolicy)
+		}
+	}
+
+	// connection policy
+	if cp != nil {
+		configVals = append(configVals, ConfigValue{
+			Class: "tls.connection_policy",
+			Value: cp,
+		})
+	}
+
+	// automation policy
+	if off {
+		configVals = append(configVals, ConfigValue{
+			Class: "tls.off",
+			Value: true,
+		})
+	} else if !reflect.DeepEqual(mgr, caddytls.ACMEManagerMaker{}) {
+		configVals = append(configVals, ConfigValue{
+			Class: "tls.automation_manager",
+			Value: mgr,
+		})
+	}
+
+	return configVals, nil
+}
+
+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 = "307"
+	}
+	var body string
+	if code == "meta" {
+		// 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
+}
+
+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
+}

caddyconfig/httpcaddyfile/directives.go

@@ -0,0 +1,225 @@
+// 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"
+
+	"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"
+)
+
+// defaultDirectiveOrder specifies the order
+// to apply directives in HTTP routes.
+var defaultDirectiveOrder = []string{
+	"rewrite",
+	"strip_prefix",
+	"strip_suffix",
+	"uri_replace",
+	"try_files",
+	"basicauth",
+	"headers",
+	"request_header",
+	"encode",
+	"templates",
+	"redir",
+	"respond",
+	"reverse_proxy",
+	"php_fastcgi",
+	"file_server",
+}
+
+// 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
+	options     map[string]interface{}
+	warnings    *[]caddyconfig.Warning
+	matcherDefs map[string]caddy.ModuleMap
+	parentBlock caddyfile.ServerBlock
+}
+
+// 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 current token is (possibly) a matcher, and
+// if so, returns the matcher set along with a true value. If the current
+// 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)
+}
+
+// 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)},
+			},
+		},
+	}
+}
+
+// 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}}
+}
+
+// NewVarsRoute returns config values relevant to adding a
+// "vars" wrapper route to the config.
+func (h Helper) NewVarsRoute(route caddyhttp.Route) []ConfigValue {
+	return []ConfigValue{{Class: "var", Value: route}}
+}
+
+// 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
+}
+
+// serverBlock pairs a Caddyfile server block
+// with a "pile" of config values, keyed by class
+// name.
+type serverBlock struct {
+	block caddyfile.ServerBlock
+	pile  map[string][]ConfigValue // config values obtained from directives
+}
+
+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.go

@@ -0,0 +1,647 @@
+// Copyright 2015 Matthew Holt and The Caddy Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package httpcaddyfile
+
+import (
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"sort"
+	"strings"
+
+	"github.com/caddyserver/caddy/v2"
+	"github.com/caddyserver/caddy/v2/caddyconfig"
+	"github.com/caddyserver/caddy/v2/caddyconfig/caddyfile"
+	"github.com/caddyserver/caddy/v2/modules/caddyhttp"
+	"github.com/caddyserver/caddy/v2/modules/caddytls"
+	"github.com/mholt/certmagic"
+)
+
+func init() {
+	caddyconfig.RegisterAdapter("caddyfile", caddyfile.Adapter{ServerType: ServerType{}})
+}
+
+// ServerType can set up a config from an HTTP Caddyfile.
+type ServerType struct {
+}
+
+// Setup makes a config from the tokens.
+func (st ServerType) Setup(originalServerBlocks []caddyfile.ServerBlock,
+	options map[string]interface{}) (*caddy.Config, []caddyconfig.Warning, error) {
+	var warnings []caddyconfig.Warning
+
+	var serverBlocks []serverBlock
+	for _, sblock := range originalServerBlocks {
+		serverBlocks = append(serverBlocks, serverBlock{
+			block: sblock,
+			pile:  make(map[string][]ConfigValue),
+		})
+	}
+
+	// global configuration
+	if len(serverBlocks) > 0 && len(serverBlocks[0].block.Keys) == 0 {
+		sb := serverBlocks[0]
+		for _, segment := range sb.block.Segments {
+			dir := segment.Directive()
+			var val interface{}
+			var err error
+			disp := caddyfile.NewDispenser(segment)
+			// TODO: make this switch into a map
+			switch dir {
+			case "http_port":
+				val, err = parseOptHTTPPort(disp)
+			case "https_port":
+				val, err = parseOptHTTPSPort(disp)
+			case "handler_order":
+				val, err = parseOptHandlerOrder(disp)
+			case "experimental_http3":
+				val, err = parseOptExperimentalHTTP3(disp)
+			case "storage":
+				val, err = parseOptStorage(disp)
+			case "acme_ca":
+				val, err = parseOptACMECA(disp)
+			case "email":
+				val, err = parseOptEmail(disp)
+			case "admin":
+				val, err = parseOptAdmin(disp)
+			default:
+				return nil, warnings, fmt.Errorf("unrecognized parameter name: %s", dir)
+			}
+			if err != nil {
+				return nil, warnings, fmt.Errorf("%s: %v", dir, err)
+			}
+			options[dir] = val
+		}
+		serverBlocks = serverBlocks[1:]
+	}
+
+	for _, sb := range serverBlocks {
+		// replace shorthand placeholders (which are
+		// convenient when writing a Caddyfile) with
+		// their actual placeholder identifiers or
+		// variable names
+		replacer := strings.NewReplacer(
+			"{uri}", "{http.request.uri}",
+			"{path}", "{http.request.uri.path}",
+			"{host}", "{http.request.host}",
+			"{hostport}", "{http.request.hostport}",
+			"{method}", "{http.request.method}",
+			"{scheme}", "{http.request.scheme}",
+			"{file}", "{http.request.uri.path.file}",
+			"{dir}", "{http.request.uri.path.dir}",
+			"{query}", "{http.request.uri.query_string}",
+		)
+		for _, segment := range sb.block.Segments {
+			for i := 0; i < len(segment); i++ {
+				segment[i].Text = replacer.Replace(segment[i].Text)
+			}
+		}
+
+		if len(sb.block.Keys) == 0 {
+			return nil, warnings, fmt.Errorf("server block without any key is global configuration, and if used, it must be first")
+		}
+
+		// extract matcher definitions
+		d := sb.block.DispenseDirective("matcher")
+		matcherDefs, err := parseMatcherDefinitions(d)
+		if err != nil {
+			return nil, warnings, err
+		}
+
+		for _, segment := range sb.block.Segments {
+			dir := segment.Directive()
+			if dir == "matcher" {
+				// TODO: This is a special case because we pre-processed it; handle this better
+				continue
+			}
+			if dirFunc, ok := registeredDirectives[dir]; ok {
+				results, err := dirFunc(Helper{
+					Dispenser:   caddyfile.NewDispenser(segment),
+					options:     options,
+					warnings:    &warnings,
+					matcherDefs: matcherDefs,
+					parentBlock: sb.block,
+				})
+				if err != nil {
+					return nil, warnings, fmt.Errorf("parsing caddyfile tokens for '%s': %v", dir, err)
+				}
+				for _, result := range results {
+					result.directive = dir
+					sb.pile[result.Class] = append(sb.pile[result.Class], result)
+				}
+			} else {
+				tkn := segment[0]
+				return nil, warnings, fmt.Errorf("%s:%d: unrecognized directive: %s", tkn.File, tkn.Line, dir)
+			}
+		}
+	}
+
+	// map
+	sbmap, err := st.mapAddressToServerBlocks(serverBlocks)
+	if err != nil {
+		return nil, warnings, err
+	}
+
+	// reduce
+	pairings := st.consolidateAddrMappings(sbmap)
+
+	// each pairing of listener addresses to list of server
+	// blocks is basically a server definition
+	servers, err := st.serversFromPairings(pairings, options, &warnings)
+	if err != nil {
+		return nil, warnings, err
+	}
+
+	// now that each server is configured, make the HTTP app
+	httpApp := caddyhttp.App{
+		HTTPPort:  tryInt(options["http_port"], &warnings),
+		HTTPSPort: tryInt(options["https_port"], &warnings),
+		Servers:   servers,
+	}
+
+	// now for the TLS app! (TODO: refactor into own func)
+	tlsApp := caddytls.TLS{CertificatesRaw: make(caddy.ModuleMap)}
+	for _, p := range pairings {
+		for i, sblock := range p.serverBlocks {
+			// tls automation policies
+			if mmVals, ok := sblock.pile["tls.automation_manager"]; ok {
+				for _, mmVal := range mmVals {
+					mm := mmVal.Value.(caddytls.ManagerMaker)
+					sblockHosts, err := st.autoHTTPSHosts(sblock)
+					if err != nil {
+						return nil, warnings, err
+					}
+					if len(sblockHosts) > 0 {
+						if tlsApp.Automation == nil {
+							tlsApp.Automation = new(caddytls.AutomationConfig)
+						}
+						tlsApp.Automation.Policies = append(tlsApp.Automation.Policies, caddytls.AutomationPolicy{
+							Hosts:         sblockHosts,
+							ManagementRaw: caddyconfig.JSONModuleObject(mm, "module", mm.(caddy.Module).CaddyModule().ID.Name(), &warnings),
+						})
+					} else {
+						warnings = append(warnings, caddyconfig.Warning{
+							Message: fmt.Sprintf("Server block %d %v has no names that qualify for automatic HTTPS, so no TLS automation policy will be added.", i, sblock.block.Keys),
+						})
+					}
+				}
+			}
+
+			// tls certificate loaders
+			if clVals, ok := sblock.pile["tls.certificate_loader"]; ok {
+				for _, clVal := range clVals {
+					loader := clVal.Value.(caddytls.CertificateLoader)
+					loaderName := caddy.GetModuleName(loader)
+					tlsApp.CertificatesRaw[loaderName] = caddyconfig.JSON(loader, &warnings)
+				}
+			}
+		}
+	}
+	// if global ACME CA or email were set, append a catch-all automation
+	// policy that ensures they will be used if no tls directive was used
+	acmeCA, hasACMECA := options["acme_ca"]
+	email, hasEmail := options["email"]
+	if hasACMECA || hasEmail {
+		if tlsApp.Automation == nil {
+			tlsApp.Automation = new(caddytls.AutomationConfig)
+		}
+		if !hasACMECA {
+			acmeCA = ""
+		}
+		if !hasEmail {
+			email = ""
+		}
+		tlsApp.Automation.Policies = append(tlsApp.Automation.Policies, caddytls.AutomationPolicy{
+			ManagementRaw: caddyconfig.JSONModuleObject(caddytls.ACMEManagerMaker{
+				CA:    acmeCA.(string),
+				Email: email.(string),
+			}, "module", "acme", &warnings),
+		})
+	}
+	if tlsApp.Automation != nil {
+		// consolidate automation policies that are the exact same
+		tlsApp.Automation.Policies = consolidateAutomationPolicies(tlsApp.Automation.Policies)
+	}
+
+	// if experimental HTTP/3 is enabled, enable it on each server
+	if enableH3, ok := options["experimental_http3"].(bool); ok && enableH3 {
+		for _, srv := range httpApp.Servers {
+			srv.ExperimentalHTTP3 = true
+		}
+	}
+
+	// annnd the top-level config, then we're done!
+	cfg := &caddy.Config{AppsRaw: make(caddy.ModuleMap)}
+	if !reflect.DeepEqual(httpApp, caddyhttp.App{}) {
+		cfg.AppsRaw["http"] = caddyconfig.JSON(httpApp, &warnings)
+	}
+	if !reflect.DeepEqual(tlsApp, caddytls.TLS{CertificatesRaw: make(caddy.ModuleMap)}) {
+		cfg.AppsRaw["tls"] = caddyconfig.JSON(tlsApp, &warnings)
+	}
+	if storageCvtr, ok := options["storage"].(caddy.StorageConverter); ok {
+		cfg.StorageRaw = caddyconfig.JSONModuleObject(storageCvtr,
+			"module",
+			storageCvtr.(caddy.Module).CaddyModule().ID.Name(),
+			&warnings)
+	}
+	if adminConfig, ok := options["admin"].(string); ok && adminConfig != "" {
+		cfg.Admin = &caddy.AdminConfig{Listen: adminConfig}
+	}
+
+	return cfg, warnings, nil
+}
+
+// hostsFromServerBlockKeys returns a list of all the
+// hostnames found in the keys of the server block sb.
+// The list may not be in a consistent order.
+func (st *ServerType) hostsFromServerBlockKeys(sb caddyfile.ServerBlock) ([]string, error) {
+	// first get each unique hostname
+	hostMap := make(map[string]struct{})
+	for _, sblockKey := range sb.Keys {
+		addr, err := ParseAddress(sblockKey)
+		if err != nil {
+			return nil, fmt.Errorf("parsing server block key: %v", err)
+		}
+		addr = addr.Normalize()
+		if addr.Host == "" {
+			continue
+		}
+		hostMap[addr.Host] = struct{}{}
+	}
+
+	// convert map to slice
+	sblockHosts := make([]string, 0, len(hostMap))
+	for host := range hostMap {
+		sblockHosts = append(sblockHosts, host)
+	}
+
+	return sblockHosts, nil
+}
+
+// serversFromPairings creates the servers for each pairing of addresses
+// to server blocks. Each pairing is essentially a server definition.
+func (st *ServerType) serversFromPairings(
+	pairings []sbAddrAssociation,
+	options map[string]interface{},
+	warnings *[]caddyconfig.Warning,
+) (map[string]*caddyhttp.Server, error) {
+	servers := make(map[string]*caddyhttp.Server)
+
+	for i, p := range pairings {
+		srv := &caddyhttp.Server{
+			Listen: p.addresses,
+		}
+
+		for _, sblock := range p.serverBlocks {
+			matcherSetsEnc, err := st.compileEncodedMatcherSets(sblock.block)
+			if err != nil {
+				return nil, fmt.Errorf("server block %v: compiling matcher sets: %v", sblock.block.Keys, err)
+			}
+
+			// if there are user-defined variables, then siteVarSubroute will
+			// wrap the handlerSubroute; otherwise handlerSubroute will be the
+			// site's primary subroute.
+			siteVarSubroute, handlerSubroute := new(caddyhttp.Subroute), new(caddyhttp.Subroute)
+
+			// tls: connection policies and toggle auto HTTPS
+
+			autoHTTPSQualifiedHosts, err := st.autoHTTPSHosts(sblock)
+			if err != nil {
+				return nil, err
+			}
+			if _, ok := sblock.pile["tls.off"]; ok && len(autoHTTPSQualifiedHosts) > 0 {
+				// tls off: disable TLS (and automatic HTTPS) for server block's names
+				if srv.AutoHTTPS == nil {
+					srv.AutoHTTPS = new(caddyhttp.AutoHTTPSConfig)
+				}
+				srv.AutoHTTPS.Skip = append(srv.AutoHTTPS.Skip, autoHTTPSQualifiedHosts...)
+			} else if cpVals, ok := sblock.pile["tls.connection_policy"]; ok {
+				// tls connection policies
+				for _, cpVal := range cpVals {
+					cp := cpVal.Value.(*caddytls.ConnectionPolicy)
+
+					// make sure the policy covers all hostnames from the block
+					hosts, err := st.hostsFromServerBlockKeys(sblock.block)
+					if err != nil {
+						return nil, err
+					}
+
+					// TODO: are matchers needed if every hostname of the config is matched?
+					if len(hosts) > 0 {
+						cp.MatchersRaw = caddy.ModuleMap{
+							"sni": caddyconfig.JSON(hosts, warnings), // make sure to match all hosts, not just auto-HTTPS-qualified ones
+						}
+					}
+					srv.TLSConnPolicies = append(srv.TLSConnPolicies, cp)
+				}
+				// TODO: consolidate equal conn policies
+			}
+
+			// vars: special routes that will have to wrap the normal handlers
+			// so that these variables can be used across their matchers too
+			for _, cfgVal := range sblock.pile["var"] {
+				siteVarSubroute.Routes = append(siteVarSubroute.Routes, cfgVal.Value.(caddyhttp.Route))
+			}
+
+			// set up each handler directive - the order of the handlers
+			// as they are added to the routes depends on user preference
+			dirRoutes := sblock.pile["route"]
+			handlerOrder, ok := options["handler_order"].([]string)
+			if !ok {
+				handlerOrder = defaultDirectiveOrder
+			}
+			if len(handlerOrder) == 1 && handlerOrder[0] == "appearance" {
+				handlerOrder = nil
+			}
+			if handlerOrder != nil {
+				dirPositions := make(map[string]int)
+				for i, dir := range handlerOrder {
+					dirPositions[dir] = i
+				}
+				sort.SliceStable(dirRoutes, func(i, j int) bool {
+					iDir, jDir := dirRoutes[i].directive, dirRoutes[j].directive
+					return dirPositions[iDir] < dirPositions[jDir]
+				})
+			}
+			for _, r := range dirRoutes {
+				handlerSubroute.Routes = append(handlerSubroute.Routes, r.Value.(caddyhttp.Route))
+			}
+
+			// the route that contains the site's handlers will
+			// be assumed to be the sub-route for this site...
+			siteSubroute := handlerSubroute
+
+			// ... unless, of course, there are variables that might
+			// be used by the site's matchers or handlers, in which
+			// case we need to nest the handlers in a sub-sub-route,
+			// and the variables go in the sub-route so the variables
+			// get evaluated first
+			if len(siteVarSubroute.Routes) > 0 {
+				subSubRoute := caddyhttp.Subroute{Routes: siteSubroute.Routes}
+				siteSubroute.Routes = append(
+					siteVarSubroute.Routes,
+					caddyhttp.Route{
+						HandlersRaw: []json.RawMessage{
+							caddyconfig.JSONModuleObject(subSubRoute, "handler", "subroute", warnings),
+						},
+					},
+				)
+			}
+
+			siteSubroute.Routes = consolidateRoutes(siteSubroute.Routes)
+
+			srv.Routes = append(srv.Routes, caddyhttp.Route{
+				MatcherSetsRaw: matcherSetsEnc,
+				HandlersRaw: []json.RawMessage{
+					caddyconfig.JSONModuleObject(siteSubroute, "handler", "subroute", warnings),
+				},
+			})
+		}
+
+		srv.Routes = consolidateRoutes(srv.Routes)
+
+		servers[fmt.Sprintf("srv%d", i)] = srv
+	}
+
+	return servers, nil
+}
+
+func (st ServerType) autoHTTPSHosts(sb serverBlock) ([]string, error) {
+	// get the hosts for this server block...
+	hosts, err := st.hostsFromServerBlockKeys(sb.block)
+	if err != nil {
+		return nil, err
+	}
+	// ...and of those, which ones qualify for auto HTTPS
+	var autoHTTPSQualifiedHosts []string
+	for _, h := range hosts {
+		if certmagic.HostQualifies(h) {
+			autoHTTPSQualifiedHosts = append(autoHTTPSQualifiedHosts, h)
+		}
+	}
+	return autoHTTPSQualifiedHosts, nil
+}
+
+// consolidateRoutes combines routes with the same properties
+// (same matchers, same Terminal and Group settings) for a
+// cleaner overall output.
+func consolidateRoutes(routes caddyhttp.RouteList) caddyhttp.RouteList {
+	for i := 0; i < len(routes)-1; i++ {
+		if reflect.DeepEqual(routes[i].MatcherSetsRaw, routes[i+1].MatcherSetsRaw) &&
+			routes[i].Terminal == routes[i+1].Terminal &&
+			routes[i].Group == routes[i+1].Group {
+			// keep the handlers in the same order, then splice out repetitive route
+			routes[i].HandlersRaw = append(routes[i].HandlersRaw, routes[i+1].HandlersRaw...)
+			routes = append(routes[:i+1], routes[i+2:]...)
+			i--
+		}
+	}
+	return routes
+}
+
+// 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 reflect.DeepEqual(aps[i].ManagementRaw, aps[j].ManagementRaw) {
+				aps[i].Hosts = append(aps[i].Hosts, aps[j].Hosts...)
+				aps = append(aps[:j], aps[j+1:]...)
+				i--
+				break
+			}
+		}
+	}
+	return aps
+}
+
+func matcherSetFromMatcherToken(
+	tkn caddyfile.Token,
+	matcherDefs map[string]caddy.ModuleMap,
+	warnings *[]caddyconfig.Warning,
+) (caddy.ModuleMap, bool, error) {
+	// matcher tokens can be wildcards, simple path matchers,
+	// or refer to a pre-defined matcher by some name
+	if tkn.Text == "*" {
+		// match all requests == no matchers, so nothing to do
+		return nil, true, nil
+	} else if strings.HasPrefix(tkn.Text, "/") || strings.HasPrefix(tkn.Text, "=/") {
+		// convenient way to specify a single path match
+		return caddy.ModuleMap{
+			"path": caddyconfig.JSON(caddyhttp.MatchPath{tkn.Text}, warnings),
+		}, true, nil
+	} else if strings.HasPrefix(tkn.Text, "match:") {
+		// pre-defined matcher
+		matcherName := strings.TrimPrefix(tkn.Text, "match:")
+		m, ok := matcherDefs[matcherName]
+		if !ok {
+			return nil, false, fmt.Errorf("unrecognized matcher name: %+v", matcherName)
+		}
+		return m, true, nil
+	}
+
+	return nil, false, nil
+}
+
+func (st *ServerType) compileEncodedMatcherSets(sblock caddyfile.ServerBlock) ([]caddy.ModuleMap, error) {
+	type hostPathPair struct {
+		hostm caddyhttp.MatchHost
+		pathm caddyhttp.MatchPath
+	}
+
+	// keep routes with common host and path matchers together
+	var matcherPairs []*hostPathPair
+
+	for _, key := range sblock.Keys {
+		addr, err := ParseAddress(key)
+		if err != nil {
+			return nil, fmt.Errorf("server block %v: parsing and standardizing address '%s': %v", sblock.Keys, key, err)
+		}
+		addr = addr.Normalize()
+
+		// choose a matcher pair that should be shared by this
+		// server block; if none exists yet, create one
+		var chosenMatcherPair *hostPathPair
+		for _, mp := range matcherPairs {
+			if (len(mp.pathm) == 0 && addr.Path == "") ||
+				(len(mp.pathm) == 1 && mp.pathm[0] == addr.Path) {
+				chosenMatcherPair = mp
+				break
+			}
+		}
+		if chosenMatcherPair == nil {
+			chosenMatcherPair = new(hostPathPair)
+			if addr.Path != "" {
+				chosenMatcherPair.pathm = []string{addr.Path}
+			}
+			matcherPairs = append(matcherPairs, chosenMatcherPair)
+		}
+
+		// add this server block's keys to the matcher
+		// pair if it doesn't already exist
+		if addr.Host != "" {
+			var found bool
+			for _, h := range chosenMatcherPair.hostm {
+				if h == addr.Host {
+					found = true
+					break
+				}
+			}
+			if !found {
+				chosenMatcherPair.hostm = append(chosenMatcherPair.hostm, addr.Host)
+			}
+		}
+	}
+
+	// iterate each pairing of host and path matchers and
+	// put them into a map for JSON encoding
+	var matcherSets []map[string]caddyhttp.RequestMatcher
+	for _, mp := range matcherPairs {
+		matcherSet := make(map[string]caddyhttp.RequestMatcher)
+		if len(mp.hostm) > 0 {
+			matcherSet["host"] = mp.hostm
+		}
+		if len(mp.pathm) > 0 {
+			matcherSet["path"] = mp.pathm
+		}
+		if len(matcherSet) > 0 {
+			matcherSets = append(matcherSets, matcherSet)
+		}
+	}
+
+	// finally, encode each of the matcher sets
+	var matcherSetsEnc []caddy.ModuleMap
+	for _, ms := range matcherSets {
+		msEncoded, err := encodeMatcherSet(ms)
+		if err != nil {
+			return nil, fmt.Errorf("server block %v: %v", sblock.Keys, err)
+		}
+		matcherSetsEnc = append(matcherSetsEnc, msEncoded)
+	}
+
+	return matcherSetsEnc, nil
+}
+
+func parseMatcherDefinitions(d *caddyfile.Dispenser) (map[string]caddy.ModuleMap, error) {
+	matchers := make(map[string]caddy.ModuleMap)
+	for d.Next() {
+		definitionName := d.Val()
+		for nesting := d.Nesting(); d.NextBlock(nesting); {
+			matcherName := d.Val()
+			mod, err := caddy.GetModule("http.matchers." + matcherName)
+			if err != nil {
+				return nil, fmt.Errorf("getting matcher module '%s': %v", matcherName, err)
+			}
+			unm, ok := mod.New().(caddyfile.Unmarshaler)
+			if !ok {
+				return nil, fmt.Errorf("matcher module '%s' is not a Caddyfile unmarshaler", matcherName)
+			}
+			err = unm.UnmarshalCaddyfile(d.NewFromNextTokens())
+			if err != nil {
+				return nil, err
+			}
+			rm, ok := unm.(caddyhttp.RequestMatcher)
+			if !ok {
+				return nil, fmt.Errorf("matcher module '%s' is not a request matcher", matcherName)
+			}
+			if _, ok := matchers[definitionName]; !ok {
+				matchers[definitionName] = make(caddy.ModuleMap)
+			}
+			matchers[definitionName][matcherName] = caddyconfig.JSON(rm, nil)
+		}
+	}
+	return matchers, nil
+}
+
+func encodeMatcherSet(matchers map[string]caddyhttp.RequestMatcher) (caddy.ModuleMap, error) {
+	msEncoded := make(caddy.ModuleMap)
+	for matcherName, val := range matchers {
+		jsonBytes, err := json.Marshal(val)
+		if err != nil {
+			return nil, fmt.Errorf("marshaling matcher set %#v: %v", matchers, err)
+		}
+		msEncoded[matcherName] = jsonBytes
+	}
+	return msEncoded, nil
+}
+
+// tryInt tries to convert val to an integer. If it fails,
+// it downgrades the error to a warning and returns 0.
+func tryInt(val interface{}, warnings *[]caddyconfig.Warning) int {
+	intVal, ok := val.(int)
+	if val != nil && !ok && warnings != nil {
+		*warnings = append(*warnings, caddyconfig.Warning{Message: "not an integer type"})
+	}
+	return intVal
+}
+
+type matcherSetAndTokens struct {
+	matcherSet caddy.ModuleMap
+	tokens     []caddyfile.Token
+}
+
+// sbAddrAssocation is a mapping from a list of
+// addresses to a list of server blocks that are
+// served on those addresses.
+type sbAddrAssociation struct {
+	addresses    []string
+	serverBlocks []serverBlock
+}
+
+// Interface guard
+var _ caddyfile.ServerType = (*ServerType)(nil)

caddyconfig/httpcaddyfile/options.go

@@ -0,0 +1,148 @@
+// 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"
+	"strconv"
+
+	"github.com/caddyserver/caddy/v2"
+	"github.com/caddyserver/caddy/v2/caddyconfig/caddyfile"
+)
+
+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 parseOptHandlerOrder(d *caddyfile.Dispenser) ([]string, error) {
+	if !d.Next() {
+		return nil, d.ArgErr()
+	}
+	order := d.RemainingArgs()
+	if len(order) == 1 && order[0] == "appearance" {
+		return []string{"appearance"}, nil
+	}
+	if len(order) > 0 && d.NextBlock(0) {
+		return nil, d.Err("cannot open block if there are arguments")
+	}
+	for d.NextBlock(0) {
+		order = append(order, d.Val())
+		if d.NextArg() {
+			return nil, d.ArgErr()
+		}
+	}
+	if len(order) == 0 {
+		return nil, d.ArgErr()
+	}
+	return order, 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, fmt.Errorf("getting storage module '%s': %v", modName, err)
+	}
+	unm, ok := mod.New().(caddyfile.Unmarshaler)
+	if !ok {
+		return nil, fmt.Errorf("storage module '%s' is not a Caddyfile unmarshaler", mod.ID)
+	}
+	err = unm.UnmarshalCaddyfile(d.NewFromNextTokens())
+	if err != nil {
+		return nil, err
+	}
+	storage, ok := unm.(caddy.StorageConverter)
+	if !ok {
+		return nil, fmt.Errorf("module %s is not a StorageConverter", mod.ID)
+	}
+	return storage, nil
+}
+
+func parseOptACMECA(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 parseOptEmail(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
+		d.AllArgs(&listenAddress)
+
+		if listenAddress == "" {
+			listenAddress = caddy.DefaultAdminListen
+		}
+
+		return listenAddress, nil
+	}
+	return "", nil
+}

caddyconfig/httpcaddyfile/parser_test.go

@@ -0,0 +1,66 @@
+// 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 (
+	"testing"
+
+	caddyfile "github.com/caddyserver/caddy/v2/caddyconfig/caddyfile"
+)
+
+func TestParse(t *testing.T) {
+
+	for i, tc := range []struct {
+		input       string
+		expectWarn  bool
+		expectError bool
+	}{
+		{
+			input: `http://localhost
+			matcher debug {
+			  query showdebug=1
+			}
+			`,
+			expectWarn:  false,
+			expectError: false,
+		},
+		{
+			input: `http://localhost
+			matcher 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
+		}
+	}
+}

caddyconfig/json5/json5.go

@@ -0,0 +1,43 @@
+// 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 json5adapter
+
+import (
+	"encoding/json"
+
+	"github.com/caddyserver/caddy/v2/caddyconfig"
+	"github.com/ilibs/json5"
+)
+
+func init() {
+	caddyconfig.RegisterAdapter("json5", Adapter{})
+}
+
+// Adapter adapts JSON5 to Caddy JSON.
+type Adapter struct{}
+
+// Adapt converts the JSON5 config in body to Caddy JSON.
+func (a Adapter) Adapt(body []byte, options map[string]interface{}) (result []byte, warnings []caddyconfig.Warning, err error) {
+	var decoded interface{}
+	err = json5.Unmarshal(body, &decoded)
+	if err != nil {
+		return
+	}
+	result, err = json.Marshal(decoded)
+	return
+}
+
+// Interface guard
+var _ caddyconfig.Adapter = (*Adapter)(nil)

caddyconfig/jsonc/jsonc.go

@@ -0,0 +1,49 @@
+// 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 jsoncadapter
+
+import (
+	"encoding/json"
+
+	"github.com/caddyserver/caddy/v2/caddyconfig"
+	"github.com/muhammadmuzzammil1998/jsonc"
+)
+
+func init() {
+	caddyconfig.RegisterAdapter("jsonc", Adapter{})
+}
+
+// Adapter adapts JSON-C to Caddy JSON.
+type Adapter struct{}
+
+// Adapt converts the JSON-C config in body to Caddy JSON.
+func (a Adapter) Adapt(body []byte, options map[string]interface{}) (result []byte, warnings []caddyconfig.Warning, err error) {
+	result = jsonc.ToJSON(body)
+
+	// any errors in the JSON will be
+	// reported during config load, but
+	// we can at least warn here that
+	// it is not valid JSON
+	if !json.Valid(result) {
+		warnings = append(warnings, caddyconfig.Warning{
+			Message: "Resulting JSON is invalid.",
+		})
+	}
+
+	return
+}
+
+// Interface guard
+var _ caddyconfig.Adapter = (*Adapter)(nil)

caddyfile/dispenser.go

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

caddyfile/json.go

@@ -1,198 +0,0 @@
-// Copyright 2015 Light Code Labs, LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package caddyfile
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"sort"
-	"strconv"
-	"strings"
-)
-
-const filename = "Caddyfile"
-
-// ToJSON converts caddyfile to its JSON representation.
-func ToJSON(caddyfile []byte) ([]byte, error) {
-	var j EncodedCaddyfile
-
-	serverBlocks, err := Parse(filename, bytes.NewReader(caddyfile), nil)
-	if err != nil {
-		return nil, err
-	}
-
-	for _, sb := range serverBlocks {
-		block := EncodedServerBlock{
-			Keys: sb.Keys,
-			Body: [][]interface{}{},
-		}
-
-		// Extract directives deterministically by sorting them
-		var directives = make([]string, len(sb.Tokens))
-		for dir := range sb.Tokens {
-			directives = append(directives, dir)
-		}
-		sort.Strings(directives)
-
-		// Convert each directive's tokens into our JSON structure
-		for _, dir := range directives {
-			disp := NewDispenserTokens(filename, sb.Tokens[dir])
-			for disp.Next() {
-				block.Body = append(block.Body, constructLine(&disp))
-			}
-		}
-
-		// tack this block onto the end of the list
-		j = append(j, block)
-	}
-
-	result, err := json.Marshal(j)
-	if err != nil {
-		return nil, err
-	}
-
-	return result, nil
-}
-
-// constructLine transforms tokens into a JSON-encodable structure;
-// but only one line at a time, to be used at the top-level of
-// a server block only (where the first token on each line is a
-// directive) - not to be used at any other nesting level.
-func constructLine(d *Dispenser) []interface{} {
-	var args []interface{}
-
-	args = append(args, d.Val())
-
-	for d.NextArg() {
-		if d.Val() == "{" {
-			args = append(args, constructBlock(d))
-			continue
-		}
-		args = append(args, d.Val())
-	}
-
-	return args
-}
-
-// constructBlock recursively processes tokens into a
-// JSON-encodable structure. To be used in a directive's
-// block. Goes to end of block.
-func constructBlock(d *Dispenser) [][]interface{} {
-	block := [][]interface{}{}
-
-	for d.Next() {
-		if d.Val() == "}" {
-			break
-		}
-		block = append(block, constructLine(d))
-	}
-
-	return block
-}
-
-// FromJSON converts JSON-encoded jsonBytes to Caddyfile text
-func FromJSON(jsonBytes []byte) ([]byte, error) {
-	var j EncodedCaddyfile
-	var result string
-
-	err := json.Unmarshal(jsonBytes, &j)
-	if err != nil {
-		return nil, err
-	}
-
-	for sbPos, sb := range j {
-		if sbPos > 0 {
-			result += "\n\n"
-		}
-		for i, key := range sb.Keys {
-			if i > 0 {
-				result += ", "
-			}
-			//result += standardizeScheme(key)
-			result += key
-		}
-		result += jsonToText(sb.Body, 1)
-	}
-
-	return []byte(result), nil
-}
-
-// jsonToText recursively transforms a scope of JSON into plain
-// Caddyfile text.
-func jsonToText(scope interface{}, depth int) string {
-	var result string
-
-	switch val := scope.(type) {
-	case string:
-		if strings.ContainsAny(val, "\" \n\t\r") {
-			result += `"` + strings.Replace(val, "\"", "\\\"", -1) + `"`
-		} else {
-			result += val
-		}
-	case int:
-		result += strconv.Itoa(val)
-	case float64:
-		result += fmt.Sprintf("%v", val)
-	case bool:
-		result += fmt.Sprintf("%t", val)
-	case [][]interface{}:
-		result += " {\n"
-		for _, arg := range val {
-			result += strings.Repeat("\t", depth) + jsonToText(arg, depth+1) + "\n"
-		}
-		result += strings.Repeat("\t", depth-1) + "}"
-	case []interface{}:
-		for i, v := range val {
-			if block, ok := v.([]interface{}); ok {
-				result += "{\n"
-				for _, arg := range block {
-					result += strings.Repeat("\t", depth) + jsonToText(arg, depth+1) + "\n"
-				}
-				result += strings.Repeat("\t", depth-1) + "}"
-				continue
-			}
-			result += jsonToText(v, depth)
-			if i < len(val)-1 {
-				result += " "
-			}
-		}
-	}
-
-	return result
-}
-
-// TODO: Will this function come in handy somewhere else?
-/*
-// standardizeScheme turns an address like host:https into https://host,
-// or "host:" into "host".
-func standardizeScheme(addr string) string {
-	if hostname, port, err := net.SplitHostPort(addr); err == nil {
-		if port == "http" || port == "https" {
-			addr = port + "://" + hostname
-		}
-	}
-	return strings.TrimSuffix(addr, ":")
-}
-*/
-
-// EncodedCaddyfile encapsulates a slice of EncodedServerBlocks.
-type EncodedCaddyfile []EncodedServerBlock
-
-// EncodedServerBlock represents a server block ripe for encoding.
-type EncodedServerBlock struct {
-	Keys []string        `json:"keys"`
-	Body [][]interface{} `json:"body"`
-}

caddyfile/json_test.go

@@ -1,178 +0,0 @@
-// Copyright 2015 Light Code Labs, LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package caddyfile
-
-import "testing"
-
-var tests = []struct {
-	caddyfile, json string
-}{
-	{ // 0
-		caddyfile: `foo {
-	root /bar
-}`,
-		json: `[{"keys":["foo"],"body":[["root","/bar"]]}]`,
-	},
-	{ // 1
-		caddyfile: `host1, host2 {
-	dir {
-		def
-	}
-}`,
-		json: `[{"keys":["host1","host2"],"body":[["dir",[["def"]]]]}]`,
-	},
-	{ // 2
-		caddyfile: `host1, host2 {
-	dir abc {
-		def ghi
-		jkl
-	}
-}`,
-		json: `[{"keys":["host1","host2"],"body":[["dir","abc",[["def","ghi"],["jkl"]]]]}]`,
-	},
-	{ // 3
-		caddyfile: `host1:1234, host2:5678 {
-	dir abc {
-	}
-}`,
-		json: `[{"keys":["host1:1234","host2:5678"],"body":[["dir","abc",[]]]}]`,
-	},
-	{ // 4
-		caddyfile: `host {
-	foo "bar baz"
-}`,
-		json: `[{"keys":["host"],"body":[["foo","bar baz"]]}]`,
-	},
-	{ // 5
-		caddyfile: `host, host:80 {
-	foo "bar \"baz\""
-}`,
-		json: `[{"keys":["host","host:80"],"body":[["foo","bar \"baz\""]]}]`,
-	},
-	{ // 6
-		caddyfile: `host {
-	foo "bar
-baz"
-}`,
-		json: `[{"keys":["host"],"body":[["foo","bar\nbaz"]]}]`,
-	},
-	{ // 7
-		caddyfile: `host {
-	dir 123 4.56 true
-}`,
-		json: `[{"keys":["host"],"body":[["dir","123","4.56","true"]]}]`, // NOTE: I guess we assume numbers and booleans should be encoded as strings...?
-	},
-	{ // 8
-		caddyfile: `http://host, https://host {
-}`,
-		json: `[{"keys":["http://host","https://host"],"body":[]}]`, // hosts in JSON are always host:port format (if port is specified), for consistency
-	},
-	{ // 9
-		caddyfile: `host {
-	dir1 a b
-	dir2 c d
-}`,
-		json: `[{"keys":["host"],"body":[["dir1","a","b"],["dir2","c","d"]]}]`,
-	},
-	{ // 10
-		caddyfile: `host {
-	dir a b
-	dir c d
-}`,
-		json: `[{"keys":["host"],"body":[["dir","a","b"],["dir","c","d"]]}]`,
-	},
-	{ // 11
-		caddyfile: `host {
-	dir1 a b
-	dir2 {
-		c
-		d
-	}
-}`,
-		json: `[{"keys":["host"],"body":[["dir1","a","b"],["dir2",[["c"],["d"]]]]}]`,
-	},
-	{ // 12
-		caddyfile: `host1 {
-	dir1
-}
-
-host2 {
-	dir2
-}`,
-		json: `[{"keys":["host1"],"body":[["dir1"]]},{"keys":["host2"],"body":[["dir2"]]}]`,
-	},
-}
-
-func TestToJSON(t *testing.T) {
-	for i, test := range tests {
-		output, err := ToJSON([]byte(test.caddyfile))
-		if err != nil {
-			t.Errorf("Test %d: %v", i, err)
-		}
-		if string(output) != test.json {
-			t.Errorf("Test %d\nExpected:\n'%s'\nActual:\n'%s'", i, test.json, string(output))
-		}
-	}
-}
-
-func TestFromJSON(t *testing.T) {
-	for i, test := range tests {
-		output, err := FromJSON([]byte(test.json))
-		if err != nil {
-			t.Errorf("Test %d: %v", i, err)
-		}
-		if string(output) != test.caddyfile {
-			t.Errorf("Test %d\nExpected:\n'%s'\nActual:\n'%s'", i, test.caddyfile, string(output))
-		}
-	}
-}
-
-// TODO: Will these tests come in handy somewhere else?
-/*
-func TestStandardizeAddress(t *testing.T) {
-	// host:https should be converted to https://host
-	output, err := ToJSON([]byte(`host:https`))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if expected, actual := `[{"keys":["https://host"],"body":[]}]`, string(output); expected != actual {
-		t.Errorf("Expected:\n'%s'\nActual:\n'%s'", expected, actual)
-	}
-
-	output, err = FromJSON([]byte(`[{"keys":["https://host"],"body":[]}]`))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if expected, actual := "https://host {\n}", string(output); expected != actual {
-		t.Errorf("Expected:\n'%s'\nActual:\n'%s'", expected, actual)
-	}
-
-	// host: should be converted to just host
-	output, err = ToJSON([]byte(`host:`))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if expected, actual := `[{"keys":["host"],"body":[]}]`, string(output); expected != actual {
-		t.Errorf("Expected:\n'%s'\nActual:\n'%s'", expected, actual)
-	}
-	output, err = FromJSON([]byte(`[{"keys":["host:"],"body":[]}]`))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if expected, actual := "host {\n}", string(output); expected != actual {
-		t.Errorf("Expected:\n'%s'\nActual:\n'%s'", expected, actual)
-	}
-}
-*/

caddyhttp/basicauth/basicauth.go

@@ -1,209 +0,0 @@
-// Copyright 2015 Light Code Labs, LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// Package basicauth implements HTTP Basic Authentication for Caddy.
-//
-// This is useful for simple protections on a website, like requiring
-// a password to access an admin interface. This package assumes a
-// fairly small threat model.
-package basicauth
-
-import (
-	"bufio"
-	"context"
-	"crypto/sha1"
-	"crypto/subtle"
-	"fmt"
-	"io"
-	"log"
-	"net/http"
-	"os"
-	"path/filepath"
-	"strings"
-	"sync"
-
-	"github.com/caddyserver/caddy/caddyhttp/httpserver"
-	"github.com/jimstudt/http-authentication/basic"
-)
-
-// BasicAuth is middleware to protect resources with a username and password.
-// Note that HTTP Basic Authentication is not secure by itself and should
-// not be used to protect important assets without HTTPS. Even then, the
-// security of HTTP Basic Auth is disputed. Use discretion when deciding
-// what to protect with BasicAuth.
-type BasicAuth struct {
-	Next     httpserver.Handler
-	SiteRoot string
-	Rules    []Rule
-}
-
-// ServeHTTP implements the httpserver.Handler interface.
-func (a BasicAuth) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error) {
-	var protected, isAuthenticated bool
-	var realm string
-	var username string
-	var password string
-	var ok bool
-
-	// do not check for basic auth on OPTIONS call
-	if r.Method == http.MethodOptions {
-		// Pass-through when no paths match
-		return a.Next.ServeHTTP(w, r)
-	}
-
-	for _, rule := range a.Rules {
-		for _, res := range rule.Resources {
-			if !httpserver.Path(r.URL.Path).Matches(res) {
-				continue
-			}
-
-			// path matches; this endpoint is protected
-			protected = true
-			realm = rule.Realm
-
-			// parse auth header
-			username, password, ok = r.BasicAuth()
-
-			// check credentials
-			if !ok ||
-				username != rule.Username ||
-				!rule.Password(password) {
-				continue
-			}
-
-			// by this point, authentication was successful
-			isAuthenticated = true
-
-			// let upstream middleware (e.g. fastcgi and cgi) know about authenticated
-			// user; this replaces the request with a wrapped instance
-			r = r.WithContext(context.WithValue(r.Context(),
-				httpserver.RemoteUserCtxKey, username))
-
-			// Provide username to be used in log by replacer
-			repl := httpserver.NewReplacer(r, nil, "-")
-			repl.Set("user", username)
-		}
-	}
-
-	if protected && !isAuthenticated {
-		// browsers show a message that says something like:
-		// "The website says: <realm>"
-		// which is kinda dumb, but whatever.
-		if realm == "" {
-			realm = "Restricted"
-		}
-		w.Header().Set("WWW-Authenticate", "Basic realm=\""+realm+"\"")
-
-		// Get a replacer so we can provide basic info for the authentication error.
-		repl := httpserver.NewReplacer(r, nil, "-")
-		repl.Set("user", username)
-		errstr := repl.Replace("BasicAuth: user \"{user}\" was not found or password was incorrect. {remote} {host} {uri} {proto}")
-		err := fmt.Errorf("%s", errstr)
-		return http.StatusUnauthorized, err
-	}
-
-	// Pass-through when no paths match
-	return a.Next.ServeHTTP(w, r)
-}
-
-// Rule represents a BasicAuth rule. A username and password
-// combination protect the associated resources, which are
-// file or directory paths.
-type Rule struct {
-	Username  string
-	Password  func(string) bool
-	Resources []string
-	Realm     string // See RFC 1945 and RFC 2617, default: "Restricted"
-}
-
-// PasswordMatcher determines whether a password matches a rule.
-type PasswordMatcher func(pw string) bool
-
-var (
-	htpasswords   map[string]map[string]PasswordMatcher
-	htpasswordsMu sync.Mutex
-)
-
-// GetHtpasswdMatcher matches password rules.
-func GetHtpasswdMatcher(filename, username, siteRoot string) (PasswordMatcher, error) {
-	filename = filepath.Join(siteRoot, filename)
-	htpasswordsMu.Lock()
-	if htpasswords == nil {
-		htpasswords = make(map[string]map[string]PasswordMatcher)
-	}
-	pm := htpasswords[filename]
-	if pm == nil {
-		fh, err := os.Open(filename)
-		if err != nil {
-			return nil, fmt.Errorf("open %q: %v", filename, err)
-		}
-		defer fh.Close()
-		pm = make(map[string]PasswordMatcher)
-		if err = parseHtpasswd(pm, fh); err != nil {
-			return nil, fmt.Errorf("parsing htpasswd %q: %v", fh.Name(), err)
-		}
-		htpasswords[filename] = pm
-	}
-	htpasswordsMu.Unlock()
-	if pm[username] == nil {
-		return nil, fmt.Errorf("username %q not found in %q", username, filename)
-	}
-	return pm[username], nil
-}
-
-func parseHtpasswd(pm map[string]PasswordMatcher, r io.Reader) error {
-	scanner := bufio.NewScanner(r)
-	for scanner.Scan() {
-		line := strings.TrimSpace(scanner.Text())
-		if line == "" || strings.IndexByte(line, '#') == 0 {
-			continue
-		}
-		i := strings.IndexByte(line, ':')
-		if i <= 0 {
-			return fmt.Errorf("malformed line, no color: %q", line)
-		}
-		user, encoded := line[:i], line[i+1:]
-		for _, p := range basic.DefaultSystems {
-			matcher, err := p(encoded)
-			if err != nil {
-				return err
-			}
-			if matcher != nil {
-				pm[user] = matcher.MatchesPassword
-				break
-			}
-		}
-	}
-	return scanner.Err()
-}
-
-// PlainMatcher returns a PasswordMatcher that does a constant-time
-// byte comparison against the password passw.
-func PlainMatcher(passw string) PasswordMatcher {
-	// compare hashes of equal length instead of actual password
-	// to avoid leaking password length
-	passwHash := sha1.New()
-	if _, err := passwHash.Write([]byte(passw)); err != nil {
-		log.Printf("[ERROR] unable to write password hash: %v", err)
-	}
-	passwSum := passwHash.Sum(nil)
-	return func(pw string) bool {
-		pwHash := sha1.New()
-		if _, err := pwHash.Write([]byte(pw)); err != nil {
-			log.Printf("[ERROR] unable to write password hash: %v", err)
-		}
-		pwSum := pwHash.Sum(nil)
-		return subtle.ConstantTimeCompare([]byte(pwSum), []byte(passwSum)) == 1
-	}
-}

caddyhttp/basicauth/basicauth_test.go

@@ -1,230 +0,0 @@
-// Copyright 2015 Light Code Labs, LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package basicauth
-
-import (
-	"encoding/base64"
-	"fmt"
-	"io/ioutil"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/caddyserver/caddy/caddyhttp/httpserver"
-)
-
-func TestBasicAuth(t *testing.T) {
-	var i int
-	// This handler is registered for tests in which the only authorized user is
-	// "okuser"
-	upstreamHandler := func(w http.ResponseWriter, r *http.Request) (int, error) {
-		remoteUser, _ := r.Context().Value(httpserver.RemoteUserCtxKey).(string)
-		if remoteUser != "okuser" {
-			t.Errorf("Test %d: expecting remote user 'okuser', got '%s'", i, remoteUser)
-		}
-		return http.StatusOK, nil
-	}
-	rws := []BasicAuth{
-		{
-			Next: httpserver.HandlerFunc(upstreamHandler),
-			Rules: []Rule{
-				{Username: "okuser", Password: PlainMatcher("okpass"),
-					Resources: []string{"/testing"}, Realm: "Resources"},
-			},
-		},
-		{
-			Next: httpserver.HandlerFunc(upstreamHandler),
-			Rules: []Rule{
-				{Username: "okuser", Password: PlainMatcher("okpass"),
-					Resources: []string{"/testing"}},
-			},
-		},
-	}
-
-	type testType struct {
-		from     string
-		result   int
-		user     string
-		password string
-		haserror bool
-	}
-
-	tests := []testType{
-		{"/testing", http.StatusOK, "okuser", "okpass", false},
-		{"/testing", http.StatusUnauthorized, "baduser", "okpass", true},
-		{"/testing", http.StatusUnauthorized, "okuser", "badpass", true},
-		{"/testing", http.StatusUnauthorized, "OKuser", "okpass", true},
-		{"/testing", http.StatusUnauthorized, "OKuser", "badPASS", true},
-		{"/testing", http.StatusUnauthorized, "", "okpass", true},
-		{"/testing", http.StatusUnauthorized, "okuser", "", true},
-		{"/testing", http.StatusUnauthorized, "", "", true},
-	}
-
-	var test testType
-	for _, rw := range rws {
-		expectRealm := rw.Rules[0].Realm
-		if expectRealm == "" {
-			expectRealm = "Restricted" // Default if Realm not specified in rule
-		}
-		for i, test = range tests {
-			req, err := http.NewRequest("GET", test.from, nil)
-			if err != nil {
-				t.Fatalf("Test %d: Could not create HTTP request: %v", i, err)
-			}
-			req.SetBasicAuth(test.user, test.password)
-
-			rec := httptest.NewRecorder()
-			result, err := rw.ServeHTTP(rec, req)
-			if err != nil {
-				if !test.haserror || !strings.HasPrefix(err.Error(), "BasicAuth: user") {
-					t.Fatalf("Test %d: Could not ServeHTTP: %v", i, err)
-				}
-			}
-			if result != test.result {
-				t.Errorf("Test %d: Expected status code %d but was %d",
-					i, test.result, result)
-			}
-			if test.result == http.StatusUnauthorized {
-				headers := rec.Header()
-				if val, ok := headers["Www-Authenticate"]; ok {
-					if got, want := val[0], "Basic realm=\""+expectRealm+"\""; got != want {
-						t.Errorf("Test %d: Www-Authenticate header should be '%s', got: '%s'", i, want, got)
-					}
-				} else {
-					t.Errorf("Test %d: response should have a 'Www-Authenticate' header", i)
-				}
-			} else {
-				if req.Header.Get("Authorization") == "" {
-					// see issue #1508: https://github.com/caddyserver/caddy/issues/1508
-					t.Errorf("Test %d: Expected Authorization header to be retained after successful auth, but was empty", i)
-				}
-			}
-		}
-	}
-}
-
-func TestMultipleOverlappingRules(t *testing.T) {
-	rw := BasicAuth{
-		Next: httpserver.HandlerFunc(contentHandler),
-		Rules: []Rule{
-			{Username: "t", Password: PlainMatcher("p1"), Resources: []string{"/t"}},
-			{Username: "t1", Password: PlainMatcher("p2"), Resources: []string{"/t/t"}},
-		},
-	}
-
-	tests := []struct {
-		from     string
-		result   int
-		cred     string
-		haserror bool
-	}{
-		{"/t", http.StatusOK, "t:p1", false},
-		{"/t/t", http.StatusOK, "t:p1", false},
-		{"/t/t", http.StatusOK, "t1:p2", false},
-		{"/a", http.StatusOK, "t1:p2", false},
-		{"/t/t", http.StatusUnauthorized, "t1:p3", true},
-		{"/t", http.StatusUnauthorized, "t1:p2", true},
-	}
-
-	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 {
-			if !test.haserror || !strings.HasPrefix(err.Error(), "BasicAuth: user") {
-				t.Fatalf("Test %d: Could not ServeHTTP %v", i, err)
-			}
-		}
-		if result != test.result {
-			t.Errorf("Test %d: Expected Header '%d' but was '%d'",
-				i, test.result, result)
-		}
-
-	}
-
-}
-
-func contentHandler(w http.ResponseWriter, r *http.Request) (int, error) {
-	fmt.Fprintf(w, r.URL.String())
-	return http.StatusOK, nil
-}
-
-func TestHtpasswd(t *testing.T) {
-	htpasswdPasswd := "IedFOuGmTpT8"
-	htpasswdFile := `sha1:{SHA}dcAUljwz99qFjYR0YLTXx0RqLww=
-md5:$apr1$l42y8rex$pOA2VJ0x/0TwaFeAF9nX61`
-
-	htfh, err := ioutil.TempFile("", "basicauth-")
-	if err != nil {
-		t.Skip("Error creating temp file, will skip htpassword test")
-		return
-	}
-	defer os.Remove(htfh.Name())
-	if _, err = htfh.Write([]byte(htpasswdFile)); err != nil {
-		t.Fatalf("write htpasswd file %q: %v", htfh.Name(), err)
-	}
-	htfh.Close()
-
-	for i, username := range []string{"sha1", "md5"} {
-		rule := Rule{Username: username, Resources: []string{"/testing"}}
-
-		siteRoot := filepath.Dir(htfh.Name())
-		filename := filepath.Base(htfh.Name())
-		if rule.Password, err = GetHtpasswdMatcher(filename, rule.Username, siteRoot); err != nil {
-			t.Fatalf("GetHtpasswdMatcher(%q, %q): %v", htfh.Name(), rule.Username, err)
-		}
-		t.Logf("%d. username=%q", i, rule.Username)
-		if !rule.Password(htpasswdPasswd) || rule.Password(htpasswdPasswd+"!") {
-			t.Errorf("%d (%s) password does not match.", i, rule.Username)
-		}
-	}
-}
-
-func TestOptionsMethod(t *testing.T) {
-	rw := BasicAuth{
-		Next: httpserver.HandlerFunc(contentHandler),
-		Rules: []Rule{
-			{Username: "username", Password: PlainMatcher("password"), Resources: []string{"/testing"}},
-		},
-	}
-
-	req, err := http.NewRequest(http.MethodOptions, "/testing", nil)
-	if err != nil {
-		t.Fatalf("Could not create HTTP request: %v", err)
-	}
-
-	// add basic auth with invalid username
-	// and password to make sure basic auth is ignored
-	req.SetBasicAuth("invaliduser", "invalidpassword")
-
-	rec := httptest.NewRecorder()
-	result, err := rw.ServeHTTP(rec, req)
-	if err != nil {
-		t.Fatalf("Could not ServeHTTP: %v", err)
-	}
-	if result != http.StatusOK {
-		t.Errorf("Expected status code %d but was %d", http.StatusOK, result)
-	}
-}

caddyhttp/basicauth/setup.go

@@ -1,113 +0,0 @@
-// Copyright 2015 Light Code Labs, LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package basicauth
-
-import (
-	"strings"
-
-	"github.com/caddyserver/caddy"
-	"github.com/caddyserver/caddy/caddyhttp/httpserver"
-)
-
-func init() {
-	caddy.RegisterPlugin("basicauth", caddy.Plugin{
-		ServerType: "http",
-		Action:     setup,
-	})
-}
-
-// setup configures a new BasicAuth middleware instance.
-func setup(c *caddy.Controller) error {
-	cfg := httpserver.GetConfig(c)
-	root := cfg.Root
-
-	rules, err := basicAuthParse(c)
-	if err != nil {
-		return err
-	}
-
-	basic := BasicAuth{Rules: rules}
-
-	cfg.AddMiddleware(func(next httpserver.Handler) httpserver.Handler {
-		basic.Next = next
-		basic.SiteRoot = root
-		return basic
-	})
-
-	return nil
-}
-
-func basicAuthParse(c *caddy.Controller) ([]Rule, error) {
-	var rules []Rule
-	cfg := httpserver.GetConfig(c)
-
-	var err error
-	for c.Next() {
-		var rule Rule
-
-		args := c.RemainingArgs()
-
-		switch len(args) {
-		case 2:
-			rule.Username = args[0]
-			if rule.Password, err = passwordMatcher(rule.Username, args[1], cfg.Root); err != nil {
-				return rules, c.Errf("Get password matcher from %s: %v", c.Val(), err)
-			}
-		case 3:
-			rule.Resources = append(rule.Resources, args[0])
-			rule.Username = args[1]
-			if rule.Password, err = passwordMatcher(rule.Username, args[2], cfg.Root); err != nil {
-				return rules, c.Errf("Get password matcher from %s: %v", c.Val(), err)
-			}
-		default:
-			return rules, c.ArgErr()
-		}
-
-		// If nested block is present, process it here
-		for c.NextBlock() {
-			val := c.Val()
-			args = c.RemainingArgs()
-			switch len(args) {
-			case 0:
-				// Assume single argument is path resource
-				rule.Resources = append(rule.Resources, val)
-			case 1:
-				if val == "realm" {
-					if rule.Realm == "" {
-						rule.Realm = strings.Replace(args[0], `"`, `\"`, -1)
-					} else {
-						return rules, c.Errf("\"realm\" subdirective can only be specified once")
-					}
-				} else {
-					return rules, c.Errf("expecting \"realm\", got \"%s\"", val)
-				}
-			default:
-				return rules, c.ArgErr()
-			}
-		}
-
-		rules = append(rules, rule)
-	}
-
-	return rules, nil
-}
-
-func passwordMatcher(username, passw, siteRoot string) (PasswordMatcher, error) {
-	htpasswdPrefix := "htpasswd="
-	if !strings.HasPrefix(passw, htpasswdPrefix) {
-		return PlainMatcher(passw), nil
-	}
-	return GetHtpasswdMatcher(passw[len(htpasswdPrefix):], username, siteRoot)
-}

caddyhttp/basicauth/setup_test.go

@@ -1,178 +0,0 @@
-// Copyright 2015 Light Code Labs, LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package basicauth
-
-import (
-	"fmt"
-	"io/ioutil"
-	"os"
-	"strings"
-	"testing"
-
-	"github.com/caddyserver/caddy"
-	"github.com/caddyserver/caddy/caddyhttp/httpserver"
-)
-
-func TestSetup(t *testing.T) {
-	c := caddy.NewTestController("http", `basicauth user pwd`)
-	err := setup(c)
-	if err != nil {
-		t.Errorf("Expected no errors, but got: %v", err)
-	}
-	mids := httpserver.GetConfig(c).Middleware()
-	if len(mids) == 0 {
-		t.Fatal("Expected middleware, got 0 instead")
-	}
-
-	handler := mids[0](httpserver.EmptyNext)
-	myHandler, ok := handler.(BasicAuth)
-	if !ok {
-		t.Fatalf("Expected handler to be type BasicAuth, got: %#v", handler)
-	}
-
-	if !httpserver.SameNext(myHandler.Next, httpserver.EmptyNext) {
-		t.Error("'Next' field of handler was not set properly")
-	}
-}
-
-func TestBasicAuthParse(t *testing.T) {
-	htpasswdPasswd := "IedFOuGmTpT8"
-	htpasswdFile := `sha1:{SHA}dcAUljwz99qFjYR0YLTXx0RqLww=
-md5:$apr1$l42y8rex$pOA2VJ0x/0TwaFeAF9nX61`
-
-	var skipHtpassword bool
-	htfh, err := ioutil.TempFile(".", "basicauth-")
-	if err != nil {
-		t.Logf("Error creating temp file (%v), will skip htpassword test", err)
-		skipHtpassword = true
-	} else {
-		if _, err = htfh.Write([]byte(htpasswdFile)); err != nil {
-			t.Fatalf("write htpasswd file %q: %v", htfh.Name(), err)
-		}
-		htfh.Close()
-		defer os.Remove(htfh.Name())
-	}
-
-	tests := []struct {
-		input     string
-		shouldErr bool
-		password  string
-		expected  []Rule
-	}{
-		{`basicauth user pwd`, false, "pwd", []Rule{
-			{Username: "user"},
-		}},
-		{`basicauth user pwd {
-		}`, false, "pwd", []Rule{
-			{Username: "user"},
-		}},
-		{`basicauth /resource1 user pwd {
-		}`, false, "pwd", []Rule{
-			{Username: "user", Resources: []string{"/resource1"}},
-		}},
-		{`basicauth /resource1 user pwd {
-			realm Resources
-		}`, false, "pwd", []Rule{
-			{Username: "user", Resources: []string{"/resource1"}, Realm: "Resources"},
-		}},
-		{`basicauth user pwd {
-			/resource1
-			/resource2
-		}`, false, "pwd", []Rule{
-			{Username: "user", Resources: []string{"/resource1", "/resource2"}},
-		}},
-		{`basicauth user pwd {
-			/resource1
-			/resource2
-			realm "Secure resources"
-		}`, false, "pwd", []Rule{
-			{Username: "user", Resources: []string{"/resource1", "/resource2"}, Realm: "Secure resources"},
-		}},
-		{`basicauth user pwd {
-			/resource1
-			realm "Secure resources"
-			realm Extra
-			/resource2
-		}`, true, "pwd", []Rule{}},
-		{`basicauth user pwd {
-			/resource1
-			foo "Resources"
-			/resource2
-		}`, true, "pwd", []Rule{}},
-		{`basicauth /resource user pwd`, false, "pwd", []Rule{
-			{Username: "user", Resources: []string{"/resource"}},
-		}},
-		{`basicauth /res1 user1 pwd1
-		  basicauth /res2 user2 pwd2`, false, "pwd", []Rule{
-			{Username: "user1", Resources: []string{"/res1"}},
-			{Username: "user2", Resources: []string{"/res2"}},
-		}},
-		{`basicauth user`, true, "", []Rule{}},
-		{`basicauth`, true, "", []Rule{}},
-		{`basicauth /resource user pwd asdf`, true, "", []Rule{}},
-
-		{`basicauth sha1 htpasswd=` + htfh.Name(), false, htpasswdPasswd, []Rule{
-			{Username: "sha1"},
-		}},
-	}
-
-	for i, test := range tests {
-		actual, err := basicAuthParse(caddy.NewTestController("http", test.input))
-
-		if err == nil && test.shouldErr {
-			t.Errorf("Test %d didn't error, but it should have", i)
-		} else if err != nil && !test.shouldErr {
-			t.Errorf("Test %d errored, but it shouldn't have; got '%v'", i, err)
-		}
-
-		if len(actual) != len(test.expected) {
-			t.Fatalf("Test %d expected %d rules, but got %d",
-				i, len(test.expected), len(actual))
-		}
-
-		for j, expectedRule := range test.expected {
-			actualRule := actual[j]
-
-			if actualRule.Username != expectedRule.Username {
-				t.Errorf("Test %d, rule %d: Expected username '%s', got '%s'",
-					i, j, expectedRule.Username, actualRule.Username)
-			}
-
-			if actualRule.Realm != expectedRule.Realm {
-				t.Errorf("Test %d, rule %d: Expected realm '%s', got '%s'",
-					i, j, expectedRule.Realm, actualRule.Realm)
-			}
-
-			if strings.Contains(test.input, "htpasswd=") && skipHtpassword {
-				continue
-			}
-			pwd := test.password
-			if len(actual) > 1 {
-				pwd = fmt.Sprintf("%s%d", pwd, j+1)
-			}
-			if !actualRule.Password(pwd) || actualRule.Password(test.password+"!") {
-				t.Errorf("Test %d, rule %d: Expected password '%v', got '%v'",
-					i, j, test.password, actualRule.Password(""))
-			}
-
-			expectedRes := fmt.Sprintf("%v", expectedRule.Resources)
-			actualRes := fmt.Sprintf("%v", actualRule.Resources)
-			if actualRes != expectedRes {
-				t.Errorf("Test %d, rule %d: Expected resource list %s, but got %s",
-					i, j, expectedRes, actualRes)
-			}
-		}
-	}
-}

caddyhttp/bind/bind_test.go

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

caddyhttp/browse/browse_test.go

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

caddyhttp/browse/setup_test.go

@@ -1,95 +0,0 @@
-// Copyright 2015 Light Code Labs, LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package browse
-
-import (
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"strconv"
-	"testing"
-	"time"
-
-	"github.com/caddyserver/caddy"
-	"github.com/caddyserver/caddy/caddyhttp/httpserver"
-)
-
-func TestSetup(t *testing.T) {
-	tempDirPath := os.TempDir()
-	_, err := os.Stat(tempDirPath)
-	if err != nil {
-		t.Fatalf("BeforeTest: Failed to find an existing directory for testing! Error was: %v", err)
-	}
-	nonExistentDirPath := filepath.Join(tempDirPath, strconv.Itoa(int(time.Now().UnixNano())))
-
-	tempTemplate, err := ioutil.TempFile(".", "tempTemplate")
-	if err != nil {
-		t.Fatalf("BeforeTest: Failed to create a temporary file in the working directory! Error was: %v", err)
-	}
-	defer os.Remove(tempTemplate.Name())
-
-	tempTemplatePath := filepath.Join(".", tempTemplate.Name())
-
-	for i, test := range []struct {
-		input             string
-		expectedPathScope []string
-		shouldErr         bool
-	}{
-		// test case #0 tests handling of multiple pathscopes
-		{"browse " + tempDirPath + "\n browse .", []string{tempDirPath, "."}, false},
-
-		// test case #1 tests instantiation of Config with default values
-		{"browse /", []string{"/"}, false},
-
-		// test case #2 tests detection of custom template
-		{"browse . " + tempTemplatePath, []string{"."}, false},
-
-		// test case #3 tests detection of non-existent template
-		{"browse . " + nonExistentDirPath, nil, true},
-
-		// test case #4 tests detection of duplicate pathscopes
-		{"browse " + tempDirPath + "\n browse " + tempDirPath, nil, true},
-	} {
-
-		c := caddy.NewTestController("http", test.input)
-		err := setup(c)
-		if err != nil && !test.shouldErr {
-			t.Errorf("Test case #%d received an error of %v", i, err)
-		}
-		if test.expectedPathScope == nil {
-			continue
-		}
-		mids := httpserver.GetConfig(c).Middleware()
-		mid := mids[len(mids)-1]
-		receivedConfigs := mid(nil).(Browse).Configs
-		for j, config := range receivedConfigs {
-			if config.PathScope != test.expectedPathScope[j] {
-				t.Errorf("Test case #%d expected a pathscope of %v, but got %v", i, test.expectedPathScope, config.PathScope)
-			}
-		}
-	}
-
-	// test case #6 tests startup with missing root directory in combination with default browse settings
-	controller := caddy.NewTestController("http", "browse")
-	cfg := httpserver.GetConfig(controller)
-
-	// Make sure non-existent root path doesn't return error
-	cfg.Root = nonExistentDirPath
-	err = setup(controller)
-
-	if err != nil {
-		t.Errorf("Test for non-existent browse path received an error, but shouldn't have: %v", err)
-	}
-}

caddyhttp/browse/testdata/header.html

@@ -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/hidden.html

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

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/test1/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,49 +0,0 @@
-// Copyright 2015 Light Code Labs, LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package caddyhttp
-
-import (
-	// plug in the server
-	_ "github.com/caddyserver/caddy/caddyhttp/httpserver"
-
-	// plug in the standard directives
-	_ "github.com/caddyserver/caddy/caddyhttp/basicauth"
-	_ "github.com/caddyserver/caddy/caddyhttp/bind"
-	_ "github.com/caddyserver/caddy/caddyhttp/browse"
-	_ "github.com/caddyserver/caddy/caddyhttp/errors"
-	_ "github.com/caddyserver/caddy/caddyhttp/expvar"
-	_ "github.com/caddyserver/caddy/caddyhttp/extensions"
-	_ "github.com/caddyserver/caddy/caddyhttp/fastcgi"
-	_ "github.com/caddyserver/caddy/caddyhttp/gzip"
-	_ "github.com/caddyserver/caddy/caddyhttp/header"
-	_ "github.com/caddyserver/caddy/caddyhttp/index"
-	_ "github.com/caddyserver/caddy/caddyhttp/internalsrv"
-	_ "github.com/caddyserver/caddy/caddyhttp/limits"
-	_ "github.com/caddyserver/caddy/caddyhttp/log"
-	_ "github.com/caddyserver/caddy/caddyhttp/markdown"
-	_ "github.com/caddyserver/caddy/caddyhttp/mime"
-	_ "github.com/caddyserver/caddy/caddyhttp/pprof"
-	_ "github.com/caddyserver/caddy/caddyhttp/proxy"
-	_ "github.com/caddyserver/caddy/caddyhttp/push"
-	_ "github.com/caddyserver/caddy/caddyhttp/redirect"
-	_ "github.com/caddyserver/caddy/caddyhttp/requestid"
-	_ "github.com/caddyserver/caddy/caddyhttp/rewrite"
-	_ "github.com/caddyserver/caddy/caddyhttp/root"
-	_ "github.com/caddyserver/caddy/caddyhttp/status"
-	_ "github.com/caddyserver/caddy/caddyhttp/templates"
-	_ "github.com/caddyserver/caddy/caddyhttp/timeouts"
-	_ "github.com/caddyserver/caddy/caddyhttp/websocket"
-	_ "github.com/caddyserver/caddy/onevent"
-)

caddyhttp/caddyhttp_test.go

@@ -1,33 +0,0 @@
-// Copyright 2015 Light Code Labs, LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package caddyhttp
-
-import (
-	"strings"
-	"testing"
-
-	"github.com/caddyserver/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 := 32 // importing caddyhttp plugs in this many plugins
-	s := caddy.DescribePlugins()
-	if got, want := strings.Count(s, "\n"), numStandardPlugins+4; got != want {
-		t.Errorf("Expected all standard plugins to be plugged in, got:\n%s", s)
-	}
-}

caddyhttp/errors/errors.go

@@ -1,159 +0,0 @@
-// Copyright 2015 Light Code Labs, LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// Package errors implements an HTTP error handling middleware.
-package errors
-
-import (
-	"fmt"
-	"io"
-	"net/http"
-	"os"
-	"runtime"
-	"strings"
-
-	"github.com/caddyserver/caddy"
-	"github.com/caddyserver/caddy/caddyhttp/httpserver"
-)
-
-func init() {
-	caddy.RegisterPlugin("errors", caddy.Plugin{
-		ServerType: "http",
-		Action:     setup,
-	})
-}
-
-// ErrorHandler handles HTTP errors (and errors from other middleware).
-type ErrorHandler struct {
-	Next             httpserver.Handler
-	GenericErrorPage string         // default error page filename
-	ErrorPages       map[int]string // map of status code to filename
-	Log              *httpserver.Logger
-	Debug            bool // if true, errors are written out to client rather than to a log
-}
-
-func (h ErrorHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error) {
-	defer h.recovery(w, r)
-
-	status, err := h.Next.ServeHTTP(w, r)
-
-	if err != nil {
-		errMsg := fmt.Sprintf("[ERROR %d %s] %v", 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("[NOTICE %d %s] could not load error page: %v", 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("[NOTICE %d %s] could not respond with %s: %v", 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 := "/github.com/caddyserver/caddy/"
-	pkgPathPos := strings.Index(file, delim)
-	if pkgPathPos > -1 && len(file) > pkgPathPos+len(delim) {
-		file = file[pkgPathPos+len(delim):]
-	}
-
-	panicMsg := fmt.Sprintf("[PANIC %s] %s:%d - %v", 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)
-	}
-}

caddyhttp/errors/errors_test.go

@@ -1,272 +0,0 @@
-// Copyright 2015 Light Code Labs, LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package errors
-
-import (
-	"bytes"
-	"errors"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"path/filepath"
-	"strconv"
-	"strings"
-	"testing"
-
-	"github.com/caddyserver/caddy/caddyhttp/httpserver"
-)
-
-func TestErrors(t *testing.T) {
-	// create a temporary page
-	const content = "This is a error page"
-
-	path, err := createErrorPageFile("errors_test.html", content)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.Remove(path)
-
-	buf := bytes.Buffer{}
-	em := ErrorHandler{
-		ErrorPages: map[int]string{
-			http.StatusNotFound:  path,
-			http.StatusForbidden: "not_exist_file",
-		},
-		Log: httpserver.NewTestLogger(&buf),
-	}
-	_, notExistErr := os.Open("not_exist_file")
-
-	testErr := errors.New("test error")
-	tests := []struct {
-		next         httpserver.Handler
-		expectedCode int
-		expectedBody string
-		expectedLog  string
-		expectedErr  error
-	}{
-		{
-			next:         genErrorHandler(http.StatusOK, nil, "normal"),
-			expectedCode: http.StatusOK,
-			expectedBody: "normal",
-			expectedLog:  "",
-			expectedErr:  nil,
-		},
-		{
-			next:         genErrorHandler(http.StatusMovedPermanently, testErr, ""),
-			expectedCode: http.StatusMovedPermanently,
-			expectedBody: "",
-			expectedLog:  fmt.Sprintf("[ERROR %d %s] %v\n", http.StatusMovedPermanently, "/", testErr),
-			expectedErr:  testErr,
-		},
-		{
-			next:         genErrorHandler(http.StatusBadRequest, nil, ""),
-			expectedCode: 0,
-			expectedBody: fmt.Sprintf("%d %s\n", http.StatusBadRequest,
-				http.StatusText(http.StatusBadRequest)),
-			expectedLog: "",
-			expectedErr: nil,
-		},
-		{
-			next:         genErrorHandler(http.StatusNotFound, nil, ""),
-			expectedCode: 0,
-			expectedBody: content,
-			expectedLog:  "",
-			expectedErr:  nil,
-		},
-		{
-			next:         genErrorHandler(http.StatusForbidden, nil, ""),
-			expectedCode: 0,
-			expectedBody: fmt.Sprintf("%d %s\n", http.StatusForbidden,
-				http.StatusText(http.StatusForbidden)),
-			expectedLog: fmt.Sprintf("[NOTICE %d /] could not load error page: %v\n",
-				http.StatusForbidden, notExistErr),
-			expectedErr: nil,
-		},
-	}
-
-	req, err := http.NewRequest("GET", "/", nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	for i, test := range tests {
-		em.Next = test.next
-		buf.Reset()
-		rec := httptest.NewRecorder()
-		code, err := em.ServeHTTP(rec, req)
-
-		if err != test.expectedErr {
-			t.Errorf("Test %d: Expected error %v, but got %v",
-				i, test.expectedErr, err)
-		}
-		if code != test.expectedCode {
-			t.Errorf("Test %d: Expected status code %d, but got %d",
-				i, test.expectedCode, code)
-		}
-		if body := rec.Body.String(); body != test.expectedBody {
-			t.Errorf("Test %d: Expected body %q, but got %q",
-				i, test.expectedBody, body)
-		}
-		if log := buf.String(); !strings.Contains(log, test.expectedLog) {
-			t.Errorf("Test %d: Expected log %q, but got %q",
-				i, test.expectedLog, log)
-		}
-	}
-}
-
-func TestVisibleErrorWithPanic(t *testing.T) {
-	const panicMsg = "I'm a panic"
-	eh := ErrorHandler{
-		ErrorPages: make(map[int]string),
-		Debug:      true,
-		Next: httpserver.HandlerFunc(func(w http.ResponseWriter, r *http.Request) (int, error) {
-			panic(panicMsg)
-		}),
-	}
-
-	req, err := http.NewRequest("GET", "/", nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	rec := httptest.NewRecorder()
-
-	code, err := eh.ServeHTTP(rec, req)
-
-	if code != 0 {
-		t.Errorf("Expected error handler to return 0 (it should write to response), got status %d", code)
-	}
-	if err != nil {
-		t.Errorf("Expected error handler to return nil error (it should panic!), but got '%v'", err)
-	}
-
-	body := rec.Body.String()
-
-	if !strings.Contains(body, "[PANIC /] caddyhttp/errors/errors_test.go") {
-		t.Errorf("Expected response body to contain error log line, but it didn't:\n%s", body)
-	}
-	if !strings.Contains(body, panicMsg) {
-		t.Errorf("Expected response body to contain panic message, but it didn't:\n%s", body)
-	}
-	if len(body) < 500 {
-		t.Errorf("Expected response body to contain stack trace, but it was too short: len=%d", len(body))
-	}
-}
-
-func TestGenericErrorPage(t *testing.T) {
-	// create temporary generic error page
-	const genericErrorContent = "This is a generic error page"
-
-	genericErrorPagePath, err := createErrorPageFile("generic_error_test.html", genericErrorContent)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.Remove(genericErrorPagePath)
-
-	// create temporary error page
-	const notFoundErrorContent = "This is a error page"
-
-	notFoundErrorPagePath, err := createErrorPageFile("not_found.html", notFoundErrorContent)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.Remove(notFoundErrorPagePath)
-
-	buf := bytes.Buffer{}
-	em := ErrorHandler{
-		GenericErrorPage: genericErrorPagePath,
-		ErrorPages: map[int]string{
-			http.StatusNotFound: notFoundErrorPagePath,
-		},
-		Log: httpserver.NewTestLogger(&buf),
-	}
-
-	tests := []struct {
-		next         httpserver.Handler
-		expectedCode int
-		expectedBody string
-		expectedLog  string
-		expectedErr  error
-	}{
-		{
-			next:         genErrorHandler(http.StatusNotFound, nil, ""),
-			expectedCode: 0,
-			expectedBody: notFoundErrorContent,
-			expectedLog:  "",
-			expectedErr:  nil,
-		},
-		{
-			next:         genErrorHandler(http.StatusInternalServerError, nil, ""),
-			expectedCode: 0,
-			expectedBody: genericErrorContent,
-			expectedLog:  "",
-			expectedErr:  nil,
-		},
-	}
-
-	req, err := http.NewRequest("GET", "/", nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	for i, test := range tests {
-		em.Next = test.next
-		buf.Reset()
-		rec := httptest.NewRecorder()
-		code, err := em.ServeHTTP(rec, req)
-
-		if err != test.expectedErr {
-			t.Errorf("Test %d: Expected error %v, but got %v",
-				i, test.expectedErr, err)
-		}
-		if code != test.expectedCode {
-			t.Errorf("Test %d: Expected status code %d, but got %d",
-				i, test.expectedCode, code)
-		}
-		if body := rec.Body.String(); body != test.expectedBody {
-			t.Errorf("Test %d: Expected body %q, but got %q",
-				i, test.expectedBody, body)
-		}
-		if log := buf.String(); !strings.Contains(log, test.expectedLog) {
-			t.Errorf("Test %d: Expected log %q, but got %q",
-				i, test.expectedLog, log)
-		}
-	}
-}
-
-func genErrorHandler(status int, err error, body string) httpserver.Handler {
-	return httpserver.HandlerFunc(func(w http.ResponseWriter, r *http.Request) (int, error) {
-		if len(body) > 0 {
-			w.Header().Set("Content-Length", strconv.Itoa(len(body)))
-			fmt.Fprint(w, body)
-		}
-		return status, err
-	})
-}
-
-func createErrorPageFile(name string, content string) (string, error) {
-	errorPageFilePath := filepath.Join(os.TempDir(), name)
-	f, err := os.Create(errorPageFilePath)
-	if err != nil {
-		return "", err
-	}
-
-	_, err = f.WriteString(content)
-	if err != nil {
-		return "", err
-	}
-	f.Close()
-
-	return errorPageFilePath, nil
-}

caddyhttp/errors/setup.go

@@ -1,138 +0,0 @@
-// Copyright 2015 Light Code Labs, LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package errors
-
-import (
-	"log"
-	"os"
-	"path/filepath"
-	"strconv"
-
-	"github.com/caddyserver/caddy"
-	"github.com/caddyserver/caddy/caddyhttp/httpserver"
-)
-
-// setup configures a new errors middleware instance.
-func setup(c *caddy.Controller) error {
-	handler, err := errorsParse(c)
-
-	if err != nil {
-		return err
-	}
-
-	handler.Log.Attach(c)
-
-	httpserver.GetConfig(c).AddMiddleware(func(next httpserver.Handler) httpserver.Handler {
-		handler.Next = next
-		return handler
-	})
-
-	return nil
-}
-
-func errorsParse(c *caddy.Controller) (*ErrorHandler, error) {
-
-	// Very important that we make a pointer because the startup
-	// function that opens the log file must have access to the
-	// same instance of the handler, not a copy.
-	handler := &ErrorHandler{
-		ErrorPages: make(map[int]string),
-		Log:        &httpserver.Logger{},
-	}
-
-	cfg := httpserver.GetConfig(c)
-
-	optionalBlock := func() error {
-		for c.NextBlock() {
-
-			what := c.Val()
-			where := c.RemainingArgs()
-
-			if httpserver.IsLogRollerSubdirective(what) {
-				var err error
-				err = httpserver.ParseRoller(handler.Log.Roller, what, where...)
-				if err != nil {
-					return err
-				}
-			} else {
-				if len(where) != 1 {
-					return c.ArgErr()
-				}
-				where := where[0]
-
-				// Error page; ensure it exists
-				if !filepath.IsAbs(where) {
-					where = filepath.Join(cfg.Root, where)
-				}
-
-				f, err := os.Open(where)
-				if err != nil {
-					log.Printf("[WARNING] Unable to open error page '%s': %v", where, err)
-				}
-				f.Close()
-
-				if what == "*" {
-					if handler.GenericErrorPage != "" {
-						return c.Errf("Duplicate status code entry: %s", what)
-					}
-					handler.GenericErrorPage = where
-				} else {
-					whatInt, err := strconv.Atoi(what)
-					if err != nil {
-						return c.Err("Expecting a numeric status code or '*', got '" + what + "'")
-					}
-
-					if _, exists := handler.ErrorPages[whatInt]; exists {
-						return c.Errf("Duplicate status code entry: %s", what)
-					}
-
-					handler.ErrorPages[whatInt] = where
-				}
-			}
-		}
-		return nil
-	}
-
-	for c.Next() {
-		// weird hack to avoid having the handler values overwritten.
-		if c.Val() == "}" {
-			continue
-		}
-
-		args := c.RemainingArgs()
-
-		if len(args) == 1 {
-			switch args[0] {
-			case "visible":
-				handler.Debug = true
-			default:
-				handler.Log.Output = args[0]
-				handler.Log.Roller = httpserver.DefaultLogRoller()
-			}
-		}
-
-		if len(args) > 1 {
-			return handler, c.Errf("Only 1 Argument expected for errors directive")
-		}
-
-		// Configuration may be in a block
-		err := optionalBlock()
-		if err != nil {
-			return handler, err
-		}
-	}
-
-	return handler, nil
-}

caddyhttp/errors/setup_test.go

@@ -1,204 +0,0 @@
-// Copyright 2015 Light Code Labs, LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package errors
-
-import (
-	"path/filepath"
-	"reflect"
-	"testing"
-
-	"github.com/caddyserver/caddy"
-	"github.com/caddyserver/caddy/caddyhttp/httpserver"
-)
-
-func TestSetup(t *testing.T) {
-	c := caddy.NewTestController("http", `errors`)
-	err := setup(c)
-	if err != nil {
-		t.Errorf("Expected no errors, got: %v", err)
-	}
-	mids := httpserver.GetConfig(c).Middleware()
-	if len(mids) == 0 {
-		t.Fatal("Expected middlewares, was nil instead")
-	}
-
-	handler := mids[0](httpserver.EmptyNext)
-	myHandler, ok := handler.(*ErrorHandler)
-	if !ok {
-		t.Fatalf("Expected handler to be type ErrorHandler, got: %#v", handler)
-	}
-
-	expectedLogger := &httpserver.Logger{}
-
-	if !reflect.DeepEqual(expectedLogger, myHandler.Log) {
-		t.Errorf("Expected '%v' as the default Log, got: '%v'", expectedLogger, myHandler.Log)
-	}
-
-	if !httpserver.SameNext(myHandler.Next, httpserver.EmptyNext) {
-		t.Error("'Next' field of handler was not set properly")
-	}
-
-	// Test Startup function -- TODO
-	// if len(c.Startup) == 0 {
-	// 	t.Fatal("Expected 1 startup function, had 0")
-	// }
-	// c.Startup[0]()
-	// if myHandler.Log == nil {
-	// 	t.Error("Expected Log to be non-nil after startup because Debug is not enabled")
-	// }
-}
-
-func TestErrorsParse(t *testing.T) {
-	testAbs, err := filepath.Abs("./404.html")
-	if err != nil {
-		t.Error(err)
-	}
-	tests := []struct {
-		inputErrorsRules     string
-		shouldErr            bool
-		expectedErrorHandler ErrorHandler
-	}{
-		{`errors`, false, ErrorHandler{
-			ErrorPages: map[int]string{},
-			Log:        &httpserver.Logger{},
-		}},
-		{`errors errors.txt`, false, ErrorHandler{
-			ErrorPages: map[int]string{},
-			Log: &httpserver.Logger{
-				Output: "errors.txt",
-				Roller: httpserver.DefaultLogRoller(),
-			},
-		}},
-		{`errors visible`, false, ErrorHandler{
-			ErrorPages: map[int]string{},
-			Debug:      true,
-			Log:        &httpserver.Logger{},
-		}},
-		{`errors errors.txt {
-        404 404.html
-        500 500.html
-}`, false, ErrorHandler{
-			ErrorPages: map[int]string{
-				404: "404.html",
-				500: "500.html",
-			},
-			Log: &httpserver.Logger{
-				Output: "errors.txt",
-				Roller: httpserver.DefaultLogRoller(),
-			},
-		}},
-		{`errors errors.txt {
-			rotate_size 2
-			rotate_age 10
-			rotate_keep 3
-			rotate_compress
-		}`, false, ErrorHandler{
-			ErrorPages: map[int]string{},
-			Log: &httpserver.Logger{
-				Output: "errors.txt", Roller: &httpserver.LogRoller{
-					MaxSize:    2,
-					MaxAge:     10,
-					MaxBackups: 3,
-					Compress:   true,
-					LocalTime:  true,
-				},
-			},
-		}},
-		{`errors errors.txt {
-		rotate_size 3
-		rotate_age 11
-		rotate_keep 5
-        404 404.html
-        503 503.html
-}`, false, ErrorHandler{
-			ErrorPages: map[int]string{
-				404: "404.html",
-				503: "503.html",
-			},
-			Log: &httpserver.Logger{
-				Output: "errors.txt",
-				Roller: &httpserver.LogRoller{
-					MaxSize:    3,
-					MaxAge:     11,
-					MaxBackups: 5,
-					Compress:   false,
-					LocalTime:  true,
-				},
-			},
-		}},
-		{`errors errors.txt {
-        * generic_error.html
-        404 404.html
-        503 503.html
-}`, false, ErrorHandler{
-			Log: &httpserver.Logger{
-				Output: "errors.txt",
-				Roller: httpserver.DefaultLogRoller(),
-			},
-			GenericErrorPage: "generic_error.html",
-			ErrorPages: map[int]string{
-				404: "404.html",
-				503: "503.html",
-			},
-		}},
-		// test absolute file path
-		{`errors {
-			404 ` + testAbs + `
-		}`,
-			false, ErrorHandler{
-				ErrorPages: map[int]string{
-					404: testAbs,
-				},
-				Log: &httpserver.Logger{},
-			}},
-		{`errors errors.txt { rotate_size 2 rotate_age 10 rotate_keep 3 rotate_compress }`,
-			true, ErrorHandler{ErrorPages: map[int]string{}, Log: &httpserver.Logger{}}},
-		{`errors errors.txt {
-			rotate_compress invalid
-		}`,
-			true, ErrorHandler{ErrorPages: map[int]string{}, Log: &httpserver.Logger{}}},
-		// Next two test cases is the detection of duplicate status codes
-		{`errors {
-			503 503.html
-			503 503.html
-		}`, true, ErrorHandler{ErrorPages: map[int]string{}, Log: &httpserver.Logger{}}},
-
-		{`errors {
-			* generic_error.html
-			* generic_error.html
-		}`, true, ErrorHandler{ErrorPages: map[int]string{}, Log: &httpserver.Logger{}}},
-		{`errors /path error.txt {
-			404 
-		}`, true, ErrorHandler{ErrorPages: map[int]string{}, Log: &httpserver.Logger{}}},
-
-		{`errors /path error.txt`, true, ErrorHandler{ErrorPages: map[int]string{}, Log: &httpserver.Logger{}}},
-	}
-
-	for i, test := range tests {
-		actualErrorsRule, err := errorsParse(caddy.NewTestController("http", test.inputErrorsRules))
-
-		if err == nil && test.shouldErr {
-			t.Errorf("Test %d didn't error, but it should have", i)
-		} else if err != nil && !test.shouldErr {
-			t.Errorf("Test %d errored, but it shouldn't have; got '%v'", i, err)
-		} else if err != nil && test.shouldErr {
-			continue
-		}
-		if !reflect.DeepEqual(actualErrorsRule, &test.expectedErrorHandler) {
-			t.Errorf("Test %d expect %v, but got %v", i,
-				test.expectedErrorHandler, actualErrorsRule)
-		}
-	}
-}

caddyhttp/expvar/expvar.go

@@ -1,59 +0,0 @@
-// Copyright 2015 Light Code Labs, LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package expvar
-
-import (
-	"expvar"
-	"fmt"
-	"net/http"
-
-	"github.com/caddyserver/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,60 +0,0 @@
-// Copyright 2015 Light Code Labs, LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package expvar
-
-import (
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	"github.com/caddyserver/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,83 +0,0 @@
-// Copyright 2015 Light Code Labs, LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package expvar
-
-import (
-	"expvar"
-	"runtime"
-	"sync"
-
-	"github.com/caddyserver/caddy"
-	"github.com/caddyserver/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,56 +0,0 @@
-// Copyright 2015 Light Code Labs, LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package expvar
-
-import (
-	"testing"
-
-	"github.com/caddyserver/caddy"
-	"github.com/caddyserver/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,58 +0,0 @@
-// Copyright 2015 Light Code Labs, LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// Package extensions contains middleware for clean URLs.
-//
-// The root path of the site is passed in as well as possible extensions
-// to try internally for paths requested that don't match an existing
-// resource. The first path+ext combination that matches a valid file
-// will be used.
-package extensions
-
-import (
-	"net/http"
-	"os"
-	"path"
-	"strings"
-
-	"github.com/caddyserver/caddy/caddyhttp/httpserver"
-)
-
-// Ext can assume an extension from clean URLs.
-// It tries extensions in the order listed in Extensions.
-type Ext struct {
-	// Next handler in the chain
-	Next httpserver.Handler
-
-	// Path to site root
-	Root string
-
-	// List of extensions to try
-	Extensions []string
-}
-
-// ServeHTTP implements the httpserver.Handler interface.
-func (e Ext) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error) {
-	urlpath := strings.TrimSuffix(r.URL.Path, "/")
-	if len(r.URL.Path) > 0 && path.Ext(urlpath) == "" && r.URL.Path[len(r.URL.Path)-1] != '/' {
-		for _, ext := range e.Extensions {
-			_, err := os.Stat(httpserver.SafePath(e.Root, urlpath) + ext)
-			if err == nil {
-				r.URL.Path = urlpath + ext
-				break
-			}
-		}
-	}
-	return e.Next.ServeHTTP(w, r)
-}

caddyhttp/extensions/setup.go

@@ -1,67 +0,0 @@
-// Copyright 2015 Light Code Labs, LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package extensions
-
-import (
-	"github.com/caddyserver/caddy"
-	"github.com/caddyserver/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,89 +0,0 @@
-// Copyright 2015 Light Code Labs, LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package extensions
-
-import (
-	"testing"
-
-	"github.com/caddyserver/caddy"
-	"github.com/caddyserver/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,497 +0,0 @@
-// Copyright 2015 Light Code Labs, LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// Package fastcgi has middleware that acts as a FastCGI client. Requests
-// that get forwarded to FastCGI stop the middleware execution chain.
-// The most common use for this package is to serve PHP websites via php-fpm.
-package fastcgi
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"io"
-	"net"
-	"net/http"
-	"net/url"
-	"os"
-	"path"
-	"path/filepath"
-	"strconv"
-	"strings"
-	"sync/atomic"
-	"time"
-
-	"crypto/tls"
-
-	"github.com/caddyserver/caddy"
-	"github.com/caddyserver/caddy/caddyhttp/httpserver"
-	"github.com/caddyserver/caddy/caddytls"
-)
-
-// Handler is a middleware type that can handle requests as a FastCGI client.
-type Handler struct {
-	Next    httpserver.Handler
-	Rules   []Rule
-	Root    string
-	FileSys http.FileSystem
-
-	// These are sent to CGI scripts in env variables
-	SoftwareName    string
-	SoftwareVersion string
-	ServerName      string
-	ServerPort      string
-}
-
-// ServeHTTP satisfies the httpserver.Handler interface.
-func (h Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error) {
-	for _, rule := range h.Rules {
-		// First requirement: Base path must match request path. If it doesn't,
-		// we check to make sure the leading slash is not missing, and if so,
-		// we check again with it prepended. This is in case people forget
-		// a leading slash when performing rewrites, and we don't want to expose
-		// the contents of the (likely PHP) script. See issue #1645.
-		hpath := httpserver.Path(r.URL.Path)
-		if !hpath.Matches(rule.Path) {
-			if strings.HasPrefix(string(hpath), "/") {
-				// this is a normal-looking path, and it doesn't match; try next rule
-				continue
-			}
-			hpath = httpserver.Path("/" + string(hpath)) // prepend leading slash
-			if !hpath.Matches(rule.Path) {
-				// even after fixing the request path, it still doesn't match; try next rule
-				continue
-			}
-		}
-		// The path must also be allowed (not ignored).
-		if !rule.AllowedPath(r.URL.Path) {
-			continue
-		}
-
-		// In addition to matching the path, a request must meet some
-		// other criteria before being proxied as FastCGI. For example,
-		// we probably want to exclude static assets (CSS, JS, images...)
-		// but we also want to be flexible for the script we proxy to.
-
-		fpath := r.URL.Path
-
-		if idx, ok := httpserver.IndexFile(h.FileSys, fpath, rule.IndexFiles); ok {
-			fpath = idx
-			// Index file present.
-			// If request path cannot be split, return error.
-			if !rule.canSplit(fpath) {
-				return http.StatusInternalServerError, ErrIndexMissingSplit
-			}
-		} else {
-			// No index file present.
-			// If request path cannot be split, ignore request.
-			if !rule.canSplit(fpath) {
-				continue
-			}
-		}
-
-		// These criteria work well in this order for PHP sites
-		// We lower path and Ext as on Windows, the system is case insensitive, so .PHP is served as .php
-		if !h.exists(fpath) || fpath[len(fpath)-1] == '/' || strings.HasSuffix(strings.ToLower(fpath), strings.ToLower(rule.Ext)) {
-
-			// Create environment for CGI script
-			env, err := h.buildEnv(r, rule, fpath)
-			if err != nil {
-				return http.StatusInternalServerError, err
-			}
-
-			// Connect to FastCGI gateway
-			address, err := rule.Address()
-			if err != nil {
-				return http.StatusBadGateway, err
-			}
-			network, address := parseAddress(address)
-
-			ctx := context.Background()
-			if rule.ConnectTimeout > 0 {
-				var cancel context.CancelFunc
-				ctx, cancel = context.WithTimeout(ctx, rule.ConnectTimeout)
-				defer cancel()
-			}
-
-			fcgiBackend, err := DialContext(ctx, network, address)
-			if err != nil {
-				return http.StatusBadGateway, err
-			}
-			defer fcgiBackend.Close()
-
-			// read/write timeouts
-			if err := fcgiBackend.SetReadTimeout(rule.ReadTimeout); err != nil {
-				return http.StatusInternalServerError, err
-			}
-			if err := fcgiBackend.SetSendTimeout(rule.SendTimeout); err != nil {
-				return http.StatusInternalServerError, err
-			}
-
-			var resp *http.Response
-
-			var contentLength int64
-			// if ContentLength is already set
-			if r.ContentLength > 0 {
-				contentLength = r.ContentLength
-			} else {
-				contentLength, _ = strconv.ParseInt(r.Header.Get("Content-Length"), 10, 64)
-			}
-			switch r.Method {
-			case "HEAD":
-				resp, err = fcgiBackend.Head(env)
-			case "GET":
-				resp, err = fcgiBackend.Get(env, r.Body, contentLength)
-			case "OPTIONS":
-				resp, err = fcgiBackend.Options(env)
-			default:
-				resp, err = fcgiBackend.Post(env, r.Method, r.Header.Get("Content-Type"), r.Body, contentLength)
-			}
-
-			if resp != nil && resp.Body != nil {
-				defer resp.Body.Close()
-			}
-
-			if err != nil {
-				if err, ok := err.(net.Error); ok && err.Timeout() {
-					return http.StatusGatewayTimeout, err
-				} else if err != io.EOF {
-					return http.StatusBadGateway, err
-				}
-			}
-
-			// Write response header
-			writeHeader(w, resp)
-
-			// Write the response body
-			_, err = io.Copy(w, resp.Body)
-			if err != nil {
-				return http.StatusBadGateway, err
-			}
-
-			// Log any stderr output from upstream
-			if fcgiBackend.stderr.Len() != 0 {
-				// Remove trailing newline, error logger already does this.
-				err = LogError(strings.TrimSuffix(fcgiBackend.stderr.String(), "\n"))
-			}
-
-			// Normally we would return the status code if it is an error status (>= 400),
-			// however, upstream FastCGI apps don't know about our contract and have
-			// probably already written an error page. So we just return 0, indicating
-			// that the response body is already written. However, we do return any
-			// error value so it can be logged.
-			// Note that the proxy middleware works the same way, returning status=0.
-			return 0, err
-		}
-	}
-
-	return h.Next.ServeHTTP(w, r)
-}
-
-// parseAddress returns the network and address of fcgiAddress.
-// The first string is the network, "tcp" or "unix", implied from the scheme and address.
-// The second string is fcgiAddress, with scheme prefixes removed.
-// The two returned strings can be used as parameters to the Dial() function.
-func parseAddress(fcgiAddress string) (string, string) {
-	// check if address has tcp scheme explicitly set
-	if strings.HasPrefix(fcgiAddress, "tcp://") {
-		return "tcp", fcgiAddress[len("tcp://"):]
-	}
-	// check if address has fastcgi scheme explicitly set
-	if strings.HasPrefix(fcgiAddress, "fastcgi://") {
-		return "tcp", fcgiAddress[len("fastcgi://"):]
-	}
-	// check if unix socket
-	if trim := strings.HasPrefix(fcgiAddress, "unix"); strings.HasPrefix(fcgiAddress, "/") || trim {
-		if trim {
-			return "unix", fcgiAddress[len("unix:"):]
-		}
-		return "unix", fcgiAddress
-	}
-	// default case, a plain tcp address with no scheme
-	return "tcp", fcgiAddress
-}
-
-func writeHeader(w http.ResponseWriter, r *http.Response) {
-	for key, vals := range r.Header {
-		for _, val := range vals {
-			w.Header().Add(key, val)
-		}
-	}
-	w.WriteHeader(r.StatusCode)
-}
-
-func (h Handler) exists(path string) bool {
-	if _, err := os.Stat(h.Root + path); err == nil {
-		return true
-	}
-	return false
-}
-
-// buildEnv returns a set of CGI environment variables for the request.
-func (h Handler) buildEnv(r *http.Request, rule Rule, fpath string) (map[string]string, error) {
-	var env map[string]string
-
-	// 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
-
-	// Strip PATH_INFO from SCRIPT_NAME
-	scriptName = strings.TrimSuffix(scriptName, pathInfo)
-
-	// SCRIPT_FILENAME is the absolute path of SCRIPT_NAME
-	scriptFilename := filepath.Join(rule.Root, scriptName)
-
-	// Add vhost path prefix to scriptName. Otherwise, some PHP software will
-	// have difficulty discovering its URL.
-	pathPrefix, _ := r.Context().Value(caddy.CtxKey("path_prefix")).(string)
-	scriptName = path.Join(pathPrefix, scriptName)
-
-	// Get the request URI from context. The context stores the original URI in case
-	// it was changed by a middleware such as rewrite. By default, we pass the
-	// original URI in as the value of REQUEST_URI (the user can overwrite this
-	// if desired). Most PHP apps seem to want the original URI. Besides, this is
-	// how nginx defaults: http://stackoverflow.com/a/12485156/1048862
-	reqURL, _ := r.Context().Value(httpserver.OriginalURLCtxKey).(url.URL)
-
-	// Retrieve name of remote user that was set by some downstream middleware such as basicauth.
-	remoteUser, _ := r.Context().Value(httpserver.RemoteUserCtxKey).(string)
-
-	requestScheme := "http"
-	if r.TLS != nil {
-		requestScheme = "https"
-	}
-
-	// Some variables are unused but cleared explicitly to prevent
-	// the parent environment from interfering.
-	env = map[string]string{
-		// Variables defined in CGI 1.1 spec
-		"AUTH_TYPE":         "", // Not used
-		"CONTENT_LENGTH":    r.Header.Get("Content-Length"),
-		"CONTENT_TYPE":      r.Header.Get("Content-Type"),
-		"GATEWAY_INTERFACE": "CGI/1.1",
-		"PATH_INFO":         pathInfo,
-		"QUERY_STRING":      r.URL.RawQuery,
-		"REMOTE_ADDR":       ip,
-		"REMOTE_HOST":       ip, // For speed, remote host lookups disabled
-		"REMOTE_PORT":       port,
-		"REMOTE_IDENT":      "", // Not used
-		"REMOTE_USER":       remoteUser,
-		"REQUEST_METHOD":    r.Method,
-		"REQUEST_SCHEME":    requestScheme,
-		"SERVER_NAME":       h.ServerName,
-		"SERVER_PORT":       h.ServerPort,
-		"SERVER_PROTOCOL":   r.Proto,
-		"SERVER_SOFTWARE":   h.SoftwareName + "/" + h.SoftwareVersion,
-
-		// Other variables
-		"DOCUMENT_ROOT":   rule.Root,
-		"DOCUMENT_URI":    docURI,
-		"HTTP_HOST":       r.Host, // added here, since not always part of headers
-		"REQUEST_URI":     reqURL.RequestURI(),
-		"SCRIPT_FILENAME": scriptFilename,
-		"SCRIPT_NAME":     scriptName,
-	}
-
-	// compliance with the CGI specification requires that
-	// PATH_TRANSLATED should only exist if PATH_INFO is defined.
-	// Info: https://www.ietf.org/rfc/rfc3875 Page 14
-	if env["PATH_INFO"] != "" {
-		env["PATH_TRANSLATED"] = filepath.Join(rule.Root, pathInfo) // Info: http://www.oreilly.com/openbook/cgi/ch02_04.html
-	}
-
-	// Some web apps rely on knowing HTTPS or not
-	if r.TLS != nil {
-		env["HTTPS"] = "on"
-		// and pass the protocol details in a manner compatible with apache's mod_ssl
-		// (which is why they have a SSL_ prefix and not TLS_).
-		v, ok := tlsProtocolStringToMap[r.TLS.Version]
-		if ok {
-			env["SSL_PROTOCOL"] = v
-		}
-		// and pass the cipher suite in a manner compatible with apache's mod_ssl
-		for k, v := range caddytls.SupportedCiphersMap {
-			if v == r.TLS.CipherSuite {
-				env["SSL_CIPHER"] = k
-				break
-			}
-		}
-	}
-
-	// Add env variables from config (with support for placeholders in values)
-	replacer := httpserver.NewReplacer(r, nil, "")
-	for _, envVar := range rule.EnvVars {
-		env[envVar[0]] = replacer.Replace(envVar[1])
-	}
-
-	// Add all HTTP headers to env variables
-	for field, val := range r.Header {
-		header := strings.ToUpper(field)
-		header = headerNameReplacer.Replace(header)
-		env["HTTP_"+header] = strings.Join(val, ", ")
-	}
-	return env, nil
-}
-
-// Rule represents a FastCGI handling rule.
-// It is parsed from the fastcgi directive in the Caddyfile, see setup.go.
-type Rule struct {
-	// The base path to match. Required.
-	Path string
-
-	// upstream load balancer
-	balancer
-
-	// Always process files with this extension with fastcgi.
-	Ext string
-
-	// Use this directory as the fastcgi root directory. Defaults to the root
-	// directory of the parent virtual host.
-	Root string
-
-	// The path in the URL will be split into two, with the first piece ending
-	// with the value of SplitPath. The first piece will be assumed as the
-	// actual resource (CGI script) name, and the second piece will be set to
-	// PATH_INFO for the CGI script to use.
-	SplitPath string
-
-	// If the URL ends with '/' (which indicates a directory), these index
-	// files will be tried instead.
-	IndexFiles []string
-
-	// Environment Variables
-	EnvVars [][2]string
-
-	// Ignored paths
-	IgnoredSubPaths []string
-
-	// The duration used to set a deadline when connecting to an upstream.
-	ConnectTimeout time.Duration
-
-	// The duration used to set a deadline when reading from the FastCGI server.
-	ReadTimeout time.Duration
-
-	// The duration used to set a deadline when sending to the FastCGI server.
-	SendTimeout time.Duration
-}
-
-// balancer is a fastcgi upstream load balancer.
-type balancer interface {
-	// Address picks an upstream address from the
-	// underlying load balancer.
-	Address() (string, error)
-}
-
-// roundRobin is a round robin balancer for fastcgi upstreams.
-type roundRobin struct {
-	// Known Go bug: https://golang.org/pkg/sync/atomic/#pkg-note-BUG
-	// must be first field for 64 bit alignment
-	// on x86 and arm.
-	index     int64
-	addresses []string
-}
-
-func (r *roundRobin) Address() (string, error) {
-	index := atomic.AddInt64(&r.index, 1) % int64(len(r.addresses))
-	return r.addresses[index], nil
-}
-
-// srvResolver is a private interface used to abstract
-// the DNS resolver. It is mainly used to facilitate testing.
-type srvResolver interface {
-	LookupSRV(ctx context.Context, service, proto, name string) (string, []*net.SRV, error)
-}
-
-// srv is a service locator for fastcgi upstreams
-type srv struct {
-	resolver srvResolver
-	service  string
-}
-
-// Address looks up the service and returns the address:port
-// from first result in resolved list.
-// No explicit balancing is required because net.LookupSRV
-// sorts the results by priority and randomizes within priority.
-func (s *srv) Address() (string, error) {
-	_, addrs, err := s.resolver.LookupSRV(context.Background(), "", "", s.service)
-	if err != nil {
-		return "", err
-	}
-
-	return fmt.Sprintf("%s:%d", strings.TrimRight(addrs[0].Target, "."), addrs[0].Port), nil
-}
-
-// canSplit checks if path can split into two based on rule.SplitPath.
-func (r Rule) canSplit(path string) bool {
-	return r.splitPos(path) >= 0
-}
-
-// splitPos returns the index where path should be split
-// based on rule.SplitPath.
-func (r Rule) splitPos(path string) int {
-	if httpserver.CaseSensitivePath {
-		return strings.Index(path, r.SplitPath)
-	}
-	return strings.Index(strings.ToLower(path), strings.ToLower(r.SplitPath))
-}
-
-// AllowedPath checks if requestPath is not an ignored path.
-func (r Rule) AllowedPath(requestPath string) bool {
-	for _, ignoredSubPath := range r.IgnoredSubPaths {
-		if httpserver.Path(path.Clean(requestPath)).Matches(path.Join(r.Path, ignoredSubPath)) {
-			return false
-		}
-	}
-	return true
-}
-
-var (
-	headerNameReplacer = strings.NewReplacer(" ", "_", "-", "_")
-	// ErrIndexMissingSplit describes an index configuration error.
-	ErrIndexMissingSplit = errors.New("configured index file(s) must include split value")
-)
-
-// LogError is a non fatal error that allows requests to go through.
-type LogError string
-
-// Error satisfies error interface.
-func (l LogError) Error() string {
-	return string(l)
-}
-
-// Map of supported protocols to Apache ssl_mod format
-// Note that these are slightly different from SupportedProtocols in caddytls/config.go's
-var tlsProtocolStringToMap = map[uint16]string{
-	tls.VersionTLS10: "TLSv1",
-	tls.VersionTLS11: "TLSv1.1",
-	tls.VersionTLS12: "TLSv1.2",
-}

caddyhttp/fastcgi/fastcgi_test.go

@@ -1,424 +0,0 @@
-// Copyright 2015 Light Code Labs, LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package fastcgi
-
-import (
-	"context"
-	"log"
-	"net"
-	"net/http"
-	"net/http/fcgi"
-	"net/http/httptest"
-	"net/url"
-	"path/filepath"
-	"strconv"
-	"sync"
-	"testing"
-	"time"
-
-	"github.com/caddyserver/caddy"
-	"github.com/caddyserver/caddy/caddyhttp/httpserver"
-)
-
-func TestServeHTTP(t *testing.T) {
-	body := "This is some test body content"
-
-	bodyLenStr := strconv.Itoa(len(body))
-	listener, err := net.Listen("tcp", "127.0.0.1:0")
-	if err != nil {
-		t.Fatalf("Unable to create listener for test: %v", err)
-	}
-	defer func() { _ = listener.Close() }()
-
-	go func() {
-		err := fcgi.Serve(listener, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			w.Header().Set("Content-Length", bodyLenStr)
-			_, err := w.Write([]byte(body))
-			if err != nil {
-				log.Printf("[ERROR] unable to write header: %v", err)
-			}
-		}))
-		if err != nil {
-			log.Printf("[ERROR] unable to start server: %v", err)
-		}
-	}()
-
-	handler := Handler{
-		Next:  nil,
-		Rules: []Rule{{Path: "/", balancer: address(listener.Addr().String())}},
-	}
-	r, err := http.NewRequest("GET", "/", nil)
-	if err != nil {
-		t.Fatalf("Unable to create request: %v", err)
-	}
-	w := httptest.NewRecorder()
-
-	status, err := handler.ServeHTTP(w, r)
-
-	if got, want := status, 0; got != want {
-		t.Errorf("Expected returned status code to be %d, got %d", want, got)
-	}
-	if err != nil {
-		t.Errorf("Expected nil error, got: %v", err)
-	}
-	if got, want := w.Header().Get("Content-Length"), bodyLenStr; got != want {
-		t.Errorf("Expected Content-Length to be '%s', got: '%s'", want, got)
-	}
-	if got, want := w.Body.String(), body; got != want {
-		t.Errorf("Expected response body to be '%s', got: '%s'", want, got)
-	}
-}
-
-func TestRuleParseAddress(t *testing.T) {
-	getClientTestTable := []struct {
-		rule            *Rule
-		expectednetwork string
-		expectedaddress string
-	}{
-		{&Rule{balancer: address("tcp://172.17.0.1:9000")}, "tcp", "172.17.0.1:9000"},
-		{&Rule{balancer: address("fastcgi://localhost:9000")}, "tcp", "localhost:9000"},
-		{&Rule{balancer: address("172.17.0.15")}, "tcp", "172.17.0.15"},
-		{&Rule{balancer: address("/my/unix/socket")}, "unix", "/my/unix/socket"},
-		{&Rule{balancer: address("unix:/second/unix/socket")}, "unix", "/second/unix/socket"},
-	}
-
-	for _, entry := range getClientTestTable {
-		addr, err := entry.rule.Address()
-		if err != nil {
-			t.Errorf("Unexpected error in retrieving address: %s", err.Error())
-		}
-		if actualnetwork, _ := parseAddress(addr); actualnetwork != entry.expectednetwork {
-			t.Errorf("Unexpected network for address string %v. Got %v, expected %v", addr, actualnetwork, entry.expectednetwork)
-		}
-		if _, actualaddress := parseAddress(addr); actualaddress != entry.expectedaddress {
-			t.Errorf("Unexpected parsed address for address string %v. Got %v, expected %v", addr, actualaddress, entry.expectedaddress)
-		}
-	}
-}
-
-func TestRuleIgnoredPath(t *testing.T) {
-	rule := &Rule{
-		Path:            "/fastcgi",
-		IgnoredSubPaths: []string{"/download", "/static"},
-	}
-	tests := []struct {
-		url      string
-		expected bool
-	}{
-		{"/fastcgi", true},
-		{"/fastcgi/dl", true},
-		{"/fastcgi/download", false},
-		{"/fastcgi/download/static", false},
-		{"/fastcgi/static", false},
-		{"/fastcgi/static/download", false},
-		{"/fastcgi/something/download", true},
-		{"/fastcgi/something/static", true},
-		{"/fastcgi//static", false},
-		{"/fastcgi//static//download", false},
-		{"/fastcgi//download", false},
-	}
-
-	for i, test := range tests {
-		allowed := rule.AllowedPath(test.url)
-		if test.expected != allowed {
-			t.Errorf("Test %d: expected %v found %v", i, test.expected, allowed)
-		}
-	}
-}
-
-func TestBuildEnv(t *testing.T) {
-	testBuildEnv := func(r *http.Request, rule Rule, fpath string, envExpected map[string]string) {
-		var h Handler
-		env, err := h.buildEnv(r, rule, fpath)
-		if err != nil {
-			t.Error("Unexpected error:", err.Error())
-		}
-		for k, v := range envExpected {
-			if env[k] != v {
-				t.Errorf("Unexpected %v. Got %v, expected %v", k, env[k], v)
-			}
-		}
-	}
-
-	rule := Rule{
-		Ext:        ".php",
-		SplitPath:  ".php",
-		IndexFiles: []string{"index.php"},
-	}
-	u, err := url.Parse("http://localhost:2015/fgci_test.php?test=foobar")
-	if err != nil {
-		t.Error("Unexpected error:", err.Error())
-	}
-
-	var newReq = func() *http.Request {
-		r := http.Request{
-			Method:     "GET",
-			URL:        u,
-			Proto:      "HTTP/1.1",
-			ProtoMajor: 1,
-			ProtoMinor: 1,
-			Host:       "localhost:2015",
-			RemoteAddr: "[2b02:1810:4f2d:9400:70ab:f822:be8a:9093]:51688",
-			RequestURI: "/fgci_test.php",
-			Header: map[string][]string{
-				"Foo": {"Bar", "two"},
-			},
-		}
-		ctx := context.WithValue(r.Context(), httpserver.OriginalURLCtxKey, *r.URL)
-		return r.WithContext(ctx)
-	}
-
-	fpath := "/fgci_test.php"
-
-	var newEnv = func() map[string]string {
-		return map[string]string{
-			"REMOTE_ADDR":     "2b02:1810:4f2d:9400:70ab:f822:be8a:9093",
-			"REMOTE_PORT":     "51688",
-			"SERVER_PROTOCOL": "HTTP/1.1",
-			"QUERY_STRING":    "test=foobar",
-			"REQUEST_METHOD":  "GET",
-			"HTTP_HOST":       "localhost:2015",
-			"SCRIPT_NAME":     "/fgci_test.php",
-		}
-	}
-
-	// request
-	var r *http.Request
-
-	// expected environment variables
-	var envExpected map[string]string
-
-	// 1. Test for full canonical IPv6 address
-	r = newReq()
-	testBuildEnv(r, rule, fpath, envExpected)
-
-	// 2. Test for shorthand notation of IPv6 address
-	r = newReq()
-	r.RemoteAddr = "[::1]:51688"
-	envExpected = newEnv()
-	envExpected["REMOTE_ADDR"] = "::1"
-	testBuildEnv(r, rule, fpath, envExpected)
-
-	// 3. Test for IPv4 address
-	r = newReq()
-	r.RemoteAddr = "192.168.0.10:51688"
-	envExpected = newEnv()
-	envExpected["REMOTE_ADDR"] = "192.168.0.10"
-	testBuildEnv(r, rule, fpath, envExpected)
-
-	// 4. Test for environment variable
-	r = newReq()
-	rule.EnvVars = [][2]string{
-		{"HTTP_HOST", "localhost:2016"},
-		{"REQUEST_METHOD", "POST"},
-	}
-	envExpected = newEnv()
-	envExpected["HTTP_HOST"] = "localhost:2016"
-	envExpected["REQUEST_METHOD"] = "POST"
-	testBuildEnv(r, rule, fpath, envExpected)
-
-	// 5. Test for environment variable placeholders
-	r = newReq()
-	rule.EnvVars = [][2]string{
-		{"HTTP_HOST", "{host}"},
-		{"CUSTOM_URI", "custom_uri{uri}"},
-		{"CUSTOM_QUERY", "custom=true&{query}"},
-	}
-	envExpected = newEnv()
-	envExpected["HTTP_HOST"] = "localhost:2015"
-	envExpected["CUSTOM_URI"] = "custom_uri/fgci_test.php?test=foobar"
-	envExpected["CUSTOM_QUERY"] = "custom=true&test=foobar"
-	testBuildEnv(r, rule, fpath, envExpected)
-
-	// 6. Test SCRIPT_NAME includes path prefix
-	r = newReq()
-	ctx := context.WithValue(r.Context(), caddy.CtxKey("path_prefix"), "/test")
-	r = r.WithContext(ctx)
-	envExpected = newEnv()
-	envExpected["SCRIPT_NAME"] = "/test/fgci_test.php"
-	testBuildEnv(r, rule, fpath, envExpected)
-
-	// 7. Test SCRIPT_NAME,SCRIPT_FILENAME do not include PATH_INFO
-	fpath = "/fgci_test.php/extra/paths"
-	r = newReq()
-	envExpected = newEnv()
-	envExpected["PATH_INFO"] = "/extra/paths"
-	envExpected["SCRIPT_NAME"] = "/fgci_test.php"
-	envExpected["SCRIPT_FILENAME"] = filepath.FromSlash("/fgci_test.php")
-	testBuildEnv(r, rule, fpath, envExpected)
-
-	// 8. Test REQUEST_SCHEME in env
-	r = newReq()
-	envExpected = newEnv()
-	envExpected["REQUEST_SCHEME"] = "http"
-	testBuildEnv(r, rule, fpath, envExpected)
-}
-
-func TestReadTimeout(t *testing.T) {
-	tests := []struct {
-		sleep       time.Duration
-		readTimeout time.Duration
-		shouldErr   bool
-	}{
-		{75 * time.Millisecond, 50 * time.Millisecond, true},
-		{0, -1 * time.Second, true},
-		{0, time.Minute, false},
-	}
-
-	var wg sync.WaitGroup
-
-	for i, test := range tests {
-		listener, err := net.Listen("tcp", "127.0.0.1:0")
-		if err != nil {
-			t.Fatalf("Test %d: Unable to create listener for test: %v", i, err)
-		}
-		defer func() { _ = listener.Close() }()
-
-		handler := Handler{
-			Next: nil,
-			Rules: []Rule{
-				{
-					Path:        "/",
-					balancer:    address(listener.Addr().String()),
-					ReadTimeout: test.readTimeout,
-				},
-			},
-		}
-		r, err := http.NewRequest("GET", "/", nil)
-		if err != nil {
-			t.Fatalf("Test %d: Unable to create request: %v", i, err)
-		}
-		w := httptest.NewRecorder()
-
-		wg.Add(1)
-		go func() {
-			err := fcgi.Serve(listener, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-				time.Sleep(test.sleep)
-				w.WriteHeader(http.StatusOK)
-				wg.Done()
-			}))
-			if err != nil {
-				log.Printf("[ERROR] unable to start server: %v", err)
-			}
-		}()
-
-		got, err := handler.ServeHTTP(w, r)
-		if test.shouldErr {
-			if err == nil {
-				t.Errorf("Test %d: Expected i/o timeout error but had none", i)
-			} else if err, ok := err.(net.Error); !ok || !err.Timeout() {
-				t.Errorf("Test %d: Expected i/o timeout error, got: '%s'", i, err.Error())
-			}
-
-			want := http.StatusGatewayTimeout
-			if got != want {
-				t.Errorf("Test %d: Expected returned status code to be %d, got: %d",
-					i, want, got)
-			}
-		} else if err != nil {
-			t.Errorf("Test %d: Expected nil error, got: %v", i, err)
-		}
-
-		wg.Wait()
-	}
-}
-
-func TestSendTimeout(t *testing.T) {
-	tests := []struct {
-		sendTimeout time.Duration
-		shouldErr   bool
-	}{
-		{-1 * time.Second, true},
-		{time.Minute, false},
-	}
-
-	for i, test := range tests {
-		listener, err := net.Listen("tcp", "127.0.0.1:0")
-		if err != nil {
-			t.Fatalf("Test %d: Unable to create listener for test: %v", i, err)
-		}
-		defer func() { _ = listener.Close() }()
-
-		handler := Handler{
-			Next: nil,
-			Rules: []Rule{
-				{
-					Path:        "/",
-					balancer:    address(listener.Addr().String()),
-					SendTimeout: test.sendTimeout,
-				},
-			},
-		}
-		r, err := http.NewRequest("GET", "/", nil)
-		if err != nil {
-			t.Fatalf("Test %d: Unable to create request: %v", i, err)
-		}
-		w := httptest.NewRecorder()
-
-		go func() {
-			err := fcgi.Serve(listener, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-				w.WriteHeader(http.StatusOK)
-			}))
-			if err != nil {
-				log.Printf("[ERROR] unable to start server: %v", err)
-			}
-		}()
-
-		got, err := handler.ServeHTTP(w, r)
-		if test.shouldErr {
-			if err == nil {
-				t.Errorf("Test %d: Expected i/o timeout error but had none", i)
-			} else if err, ok := err.(net.Error); !ok || !err.Timeout() {
-				t.Errorf("Test %d: Expected i/o timeout error, got: '%s'", i, err.Error())
-			}
-
-			want := http.StatusGatewayTimeout
-			if got != want {
-				t.Errorf("Test %d: Expected returned status code to be %d, got: %d",
-					i, want, got)
-			}
-		} else if err != nil {
-			t.Errorf("Test %d: Expected nil error, got: %v", i, err)
-		}
-	}
-}
-
-func TestBalancer(t *testing.T) {
-	tests := [][]string{
-		{"localhost", "host.local"},
-		{"localhost"},
-		{"localhost", "host.local", "example.com"},
-		{"localhost", "host.local", "example.com", "127.0.0.1"},
-	}
-	for i, test := range tests {
-		b := address(test...)
-		for _, host := range test {
-			a, err := b.Address()
-			if err != nil {
-				t.Errorf("Unexpected error in trying to retrieve address: %s", err.Error())
-			}
-			if a != host {
-				t.Errorf("Test %d: expected %s, found %s", i, host, a)
-			}
-		}
-	}
-}
-
-func address(addresses ...string) balancer {
-	return &roundRobin{
-		addresses: addresses,
-		index:     -1,
-	}
-}

caddyhttp/fastcgi/fcgi_test.php

@@ -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,220 +0,0 @@
-// Copyright 2015 Light Code Labs, LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package fastcgi
-
-import (
-	"errors"
-	"fmt"
-	"net"
-	"net/http"
-	"path/filepath"
-	"strings"
-	"time"
-
-	"github.com/caddyserver/caddy"
-	"github.com/caddyserver/caddy/caddyhttp/httpserver"
-)
-
-var defaultTimeout = 60 * time.Second
-
-func init() {
-	caddy.RegisterPlugin("fastcgi", caddy.Plugin{
-		ServerType: "http",
-		Action:     setup,
-	})
-}
-
-// setup configures a new FastCGI middleware instance.
-func setup(c *caddy.Controller) error {
-	cfg := httpserver.GetConfig(c)
-
-	rules, err := fastcgiParse(c)
-	if err != nil {
-		return err
-	}
-
-	cfg.AddMiddleware(func(next httpserver.Handler) httpserver.Handler {
-		return Handler{
-			Next:            next,
-			Rules:           rules,
-			Root:            cfg.Root,
-			FileSys:         http.Dir(cfg.Root),
-			SoftwareName:    caddy.AppName,
-			SoftwareVersion: caddy.AppVersion,
-			ServerName:      cfg.Addr.Host,
-			ServerPort:      cfg.Addr.Port,
-		}
-	})
-
-	return nil
-}
-
-func fastcgiParse(c *caddy.Controller) ([]Rule, error) {
-	var rules []Rule
-
-	cfg := httpserver.GetConfig(c)
-	absRoot, err := filepath.Abs(cfg.Root)
-	if err != nil {
-		return nil, err
-	}
-
-	for c.Next() {
-		args := c.RemainingArgs()
-
-		if len(args) < 2 || len(args) > 3 {
-			return rules, c.ArgErr()
-		}
-
-		rule := Rule{
-			Root:           absRoot,
-			Path:           args[0],
-			ConnectTimeout: defaultTimeout,
-			ReadTimeout:    defaultTimeout,
-			SendTimeout:    defaultTimeout,
-		}
-
-		upstreams := []string{args[1]}
-
-		srvUpstream := false
-		if strings.HasPrefix(upstreams[0], "srv://") {
-			srvUpstream = true
-		}
-
-		if len(args) == 3 {
-			if err := fastcgiPreset(args[2], &rule); err != nil {
-				return rules, err
-			}
-		}
-
-		var err error
-
-		for c.NextBlock() {
-			switch c.Val() {
-			case "root":
-				if !c.NextArg() {
-					return rules, c.ArgErr()
-				}
-				rule.Root = c.Val()
-
-			case "ext":
-				if !c.NextArg() {
-					return rules, c.ArgErr()
-				}
-				rule.Ext = c.Val()
-			case "split":
-				if !c.NextArg() {
-					return rules, c.ArgErr()
-				}
-				rule.SplitPath = c.Val()
-			case "index":
-				args := c.RemainingArgs()
-				if len(args) == 0 {
-					return rules, c.ArgErr()
-				}
-				rule.IndexFiles = args
-
-			case "upstream":
-				if srvUpstream {
-					return rules, c.Err("additional upstreams are not supported with SRV upstream")
-				}
-
-				args := c.RemainingArgs()
-
-				if len(args) != 1 {
-					return rules, c.ArgErr()
-				}
-
-				upstreams = append(upstreams, args[0])
-			case "env":
-				envArgs := c.RemainingArgs()
-				if len(envArgs) < 2 {
-					return rules, c.ArgErr()
-				}
-				rule.EnvVars = append(rule.EnvVars, [2]string{envArgs[0], envArgs[1]})
-			case "except":
-				ignoredPaths := c.RemainingArgs()
-				if len(ignoredPaths) == 0 {
-					return rules, c.ArgErr()
-				}
-				rule.IgnoredSubPaths = ignoredPaths
-
-			case "connect_timeout":
-				if !c.NextArg() {
-					return rules, c.ArgErr()
-				}
-				rule.ConnectTimeout, err = time.ParseDuration(c.Val())
-				if err != nil {
-					return rules, err
-				}
-			case "read_timeout":
-				if !c.NextArg() {
-					return rules, c.ArgErr()
-				}
-				readTimeout, err := time.ParseDuration(c.Val())
-				if err != nil {
-					return rules, err
-				}
-				rule.ReadTimeout = readTimeout
-			case "send_timeout":
-				if !c.NextArg() {
-					return rules, c.ArgErr()
-				}
-				sendTimeout, err := time.ParseDuration(c.Val())
-				if err != nil {
-					return rules, err
-				}
-				rule.SendTimeout = sendTimeout
-			}
-		}
-
-		if srvUpstream {
-			balancer, err := parseSRV(upstreams[0])
-			if err != nil {
-				return rules, c.Err("malformed service locator string: " + err.Error())
-			}
-			rule.balancer = balancer
-		} else {
-			rule.balancer = &roundRobin{addresses: upstreams, index: -1}
-		}
-
-		rules = append(rules, rule)
-	}
-	return rules, nil
-}
-
-func parseSRV(locator string) (*srv, error) {
-	if locator[6:] == "" {
-		return nil, fmt.Errorf("%s does not include the host", locator)
-	}
-
-	return &srv{
-		service:  locator[6:],
-		resolver: &net.Resolver{},
-	}, nil
-}
-
-// fastcgiPreset configures rule according to name. It returns an error if
-// name is not a recognized preset name.
-func fastcgiPreset(name string, rule *Rule) error {
-	switch name {
-	case "php":
-		rule.Ext = ".php"
-		rule.SplitPath = ".php"
-		rule.IndexFiles = []string{"index.php"}
-	default:
-		return errors.New(name + " is not a valid preset name")
-	}
-	return nil
-}

caddyhttp/fastcgi/setup_test.go

@@ -1,255 +0,0 @@
-// Copyright 2015 Light Code Labs, LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package fastcgi
-
-import (
-	"context"
-	"fmt"
-	"net"
-	"testing"
-	"time"
-
-	"github.com/caddyserver/caddy"
-	"github.com/caddyserver/caddy/caddyhttp/httpserver"
-)
-
-func TestSetup(t *testing.T) {
-	c := caddy.NewTestController("http", `fastcgi / 127.0.0.1:9000`)
-	err := setup(c)
-	if err != nil {
-		t.Errorf("Expected no errors, got: %v", err)
-	}
-	mids := httpserver.GetConfig(c).Middleware()
-	if len(mids) == 0 {
-		t.Fatal("Expected middleware, got 0 instead")
-	}
-
-	handler := mids[0](httpserver.EmptyNext)
-	myHandler, ok := handler.(Handler)
-
-	if !ok {
-		t.Fatalf("Expected handler to be type , got: %#v", handler)
-	}
-
-	if myHandler.Rules[0].Path != "/" {
-		t.Errorf("Expected / as the Path")
-	}
-	addr, err := myHandler.Rules[0].Address()
-	if err != nil {
-		t.Errorf("Unexpected error in trying to retrieve address: %s", err.Error())
-	}
-
-	if addr != "127.0.0.1:9000" {
-		t.Errorf("Expected 127.0.0.1:9000 as the Address")
-	}
-
-	if myHandler.Rules[0].ConnectTimeout != 60*time.Second {
-		t.Errorf("Expected default value of 60 seconds")
-	}
-
-	if myHandler.Rules[0].ReadTimeout != 60*time.Second {
-		t.Errorf("Expected default value of 60 seconds")
-	}
-
-	if myHandler.Rules[0].SendTimeout != 60*time.Second {
-		t.Errorf("Expected default value of 60 seconds")
-	}
-}
-
-func TestFastcgiParse(t *testing.T) {
-	tests := []struct {
-		inputFastcgiConfig    string
-		shouldErr             bool
-		expectedFastcgiConfig []Rule
-	}{
-
-		{`fastcgi /blog 127.0.0.1:9000 php`,
-			false, []Rule{{
-				Path:        "/blog",
-				balancer:    &roundRobin{addresses: []string{"127.0.0.1:9000"}},
-				Ext:         ".php",
-				SplitPath:   ".php",
-				IndexFiles:  []string{"index.php"},
-				SendTimeout: 60 * time.Second,
-			}}},
-		{`fastcgi / 127.0.0.1:9001 {
-	              split .html
-	              }`,
-			false, []Rule{{
-				Path:        "/",
-				balancer:    &roundRobin{addresses: []string{"127.0.0.1:9001"}},
-				Ext:         "",
-				SplitPath:   ".html",
-				IndexFiles:  []string{},
-				SendTimeout: 60 * time.Second,
-			}}},
-		{`fastcgi / 127.0.0.1:9001 {
-	              split .html
-	              except /admin /user
-	              }`,
-			false, []Rule{{
-				Path:            "/",
-				balancer:        &roundRobin{addresses: []string{"127.0.0.1:9001"}},
-				Ext:             "",
-				SplitPath:       ".html",
-				IndexFiles:      []string{},
-				IgnoredSubPaths: []string{"/admin", "/user"},
-				SendTimeout:     60 * time.Second,
-			}}},
-		{`fastcgi / 127.0.0.1:9001 {
-					send_timeout 30s
-				}`,
-			false, []Rule{{
-				Path:        "/",
-				balancer:    &roundRobin{addresses: []string{"127.0.0.1:9001"}},
-				Ext:         "",
-				IndexFiles:  []string{},
-				SendTimeout: 30 * time.Second,
-			}}},
-	}
-	for i, test := range tests {
-		actualFastcgiConfigs, err := fastcgiParse(caddy.NewTestController("http", test.inputFastcgiConfig))
-
-		if err == nil && test.shouldErr {
-			t.Errorf("Test %d didn't error, but it should have", i)
-		} else if err != nil && !test.shouldErr {
-			t.Errorf("Test %d errored, but it shouldn't have; got '%v'", i, err)
-		}
-		if len(actualFastcgiConfigs) != len(test.expectedFastcgiConfig) {
-			t.Fatalf("Test %d expected %d no of FastCGI configs, but got %d ",
-				i, len(test.expectedFastcgiConfig), len(actualFastcgiConfigs))
-		}
-		for j, actualFastcgiConfig := range actualFastcgiConfigs {
-
-			if actualFastcgiConfig.Path != test.expectedFastcgiConfig[j].Path {
-				t.Errorf("Test %d expected %dth FastCGI Path to be  %s  , but got %s",
-					i, j, test.expectedFastcgiConfig[j].Path, actualFastcgiConfig.Path)
-			}
-
-			actualAddr, err := actualFastcgiConfig.Address()
-			if err != nil {
-				t.Errorf("Test %d unexpected error in trying to retrieve %dth actual address: %s", i, j, err.Error())
-			}
-
-			expectedAddr, err := test.expectedFastcgiConfig[j].Address()
-			if err != nil {
-				t.Errorf("Test %d unexpected error in trying to retrieve %dth expected address: %s", i, j, err.Error())
-			}
-
-			if actualAddr != expectedAddr {
-				t.Errorf("Test %d expected %dth FastCGI Address to be  %s  , but got %s",
-					i, j, expectedAddr, actualAddr)
-			}
-
-			if actualFastcgiConfig.Ext != test.expectedFastcgiConfig[j].Ext {
-				t.Errorf("Test %d expected %dth FastCGI Ext to be  %s  , but got %s",
-					i, j, test.expectedFastcgiConfig[j].Ext, actualFastcgiConfig.Ext)
-			}
-
-			if actualFastcgiConfig.SplitPath != test.expectedFastcgiConfig[j].SplitPath {
-				t.Errorf("Test %d expected %dth FastCGI SplitPath to be  %s  , but got %s",
-					i, j, test.expectedFastcgiConfig[j].SplitPath, actualFastcgiConfig.SplitPath)
-			}
-
-			if fmt.Sprint(actualFastcgiConfig.IndexFiles) != fmt.Sprint(test.expectedFastcgiConfig[j].IndexFiles) {
-				t.Errorf("Test %d expected %dth FastCGI IndexFiles to be  %s  , but got %s",
-					i, j, test.expectedFastcgiConfig[j].IndexFiles, actualFastcgiConfig.IndexFiles)
-			}
-
-			if fmt.Sprint(actualFastcgiConfig.IgnoredSubPaths) != fmt.Sprint(test.expectedFastcgiConfig[j].IgnoredSubPaths) {
-				t.Errorf("Test %d expected %dth FastCGI IgnoredSubPaths to be  %s  , but got %s",
-					i, j, test.expectedFastcgiConfig[j].IgnoredSubPaths, actualFastcgiConfig.IgnoredSubPaths)
-			}
-
-			if actualFastcgiConfig.SendTimeout != test.expectedFastcgiConfig[j].SendTimeout {
-				t.Errorf("Test %d expected %dth FastCGI SendTimeout to be %s   , but got %s",
-					i, j, test.expectedFastcgiConfig[j].SendTimeout, actualFastcgiConfig.SendTimeout)
-			}
-		}
-	}
-
-}
-
-func TestFastCGIResolveSRV(t *testing.T) {
-	tests := []struct {
-		inputFastcgiConfig string
-		locator            string
-		target             string
-		port               uint16
-		shouldErr          bool
-	}{
-		{
-			`fastcgi / srv://fpm.tcp.service.consul {
-				upstream yolo
-			}`,
-			"fpm.tcp.service.consul",
-			"127.0.0.1",
-			9000,
-			true,
-		},
-		{
-			`fastcgi / srv://fpm.tcp.service.consul`,
-			"fpm.tcp.service.consul",
-			"127.0.0.1",
-			9000,
-			false,
-		},
-	}
-
-	for i, test := range tests {
-		actualFastcgiConfigs, err := fastcgiParse(caddy.NewTestController("http", test.inputFastcgiConfig))
-
-		if err == nil && test.shouldErr {
-			t.Errorf("Test %d didn't error, but it should have", i)
-		} else if err != nil && !test.shouldErr {
-			t.Errorf("Test %d errored, but it shouldn't have; got '%v'", i, err)
-		}
-
-		for _, actualFastcgiConfig := range actualFastcgiConfigs {
-			resolver, ok := (actualFastcgiConfig.balancer).(*srv)
-			if !ok {
-				t.Errorf("Test %d upstream balancer is not srv", i)
-			}
-			resolver.resolver = buildTestResolver(test.target, test.port)
-
-			addr, err := actualFastcgiConfig.Address()
-			if err != nil {
-				t.Errorf("Test %d failed to retrieve upstream address. %s", i, err.Error())
-			}
-
-			expectedAddr := fmt.Sprintf("%s:%d", test.target, test.port)
-			if addr != expectedAddr {
-				t.Errorf("Test %d expected upstream address to be %s, got %s", i, expectedAddr, addr)
-			}
-		}
-	}
-}
-
-func buildTestResolver(target string, port uint16) srvResolver {
-	return &testSRVResolver{target, port}
-}
-
-type testSRVResolver struct {
-	target string
-	port   uint16
-}
-
-func (r *testSRVResolver) LookupSRV(ctx context.Context, service, proto, name string) (string, []*net.SRV, error) {
-	return "", []*net.SRV{
-		{Target: r.target,
-			Port:     r.port,
-			Priority: 1,
-			Weight:   1}}, nil
-}

caddyhttp/gzip/gzip.go

@@ -1,163 +0,0 @@
-// 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 gzip provides a middleware layer that performs
-// gzip compression on the response.
-package gzip
-
-import (
-	"compress/gzip"
-	"io"
-	"net/http"
-	"strings"
-
-	"github.com/caddyserver/caddy"
-	"github.com/caddyserver/caddy/caddyhttp/httpserver"
-)
-
-func init() {
-	caddy.RegisterPlugin("gzip", caddy.Plugin{
-		ServerType: "http",
-		Action:     setup,
-	})
-
-	initWriterPool()
-}
-
-// 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
-			}
-		}
-
-		// In order to avoid unused memory allocation, gzip.putWriter only be called when gzip compression happened.
-		// see https://github.com/caddyserver/caddy/issues/2395
-		gz := &gzipResponseWriter{
-			ResponseWriterWrapper: &httpserver.ResponseWriterWrapper{ResponseWriter: w},
-			newWriter: func() io.Writer {
-				// gzipWriter modifies underlying writer at init,
-				// use a discard writer instead to leave ResponseWriter in
-				// original form.
-				return getWriter(c.Level)
-			},
-		}
-
-		defer func() {
-			if gzWriter, ok := gz.internalWriter.(*gzip.Writer); ok {
-				putWriter(c.Level, gzWriter)
-			}
-		}()
-
-		var rw http.ResponseWriter
-		// if no response filter is used
-		if len(c.ResponseFilters) == 0 {
-			// replace discard writer with ResponseWriter
-			if gzWriter, ok := gz.Writer().(*gzip.Writer); ok {
-				gzWriter.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)
-}
-
-// gzipResponseWriter wraps the underlying Write method
-// with a gzip.Writer to compress the output.
-type gzipResponseWriter struct {
-	internalWriter io.Writer
-	*httpserver.ResponseWriterWrapper
-	statusCodeWritten bool
-	newWriter         func() io.Writer
-}
-
-// 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")
-	originalEtag := w.Header().Get("ETag")
-	if originalEtag != "" && !strings.HasPrefix(originalEtag, "W/") {
-		w.Header().Set("ETag", "W/"+originalEtag)
-	}
-	w.ResponseWriterWrapper.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
-}
-
-//Writer use a lazy way to initialize Writer
-func (w *gzipResponseWriter) Writer() io.Writer {
-	if w.internalWriter == nil {
-		w.internalWriter = w.newWriter()
-	}
-	return w.internalWriter
-}
-
-// Interface guards
-var _ httpserver.HTTPInterfaces = (*gzipResponseWriter)(nil)

caddyhttp/gzip/gzip_test.go

@@ -1,196 +0,0 @@
-// 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 gzip
-
-import (
-	"compress/gzip"
-	"fmt"
-	"io/ioutil"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-
-	"github.com/caddyserver/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")
-		w.Header().Set("ETag", `"2n9cd"`)
-		_, err = gz.ServeHTTP(w, r)
-		if err != nil {
-			t.Error(err)
-		}
-
-		// The second pass, test if the ETag is already weak
-		w.Header().Set("ETag", `W/"2n9cd"`)
-		_, 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)
-		}
-	}
-
-	// test all levels
-	w = httptest.NewRecorder()
-	gz.Next = nextFunc(true)
-	for i := 0; i <= gzip.BestCompression; i++ {
-		gz.Configs[0].Level = i
-		r, err := http.NewRequest("GET", "/file.txt", 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 w.Header().Get("Content-Encoding") != "gzip" {
-				return 0, fmt.Errorf("Content-Encoding must be gzip, found %v", w.Header().Get("Content-Encoding"))
-			}
-			if w.Header().Get("Vary") != "Accept-Encoding" {
-				return 0, fmt.Errorf("Vary must be Accept-Encoding, found %v", w.Header().Get("Vary"))
-			}
-			etag := w.Header().Get("ETag")
-			if etag != "" && etag != `W/"2n9cd"` {
-				return 0, fmt.Errorf("ETag must be converted to weak Etag, found %v", w.Header().Get("ETag"))
-			}
-			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
-	})
-}
-
-func BenchmarkGzip(b *testing.B) {
-	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)
-	url := "/file.txt"
-	r, err := http.NewRequest("GET", url, nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	r.Header.Set("Accept-Encoding", "gzip")
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		_, err = gz.ServeHTTP(w, r)
-		if err != nil {
-			b.Fatal(err)
-		}
-	}
-}

caddyhttp/gzip/requestfilter.go

@@ -1,105 +0,0 @@
-// 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 gzip
-
-import (
-	"net/http"
-	"path"
-
-	"github.com/caddyserver/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", ".m3u", ".m3u8", ".wasm"}
-
-// 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,127 +0,0 @@
-// 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 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,107 +0,0 @@
-// 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 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
-}
-
-// SkipCompressedFilter is ResponseFilter that will discard already compressed responses
-type SkipCompressedFilter struct{}
-
-// ShouldCompress returns true if served file is not already compressed
-// encodings via https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Encoding
-func (n SkipCompressedFilter) ShouldCompress(w http.ResponseWriter) bool {
-	switch w.Header().Get("Content-Encoding") {
-	case "gzip", "compress", "deflate", "br":
-		return false
-	default:
-		return true
-	}
-}
-
-// 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,135 +0,0 @@
-// 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 gzip
-
-import (
-	"compress/gzip"
-	"fmt"
-	"log"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	"github.com/caddyserver/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), &httpserver.ResponseWriterWrapper{ResponseWriter: r}, false, nil})
-			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)))
-			if _, err := w.Write([]byte(ts.body)); err != nil {
-				log.Println("[ERROR] failed to write response: ", err)
-			}
-			return 200, nil
-		})
-
-		r := urlRequest("/")
-		r.Header.Set("Accept-Encoding", "gzip")
-
-		w := httptest.NewRecorder()
-
-		if _, err := server.ServeHTTP(w, r); err != nil {
-			log.Println("[ERROR] unable to serve a gzipped response: ", err)
-		}
-
-		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)
-			}
-		}
-	}
-}
-
-func TestResponseGzippedOutput(t *testing.T) {
-	server := Gzip{Configs: []Config{
-		{ResponseFilters: []ResponseFilter{SkipCompressedFilter{}}},
-	}}
-
-	server.Next = httpserver.HandlerFunc(func(w http.ResponseWriter, r *http.Request) (int, error) {
-		w.Header().Set("Content-Encoding", "gzip")
-		if _, err := w.Write([]byte("gzipped")); err != nil {
-			log.Println("[ERROR] failed to write response: ", err)
-		}
-		return 200, nil
-	})
-
-	r := urlRequest("/")
-	r.Header.Set("Accept-Encoding", "gzip")
-
-	w := httptest.NewRecorder()
-	if _, err := server.ServeHTTP(w, r); err != nil {
-		log.Println("[ERROR] unable to serve a gzipped response: ", err)
-	}
-	resp := w.Body.String()
-
-	if resp != "gzipped" {
-		t.Errorf("Expected output not to be gzipped")
-	}
-}

caddyhttp/gzip/setup.go

@@ -1,183 +0,0 @@
-// 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 gzip
-
-import (
-	"compress/gzip"
-	"fmt"
-	"io/ioutil"
-	"strconv"
-	"strings"
-	"sync"
-
-	"github.com/caddyserver/caddy"
-	"github.com/caddyserver/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())
-		}
-
-		config.ResponseFilters = append(config.ResponseFilters, SkipCompressedFilter{})
-
-		// 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
-}
-
-// pool gzip.Writer according to compress level
-// so we can reuse allocations over time
-var (
-	writerPool             = map[int]*sync.Pool{}
-	defaultWriterPoolIndex int
-)
-
-func initWriterPool() {
-	var i int
-	newWriterPool := func(level int) *sync.Pool {
-		return &sync.Pool{
-			New: func() interface{} {
-				w, _ := gzip.NewWriterLevel(ioutil.Discard, level)
-				return w
-			},
-		}
-	}
-	for i = gzip.BestSpeed; i <= gzip.BestCompression; i++ {
-		writerPool[i] = newWriterPool(i)
-	}
-
-	// add default writer pool
-	defaultWriterPoolIndex = i
-	writerPool[defaultWriterPoolIndex] = newWriterPool(gzip.DefaultCompression)
-}
-
-func getWriter(level int) *gzip.Writer {
-	index := defaultWriterPoolIndex
-	if level >= gzip.BestSpeed && level <= gzip.BestCompression {
-		index = level
-	}
-	w := writerPool[index].Get().(*gzip.Writer)
-	w.Reset(ioutil.Discard)
-	return w
-}
-
-func putWriter(level int, w *gzip.Writer) {
-	index := defaultWriterPoolIndex
-	if level >= gzip.BestSpeed && level <= gzip.BestCompression {
-		index = level
-	}
-	w.Close()
-	writerPool[index].Put(w)
-}

caddyhttp/gzip/setup_test.go

@@ -1,143 +0,0 @@
-// 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 gzip
-
-import (
-	"testing"
-
-	"github.com/caddyserver/caddy"
-	"github.com/caddyserver/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)
-		}
-	}
-}
-
-func TestShouldAddResponseFilters(t *testing.T) {
-	configs, err := gzipParse(caddy.NewTestController("http", `gzip { min_length 654 }`))
-
-	if err != nil {
-		t.Errorf("Test expected no error but found: %v", err)
-	}
-	filters := 0
-
-	for _, config := range configs {
-		for _, filter := range config.ResponseFilters {
-			switch filter.(type) {
-			case SkipCompressedFilter:
-				filters++
-			case LengthFilter:
-				filters++
-
-				if filter != LengthFilter(654) {
-					t.Errorf("Expected LengthFilter to have length 654, got: %v", filter)
-				}
-			}
-		}
-
-		if filters != 2 {
-			t.Errorf("Expected 2 response filters to be registered, got: %v", filters)
-		}
-	}
-}

caddyhttp/gzip/testdata/test.txt

@@ -1,308 +0,0 @@
-Sigh view am high neat half to what. Sent late held than set why wife our. If an blessing building steepest. Agreement distrusts mrs six affection satisfied. Day blushes visitor end company old prevent chapter. Consider declared out expenses her concerns. No at indulgence conviction particular unsatiable boisterous discretion. Direct enough off others say eldest may exeter she. Possible all ignorant supplied get settling marriage recurred. 
-
-Boy desirous families prepared gay reserved add ecstatic say. Replied joy age visitor nothing cottage. Mrs door paid led loud sure easy read. Hastily at perhaps as neither or ye fertile tedious visitor. Use fine bed none call busy dull when. Quiet ought match my right by table means. Principles up do in me favourable affronting. Twenty mother denied effect we to do on. 
-
-Compliment interested discretion estimating on stimulated apartments oh. Dear so sing when in find read of call. As distrusts behaviour abilities defective is. Never at water me might. On formed merits hunted unable merely by mr whence or. Possession the unpleasing simplicity her uncommonly. 
-
-Bringing so sociable felicity supplied mr. September suspicion far him two acuteness perfectly. Covered as an examine so regular of. Ye astonished friendship remarkably no. Window admire matter praise you bed whence. Delivered ye sportsmen zealously arranging frankness estimable as. Nay any article enabled musical shyness yet sixteen yet blushes. Entire its the did figure wonder off. 
-
-Inhabit hearing perhaps on ye do no. It maids decay as there he. Smallest on suitable disposed do although blessing he juvenile in. Society or if excited forbade. Here name off yet she long sold easy whom. Differed oh cheerful procured pleasure securing suitable in. Hold rich on an he oh fine. Chapter ability shyness article welcome be do on service. 
-
-An sincerity so extremity he additions. Her yet there truth merit. Mrs all projecting favourable now unpleasing. Son law garden chatty temper. Oh children provided to mr elegance marriage strongly. Off can admiration prosperous now devonshire diminution law. 
-
-Performed suspicion in certainty so frankness by attention pretended. Newspaper or in tolerably education enjoyment. Extremity excellent certainty discourse sincerity no he so resembled. Joy house worse arise total boy but. Elderly up chicken do at feeling is. Like seen drew no make fond at on rent. Behaviour extremely her explained situation yet september gentleman are who. Is thought or pointed hearing he. 
-
-Not far stuff she think the jokes. Going as by do known noise he wrote round leave. Warmly put branch people narrow see. Winding its waiting yet parlors married own feeling. Marry fruit do spite jokes an times. Whether at it unknown warrant herself winding if. Him same none name sake had post love. An busy feel form hand am up help. Parties it brother amongst an fortune of. Twenty behind wicket why age now itself ten. 
-
-On no twenty spring of in esteem spirit likely estate. Continue new you declared differed learning bringing honoured. At mean mind so upon they rent am walk. Shortly am waiting inhabit smiling he chiefly of in. Lain tore time gone him his dear sure. Fat decisively estimating affronting assistance not. Resolve pursuit regular so calling me. West he plan girl been my then up no. 
-
-Expenses as material breeding insisted building to in. Continual so distrusts pronounce by unwilling listening. Thing do taste on we manor. Him had wound use found hoped. Of distrusts immediate enjoyment curiosity do. Marianne numerous saw thoughts the humoured. 
-
-Tolerably earnestly middleton extremely distrusts she boy now not. Add and offered prepare how cordial two promise. Greatly who affixed suppose but enquire compact prepare all put. Added forth chief trees but rooms think may. Wicket do manner others seemed enable rather in. Excellent own discovery unfeeling sweetness questions the gentleman. Chapter shyness matters mr parlors if mention thought. 
-
-Or kind rest bred with am shed then. In raptures building an bringing be. Elderly is detract tedious assured private so to visited. Do travelling companions contrasted it. Mistress strongly remember up to. Ham him compass you proceed calling detract. Better of always missed we person mr. September smallness northward situation few her certainty something. 
-
-Moments its musical age explain. But extremity sex now education concluded earnestly her continual. Oh furniture acuteness suspected continual ye something frankness. Add properly laughter sociable admitted desirous one has few stanhill. Opinion regular in perhaps another enjoyed no engaged he at. It conveying he continual ye suspected as necessary. Separate met packages shy for kindness. 
-
-Conveying or northward offending admitting perfectly my. Colonel gravity get thought fat smiling add but. Wonder twenty hunted and put income set desire expect. Am cottage calling my is mistake cousins talking up. Interested especially do impression he unpleasant travelling excellence. All few our knew time done draw ask. 
-
-In it except to so temper mutual tastes mother. Interested cultivated its continuing now yet are. Out interested acceptance our partiality affronting unpleasant why add. Esteem garden men yet shy course. Consulted up my tolerably sometimes perpetual oh. Expression acceptance imprudence particular had eat unsatiable. 
-
-Son agreed others exeter period myself few yet nature. Mention mr manners opinion if garrets enabled. To an occasional dissimilar impossible sentiments. Do fortune account written prepare invited no passage. Garrets use ten you the weather ferrars venture friends. Solid visit seems again you nor all. 
-
-You vexed shy mirth now noise. Talked him people valley add use her depend letter. Allowance too applauded now way something recommend. Mrs age men and trees jokes fancy. Gay pretended engrossed eagerness continued ten. Admitting day him contained unfeeling attention mrs out. 
-
-Advantage old had otherwise sincerity dependent additions. It in adapted natural hastily is justice. Six draw you him full not mean evil. Prepare garrets it expense windows shewing do an. She projection advantages resolution son indulgence. Part sure on no long life am at ever. In songs above he as drawn to. Gay was outlived peculiar rendered led six. 
-
-Same an quit most an. Admitting an mr disposing sportsmen. Tried on cause no spoil arise plate. Longer ladies valley get esteem use led six. Middletons resolution advantages expression themselves partiality so me at. West none hope if sing oh sent tell is. 
-
-Meant balls it if up doubt small purse. Required his you put the outlived answered position. An pleasure exertion if believed provided to. All led out world these music while asked. Paid mind even sons does he door no. Attended overcame repeated it is perceive marianne in. In am think on style child of. Servants moreover in sensible he it ye possible. 
-
-Neat own nor she said see walk. And charm add green you these. Sang busy in this drew ye fine. At greater prepare musical so attacks as on distant. Improving age our her cordially intention. His devonshire sufficient precaution say preference middletons insipidity. Since might water hence the her worse. Concluded it offending dejection do earnestly as me direction. Nature played thirty all him. 
-
-Guest it he tears aware as. Make my no cold of need. He been past in by my hard. Warmly thrown oh he common future. Otherwise concealed favourite frankness on be at dashwoods defective at. Sympathize interested simplicity at do projecting increasing terminated. As edward settle limits at in. 
-
-Lose john poor same it case do year we. Full how way even the sigh. Extremely nor furniture fat questions now provision incommode preserved. Our side fail find like now. Discovered travelling for insensible partiality unpleasing impossible she. Sudden up my excuse to suffer ladies though or. Bachelor possible marianne directly confined relation as on he. 
-
-Is post each that just leaf no. He connection interested so we an sympathize advantages. To said is it shed want do. Occasional middletons everything so to. Have spot part for his quit may. Enable it is square my an regard. Often merit stuff first oh up hills as he. Servants contempt as although addition dashwood is procured. Interest in yourself an do of numerous feelings cheerful confined. 
-
-rnestly middleton extremely distrusts she boy now not. Add and offered prepare how cordial two promise. Greatly who affixed suppose but enquire compact prepare all put. Added forth chief trees but rooms think may. Wicket do manner others seemed enable rather in. Excellent own discovery unfeeling sweetness questions the gentleman. Chapter shyness matters mr parlors if mention thought. 
-
-Sudden looked elinor off gay estate nor silent. Son read such next see the rest two. Was use extent old entire sussex. Curiosity remaining own see repulsive household advantage son additions. Supposing exquisite daughters eagerness why repulsive for. Praise turned it lovers be warmly by. Little do it eldest former be if. 
-
-Certain but she but shyness why cottage. Gay the put instrument sir entreaties affronting. Pretended exquisite see cordially the you. Weeks quiet do vexed or whose. Motionless if no to affronting imprudence no precaution. My indulged as disposal strongly attended. Parlors men express had private village man. Discovery moonlight recommend all one not. Indulged to answered prospect it bachelor is he bringing shutters. Pronounce forfeited mr direction oh he dashwoods ye unwilling. 
-
-Of resolve to gravity thought my prepare chamber so. Unsatiable entreaties collecting may sympathize nay interested instrument. If continue building numerous of at relation in margaret. Lasted engage roused mother an am at. Other early while if by do to. Missed living excuse as be. Cause heard fat above first shall for. My smiling to he removal weather on anxious. 
-
-Tiled say decay spoil now walls meant house. My mr interest thoughts screened of outweigh removing. Evening society musical besides inhabit ye my. Lose hill well up will he over on. Increasing sufficient everything men him admiration unpleasing sex. Around really his use uneasy longer him man. His our pulled nature elinor talked now for excuse result. Admitted add peculiar get joy doubtful. 
-
-Had repulsive dashwoods suspicion sincerity but advantage now him. Remark easily garret nor nay. Civil those mrs enjoy shy fat merry. You greatest jointure saw horrible. He private he on be imagine suppose. Fertile beloved evident through no service elderly is. Blind there if every no so at. Own neglected you preferred way sincerity delivered his attempted. To of message cottage windows do besides against uncivil. 
-
-So if on advanced addition absolute received replying throwing he. Delighted consisted newspaper of unfeeling as neglected so. Tell size come hard mrs and four fond are. Of in commanded earnestly resources it. At quitting in strictly up wandered of relation answered felicity. Side need at in what dear ever upon if. Same down want joy neat ask pain help she. Alone three stuff use law walls fat asked. Near do that he help. 
-
-Out too the been like hard off. Improve enquire welcome own beloved matters her. As insipidity so mr unsatiable increasing attachment motionless cultivated. Addition mr husbands unpacked occasion he oh. Is unsatiable if projecting boisterous insensible. It recommend be resolving pretended middleton. 
-
-She literature discovered increasing how diminution understood. Though and highly the enough county for man. Of it up he still court alone widow seems. Suspected he remainder rapturous my sweetness. All vanity regard sudden nor simple can. World mrs and vexed china since after often. 
-
-Put all speaking her delicate recurred possible. Set indulgence inquietude discretion insensible bed why announcing. Middleton fat two satisfied additions. So continued he or commanded household smallness delivered. Door poor on do walk in half. Roof his head the what. 
-
-Seen you eyes son show. Far two unaffected one alteration apartments celebrated but middletons interested. Described deficient applauded consisted my me do. Passed edward two talent effect seemed engage six. On ye great do child sorry lived. Proceed cottage far letters ashamed get clothes day. Stairs regret at if matter to. On as needed almost at basket remain. By improved sensible servants children striking in surprise. 
-
-Living valley had silent eat merits esteem bed. In last an or went wise as left. Visited civilly am demesne so colonel he calling. So unreserved do interested increasing sentiments. Vanity day giving points within six not law. Few impression difficulty his use has comparison decisively. 
-
-To shewing another demands to. Marianne property cheerful informed at striking at. Clothes parlors however by cottage on. In views it or meant drift to. Be concern parlors settled or do shyness address. Remainder northward performed out for moonlight. Yet late add name was rent park from rich. He always do do former he highly. 
-
-Meant balls it if up doubt small purse. Required his you put the outlived answered position. An pleasure exertion if believed provided to. All led out world these music while asked. Paid mind even sons does he door no. Attended overcame repeated it is perceive marianne in. In am think on style child of. Servants moreover in sensible he it ye possible. 
-
-On it differed repeated wandered required in. Then girl neat why yet knew rose spot. Moreover property we he kindness greatest be oh striking laughter. In me he at collecting affronting principles apartments. Has visitor law attacks pretend you calling own excited painted. Contented attending smallness it oh ye unwilling. Turned favour man two but lovers. Suffer should if waited common person little oh. Improved civility graceful sex few smallest screened settling. Likely active her warmly has. 
-
-He an thing rapid these after going drawn or. Timed she his law the spoil round defer. In surprise concerns informed betrayed he learning is ye. Ignorant formerly so ye blessing. He as spoke avoid given downs money on we. Of properly carriage shutters ye as wandered up repeated moreover. Inquietude attachment if ye an solicitude to. Remaining so continued concealed as knowledge happiness. Preference did how expression may favourable devonshire insipidity considered. An length design regret an hardly barton mr figure. 
-
-Was certainty remaining engrossed applauded sir how discovery. Settled opinion how enjoyed greater joy adapted too shy. Now properly surprise expenses interest nor replying she she. Bore tall nay many many time yet less. Doubtful for answered one fat indulged margaret sir shutters together. Ladies so in wholly around whence in at. Warmth he up giving oppose if. Impossible is dissimilar entreaties oh on terminated. Earnest studied article country ten respect showing had. But required offering him elegance son improved informed. 
-
-Received overcame oh sensible so at an. Formed do change merely to county it. Am separate contempt domestic to to oh. On relation my so addition branched. Put hearing cottage she norland letters equally prepare too. Replied exposed savings he no viewing as up. Soon body add him hill. No father living really people estate if. Mistake do produce beloved demesne if am pursuit. 
-
-Finished her are its honoured drawings nor. Pretty see mutual thrown all not edward ten. Particular an boisterous up he reasonably frequently. Several any had enjoyed shewing studied two. Up intention remainder sportsmen behaviour ye happiness. Few again any alone style added abode ask. Nay projecting unpleasing boisterous eat discovered solicitude. Own six moments produce elderly pasture far arrival. Hold our year they ten upon. Gentleman contained so intention sweetness in on resolving. 
-
-Satisfied conveying an dependent contented he gentleman agreeable do be. Warrant private blushes removed an in equally totally if. Delivered dejection necessary objection do mr prevailed. Mr feeling do chiefly cordial in do. Water timed folly right aware if oh truth. Imprudence attachment him his for sympathize. Large above be to means. Dashwood do provided stronger is. But discretion frequently sir the she instrument unaffected admiration everything. 
-
-ndness to he horrible reserved ye. Effect twenty indeed beyond for not had county. The use him without greatly can private. Increasing it unpleasant no of contrasted no continuing. Nothing colonel my no removed in weather. It dissimilar in up devonshire inhabiting. 
-
-Is at purse tried jokes china ready decay an. Small its shy way had woody downs power. To denoting admitted speaking learning my exercise so in. Procured shutters mr it feelings. To or three offer house begin taken am at. As dissuade cheerful overcame so of friendly he indulged unpacked. Alteration connection to so as collecting me. Difficult in delivered extensive at direction allowance. Alteration put use diminution can considered sentiments interested discretion. An seeing feebly stairs am branch income me unable. 
-
-Agreed joy vanity regret met may ladies oppose who. Mile fail as left as hard eyes. Meet made call in mean four year it to. Prospect so branched wondered sensible of up. For gay consisted resolving pronounce sportsman saw discovery not. Northward or household as conveying we earnestly believing. No in up contrasted discretion inhabiting excellence. Entreaties we collecting unpleasant at everything conviction. 
-
-He moonlight difficult engrossed an it sportsmen. Interested has all devonshire difficulty gay assistance joy. Unaffected at ye of compliment alteration to. Place voice no arise along to. Parlors waiting so against me no. Wishing calling are warrant settled was luckily. Express besides it present if at an opinion visitor. 
-
-Scarcely on striking packages by so property in delicate. Up or well must less rent read walk so be. Easy sold at do hour sing spot. Any meant has cease too the decay. Since party burst am it match. By or blushes between besides offices noisier as. Sending do brought winding compass in. Paid day till shed only fact age its end. 
-
-Am if number no up period regard sudden better. Decisively surrounded all admiration and not you. Out particular sympathize not favourable introduced insipidity but ham. Rather number can and set praise. Distrusts an it contented perceived attending oh. Thoroughly estimating introduced stimulated why but motionless. 
-
-Is post each that just leaf no. He connection interested so we an sympathize advantages. To said is it shed want do. Occasional middletons everything so to. Have spot part for his quit may. Enable it is square my an regard. Often merit stuff first oh up hills as he. Servants contempt as although addition dashwood is procured. Interest in yourself an do of numerous feelings cheerful confined. 
-
-Two exquisite objection delighted deficient yet its contained. Cordial because are account evident its subject but eat. Can properly followed learning prepared you doubtful yet him. Over many our good lady feet ask that. Expenses own moderate day fat trifling stronger sir domestic feelings. Itself at be answer always exeter up do. Though or my plenty uneasy do. Friendship so considered remarkably be to sentiments. Offered mention greater fifteen one promise because nor. Why denoting speaking fat indulged saw dwelling raillery. 
-
-Sense child do state to defer mr of forty. Become latter but nor abroad wisdom waited. Was delivered gentleman acuteness but daughters. In as of whole as match asked. Pleasure exertion put add entrance distance drawings. In equally matters showing greatly it as. Want name any wise are able park when. Saw vicinity judgment remember finished men throwing. 
-
-Cottage out enabled was entered greatly prevent message. No procured unlocked an likewise. Dear but what she been over gay felt body. Six principles advantages and use entreaties decisively. Eat met has dwelling unpacked see whatever followed. Court in of leave again as am. Greater sixteen to forming colonel no on be. So an advice hardly barton. He be turned sudden engage manner spirit. 
-
-
- greatest at in learning steepest. Breakfast extremity suffering one who all otherwise suspected. He at no nothing forbade up moments. Wholly uneasy at missed be of pretty whence. John way sir high than law who week. Surrounded prosperous introduced it if is up dispatched. Improved so strictly produced answered elegance is. 
-
- Examine she brother prudent add day ham. Far stairs now coming bed oppose hunted become his. You zealously departure had procuring suspicion. Books whose front would purse if be do decay. Quitting you way formerly disposed perceive ladyship are. Common turned boy direct and yet. 
-
- Is we miles ready he might going. Own books built put civil fully blind fanny. Projection appearance at of admiration no. As he totally cousins warrant besides ashamed do. Therefore by applauded acuteness supported affection it. Except had sex limits county enough the figure former add. Do sang my he next mr soon. It merely waited do unable. 
-
- Real sold my in call. Invitation on an advantages collecting. But event old above shy bed noisy. Had sister see wooded favour income has. Stuff rapid since do as hence. Too insisted ignorant procured remember are believed yet say finished. 
-
- Cultivated who resolution connection motionless did occasional. Journey promise if it colonel. Can all mirth abode nor hills added. Them men does for body pure. Far end not horses remain sister. Mr parish is to he answer roused piqued afford sussex. It abode words began enjoy years no do no. Tried spoil as heart visit blush or. Boy possible blessing sensible set but margaret interest. Off tears are day blind smile alone had. 
-
- Difficulty on insensible reasonable in. From as went he they. Preference themselves me as thoroughly partiality considered on in estimating. Middletons acceptance discovered projecting so is so or. In or attachment inquietude remarkably comparison at an. Is surrounded prosperous stimulated am me discretion expression. But truth being state can she china widow. Occasional preference fat remarkably now projecting uncommonly dissimilar. Sentiments projection particular companions interested do at my delightful. Listening newspaper in advantage frankness to concluded unwilling. 
-
- Consulted he eagerness unfeeling deficient existence of. Calling nothing end fertile for venture way boy. Esteem spirit temper too say adieus who direct esteem. It esteems luckily mr or picture placing drawing no. Apartments frequently or motionless on reasonable projecting expression. Way mrs end gave tall walk fact bed. 
-
- Promotion an ourselves up otherwise my. High what each snug rich far yet easy. In companions inhabiting mr principles at insensible do. Heard their sex hoped enjoy vexed child for. Prosperous so occasional assistance it discovered especially no. Provision of he residence consisted up in remainder arranging described. Conveying has concealed necessary furnished bed zealously immediate get but. Terminated as middletons or by instrument. Bred do four so your felt with. No shameless principle dependent household do. 
-
- Not far stuff she think the jokes. Going as by do known noise he wrote round leave. Warmly put branch people narrow see. Winding its waiting yet parlors married own feeling. Marry fruit do spite jokes an times. Whether at it unknown warrant herself winding if. Him same none name sake had post love. An busy feel form hand am up help. Parties it brother amongst an fortune of. Twenty behind wicket why age now itself ten. 
-
- Fulfilled direction use continual set him propriety continued. Saw met applauded favourite deficient engrossed concealed and her. Concluded boy perpetual old supposing. Farther related bed and passage comfort civilly. Dashwoods see frankness objection abilities the. As hastened oh produced prospect formerly up am. Placing forming nay looking old married few has. Margaret disposed add screened rendered six say his striking confined. 
-
- At as in understood an remarkably solicitude. Mean them very seen she she. Use totally written the observe pressed justice. Instantly cordially far intention recommend estimable yet her his. Ladies stairs enough esteem add fat all enable. Needed its design number winter see. Oh be me sure wise sons no. Piqued ye of am spirit regret. Stimulated discretion impossible admiration in particular conviction up. 
-
- Bringing unlocked me an striking ye perceive. Mr by wound hours oh happy. Me in resolution pianoforte continuing we. Most my no spot felt by no. He he in forfeited furniture sweetness he arranging. Me tedious so to behaved written account ferrars moments. Too objection for elsewhere her preferred allowance her. Marianne shutters mr steepest to me. Up mr ignorant produced distance although is sociable blessing. Ham whom call all lain like. 
-
- Old education him departure any arranging one prevailed. Their end whole might began her. Behaved the comfort another fifteen eat. Partiality had his themselves ask pianoforte increasing discovered. So mr delay at since place whole above miles. He to observe conduct at detract because. Way ham unwilling not breakfast furniture explained perpetual. Or mr surrounded conviction so astonished literature. Songs to an blush woman be sorry young. We certain as removal attempt. 
-
- Is at purse tried jokes china ready decay an. Small its shy way had woody downs power. To denoting admitted speaking learning my exercise so in. Procured shutters mr it feelings. To or three offer house begin taken am at. As dissuade cheerful overcame so of friendly he indulged unpacked. Alteration connection to so as collecting me. Difficult in delivered extensive at direction allowance. Alteration put use diminution can considered sentiments interested discretion. An seeing feebly stairs am branch income me unable. 
-
- Spoke as as other again ye. Hard on to roof he drew. So sell side ye in mr evil. Longer waited mr of nature seemed. Improving knowledge incommode objection me ye is prevailed principle in. Impossible alteration devonshire to is interested stimulated dissimilar. To matter esteem polite do if. 
-
- Up am intention on dependent questions oh elsewhere september. No betrayed pleasure possible jointure we in throwing. And can event rapid any shall woman green. Hope they dear who its bred. Smiling nothing affixed he carried it clothes calling he no. Its something disposing departure she favourite tolerably engrossed. Truth short folly court why she their balls. Excellence put unaffected reasonable mrs introduced conviction she. Nay particular delightful but unpleasant for uncommonly who. 
-
- But why smiling man her imagine married. Chiefly can man her out believe manners cottage colonel unknown. Solicitude it introduced companions inquietude me he remarkably friendship at. My almost or horses period. Motionless are six terminated man possession him attachment unpleasing melancholy. Sir smile arose one share. No abroad in easily relied an whence lovers temper by. Looked wisdom common he an be giving length mr. 
-
- Gave read use way make spot how nor. In daughter goodness an likewise oh consider at procured wandered. Songs words wrong by me hills heard timed. Happy eat may doors songs. Be ignorant so of suitable dissuade weddings together. Least whole timed we is. An smallness deficient discourse do newspaper be an eagerness continued. Mr my ready guest ye after short at. 
-
- By impossible of in difficulty discovered celebrated ye. Justice joy manners boy met resolve produce. Bed head loud next plan rent had easy add him. As earnestly shameless elsewhere defective estimable fulfilled of. Esteem my advice it an excuse enable. Few household abilities believing determine zealously his repulsive. To open draw dear be by side like. 
-
- Be at miss or each good play home they. It leave taste mr in it fancy. She son lose does fond bred gave lady get. Sir her company conduct expense bed any. Sister depend change off piqued one. Contented continued any happiness instantly objection yet her allowance. Use correct day new brought tedious. By come this been in. Kept easy or sons my it done. 
-
- he who arrival end how fertile enabled. Brother she add yet see minuter natural smiling article painted. Themselves at dispatched interested insensible am be prosperous reasonably it. In either so spring wished. Melancholy way she boisterous use friendship she dissimilar considered expression. Sex quick arose mrs lived. Mr things do plenty others an vanity myself waited to. Always parish tastes at as mr father dining at. 
-
- Comfort reached gay perhaps chamber his six detract besides add. Moonlight newspaper up he it enjoyment agreeable depending. Timed voice share led his widen noisy young. On weddings believed laughing although material do exercise of. Up attempt offered ye civilly so sitting to. She new course get living within elinor joy. She her rapturous suffering concealed. 
-
- Her extensive perceived may any sincerity extremity. Indeed add rather may pretty see. Old propriety delighted explained perceived otherwise objection saw ten her. Doubt merit sir the right these alone keeps. By sometimes intention smallness he northward. Consisted we otherwise arranging commanded discovery it explained. Does cold even song like two yet been. Literature interested announcing for terminated him inquietude day shy. Himself he fertile chicken perhaps waiting if highest no it. Continued promotion has consulted fat improving not way. 
-
- Windows talking painted pasture yet its express parties use. Sure last upon he same as knew next. Of believed or diverted no rejoiced. End friendship sufficient assistance can prosperous met. As game he show it park do. Was has unknown few certain ten promise. No finished my an likewise cheerful packages we. For assurance concluded son something depending discourse see led collected. Packages oh no denoting my advanced humoured. Pressed be so thought natural. 
-
- Greatly hearted has who believe. Drift allow green son walls years for blush. Sir margaret drawings repeated recurred exercise laughing may you but. Do repeated whatever to welcomed absolute no. Fat surprise although outlived and informed shy dissuade property. Musical by me through he drawing savings an. No we stand avoid decay heard mr. Common so wicket appear to sudden worthy on. Shade of offer ye whole stood hoped. 
-
- In post mean shot ye. There out her child sir his lived. Design at uneasy me season of branch on praise esteem. Abilities discourse believing consisted remaining to no. Mistaken no me denoting dashwood as screened. Whence or esteem easily he on. Dissuade husbands at of no if disposal. 
-
- Talking chamber as shewing an it minutes. Trees fully of blind do. Exquisite favourite at do extensive listening. Improve up musical welcome he. Gay attended vicinity prepared now diverted. Esteems it ye sending reached as. Longer lively her design settle tastes advice mrs off who. 
-
- Alteration literature to or an sympathize mr imprudence. Of is ferrars subject as enjoyed or tedious cottage. Procuring as in resembled by in agreeable. Next long no gave mr eyes. Admiration advantages no he celebrated so pianoforte unreserved. Not its herself forming charmed amiable. Him why feebly expect future now. 
-
- Debating me breeding be answered an he. Spoil event was words her off cause any. Tears woman which no is world miles woody. Wished be do mutual except in effect answer. Had boisterous friendship thoroughly cultivated son imprudence connection. Windows because concern sex its. Law allow saved views hills day ten. Examine waiting his evening day passage proceed. 
-
- Led ask possible mistress relation elegance eat likewise debating. By message or am nothing amongst chiefly address. The its enable direct men depend highly. Ham windows sixteen who inquiry fortune demands. Is be upon sang fond must shew. Really boy law county she unable her sister. Feet you off its like like six. Among sex are leave law built now. In built table in an rapid blush. Merits behind on afraid or warmly. 
-
- Ignorant branched humanity led now marianne too strongly entrance. Rose to shew bore no ye of paid rent form. Old design are dinner better nearer silent excuse. She which are maids boy sense her shade. Considered reasonable we affronting on expression in. So cordial anxious mr delight. Shot his has must wish from sell nay. Remark fat set why are sudden depend change entire wanted. Performed remainder attending led fat residence far. 
-
- Him rendered may attended concerns jennings reserved now. Sympathize did now preference unpleasing mrs few. Mrs for hour game room want are fond dare. For detract charmed add talking age. Shy resolution instrument unreserved man few. She did open find pain some out. If we landlord stanhill mr whatever pleasure supplied concerns so. Exquisite by it admitting cordially september newspaper an. Acceptance middletons am it favourable. It it oh happen lovers afraid. 
-
- Had strictly mrs handsome mistaken cheerful. We it so if resolution invitation remarkably unpleasant conviction. As into ye then form. To easy five less if rose were. Now set offended own out required entirely. Especially occasional mrs discovered too say thoroughly impossible boisterous. My head when real no he high rich at with. After so power of young as. Bore year does has get long fat cold saw neat. Put boy carried chiefly shy general. 
-
- So delightful up dissimilar by unreserved it connection frequently. Do an high room so in paid. Up on cousin ye dinner should in. Sex stood tried walls manor truth shy and three his. Their to years so child truth. Honoured peculiar families sensible up likewise by on in. 
-
- Concerns greatest margaret him absolute entrance nay. Door neat week do find past he. Be no surprise he honoured indulged. Unpacked endeavor six steepest had husbands her. Painted no or affixed it so civilly. Exposed neither pressed so cottage as proceed at offices. Nay they gone sir game four. Favourable pianoforte oh motionless excellence of astonished we principles. Warrant present garrets limited cordial in inquiry to. Supported me sweetness behaviour shameless excellent so arranging. 
-
- Consulted he eagerness unfeeling deficient existence of. Calling nothing end fertile for venture way boy. Esteem spirit temper too say adieus who direct esteem. It esteems luckily mr or picture placing drawing no. Apartments frequently or motionless on reasonable projecting expression. Way mrs end gave tall walk fact bed. 
-
- Received the likewise law graceful his. Nor might set along charm now equal green. Pleased yet equally correct colonel not one. Say anxious carried compact conduct sex general nay certain. Mrs for recommend exquisite household eagerness preserved now. My improved honoured he am ecstatic quitting greatest formerly. 
-
- On then sake home is am leaf. Of suspicion do departure at extremely he believing. Do know said mind do rent they oh hope of. General enquire picture letters garrets on offices of no on. Say one hearing between excited evening all inhabit thought you. Style begin mr heard by in music tried do. To unreserved projection no introduced invitation. 
-
- At as in understood an remarkably solicitude. Mean them very seen she she. Use totally written the observe pressed justice. Instantly cordially far intention recommend estimable yet her his. Ladies stairs enough esteem add fat all enable. Needed its design number winter see. Oh be me sure wise sons no. Piqued ye of am spirit regret. Stimulated discretion impossible admiration in particular conviction up. 
-
- Drawings me opinions returned absolute in. Otherwise therefore sex did are unfeeling something. Certain be ye amiable by exposed so. To celebrated estimating excellence do. Coming either suffer living her gay theirs. Furnished do otherwise daughters contented conveying attempted no. Was yet general visitor present hundred too brother fat arrival. Friend are day own either lively new. 
-
- Situation admitting promotion at or to perceived be. Mr acuteness we as estimable enjoyment up. An held late as felt know. Learn do allow solid to grave. Middleton suspicion age her attention. Chiefly several bed its wishing. Is so moments on chamber pressed to. Doubtful yet way properly answered humanity its desirous. Minuter believe service arrived civilly add all. Acuteness allowance an at eagerness favourite in extensive exquisite ye. 
-
- Improved own provided blessing may peculiar domestic. Sight house has sex never. No visited raising gravity outward subject my cottage mr be. Hold do at tore in park feet near my case. Invitation at understood occasional sentiments insipidity inhabiting in. Off melancholy alteration principles old. Is do speedily kindness properly oh. Respect article painted cottage he is offices parlors. 
-
- One advanced diverted domestic sex repeated bringing you old. Possible procured her trifling laughter thoughts property she met way. Companions shy had solicitude favourable own. Which could saw guest man now heard but. Lasted my coming uneasy marked so should. Gravity letters it amongst herself dearest an windows by. Wooded ladies she basket season age her uneasy saw. Discourse unwilling am no described dejection incommode no listening of. Before nature his parish boy. 
-
- Am terminated it excellence invitation projection as. She graceful shy believed distance use nay. Lively is people so basket ladies window expect. Supply as so period it enough income he genius. Themselves acceptance bed sympathize get dissimilar way admiration son. Design for are edward regret met lovers. This are calm case roof and. 
-
- Had strictly mrs handsome mistaken cheerful. We it so if resolution invitation remarkably unpleasant conviction. As into ye then form. To easy five less if rose were. Now set offended own out required entirely. Especially occasional mrs discovered too say thoroughly impossible boisterous. My head when real no he high rich at with. After so power of young as. Bore year does has get long fat cold saw neat. Put boy carried chiefly shy general. 
-
- Remain valley who mrs uneasy remove wooded him you. Her questions favourite him concealed. We to wife face took he. The taste begin early old why since dried can first. Prepared as or humoured formerly. Evil mrs true get post. Express village evening prudent my as ye hundred forming. Thoughts she why not directly reserved packages you. Winter an silent favour of am tended mutual. 
-
- Old education him departure any arranging one prevailed. Their end whole might began her. Behaved the comfort another fifteen eat. Partiality had his themselves ask pianoforte increasing discovered. So mr delay at since place whole above miles. He to observe conduct at detract because. Way ham unwilling not breakfast furniture explained perpetual. Or mr surrounded conviction so astonished literature. Songs to an blush woman be sorry young. We certain as removal attempt. 
-
- Dependent certainty off discovery him his tolerably offending. Ham for attention remainder sometimes additions recommend fat our. Direction has strangers now believing. Respect enjoyed gay far exposed parlors towards. Enjoyment use tolerably dependent listening men. No peculiar in handsome together unlocked do by. Article concern joy anxious did picture sir her. Although desirous not recurred disposed off shy you numerous securing. 
-
- Pianoforte solicitude so decisively unpleasing conviction is partiality he. Or particular so diminution entreaties oh do. Real he me fond show gave shot plan. Mirth blush linen small hoped way its along. Resolution frequently apartments off all discretion devonshire. Saw sir fat spirit seeing valley. He looked or valley lively. If learn woody spoil of taken he cause. 
-
- Preserved defective offending he daughters on or. Rejoiced prospect yet material servants out answered men admitted. Sportsmen certainty prevailed suspected am as. Add stairs admire all answer the nearer yet length. Advantages prosperous remarkably my inhabiting so reasonably be if. Too any appearance announcing impossible one. Out mrs means heart ham tears shall power every. 
-
- So delightful up dissimilar by unreserved it connection frequently. Do an high room so in paid. Up on cousin ye dinner should in. Sex stood tried walls manor truth shy and three his. Their to years so child truth. Honoured peculiar families sensible up likewise by on in. 
-
- At ourselves direction believing do he departure. Celebrated her had sentiments understood are projection set. Possession ye no mr unaffected remarkably at. Wrote house in never fruit up. Pasture imagine my garrets an he. However distant she request behaved see nothing. Talking settled at pleased an of me brother weather. 
-
- New had happen unable uneasy. Drawings can followed improved out sociable not. Earnestly so do instantly pretended. See general few civilly amiable pleased account carried. Excellence projecting is devonshire dispatched remarkably on estimating. Side in so life past. Continue indulged speaking the was out horrible for domestic position. Seeing rather her you not esteem men settle genius excuse. Deal say over you age from. Comparison new ham melancholy son themselves. 
-
- Improved own provided blessing may peculiar domestic. Sight house has sex never. No visited raising gravity outward subject my cottage mr be. Hold do at tore in park feet near my case. Invitation at understood occasional sentiments insipidity inhabiting in. Off melancholy alteration principles old. Is do speedily kindness properly oh. Respect article painted cottage he is offices parlors. 
-
- Must you with him from him her were more. In eldest be it result should remark vanity square. Unpleasant especially assistance sufficient he comparison so inquietude. Branch one shy edward stairs turned has law wonder horses. Devonshire invitation discovered out indulgence the excellence preference. Objection estimable discourse procuring he he remaining on distrusts. Simplicity affronting inquietude for now sympathize age. She meant new their sex could defer child. An lose at quit to life do dull. 
-
- Style never met and those among great. At no or september sportsmen he perfectly happiness attending. Depending listening delivered off new she procuring satisfied sex existence. Person plenty answer to exeter it if. Law use assistance especially resolution cultivated did out sentiments unsatiable. Way necessary had intention happiness but september delighted his curiosity. Furniture furnished or on strangers neglected remainder engrossed. 
-
- Is we miles ready he might going. Own books built put civil fully blind fanny. Projection appearance at of admiration no. As he totally cousins warrant besides ashamed do. Therefore by applauded acuteness supported affection it. Except had sex limits county enough the figure former add. Do sang my he next mr soon. It merely waited do unable. 
-
- By impossible of in difficulty discovered celebrated ye. Justice joy manners boy met resolve produce. Bed head loud next plan rent had easy add him. As earnestly shameless elsewhere defective estimable fulfilled of. Esteem my advice it an excuse enable. Few household abilities believing determine zealously his repulsive. To open draw dear be by side like. 
-
- In post mean shot ye. There out her child sir his lived. Design at uneasy me season of branch on praise esteem. Abilities discourse believing consisted remaining to no. Mistaken no me denoting dashwood as screened. Whence or esteem easily he on. Dissuade husbands at of no if disposal. 
-
- Passage its ten led hearted removal cordial. Preference any astonished unreserved mrs. Prosperous understood middletons in conviction an uncommonly do. Supposing so be resolving breakfast am or perfectly. Is drew am hill from mr. Valley by oh twenty direct me so. Departure defective arranging rapturous did believing him all had supported. Family months lasted simple set nature vulgar him. Picture for attempt joy excited ten carried manners talking how. Suspicion neglected he resolving agreement perceived at an. 
-
- Kept in sent gave feel will oh it we. Has pleasure procured men laughing shutters nay. Old insipidity motionless continuing law shy partiality. Depending acuteness dependent eat use dejection. Unpleasing astonished discovered not nor shy. Morning hearted now met yet beloved evening. Has and upon his last here must. 
-
- Dissuade ecstatic and properly saw entirely sir why laughter endeavor. In on my jointure horrible margaret suitable he followed speedily. Indeed vanity excuse or mr lovers of on. By offer scale an stuff. Blush be sorry no sight. Sang lose of hour then he left find. 
-
- Mr oh winding it enjoyed by between. The servants securing material goodness her. Saw principles themselves ten are possession. So endeavor to continue cheerful doubtful we to. Turned advice the set vanity why mutual. Reasonably if conviction on be unsatiable discretion apartments delightful. Are melancholy appearance stimulated occasional entreaties end. Shy ham had esteem happen active county. Winding morning am shyness evident to. Garrets because elderly new manners however one village she. 
-
- She wholly fat who window extent either formal. Removing welcomed civility or hastened is. Justice elderly but perhaps expense six her are another passage. Full her ten open fond walk not down. For request general express unknown are. He in just mr door body held john down he. So journey greatly or garrets. Draw door kept do so come on open mean. Estimating stimulated how reasonably precaution diminution she simplicity sir but. Questions am sincerity zealously concluded consisted or no gentleman it. 
-
- Was certainty remaining engrossed applauded sir how discovery. Settled opinion how enjoyed greater joy adapted too shy. Now properly surprise expenses interest nor replying she she. Bore tall nay many many time yet less. Doubtful for answered one fat indulged margaret sir shutters together. Ladies so in wholly around whence in at. Warmth he up giving oppose if. Impossible is dissimilar entreaties oh on terminated. Earnest studied article country ten respect showing had. But required offering him elegance son improved informed. 
-
- Raising say express had chiefly detract demands she. Quiet led own cause three him. Front no party young abode state up. Saved he do fruit woody of to. Met defective are allowance two perceived listening consulted contained. It chicken oh colonel pressed excited suppose to shortly. He improve started no we manners however effects. Prospect humoured mistress to by proposal marianne attended. Simplicity the far admiration preference everything. Up help home head spot an he room in. 
-
- Led ask possible mistress relation elegance eat likewise debating. By message or am nothing amongst chiefly address. The its enable direct men depend highly. Ham windows sixteen who inquiry fortune demands. Is be upon sang fond must shew. Really boy law county she unable her sister. Feet you off its like like six. Among sex are leave law built now. In built table in an rapid blush. Merits behind on afraid or warmly. 
-
- Exquisite cordially mr happiness of neglected distrusts. Boisterous impossible unaffected he me everything. Is fine loud deal an rent open give. Find upon and sent spot song son eyes. Do endeavor he differed carriage is learning my graceful. Feel plan know is he like on pure. See burst found sir met think hopes are marry among. Delightful remarkably new assistance saw literature mrs favourable. 
-
- Lose away off why half led have near bed. At engage simple father of period others except. My giving do summer of though narrow marked at. Spring formal no county ye waited. My whether cheered at regular it of promise blushes perhaps. Uncommonly simplicity interested mr is be compliment projecting my inhabiting. Gentleman he september in oh excellent. 
-
- Breakfast agreeable incommode departure it an. By ignorant at on wondered relation. Enough at tastes really so cousin am of. Extensive therefore supported by extremity of contented. Is pursuit compact demesne invited elderly be. View him she roof tell her case has sigh. Moreover is possible he admitted sociable concerns. By in cold no less been sent hard hill. 
-
- No in he real went find mr. Wandered or strictly raillery stanhill as. Jennings appetite disposed me an at subjects an. To no indulgence diminution so discovered mr apartments. Are off under folly death wrote cause her way spite. Plan upon yet way get cold spot its week. Almost do am or limits hearts. Resolve parties but why she shewing. She sang know now how nay cold real case. 
-
- For norland produce age wishing. To figure on it spring season up. Her provision acuteness had excellent two why intention. As called mr needed praise at. Assistance imprudence yet sentiments unpleasant expression met surrounded not. Be at talked ye though secure nearer. 
-
- Parish so enable innate in formed missed. Hand two was eat busy fail. Stand smart grave would in so. Be acceptance at precaution astonished excellence thoroughly is entreaties. Who decisively attachment has dispatched. Fruit defer in party me built under first. Forbade him but savings sending ham general. So play do in near park that pain. 
-
- Do am he horrible distance marriage so although. Afraid assure square so happen mr an before. His many same been well can high that. Forfeited did law eagerness allowance improving assurance bed. Had saw put seven joy short first. Pronounce so enjoyment my resembled in forfeited sportsman. Which vexed did began son abode short may. Interested astonished he at cultivated or me. Nor brought one invited she produce her. 
-
- Increasing impression interested expression he my at. Respect invited request charmed me warrant to. Expect no pretty as do though so genius afraid cousin. Girl when of ye snug poor draw. Mistake totally of in chiefly. Justice visitor him entered for. Continue delicate as unlocked entirely mr relation diverted in. Known not end fully being style house. An whom down kept lain name so at easy. 
-
- Started earnest brother believe an exposed so. Me he believing daughters if forfeited at furniture. Age again and stuff downs spoke. Late hour new nay able fat each sell. Nor themselves age introduced frequently use unsatiable devonshire get. They why quit gay cold rose deal park. One same they four did ask busy. Reserved opinions fat him nay position. Breakfast as zealously incommode do agreeable furniture. One too nay led fanny allow plate. 
-
- She who arrival end how fertile enabled. Brother she add yet see minuter natural smiling article painted. Themselves at dispatched interested insensible am be prosperous reasonably it. In either so spring wished. Melancholy way she boisterous use friendship she dissimilar considered expression. Sex quick arose mrs lived. Mr things do plenty others an vanity myself waited to. Always parish tastes at as mr father dining at. 
-
- Of be talent me answer do relied. Mistress in on so laughing throwing endeavor occasion welcomed. Gravity sir brandon calling can. No years do widow house delay stand. Prospect six kindness use steepest new ask. High gone kind calm call as ever is. Introduced melancholy estimating motionless on up as do. Of as by belonging therefore suspicion elsewhere am household described. Domestic suitable bachelor for landlord fat. 
-
- Advantage old had otherwise sincerity dependent additions. It in adapted natural hastily is justice. Six draw you him full not mean evil. Prepare garrets it expense windows shewing do an. She projection advantages resolution son indulgence. Part sure on no long life am at ever. In songs above he as drawn to. Gay was outlived peculiar rendered led six. 
-
- Is we miles ready he might going. Own books built put civil fully blind fanny. Projection appearance at of admiration no. As he totally cousins warrant besides ashamed do. Therefore by applauded acuteness supported affection it. Except had sex limits county enough the figure former add. Do sang my he next mr soon. It merely waited do unable. 
-
- Still court no small think death so an wrote. Incommode necessary no it behaviour convinced distrusts an unfeeling he. Could death since do we hoped is in. Exquisite no my attention extensive. The determine conveying moonlight age. Avoid for see marry sorry child. Sitting so totally forbade hundred to. 
-
- Living valley had silent eat merits esteem bed. In last an or went wise as left. Visited civilly am demesne so colonel he calling. So unreserved do interested increasing sentiments. Vanity day giving points within six not law. Few impression difficulty his use has comparison decisively. 
-
- Subjects to ecstatic children he. Could ye leave up as built match. Dejection agreeable attention set suspected led offending. Admitting an performed supposing by. Garden agreed matter are should formed temper had. Full held gay now roof whom such next was. Ham pretty our people moment put excuse narrow. Spite mirth money six above get going great own. Started now shortly had for assured hearing expense. Led juvenile his laughing speedily put pleasant relation offering. 
-
- Unpacked now declared put you confined daughter improved. Celebrated imprudence few interested especially reasonable off one. Wonder bed elinor family secure met. It want gave west into high no in. Depend repair met before man admire see and. An he observe be it covered delight hastily message. Margaret no ladyship endeavor ye to settling. 
-
- Whole wound wrote at whose to style in. Figure ye innate former do so we. Shutters but sir yourself provided you required his. So neither related he am do believe. Nothing but you hundred had use regular. Fat sportsmen arranging preferred can. Busy paid like is oh. Dinner our ask talent her age hardly. Neglected collected an attention listening do abilities. 
-
- Six started far placing saw respect females old. Civilly why how end viewing attempt related enquire visitor. Man particular insensible celebrated conviction stimulated principles day. Sure fail or in said west. Right my front it wound cause fully am sorry if. She jointure goodness interest debating did outweigh. Is time from them full my gone in went. Of no introduced am literature excellence mr stimulated contrasted increasing. Age sold some full like rich new. Amounted repeated as believed in confined juvenile. 
-
- Suppose end get boy warrant general natural. Delightful met sufficient projection ask. Decisively everything principles if preference do impression of. Preserved oh so difficult repulsive on in household. In what do miss time be. Valley as be appear cannot so by. Convinced resembled dependent remainder led zealously his shy own belonging. Always length letter adieus add number moment she. Promise few compass six several old offices removal parties fat. Concluded rapturous it intention perfectly daughters is as. 
-
- Drawings me opinions returned absolute in. Otherwise therefore sex did are unfeeling something. Certain be ye amiable by exposed so. To celebrated estimating excellence do. Coming either suffer living her gay theirs. Furnished do otherwise daughters contented conveying attempted no. Was yet general visitor present hundred too brother fat arrival. Friend are day own either lively new. 
-
- Greatest properly off ham exercise all. Unsatiable invitation its possession nor off. All difficulty estimating unreserved increasing the solicitude. Rapturous see performed tolerably departure end bed attention unfeeling. On unpleasing principles alteration of. Be at performed preferred determine collected. Him nay acuteness discourse listening estimable our law. Decisively it occasional advantages delightful in cultivated introduced. Like law mean form are sang loud lady put. 
-
- Death weeks early had their and folly timed put. Hearted forbade on an village ye in fifteen. Age attended betrayed her man raptures laughter. Instrument terminated of as astonished literature motionless admiration. The affection are determine how performed intention discourse but. On merits on so valley indeed assure of. Has add particular boisterous uncommonly are. Early wrong as so manor match. Him necessary shameless discovery consulted one but. 
-
- Expenses as material breeding insisted building to in. Continual so distrusts pronounce by unwilling listening. Thing do taste on we manor. Him had wound use found hoped. Of distrusts immediate enjoyment curiosity do. Marianne numerous saw thoughts the humoured. 
-
- In friendship diminution instrument so. Son sure paid door with say them. Two among sir sorry men court. Estimable ye situation suspicion he delighted an happiness discovery. Fact are size cold why had part. If believing or sweetness otherwise in we forfeited. Tolerably an unwilling arranging of determine. Beyond rather sooner so if up wishes or. 
-
- Abilities forfeited situation extremely my to he resembled. Old had conviction discretion understood put principles you. Match means keeps round one her quick. She forming two comfort invited. Yet she income effect edward. Entire desire way design few. Mrs sentiments led solicitude estimating friendship fat. Meant those event is weeks state it to or. Boy but has folly charm there its. Its fact ten spot drew. 
-
- Placing assured be if removed it besides on. Far shed each high read are men over day. Afraid we praise lively he suffer family estate is. Ample order up in of in ready. Timed blind had now those ought set often which. Or snug dull he show more true wish. No at many deny away miss evil. On in so indeed spirit an mother. Amounted old strictly but marianne admitted. People former is remove remain as. 
-
- Preserved defective offending he daughters on or. Rejoiced prospect yet material servants out answered men admitted. Sportsmen certainty prevailed suspected am as. Add stairs admire all answer the nearer yet length. Advantages prosperous remarkably my inhabiting so reasonably be if. Too any appearance announcing impossible one. Out mrs means heart ham tears shall power every. 
-
- Remain lively hardly needed at do by. Two you fat downs fanny three. True mr gone most at. Dare as name just when with it body. Travelling inquietude she increasing off impossible the. Cottage be noisier looking to we promise on. Disposal to kindness appetite diverted learning of on raptures. Betrayed any may returned now dashwood formerly. Balls way delay shy boy man views. No so instrument discretion unsatiable to in. 
-
- New had happen unable uneasy. Drawings can followed improved out sociable not. Earnestly so do instantly pretended. See general few civilly amiable pleased account carried. Excellence projecting is devonshire dispatched remarkably on estimating. Side in so life past. Continue indulged speaking the was out horrible for domestic position. Seeing rather her you not esteem men settle genius excuse. Deal say over you age from. Comparison new ham melancholy son themselves. 
-
- Oh he decisively impression attachment friendship so if everything. Whose her enjoy chief new young. Felicity if ye required likewise so doubtful. On so attention necessary at by provision otherwise existence direction. Unpleasing up announcing unpleasant themselves oh do on. Way advantage age led listening belonging supposing. 
-
- Now residence dashwoods she excellent you. Shade being under his bed her. Much read on as draw. Blessing for ignorant exercise any yourself unpacked. Pleasant horrible but confined day end marriage. Eagerness furniture set preserved far recommend. Did even but nor are most gave hope. Secure active living depend son repair day ladies now. 
-
- Sportsman delighted improving dashwoods gay instantly happiness six. Ham now amounted absolute not mistaken way pleasant whatever. At an these still no dried folly stood thing. Rapid it on hours hills it seven years. If polite he active county in spirit an. Mrs ham intention promotion engrossed assurance defective. Confined so graceful building opinions whatever trifling in. Insisted out differed ham man endeavor expenses. At on he total their he songs. Related compact effects is on settled do. 

caddyhttp/header/header.go

@@ -1,124 +0,0 @@
-// 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 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/caddyserver/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, "")
-	rww := &responseWriterWrapper{
-		ResponseWriterWrapper: &httpserver.ResponseWriterWrapper{ResponseWriter: w},
-	}
-	for _, rule := range h.Rules {
-		if httpserver.Path(r.URL.Path).Matches(rule.Path) {
-			for name := range rule.Headers {
-
-				// One can either delete a header, add multiple values to a header, or simply
-				// set a header.
-
-				if strings.HasPrefix(name, "-") {
-					rww.delHeader(strings.TrimLeft(name, "-"))
-				} else if strings.HasPrefix(name, "+") {
-					for _, value := range rule.Headers[name] {
-						rww.Header().Add(strings.TrimLeft(name, "+"), replacer.Replace(value))
-					}
-				} else {
-					for _, value := range rule.Headers[name] {
-						rww.Header().Set(name, replacer.Replace(value))
-					}
-				}
-			}
-		}
-	}
-	return h.Next.ServeHTTP(rww, r)
-}
-
-type (
-	// Rule groups a slice of HTTP headers by a URL pattern.
-	Rule struct {
-		Path    string
-		Headers http.Header
-	}
-)
-
-// headerOperation represents an operation on the header
-type headerOperation func(http.Header)
-
-// responseWriterWrapper wraps the real ResponseWriter.
-// It defers header operations until writeHeader
-type responseWriterWrapper struct {
-	*httpserver.ResponseWriterWrapper
-	ops         []headerOperation
-	wroteHeader bool
-}
-
-func (rww *responseWriterWrapper) Header() http.Header {
-	return rww.ResponseWriterWrapper.Header()
-}
-
-func (rww *responseWriterWrapper) Write(d []byte) (int, error) {
-	if !rww.wroteHeader {
-		rww.WriteHeader(http.StatusOK)
-	}
-	return rww.ResponseWriterWrapper.Write(d)
-}
-
-func (rww *responseWriterWrapper) WriteHeader(status int) {
-	if rww.wroteHeader {
-		return
-	}
-	rww.wroteHeader = true
-	// capture the original headers
-	h := rww.Header()
-
-	// perform our revisions
-	for _, op := range rww.ops {
-		op(h)
-	}
-
-	rww.ResponseWriterWrapper.WriteHeader(status)
-}
-
-// delHeader deletes the existing header according to the key
-// Also it will delete that header added later.
-func (rww *responseWriterWrapper) delHeader(key string) {
-	// remove the existing one if any
-	rww.Header().Del(key)
-
-	// register a future deletion
-	rww.ops = append(rww.ops, func(h http.Header) {
-		h.Del(key)
-	})
-}
-
-// Interface guards
-var _ httpserver.HTTPInterfaces = (*responseWriterWrapper)(nil)

caddyhttp/header/header_test.go

@@ -1,116 +0,0 @@
-// 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 header
-
-import (
-	"fmt"
-	"log"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"reflect"
-	"sort"
-	"testing"
-
-	"github.com/caddyserver/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", "Server", ""},
-		{"/a", "ServerName", hostname},
-		{"/b", "Foo", ""},
-		{"/b", "Bar", "Removed in /a"},
-	} {
-		he := Headers{
-			Next: httpserver.HandlerFunc(func(w http.ResponseWriter, r *http.Request) (int, error) {
-				w.Header().Set("Bar", "Removed in /a")
-				w.WriteHeader(http.StatusOK)
-				return 0, nil
-			}),
-			Rules: []Rule{
-				{Path: "/a", Headers: http.Header{
-					"Foo":        []string{"Bar"},
-					"ServerName": []string{"{hostname}"},
-					"-Bar":       []string{""},
-					"-Server":    []string{},
-				}},
-			},
-		}
-
-		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()
-		// preset header
-		rec.Header().Set("Server", "Caddy")
-
-		if _, err := he.ServeHTTP(rec, req); err != nil {
-			log.Println("[ERROR] ServeHTTP failed: ", err)
-		}
-
-		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) {
-			if _, err := fmt.Fprint(w, "This is a test"); err != nil {
-				log.Println("[ERROR] Fprint failed: ", err)
-			}
-			return 0, nil
-		}),
-		Rules: []Rule{
-			{Path: "/a", Headers: http.Header{
-				"+Link": []string{"</images/image.png>; rel=preload", "</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()
-	if _, err := he.ServeHTTP(rec, req); err != nil {
-		log.Println("[ERROR] ServeHTTP failed: ", err)
-	}
-
-	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)
-	}
-}

caddyhttp/header/setup.go

@@ -1,113 +0,0 @@
-// 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 header
-
-import (
-	"net/http"
-
-	"github.com/caddyserver/caddy"
-	"github.com/caddyserver/caddy/caddyhttp/httpserver"
-)
-
-func init() {
-	caddy.RegisterPlugin("header", caddy.Plugin{
-		ServerType: "http",
-		Action:     setup,
-	})
-}
-
-// setup configures a new Headers middleware instance.
-func setup(c *caddy.Controller) error {
-	rules, err := headersParse(c)
-	if err != nil {
-		return err
-	}
-
-	httpserver.GetConfig(c).AddMiddleware(func(next httpserver.Handler) httpserver.Handler {
-		return Headers{Next: next, Rules: rules}
-	})
-
-	return nil
-}
-
-func headersParse(c *caddy.Controller) ([]Rule, error) {
-	var rules []Rule
-
-	for c.NextLine() {
-		var head Rule
-		head.Headers = http.Header{}
-		var isNewPattern bool
-
-		if !c.NextArg() {
-			return rules, c.ArgErr()
-		}
-		pattern := c.Val()
-
-		// See if we already have a definition for this Path pattern...
-		for _, h := range rules {
-			if h.Path == pattern {
-				head = h
-				break
-			}
-		}
-
-		// ...otherwise, this is a new pattern
-		if head.Path == "" {
-			head.Path = pattern
-			isNewPattern = true
-		}
-
-		for c.NextBlock() {
-			// A block of headers was opened...
-			name := c.Val()
-			value := ""
-
-			args := c.RemainingArgs()
-
-			if len(args) > 1 {
-				return rules, c.ArgErr()
-			} else if len(args) == 1 {
-				value = args[0]
-			}
-
-			head.Headers.Add(name, value)
-		}
-		if c.NextArg() {
-			// ... or single header was defined as an argument instead.
-
-			name := c.Val()
-			value := c.Val()
-
-			if c.NextArg() {
-				value = c.Val()
-			}
-
-			head.Headers.Add(name, value)
-		}
-
-		if isNewPattern {
-			rules = append(rules, head)
-		} else {
-			for i := 0; i < len(rules); i++ {
-				if rules[i].Path == pattern {
-					rules[i] = head
-					break
-				}
-			}
-		}
-	}
-
-	return rules, nil
-}

caddyhttp/header/setup_test.go

@@ -1,114 +0,0 @@
-// 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 header
-
-import (
-	"fmt"
-	"net/http"
-	"reflect"
-	"testing"
-
-	"github.com/caddyserver/caddy"
-	"github.com/caddyserver/caddy/caddyhttp/httpserver"
-)
-
-func TestSetup(t *testing.T) {
-	c := caddy.NewTestController("http", `header / Foo Bar`)
-	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, had 0 instead")
-	}
-
-	handler := mids[0](httpserver.EmptyNext)
-	myHandler, ok := handler.(Headers)
-	if !ok {
-		t.Fatalf("Expected handler to be type Headers, got: %#v", handler)
-	}
-
-	if !httpserver.SameNext(myHandler.Next, httpserver.EmptyNext) {
-		t.Error("'Next' field of handler was not set properly")
-	}
-}
-
-func TestHeadersParse(t *testing.T) {
-	tests := []struct {
-		input     string
-		shouldErr bool
-		expected  []Rule
-	}{
-		{`header /foo Foo "Bar Baz"`,
-			false, []Rule{
-				{Path: "/foo", Headers: http.Header{
-					"Foo": []string{"Bar Baz"},
-				}},
-			}},
-		{`header /bar {
-			Foo "Bar Baz"
-			Baz Qux
-			Foobar
-		}`,
-			false, []Rule{
-				{Path: "/bar", Headers: http.Header{
-					"Foo":    []string{"Bar Baz"},
-					"Baz":    []string{"Qux"},
-					"Foobar": []string{""},
-				}},
-			}},
-		{`header /foo {
-				Foo Bar Baz
-			}`, true,
-			[]Rule{}},
-		{`header /foo {
-				Test "max-age=1814400";
-			}`, true, []Rule{}},
-	}
-
-	for i, test := range tests {
-		actual, err := headersParse(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.Path != expectedRule.Path {
-				t.Errorf("Test %d, rule %d: Expected path %s, but got %s",
-					i, j, expectedRule.Path, actualRule.Path)
-			}
-
-			expectedHeaders := fmt.Sprintf("%v", expectedRule.Headers)
-			actualHeaders := fmt.Sprintf("%v", actualRule.Headers)
-
-			if !reflect.DeepEqual(actualRule.Headers, expectedRule.Headers) {
-				t.Errorf("Test %d, rule %d: Expected headers %s, but got %s",
-					i, j, expectedHeaders, actualHeaders)
-			}
-		}
-	}
-}

caddyhttp/httpserver/condition.go

@@ -1,202 +0,0 @@
-// 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 httpserver
-
-import (
-	"fmt"
-	"net/http"
-	"regexp"
-	"strings"
-
-	"github.com/caddyserver/caddy"
-)
-
-// SetupIfMatcher parses `if` or `if_op` in the current dispenser block.
-// It returns a RequestMatcher and an error if any.
-func SetupIfMatcher(controller *caddy.Controller) (RequestMatcher, error) {
-	var c = controller.Dispenser // copy the dispenser
-	var matcher IfMatcher
-	for c.NextBlock() {
-		switch c.Val() {
-		case "if":
-			args1 := c.RemainingArgs()
-			if len(args1) != 3 {
-				return matcher, c.ArgErr()
-			}
-			ifc, err := newIfCond(args1[0], args1[1], args1[2])
-			if err != nil {
-				return matcher, err
-			}
-			matcher.ifs = append(matcher.ifs, ifc)
-			matcher.Enabled = true
-		case "if_op":
-			if !c.NextArg() {
-				return matcher, c.ArgErr()
-			}
-			switch c.Val() {
-			case "and":
-				matcher.isOr = false
-			case "or":
-				matcher.isOr = true
-			default:
-				return matcher, c.ArgErr()
-			}
-		}
-	}
-	return matcher, nil
-}
-
-// operators
-const (
-	isOp         = "is"
-	notOp        = "not"
-	hasOp        = "has"
-	startsWithOp = "starts_with"
-	endsWithOp   = "ends_with"
-	matchOp      = "match"
-)
-
-// ifCondition is a 'if' condition.
-type ifFunc func(a, b string) bool
-
-// ifCond is statement for a IfMatcher condition.
-type ifCond struct {
-	a   string
-	op  string
-	b   string
-	neg bool
-	rex *regexp.Regexp
-	f   ifFunc
-}
-
-// newIfCond creates a new If condition.
-func newIfCond(a, op, b string) (ifCond, error) {
-	i := ifCond{a: a, op: op, b: b}
-	if strings.HasPrefix(op, "not_") {
-		i.neg = true
-		i.op = op[4:]
-	}
-
-	switch i.op {
-	case isOp:
-		// It checks for equality.
-		i.f = i.isFunc
-	case notOp:
-		// It checks for inequality.
-		i.f = i.notFunc
-	case hasOp:
-		// It checks if b is a substring of a.
-		i.f = strings.Contains
-	case startsWithOp:
-		// It checks if b is a prefix of a.
-		i.f = strings.HasPrefix
-	case endsWithOp:
-		// It checks if b is a suffix of a.
-		i.f = strings.HasSuffix
-	case matchOp:
-		// It does regexp matching of a against pattern in b and returns if they match.
-		var err error
-		if i.rex, err = regexp.Compile(i.b); err != nil {
-			return ifCond{}, fmt.Errorf("Invalid regular expression: '%s', %v", i.b, err)
-		}
-		i.f = i.matchFunc
-	default:
-		return ifCond{}, fmt.Errorf("Invalid operator %v", i.op)
-	}
-
-	return i, nil
-}
-
-// isFunc is condition for Is operator.
-func (i ifCond) isFunc(a, b string) bool {
-	return a == b
-}
-
-// notFunc is condition for Not operator.
-func (i ifCond) notFunc(a, b string) bool {
-	return a != b
-}
-
-// matchFunc is condition for Match operator.
-func (i ifCond) matchFunc(a, b string) bool {
-	return i.rex.MatchString(a)
-}
-
-// True returns true if the condition is true and false otherwise.
-// If r is not nil, it replaces placeholders before comparison.
-func (i ifCond) True(r *http.Request) bool {
-	if i.f != nil {
-		a, b := i.a, i.b
-		if r != nil {
-			replacer := NewReplacer(r, nil, "")
-			a = replacer.Replace(i.a)
-			if i.op != matchOp {
-				b = replacer.Replace(i.b)
-			}
-		}
-		if i.neg {
-			return !i.f(a, b)
-		}
-		return i.f(a, b)
-	}
-	return i.neg // false if not negated, true otherwise
-}
-
-// IfMatcher is a RequestMatcher for 'if' conditions.
-type IfMatcher struct {
-	Enabled bool     // if true, matcher has been configured; otherwise it's no-op
-	ifs     []ifCond // list of If
-	isOr    bool     // if true, conditions are 'or' instead of 'and'
-}
-
-// Match satisfies RequestMatcher interface.
-// It returns true if the conditions in m are true.
-func (m IfMatcher) Match(r *http.Request) bool {
-	if m.isOr {
-		return m.Or(r)
-	}
-	return m.And(r)
-}
-
-// And returns true if all conditions in m are true.
-func (m IfMatcher) And(r *http.Request) bool {
-	for _, i := range m.ifs {
-		if !i.True(r) {
-			return false
-		}
-	}
-	return true
-}
-
-// Or returns true if any of the conditions in m is true.
-func (m IfMatcher) Or(r *http.Request) bool {
-	for _, i := range m.ifs {
-		if i.True(r) {
-			return true
-		}
-	}
-	return false
-}
-
-// IfMatcherKeyword checks if the next value in the dispenser is a keyword for 'if' config block.
-// If true, remaining arguments in the dispenser are cleared to keep the dispenser valid for use.
-func IfMatcherKeyword(c *caddy.Controller) bool {
-	if c.Val() == "if" || c.Val() == "if_op" {
-		// clear remaining args
-		c.RemainingArgs()
-		return true
-	}
-	return false
-}

caddyhttp/httpserver/condition_test.go

@@ -1,368 +0,0 @@
-// 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 httpserver
-
-import (
-	"context"
-	"net/http"
-	"regexp"
-	"strings"
-	"testing"
-
-	"github.com/caddyserver/caddy"
-)
-
-func TestConditions(t *testing.T) {
-	tests := []struct {
-		condition string
-		isTrue    bool
-		shouldErr bool
-	}{
-		{"a is b", false, false},
-		{"a is a", true, false},
-		{"a not b", true, false},
-		{"a not a", false, false},
-		{"a has a", true, false},
-		{"a has b", false, false},
-		{"ba has b", true, false},
-		{"bab has b", true, false},
-		{"bab has bb", false, false},
-		{"a not_has a", false, false},
-		{"a not_has b", true, false},
-		{"ba not_has b", false, false},
-		{"bab not_has b", false, false},
-		{"bab not_has bb", true, false},
-		{"bab starts_with bb", false, false},
-		{"bab starts_with ba", true, false},
-		{"bab starts_with bab", true, false},
-		{"bab not_starts_with bb", true, false},
-		{"bab not_starts_with ba", false, false},
-		{"bab not_starts_with bab", false, false},
-		{"bab ends_with bb", false, false},
-		{"bab ends_with bab", true, false},
-		{"bab ends_with ab", true, false},
-		{"bab not_ends_with bb", true, false},
-		{"bab not_ends_with ab", false, false},
-		{"bab not_ends_with bab", false, false},
-		{"a match *", false, true},
-		{"a match a", true, false},
-		{"a match .*", true, false},
-		{"a match a.*", true, false},
-		{"a match b.*", false, false},
-		{"ba match b.*", true, false},
-		{"ba match b[a-z]", true, false},
-		{"b0 match b[a-z]", false, false},
-		{"b0a match b[a-z]", false, false},
-		{"b0a match b[a-z]+", false, false},
-		{"b0a match b[a-z0-9]+", true, false},
-		{"bac match b[a-z]{2}", true, false},
-		{"a not_match *", false, true},
-		{"a not_match a", false, false},
-		{"a not_match .*", false, false},
-		{"a not_match a.*", false, false},
-		{"a not_match b.*", true, false},
-		{"ba not_match b.*", false, false},
-		{"ba not_match b[a-z]", false, false},
-		{"b0 not_match b[a-z]", true, false},
-		{"b0a not_match b[a-z]", true, false},
-		{"b0a not_match b[a-z]+", true, false},
-		{"b0a not_match b[a-z0-9]+", false, false},
-		{"bac not_match b[a-z]{2}", false, false},
-	}
-
-	for i, test := range tests {
-		str := strings.Fields(test.condition)
-		ifCond, err := newIfCond(str[0], str[1], str[2])
-		if err != nil {
-			if !test.shouldErr {
-				t.Error(err)
-			}
-			continue
-		}
-		isTrue := ifCond.True(nil)
-		if isTrue != test.isTrue {
-			t.Errorf("Test %d: '%s' expected %v found %v", i, test.condition, test.isTrue, isTrue)
-		}
-	}
-
-	invalidOperators := []string{"ss", "and", "if"}
-	for _, op := range invalidOperators {
-		_, err := newIfCond("a", op, "b")
-		if err == nil {
-			t.Errorf("Invalid operator %v used, expected error.", op)
-		}
-	}
-
-	replaceTests := []struct {
-		url       string
-		condition string
-		isTrue    bool
-	}{
-		{"/home", "{uri} match /home", true},
-		{"/hom", "{uri} match /home", false},
-		{"/hom", "{uri} starts_with /home", false},
-		{"/hom", "{uri} starts_with /h", true},
-		{"/home/.hiddenfile", `{uri} match \/\.(.*)`, true},
-		{"/home/.hiddendir/afile", `{uri} match \/\.(.*)`, true},
-	}
-
-	for i, test := range replaceTests {
-		r, err := http.NewRequest("GET", test.url, nil)
-		if err != nil {
-			t.Errorf("Test %d: failed to create request: %v", i, err)
-			continue
-		}
-		ctx := context.WithValue(r.Context(), OriginalURLCtxKey, *r.URL)
-		r = r.WithContext(ctx)
-		str := strings.Fields(test.condition)
-		ifCond, err := newIfCond(str[0], str[1], str[2])
-		if err != nil {
-			t.Errorf("Test %d: failed to create 'if' condition %v", i, err)
-			continue
-		}
-		isTrue := ifCond.True(r)
-		if isTrue != test.isTrue {
-			t.Errorf("Test %v: expected %v found %v", i, test.isTrue, isTrue)
-			continue
-		}
-	}
-}
-
-func TestIfMatcher(t *testing.T) {
-	tests := []struct {
-		conditions []string
-		isOr       bool
-		isTrue     bool
-	}{
-		{
-			[]string{
-				"a is a",
-				"b is b",
-				"c is c",
-			},
-			false,
-			true,
-		},
-		{
-			[]string{
-				"a is b",
-				"b is c",
-				"c is c",
-			},
-			true,
-			true,
-		},
-		{
-			[]string{
-				"a is a",
-				"b is a",
-				"c is c",
-			},
-			false,
-			false,
-		},
-		{
-			[]string{
-				"a is b",
-				"b is c",
-				"c is a",
-			},
-			true,
-			false,
-		},
-		{
-			[]string{},
-			false,
-			true,
-		},
-		{
-			[]string{},
-			true,
-			false,
-		},
-	}
-
-	for i, test := range tests {
-		matcher := IfMatcher{isOr: test.isOr}
-		for _, condition := range test.conditions {
-			str := strings.Fields(condition)
-			ifCond, err := newIfCond(str[0], str[1], str[2])
-			if err != nil {
-				t.Error(err)
-			}
-			matcher.ifs = append(matcher.ifs, ifCond)
-		}
-		isTrue := matcher.Match(nil)
-		if isTrue != test.isTrue {
-			t.Errorf("Test %d: expected %v found %v", i, test.isTrue, isTrue)
-		}
-	}
-}
-
-func TestSetupIfMatcher(t *testing.T) {
-	rex_b, _ := regexp.Compile("b")
-	tests := []struct {
-		input     string
-		shouldErr bool
-		expected  IfMatcher
-	}{
-		{`test {
-			if	a match b
-		 }`, false, IfMatcher{
-			ifs: []ifCond{
-				{a: "a", op: "match", b: "b", neg: false, rex: rex_b},
-			},
-		}},
-		{`test {
-			if a match b
-			if_op or
-		 }`, false, IfMatcher{
-			ifs: []ifCond{
-				{a: "a", op: "match", b: "b", neg: false, rex: rex_b},
-			},
-			isOr: true,
-		}},
-		{`test {
-			if	a match
-		 }`, true, IfMatcher{},
-		},
-		{`test {
-			if	a isn't b
-		 }`, true, IfMatcher{},
-		},
-		{`test {
-			if a match b c
-		 }`, true, IfMatcher{},
-		},
-		{`test {
-			if goal has go
-			if cook not_has go
-		 }`, false, IfMatcher{
-			ifs: []ifCond{
-				{a: "goal", op: "has", b: "go", neg: false},
-				{a: "cook", op: "has", b: "go", neg: true},
-			},
-		}},
-		{`test {
-			if goal has go
-			if cook not_has go
-			if_op and
-		 }`, false, IfMatcher{
-			ifs: []ifCond{
-				{a: "goal", op: "has", b: "go", neg: false},
-				{a: "cook", op: "has", b: "go", neg: true},
-			},
-		}},
-		{`test {
-			if goal has go
-			if cook not_has go
-			if_op not
-		 }`, true, IfMatcher{},
-		},
-	}
-
-	for i, test := range tests {
-		c := caddy.NewTestController("http", test.input)
-		c.Next()
-
-		matcher, err := SetupIfMatcher(c)
-		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
-		}
-
-		test_if, ok := matcher.(IfMatcher)
-		if !ok {
-			t.Error("RequestMatcher should be of type IfMatcher")
-		}
-
-		if err != nil {
-			t.Errorf("Expected no error, but got: %v", err)
-		}
-
-		if len(test_if.ifs) != len(test.expected.ifs) {
-			t.Errorf("Test %d: Expected %d ifConditions, found %v", i,
-				len(test.expected.ifs), len(test_if.ifs))
-		}
-
-		for j, if_c := range test_if.ifs {
-			expected_c := test.expected.ifs[j]
-
-			if if_c.a != expected_c.a {
-				t.Errorf("Test %d, ifCond %d: Expected A=%s, got %s",
-					i, j, if_c.a, expected_c.a)
-			}
-
-			if if_c.op != expected_c.op {
-				t.Errorf("Test %d, ifCond %d: Expected Op=%s, got %s",
-					i, j, if_c.op, expected_c.op)
-			}
-
-			if if_c.b != expected_c.b {
-				t.Errorf("Test %d, ifCond %d: Expected B=%s, got %s",
-					i, j, if_c.b, expected_c.b)
-			}
-
-			if if_c.neg != expected_c.neg {
-				t.Errorf("Test %d, ifCond %d: Expected Neg=%v, got %v",
-					i, j, if_c.neg, expected_c.neg)
-			}
-
-			if expected_c.rex != nil && if_c.rex == nil {
-				t.Errorf("Test %d, ifCond %d: Expected Rex=%v, got <nil>",
-					i, j, expected_c.rex)
-			}
-
-			if expected_c.rex == nil && if_c.rex != nil {
-				t.Errorf("Test %d, ifCond %d: Expected Rex=<nil>, got %v",
-					i, j, if_c.rex)
-			}
-
-			if expected_c.rex != nil && if_c.rex != nil {
-				if if_c.rex.String() != expected_c.rex.String() {
-					t.Errorf("Test %d, ifCond %d: Expected Rex=%v, got %v",
-						i, j, if_c.rex, expected_c.rex)
-				}
-			}
-		}
-	}
-}
-
-func TestIfMatcherKeyword(t *testing.T) {
-	tests := []struct {
-		keyword  string
-		expected bool
-	}{
-		{"if", true},
-		{"ifs", false},
-		{"tls", false},
-		{"http", false},
-		{"if_op", true},
-		{"if_type", false},
-		{"if_cond", false},
-	}
-
-	for i, test := range tests {
-		c := caddy.NewTestController("http", test.keyword)
-		c.Next()
-		valid := IfMatcherKeyword(c)
-		if valid != test.expected {
-			t.Errorf("Test %d: expected %v found %v", i, test.expected, valid)
-		}
-	}
-}

caddyhttp/httpserver/error.go

@@ -1,70 +0,0 @@
-// 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 httpserver
-
-import (
-	"fmt"
-)
-
-var (
-	_ error = NonHijackerError{}
-	_ error = NonFlusherError{}
-	_ error = NonCloseNotifierError{}
-	_ error = NonPusherError{}
-)
-
-// NonHijackerError is more descriptive error caused by a non hijacker
-type NonHijackerError struct {
-	// underlying type which doesn't implement Hijack
-	Underlying interface{}
-}
-
-// Implement Error
-func (h NonHijackerError) Error() string {
-	return fmt.Sprintf("%T is not a hijacker", h.Underlying)
-}
-
-// NonFlusherError is more descriptive error caused by a non flusher
-type NonFlusherError struct {
-	// underlying type which doesn't implement Flush
-	Underlying interface{}
-}
-
-// Implement Error
-func (f NonFlusherError) Error() string {
-	return fmt.Sprintf("%T is not a flusher", f.Underlying)
-}
-
-// NonCloseNotifierError is more descriptive error caused by a non closeNotifier
-type NonCloseNotifierError struct {
-	// underlying type which doesn't implement CloseNotify
-	Underlying interface{}
-}
-
-// Implement Error
-func (c NonCloseNotifierError) Error() string {
-	return fmt.Sprintf("%T is not a closeNotifier", c.Underlying)
-}
-
-// NonPusherError is more descriptive error caused by a non pusher
-type NonPusherError struct {
-	// underlying type which doesn't implement pusher
-	Underlying interface{}
-}
-
-// Implement Error
-func (c NonPusherError) Error() string {
-	return fmt.Sprintf("%T is not a pusher", c.Underlying)
-}

caddyhttp/httpserver/https.go

@@ -1,226 +0,0 @@
-// 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 httpserver
-
-import (
-	"fmt"
-	"net"
-	"net/http"
-	"strconv"
-
-	"github.com/caddyserver/caddy"
-	"github.com/caddyserver/caddy/caddytls"
-	"github.com/mholt/certmagic"
-)
-
-func activateHTTPS(cctx caddy.Context) error {
-	operatorPresent := !caddy.Started()
-
-	if !caddy.Quiet && operatorPresent {
-		fmt.Print("Activating privacy features... ")
-	}
-
-	ctx := cctx.(*httpContext)
-
-	// pre-screen each config and earmark the ones that qualify for managed TLS
-	markQualifiedForAutoHTTPS(ctx.siteConfigs)
-
-	// place certificates and keys on disk
-	for _, c := range ctx.siteConfigs {
-		if !c.TLS.Managed {
-			continue
-		}
-		if c.TLS.Manager.OnDemand != nil {
-			continue // obtain these certificates on-demand instead
-		}
-		err := c.TLS.Manager.ObtainCert(c.TLS.Hostname, operatorPresent)
-		if err != nil {
-			return err
-		}
-	}
-
-	// update TLS configurations
-	err := enableAutoHTTPS(ctx.siteConfigs, true)
-	if err != nil {
-		return err
-	}
-
-	// set up redirects
-	ctx.siteConfigs = makePlaintextRedirects(ctx.siteConfigs)
-
-	// renew all relevant certificates that need renewal. this is important
-	// to do right away so we guarantee that renewals aren't missed, and
-	// also the user can respond to any potential errors that occur.
-	// (skip if upgrading, because the parent process is likely already listening
-	// on the ports we'd need to do ACME before we finish starting; parent process
-	// already running renewal ticker, so renewal won't be missed anyway.)
-	if !caddy.IsUpgrade() {
-		ctx.instance.StorageMu.RLock()
-		certCache, ok := ctx.instance.Storage[caddytls.CertCacheInstStorageKey].(*certmagic.Cache)
-		ctx.instance.StorageMu.RUnlock()
-		if ok && certCache != nil {
-			err = certCache.RenewManagedCertificates()
-			if err != nil {
-				return err
-			}
-		}
-	}
-
-	if !caddy.Quiet && operatorPresent {
-		fmt.Println("done.")
-	}
-
-	return nil
-}
-
-// markQualifiedForAutoHTTPS scans each config and, if it
-// qualifies for managed TLS, it sets the Managed field of
-// the TLS config to true.
-func markQualifiedForAutoHTTPS(configs []*SiteConfig) {
-	for _, cfg := range configs {
-		if caddytls.QualifiesForManagedTLS(cfg) && cfg.Addr.Scheme != "http" {
-			cfg.TLS.Managed = true
-		}
-	}
-}
-
-// enableAutoHTTPS configures each config to use TLS according to default settings.
-// It will only change configs that are marked as managed but not on-demand, and
-// assumes that certificates and keys are already on disk. If loadCertificates is
-// true, the certificates will be loaded from disk into the cache for this process
-// to use. If false, TLS will still be enabled and configured with default settings,
-// but no certificates will be parsed loaded into the cache, and the returned error
-// value will always be nil.
-func enableAutoHTTPS(configs []*SiteConfig, loadCertificates bool) error {
-	for _, cfg := range configs {
-		if cfg == nil || cfg.TLS == nil || !cfg.TLS.Managed ||
-			cfg.TLS.Manager == nil || cfg.TLS.Manager.OnDemand != nil {
-			continue
-		}
-		cfg.TLS.Enabled = true
-		cfg.Addr.Scheme = "https"
-		if loadCertificates && certmagic.HostQualifies(cfg.TLS.Hostname) {
-			_, err := cfg.TLS.Manager.CacheManagedCertificate(cfg.TLS.Hostname)
-			if err != nil {
-				return err
-			}
-		}
-
-		// Make sure any config values not explicitly set are set to default
-		caddytls.SetDefaultTLSParams(cfg.TLS)
-
-		// Set default port of 443 if not explicitly set
-		if cfg.Addr.Port == "" &&
-			cfg.TLS.Enabled &&
-			(!cfg.TLS.Manual || cfg.TLS.Manager.OnDemand != nil) &&
-			cfg.Addr.Host != "localhost" {
-			cfg.Addr.Port = strconv.Itoa(certmagic.HTTPSPort)
-		}
-	}
-	return nil
-}
-
-// makePlaintextRedirects sets up redirects from port 80 to the relevant HTTPS
-// hosts. You must pass in all configs, not just configs that qualify, since
-// we must know whether the same host already exists on port 80, and those would
-// not be in a list of configs that qualify for automatic HTTPS. This function will
-// only set up redirects for configs that qualify. It returns the updated list of
-// all configs.
-func makePlaintextRedirects(allConfigs []*SiteConfig) []*SiteConfig {
-	httpPort := strconv.Itoa(certmagic.HTTPPort)
-	httpsPort := strconv.Itoa(certmagic.HTTPSPort)
-	for i, cfg := range allConfigs {
-		if cfg.TLS.Managed &&
-			!hostHasOtherPort(allConfigs, i, httpPort) &&
-			(cfg.Addr.Port == httpsPort || !hostHasOtherPort(allConfigs, i, httpsPort)) {
-			allConfigs = append(allConfigs, redirPlaintextHost(cfg))
-		}
-	}
-	return allConfigs
-}
-
-// hostHasOtherPort returns true if there is another config in the list with the same
-// hostname that has port otherPort, or false otherwise. All the configs are checked
-// against the hostname of allConfigs[thisConfigIdx].
-func hostHasOtherPort(allConfigs []*SiteConfig, thisConfigIdx int, otherPort string) bool {
-	for i, otherCfg := range allConfigs {
-		if i == thisConfigIdx {
-			continue // has to be a config OTHER than the one we're comparing against
-		}
-		if otherCfg.Addr.Host == allConfigs[thisConfigIdx].Addr.Host &&
-			otherCfg.Addr.Port == otherPort {
-			return true
-		}
-	}
-	return false
-}
-
-// redirPlaintextHost returns a new plaintext HTTP configuration for
-// a virtualHost that simply redirects to cfg, which is assumed to
-// be the HTTPS configuration. The returned configuration is set
-// to listen on certmagic.HTTPPort. The TLS field of cfg must not be nil.
-func redirPlaintextHost(cfg *SiteConfig) *SiteConfig {
-	redirPort := cfg.Addr.Port
-	if redirPort == strconv.Itoa(certmagic.HTTPSPort) {
-		// By default, HTTPSPort should be DefaultHTTPSPort,
-		// which of course doesn't need to be explicitly stated
-		// in the Location header. Even if HTTPSPort is changed
-		// so that it is no longer DefaultHTTPSPort, we shouldn't
-		// append it to the URL in the Location because changing
-		// the HTTPS port is assumed to be an internal-only change
-		// (in other words, we assume port forwarding is going on);
-		// but redirects go back to a presumably-external client.
-		// (If redirect clients are also internal, that is more
-		// advanced, and the user should configure HTTP->HTTPS
-		// redirects themselves.)
-		redirPort = ""
-	}
-
-	redirMiddleware := func(next Handler) Handler {
-		return HandlerFunc(func(w http.ResponseWriter, r *http.Request) (int, error) {
-			// Construct the URL to which to redirect. Note that the Host in a
-			// request might contain a port, but we just need the hostname from
-			// it; and we'll set the port if needed.
-			toURL := "https://"
-			requestHost, _, err := net.SplitHostPort(r.Host)
-			if err != nil {
-				requestHost = r.Host // Host did not contain a port, so use the whole value
-			}
-			if redirPort == "" {
-				toURL += requestHost
-			} else {
-				toURL += net.JoinHostPort(requestHost, redirPort)
-			}
-
-			toURL += r.URL.RequestURI()
-
-			w.Header().Set("Connection", "close")
-			http.Redirect(w, r, toURL, http.StatusMovedPermanently)
-			return 0, nil
-		})
-	}
-
-	host := cfg.Addr.Host
-	port := strconv.Itoa(certmagic.HTTPPort)
-	addr := net.JoinHostPort(host, port)
-
-	return &SiteConfig{
-		Addr:       Address{Original: addr, Host: host, Port: port},
-		ListenHost: cfg.ListenHost,
-		middleware: []Middleware{redirMiddleware},
-		TLS:        &caddytls.Config{Manager: cfg.TLS.Manager},
-		Timeouts:   cfg.Timeouts,
-	}
-}

caddyhttp/httpserver/https_test.go

@@ -1,235 +0,0 @@
-// 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 httpserver
-
-import (
-	"fmt"
-	"log"
-	"net"
-	"net/http"
-	"net/http/httptest"
-	"strconv"
-	"testing"
-
-	"github.com/caddyserver/caddy/caddytls"
-	"github.com/mholt/certmagic"
-)
-
-func TestRedirPlaintextHost(t *testing.T) {
-	for i, testcase := range []struct {
-		Host        string // used for the site config
-		Port        string
-		ListenHost  string
-		RequestHost string // if different from Host
-	}{
-		{
-			Host: "foohost",
-		},
-		{
-			Host: "foohost",
-			Port: "80",
-		},
-		{
-			Host: "foohost",
-			Port: "1234",
-		},
-		{
-			Host:       "foohost",
-			ListenHost: "93.184.216.34",
-		},
-		{
-			Host:       "foohost",
-			Port:       "1234",
-			ListenHost: "93.184.216.34",
-		},
-		{
-			Host: "foohost",
-			Port: strconv.Itoa(certmagic.HTTPSPort), // since this is the 'default' HTTPS port, should not be included in Location value
-		},
-		{
-			Host:        "*.example.com",
-			RequestHost: "foo.example.com",
-		},
-		{
-			Host:        "*.example.com",
-			Port:        "1234",
-			RequestHost: "foo.example.com:1234",
-		},
-	} {
-		cfg := redirPlaintextHost(&SiteConfig{
-			Addr: Address{
-				Host: testcase.Host,
-				Port: testcase.Port,
-			},
-			ListenHost: testcase.ListenHost,
-			TLS:        new(caddytls.Config),
-		})
-
-		// Check host and port
-		if actual, expected := cfg.Addr.Host, testcase.Host; actual != expected {
-			t.Errorf("Test %d: Expected redir config to have host %s but got %s", i, expected, actual)
-		}
-		if actual, expected := cfg.ListenHost, testcase.ListenHost; actual != expected {
-			t.Errorf("Test %d: Expected redir config to have bindhost %s but got %s", i, expected, actual)
-		}
-		if actual, expected := cfg.Addr.Port, strconv.Itoa(certmagic.HTTPPort); actual != expected {
-			t.Errorf("Test %d: Expected redir config to have port '%s' but got '%s'", i, expected, actual)
-		}
-
-		// Make sure redirect handler is set up properly
-		if cfg.middleware == nil || len(cfg.middleware) != 1 {
-			t.Fatalf("Test %d: Redir config middleware not set up properly; got: %#v", i, cfg.middleware)
-		}
-
-		handler := cfg.middleware[0](nil)
-
-		// Check redirect for correctness, first by inspecting error and status code
-		requestHost := testcase.Host // hostname of request might be different than in config (e.g. wildcards)
-		if testcase.RequestHost != "" {
-			requestHost = testcase.RequestHost
-		}
-		rec := httptest.NewRecorder()
-		req, err := http.NewRequest("GET", "http://"+requestHost+"/bar?q=1", nil)
-		if err != nil {
-			t.Fatalf("Test %d: %v", i, err)
-		}
-		status, err := handler.ServeHTTP(rec, req)
-		if status != 0 {
-			t.Errorf("Test %d: Expected status return to be 0, but was %d", i, status)
-		}
-		if err != nil {
-			t.Errorf("Test %d: Expected returned error to be nil, but was %v", i, err)
-		}
-		if rec.Code != http.StatusMovedPermanently {
-			t.Errorf("Test %d: Expected status %d but got %d", http.StatusMovedPermanently, i, rec.Code)
-		}
-
-		// Now check the Location value. It should mirror the hostname and port of the request
-		// unless the port is redundant, in which case it should be dropped.
-		locationHost, _, err := net.SplitHostPort(requestHost)
-		if err != nil {
-			locationHost = requestHost
-		}
-		expectedLoc := fmt.Sprintf("https://%s/bar?q=1", locationHost)
-		if testcase.Port != "" && testcase.Port != DefaultHTTPSPort {
-			expectedLoc = fmt.Sprintf("https://%s:%s/bar?q=1", locationHost, testcase.Port)
-		}
-		if got, want := rec.Header().Get("Location"), expectedLoc; got != want {
-			t.Errorf("Test %d: Expected Location: '%s' but got '%s'", i, want, got)
-		}
-	}
-}
-
-func TestHostHasOtherPort(t *testing.T) {
-	configs := []*SiteConfig{
-		{Addr: Address{Host: "example.com", Port: "80"}},
-		{Addr: Address{Host: "sub1.example.com", Port: "80"}},
-		{Addr: Address{Host: "sub1.example.com", Port: "443"}},
-	}
-
-	if hostHasOtherPort(configs, 0, "80") {
-		t.Errorf(`Expected hostHasOtherPort(configs, 0, "80") to be false, but got true`)
-	}
-	if hostHasOtherPort(configs, 0, "443") {
-		t.Errorf(`Expected hostHasOtherPort(configs, 0, "443") to be false, but got true`)
-	}
-	if !hostHasOtherPort(configs, 1, "443") {
-		t.Errorf(`Expected hostHasOtherPort(configs, 1, "443") to be true, but got false`)
-	}
-}
-
-func TestMakePlaintextRedirects(t *testing.T) {
-	configs := []*SiteConfig{
-		// Happy path = standard redirect from 80 to 443
-		{Addr: Address{Host: "example.com"}, TLS: &caddytls.Config{Managed: true}},
-
-		// Host on port 80 already defined; don't change it (no redirect)
-		{Addr: Address{Host: "sub1.example.com", Port: "80", Scheme: "http"}, TLS: new(caddytls.Config)},
-		{Addr: Address{Host: "sub1.example.com"}, TLS: &caddytls.Config{Managed: true}},
-
-		// Redirect from port 80 to port 5000 in this case
-		{Addr: Address{Host: "sub2.example.com", Port: "5000"}, TLS: &caddytls.Config{Managed: true}},
-
-		// Can redirect from 80 to either 443 or 5001, but choose 443
-		{Addr: Address{Host: "sub3.example.com", Port: "443"}, TLS: &caddytls.Config{Managed: true}},
-		{Addr: Address{Host: "sub3.example.com", Port: "5001", Scheme: "https"}, TLS: &caddytls.Config{Managed: true}},
-	}
-
-	result := makePlaintextRedirects(configs)
-	expectedRedirCount := 3
-
-	if len(result) != len(configs)+expectedRedirCount {
-		t.Errorf("Expected %d redirect(s) to be added, but got %d",
-			expectedRedirCount, len(result)-len(configs))
-	}
-}
-
-func TestEnableAutoHTTPS(t *testing.T) {
-	configs := []*SiteConfig{
-		{Addr: Address{Host: "example.com"}, TLS: &caddytls.Config{Managed: true, Manager: &certmagic.Config{}}},
-		{}, // not managed - no changes!
-	}
-
-	if err := enableAutoHTTPS(configs, false); err != nil {
-		log.Println("[ERROR]  enableAutoHTTPS failed: ", err)
-	}
-
-	if !configs[0].TLS.Enabled {
-		t.Errorf("Expected config 0 to have TLS.Enabled == true, but it was false")
-	}
-	if configs[0].Addr.Scheme != "https" {
-		t.Errorf("Expected config 0 to have Addr.Scheme == \"https\", but it was \"%s\"",
-			configs[0].Addr.Scheme)
-	}
-	if configs[1].TLS != nil && configs[1].TLS.Enabled {
-		t.Errorf("Expected config 1 to have TLS.Enabled == false, but it was true")
-	}
-}
-
-func TestMarkQualifiedForAutoHTTPS(t *testing.T) {
-	// TODO: caddytls.TestQualifiesForManagedTLS and this test share nearly the same config list...
-	configs := []*SiteConfig{
-		{Addr: Address{Host: ""}, TLS: newManagedConfig()},
-		{Addr: Address{Host: "localhost"}, TLS: newManagedConfig()},
-		{Addr: Address{Host: "123.44.3.21"}, TLS: newManagedConfig()},
-		{Addr: Address{Host: "example.com"}, TLS: newManagedConfig()},
-		{Addr: Address{Host: "example.com"}, TLS: &caddytls.Config{Manual: true}},
-		{Addr: Address{Host: "example.com"}, TLS: &caddytls.Config{ACMEEmail: "off"}},
-		{Addr: Address{Host: "example.com"}, TLS: &caddytls.Config{ACMEEmail: "foo@bar.com", Manager: &certmagic.Config{}}},
-		{Addr: Address{Host: "example.com", Scheme: "http"}, TLS: newManagedConfig()},
-		{Addr: Address{Host: "example.com", Port: "80"}, TLS: newManagedConfig()},
-		{Addr: Address{Host: "example.com", Port: "1234"}, TLS: newManagedConfig()},
-		{Addr: Address{Host: "example.com", Scheme: "https"}, TLS: newManagedConfig()},
-		{Addr: Address{Host: "example.com", Port: "80", Scheme: "https"}, TLS: newManagedConfig()},
-	}
-	expectedManagedCount := 4
-
-	markQualifiedForAutoHTTPS(configs)
-
-	count := 0
-	for _, cfg := range configs {
-		if cfg.TLS.Managed {
-			count++
-		}
-	}
-
-	if count != expectedManagedCount {
-		t.Errorf("Expected %d managed configs, but got %d", expectedManagedCount, count)
-	}
-}
-
-func newManagedConfig() *caddytls.Config {
-	return &caddytls.Config{Manager: &certmagic.Config{}}
-}

caddyhttp/httpserver/logger.go

@@ -1,196 +0,0 @@
-// 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 httpserver
-
-import (
-	"bytes"
-	"io"
-	"log"
-	"net"
-	"os"
-	"strings"
-	"sync"
-
-	"github.com/caddyserver/caddy"
-	gsyslog "github.com/hashicorp/go-syslog"
-)
-
-var remoteSyslogPrefixes = map[string]string{
-	"syslog+tcp://": "tcp",
-	"syslog+udp://": "udp",
-	"syslog://":     "udp",
-}
-
-// Logger is shared between errors and log plugins and supports both logging to
-// a file (with an optional file roller), local and remote syslog servers.
-type Logger struct {
-	Output string
-	*log.Logger
-	Roller       *LogRoller
-	writer       io.Writer
-	fileMu       *sync.RWMutex
-	V4ipMask     net.IPMask
-	V6ipMask     net.IPMask
-	IPMaskExists bool
-	Exceptions   []string
-}
-
-// NewTestLogger creates logger suitable for testing purposes
-func NewTestLogger(buffer *bytes.Buffer) *Logger {
-	return &Logger{
-		Logger: log.New(buffer, "", 0),
-		fileMu: new(sync.RWMutex),
-	}
-}
-
-// Println wraps underlying logger with mutex
-func (l Logger) Println(args ...interface{}) {
-	l.fileMu.RLock()
-	l.Logger.Println(args...)
-	l.fileMu.RUnlock()
-}
-
-// Printf wraps underlying logger with mutex
-func (l Logger) Printf(format string, args ...interface{}) {
-	l.fileMu.RLock()
-	l.Logger.Printf(format, args...)
-	l.fileMu.RUnlock()
-}
-
-func (l Logger) MaskIP(ip string) string {
-	var reqIP net.IP
-	// If unable to parse, simply return IP as provided.
-	reqIP = net.ParseIP(ip)
-	if reqIP == nil {
-		return ip
-	}
-
-	if reqIP.To4() != nil {
-		return reqIP.Mask(l.V4ipMask).String()
-	} else {
-		return reqIP.Mask(l.V6ipMask).String()
-	}
-
-}
-
-// ShouldLog returns true if the path is not exempted from
-// being logged (i.e. it is not found in l.Exceptions).
-func (l Logger) ShouldLog(path string) bool {
-	for _, exc := range l.Exceptions {
-		if Path(path).Matches(exc) {
-			return false
-		}
-	}
-	return true
-}
-
-// Attach binds logger Start and Close functions to
-// controller's OnStartup and OnShutdown hooks.
-func (l *Logger) Attach(controller *caddy.Controller) {
-	if controller != nil {
-		// Opens file or connect to local/remote syslog
-		controller.OnStartup(l.Start)
-
-		// Closes file or disconnects from local/remote syslog
-		controller.OnShutdown(l.Close)
-	}
-}
-
-type syslogAddress struct {
-	network string
-	address string
-}
-
-func parseSyslogAddress(location string) *syslogAddress {
-	for prefix, network := range remoteSyslogPrefixes {
-		if strings.HasPrefix(location, prefix) {
-			return &syslogAddress{
-				network: network,
-				address: strings.TrimPrefix(location, prefix),
-			}
-		}
-	}
-
-	return nil
-}
-
-// Start initializes logger opening files or local/remote syslog connections
-func (l *Logger) Start() error {
-	// initialize mutex on start
-	l.fileMu = new(sync.RWMutex)
-
-	var err error
-
-selectwriter:
-	switch l.Output {
-	case "", "stderr":
-		l.writer = os.Stderr
-	case "stdout":
-		l.writer = os.Stdout
-	case "syslog":
-		l.writer, err = gsyslog.NewLogger(gsyslog.LOG_ERR, "LOCAL0", "caddy")
-		if err != nil {
-			return err
-		}
-	default:
-		if address := parseSyslogAddress(l.Output); address != nil {
-			l.writer, err = gsyslog.DialLogger(address.network, address.address, gsyslog.LOG_ERR, "LOCAL0", "caddy")
-
-			if err != nil {
-				return err
-			}
-
-			break selectwriter
-		}
-
-		var file *os.File
-
-		file, err = os.OpenFile(l.Output, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0644)
-		if err != nil {
-			return err
-		}
-
-		if l.Roller != nil && !l.Roller.Disabled {
-			file.Close()
-			l.Roller.Filename = l.Output
-			l.writer = l.Roller.GetLogWriter()
-		} else {
-			l.writer = file
-		}
-	}
-
-	l.Logger = log.New(l.writer, "", log.Flags())
-
-	return nil
-
-}
-
-// Close closes open log files or connections to syslog.
-func (l *Logger) Close() error {
-	// don't close stdout or stderr
-	if l.writer == os.Stdout || l.writer == os.Stderr {
-		return nil
-	}
-
-	// Will close local/remote syslog connections too :)
-	if closer, ok := l.writer.(io.WriteCloser); ok {
-		l.fileMu.Lock()
-		err := closer.Close()
-		l.fileMu.Unlock()
-		return err
-	}
-
-	return nil
-}

caddyhttp/httpserver/logger_test.go

@@ -1,231 +0,0 @@
-// Copyright 2015 Light Code Labs, LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-//+build linux darwin
-
-package httpserver
-
-import (
-	"bytes"
-	"fmt"
-	"io/ioutil"
-	"log"
-	"os"
-	"path/filepath"
-	"strings"
-	"sync"
-	"testing"
-
-	syslog "gopkg.in/mcuadros/go-syslog.v2"
-	"gopkg.in/mcuadros/go-syslog.v2/format"
-)
-
-func TestLoggingToStdout(t *testing.T) {
-	testCases := []struct {
-		Output         string
-		ExpectedOutput string
-	}{
-		{
-			Output:         "stdout",
-			ExpectedOutput: "Hello world logged to stdout",
-		},
-	}
-
-	for i, testCase := range testCases {
-		output := captureStdout(func() {
-			logger := Logger{Output: testCase.Output, fileMu: new(sync.RWMutex)}
-
-			if err := logger.Start(); err != nil {
-				t.Fatalf("Got unexpected error: %v", err)
-			}
-
-			logger.Println(testCase.ExpectedOutput)
-		})
-
-		if !strings.Contains(output, testCase.ExpectedOutput) {
-			t.Fatalf("Test #%d: Expected output to contain: %s, got: %s", i, testCase.ExpectedOutput, output)
-		}
-	}
-}
-
-func TestLoggingToStderr(t *testing.T) {
-
-	testCases := []struct {
-		Output         string
-		ExpectedOutput string
-	}{
-		{
-			Output:         "stderr",
-			ExpectedOutput: "Hello world logged to stderr",
-		},
-		{
-			Output:         "",
-			ExpectedOutput: "Hello world logged to stderr #2",
-		},
-	}
-
-	for i, testCase := range testCases {
-		output := captureStderr(func() {
-			logger := Logger{Output: testCase.Output, fileMu: new(sync.RWMutex)}
-
-			if err := logger.Start(); err != nil {
-				t.Fatalf("Got unexpected error: %v", err)
-			}
-
-			logger.Println(testCase.ExpectedOutput)
-		})
-
-		if !strings.Contains(output, testCase.ExpectedOutput) {
-			t.Fatalf("Test #%d: Expected output to contain: %s, got: %s", i, testCase.ExpectedOutput, output)
-		}
-	}
-}
-
-func TestLoggingToFile(t *testing.T) {
-	file := filepath.Join(os.TempDir(), "access.log")
-	expectedOutput := "Hello world written to file"
-
-	logger := Logger{Output: file}
-
-	if err := logger.Start(); err != nil {
-		t.Fatalf("Got unexpected error during logger start: %v", err)
-	}
-
-	logger.Print(expectedOutput)
-
-	content, err := ioutil.ReadFile(file)
-	if err != nil {
-		t.Fatalf("Could not read log file content: %v", err)
-	}
-
-	if !bytes.Contains(content, []byte(expectedOutput)) {
-		t.Fatalf("Expected log file to contain: %s, got: %s", expectedOutput, string(content))
-	}
-
-	os.Remove(file)
-}
-
-func TestLoggingToSyslog(t *testing.T) {
-
-	testCases := []struct {
-		Output         string
-		ExpectedOutput string
-	}{
-		{
-			Output:         "syslog://127.0.0.1:5660",
-			ExpectedOutput: "Hello world! Test #1 over tcp",
-		},
-		{
-			Output:         "syslog+tcp://127.0.0.1:5661",
-			ExpectedOutput: "Hello world! Test #2 over tcp",
-		},
-		{
-			Output:         "syslog+udp://127.0.0.1:5662",
-			ExpectedOutput: "Hello world! Test #3 over udp",
-		},
-	}
-
-	for i, testCase := range testCases {
-
-		ch := make(chan format.LogParts, 256)
-		server, err := bootServer(testCase.Output, ch)
-		defer server.Kill()
-
-		if err != nil {
-			t.Errorf("Test #%d: expected no error during syslog server boot, got: %v", i, err)
-		}
-
-		logger := Logger{Output: testCase.Output, fileMu: new(sync.RWMutex)}
-
-		if err := logger.Start(); err != nil {
-			t.Errorf("Test #%d: expected no error during logger start, got: %v", i, err)
-		}
-
-		defer logger.Close()
-
-		logger.Print(testCase.ExpectedOutput)
-
-		actual := <-ch
-
-		if content, ok := actual["content"].(string); ok {
-			if !strings.Contains(content, testCase.ExpectedOutput) {
-				t.Errorf("Test #%d: expected server to capture content: %s, but got: %s", i, testCase.ExpectedOutput, content)
-			}
-		} else {
-			t.Errorf("Test #%d: expected server to capture content but got: %v", i, actual)
-		}
-	}
-}
-
-func bootServer(location string, ch chan format.LogParts) (*syslog.Server, error) {
-	address := parseSyslogAddress(location)
-
-	if address == nil {
-		return nil, fmt.Errorf("Could not parse syslog address: %s", location)
-	}
-
-	server := syslog.NewServer()
-	server.SetFormat(syslog.Automatic)
-
-	switch address.network {
-	case "tcp":
-		if err := server.ListenTCP(address.address); err != nil {
-			log.Println("[ERROR] server failed to listen on TCP address: ", err)
-		}
-	case "udp":
-		if err := server.ListenUDP(address.address); err != nil {
-			log.Println("[ERROR] server failed to listen on UDP address: ", err)
-		}
-	}
-
-	server.SetHandler(syslog.NewChannelHandler(ch))
-
-	if err := server.Boot(); err != nil {
-		return nil, err
-	}
-
-	return server, nil
-}
-
-func captureStdout(f func()) string {
-	original := os.Stdout
-	r, w, _ := os.Pipe()
-
-	os.Stdout = w
-
-	f()
-
-	w.Close()
-
-	written, _ := ioutil.ReadAll(r)
-	os.Stdout = original
-
-	return string(written)
-}
-
-func captureStderr(f func()) string {
-	original := os.Stderr
-	r, w, _ := os.Pipe()
-
-	os.Stderr = w
-
-	f()
-
-	w.Close()
-
-	written, _ := ioutil.ReadAll(r)
-	os.Stderr = original
-
-	return string(written)
-}