diff --git a/cmd/caddy2/main.go b/cmd/caddy2/main.go index 4276d7d08..59239a2f1 100644 --- a/cmd/caddy2/main.go +++ b/cmd/caddy2/main.go @@ -9,6 +9,7 @@ import ( _ "bitbucket.org/lightcodelabs/caddy2/modules/caddyhttp/fileserver" _ "bitbucket.org/lightcodelabs/caddy2/modules/caddyhttp/headers" _ "bitbucket.org/lightcodelabs/caddy2/modules/caddyhttp/reverseproxy" + _ "bitbucket.org/lightcodelabs/caddy2/modules/caddyhttp/rewrite" _ "bitbucket.org/lightcodelabs/caddy2/modules/caddytls" ) diff --git a/modules/caddyhttp/fileserver/staticfiles.go b/modules/caddyhttp/fileserver/staticfiles.go index e859abec9..873c5fb81 100644 --- a/modules/caddyhttp/fileserver/staticfiles.go +++ b/modules/caddyhttp/fileserver/staticfiles.go @@ -104,7 +104,7 @@ func (fsrv *FileServer) ServeHTTP(w http.ResponseWriter, r *http.Request) error if filename == "" { // no files worked, so resort to fallback if fsrv.Fallback != nil { - fallback := fsrv.Fallback.BuildCompositeRoute(w, r) + fallback, w := fsrv.Fallback.BuildCompositeRoute(w, r) return fallback.ServeHTTP(w, r) } return caddyhttp.Error(http.StatusNotFound, nil) diff --git a/modules/caddyhttp/headers/headers.go b/modules/caddyhttp/headers/headers.go index 37efc571c..b56bbf9ca 100644 --- a/modules/caddyhttp/headers/headers.go +++ b/modules/caddyhttp/headers/headers.go @@ -37,29 +37,36 @@ type RespHeaderOps struct { } func (h Headers) ServeHTTP(w http.ResponseWriter, r *http.Request, next caddyhttp.Handler) error { - apply(h.Request, r.Header) + repl := r.Context().Value(caddy2.ReplacerCtxKey).(caddy2.Replacer) + apply(h.Request, r.Header, repl) if h.Response.Deferred { w = &responseWriterWrapper{ ResponseWriterWrapper: &caddyhttp.ResponseWriterWrapper{ResponseWriter: w}, + replacer: repl, headerOps: h.Response.HeaderOps, } } else { - apply(h.Response.HeaderOps, w.Header()) + apply(h.Response.HeaderOps, w.Header(), repl) } return next.ServeHTTP(w, r) } -func apply(ops HeaderOps, hdr http.Header) { +func apply(ops HeaderOps, hdr http.Header, repl caddy2.Replacer) { for fieldName, vals := range ops.Add { + fieldName = repl.ReplaceAll(fieldName, "") for _, v := range vals { - hdr.Add(fieldName, v) + hdr.Add(fieldName, repl.ReplaceAll(v, "")) } } for fieldName, vals := range ops.Set { + fieldName = repl.ReplaceAll(fieldName, "") + for i := range vals { + vals[i] = repl.ReplaceAll(vals[i], "") + } hdr.Set(fieldName, strings.Join(vals, ",")) } for _, fieldName := range ops.Delete { - hdr.Del(fieldName) + hdr.Del(repl.ReplaceAll(fieldName, "")) } } @@ -67,6 +74,7 @@ func apply(ops HeaderOps, hdr http.Header) { // operations until WriteHeader is called. type responseWriterWrapper struct { *caddyhttp.ResponseWriterWrapper + replacer caddy2.Replacer headerOps HeaderOps wroteHeader bool } @@ -83,7 +91,7 @@ func (rww *responseWriterWrapper) WriteHeader(status int) { return } rww.wroteHeader = true - apply(rww.headerOps, rww.ResponseWriterWrapper.Header()) + apply(rww.headerOps, rww.ResponseWriterWrapper.Header(), rww.replacer) rww.ResponseWriterWrapper.WriteHeader(status) } diff --git a/modules/caddyhttp/matchers_test.go b/modules/caddyhttp/matchers_test.go index c279bad9f..c4c7845b6 100644 --- a/modules/caddyhttp/matchers_test.go +++ b/modules/caddyhttp/matchers_test.go @@ -227,9 +227,10 @@ func TestPathREMatcher(t *testing.T) { // set up the fake request and its Replacer req := &http.Request{URL: &url.URL{Path: tc.input}} - repl := newReplacer(req, httptest.NewRecorder()) + repl := caddy2.NewReplacer() ctx := context.WithValue(req.Context(), caddy2.ReplacerCtxKey, repl) req = req.WithContext(ctx) + addHTTPVarsToReplacer(repl, req, httptest.NewRecorder()) actual := tc.match.Match(req) if actual != tc.expect { @@ -344,9 +345,10 @@ func TestHeaderREMatcher(t *testing.T) { // set up the fake request and its Replacer req := &http.Request{Header: tc.input, URL: new(url.URL)} - repl := newReplacer(req, httptest.NewRecorder()) + repl := caddy2.NewReplacer() ctx := context.WithValue(req.Context(), caddy2.ReplacerCtxKey, repl) req = req.WithContext(ctx) + addHTTPVarsToReplacer(repl, req, httptest.NewRecorder()) actual := tc.match.Match(req) if actual != tc.expect { diff --git a/modules/caddyhttp/replacer.go b/modules/caddyhttp/replacer.go index 6feb1437c..16cc1fe99 100644 --- a/modules/caddyhttp/replacer.go +++ b/modules/caddyhttp/replacer.go @@ -13,9 +13,7 @@ import ( // TODO: A simple way to format or escape or encode each value would be nice // ... TODO: Should we just use templates? :-/ yeesh... -func newReplacer(req *http.Request, w http.ResponseWriter) caddy2.Replacer { - repl := caddy2.NewReplacer() - +func addHTTPVarsToReplacer(repl caddy2.Replacer, req *http.Request, w http.ResponseWriter) { httpVars := func() map[string]string { m := make(map[string]string) if req != nil { @@ -78,6 +76,4 @@ func newReplacer(req *http.Request, w http.ResponseWriter) caddy2.Replacer { } repl.Map(httpVars) - - return repl } diff --git a/modules/caddyhttp/rewrite/rewrite.go b/modules/caddyhttp/rewrite/rewrite.go new file mode 100644 index 000000000..1afb8a421 --- /dev/null +++ b/modules/caddyhttp/rewrite/rewrite.go @@ -0,0 +1,71 @@ +package headers + +import ( + "net/http" + "net/url" + "strings" + + "bitbucket.org/lightcodelabs/caddy2" + "bitbucket.org/lightcodelabs/caddy2/modules/caddyhttp" +) + +func init() { + caddy2.RegisterModule(caddy2.Module{ + Name: "http.middleware.rewrite", + New: func() (interface{}, error) { return new(Rewrite), nil }, + }) +} + +// Rewrite is a middleware which can rewrite HTTP requests. +type Rewrite struct { + Method string `json:"method"` + URI string `json:"uri"` + Rehandle bool `json:"rehandle"` +} + +func (rewr Rewrite) ServeHTTP(w http.ResponseWriter, r *http.Request, next caddyhttp.Handler) error { + repl := r.Context().Value(caddy2.ReplacerCtxKey).(caddy2.Replacer) + var rehandleNeeded bool + + if rewr.Method != "" { + method := r.Method + r.Method = strings.ToUpper(repl.ReplaceAll(rewr.Method, "")) + if r.Method != method { + rehandleNeeded = true + } + } + + if rewr.URI != "" { + // TODO: clean this all up, I don't think it's right + + oldURI := r.RequestURI + newURI := repl.ReplaceAll(rewr.URI, "") + u, err := url.Parse(newURI) + if err != nil { + return caddyhttp.Error(http.StatusInternalServerError, err) + } + + r.RequestURI = newURI + + r.URL.Path = u.Path + if u.RawQuery != "" { + r.URL.RawQuery = u.RawQuery + } + if u.Fragment != "" { + r.URL.Fragment = u.Fragment + } + + if newURI != oldURI { + rehandleNeeded = true + } + } + + if rehandleNeeded && rewr.Rehandle { + return caddyhttp.ErrRehandle + } + + return next.ServeHTTP(w, r) +} + +// Interface guard +var _ caddyhttp.MiddlewareHandler = (*Rewrite)(nil) diff --git a/modules/caddyhttp/routes.go b/modules/caddyhttp/routes.go index daae08079..92aa3e87b 100644 --- a/modules/caddyhttp/routes.go +++ b/modules/caddyhttp/routes.go @@ -65,23 +65,24 @@ func (routes RouteList) Provision(ctx caddy2.Context) error { return nil } -// BuildCompositeRoute creates a chain of handlers by -// applying all the matching routes. -func (routes RouteList) BuildCompositeRoute(w http.ResponseWriter, r *http.Request) Handler { +// BuildCompositeRoute creates a chain of handlers by applying all the matching +// routes. The returned ResponseWriter should be used instead of rw. +func (routes RouteList) BuildCompositeRoute(rw http.ResponseWriter, req *http.Request) (Handler, http.ResponseWriter) { + mrw := &middlewareResponseWriter{ResponseWriterWrapper: &ResponseWriterWrapper{rw}} + if len(routes) == 0 { - return emptyHandler + return emptyHandler, mrw } var mid []Middleware var responder Handler - mrw := &middlewareResponseWriter{ResponseWriterWrapper: &ResponseWriterWrapper{w}} groups := make(map[string]struct{}) routeLoop: for _, route := range routes { // see if route matches for _, m := range route.matchers { - if !m.Match(r) { + if !m.Match(req) { continue routeLoop } } @@ -102,15 +103,13 @@ routeLoop: // apply the rest of the route for _, m := range route.middleware { - mid = append(mid, func(next HandlerFunc) HandlerFunc { - return func(w http.ResponseWriter, r *http.Request) error { - // TODO: This is where request tracing could be implemented; also - // see below to trace the responder as well - // TODO: Trace a diff of the request, would be cool too! see what changed since the last middleware (host, headers, URI...) - // TODO: see what the std lib gives us in terms of stack trracing too - return m.ServeHTTP(mrw, r, next) - } - }) + // we have to be sure to wrap m outside + // of our current scope so that the + // reference to this m isn't overwritten + // on the next iteration, leaving only + // the last middleware in the chain as + // the ONLY middleware in the chain! + mid = append(mid, wrapMiddleware(m)) } if responder == nil { responder = route.responder @@ -132,7 +131,25 @@ routeLoop: stack = mid[i](stack) } - return stack + return stack, mrw +} + +// wrapMiddleware wraps m such that it can be correctly +// appended to a list of middleware. This is necessary +// so that only the last middleware in a loop does not +// become the only middleware of the stack, repeatedly +// executed (i.e. it is necessary to keep a reference +// to this m outside of the scope of a loop)! +func wrapMiddleware(m MiddlewareHandler) Middleware { + return func(next HandlerFunc) HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) error { + // TODO: This is where request tracing could be implemented; also + // see below to trace the responder as well + // TODO: Trace a diff of the request, would be cool too! see what changed since the last middleware (host, headers, URI...) + // TODO: see what the std lib gives us in terms of stack tracing too + return m.ServeHTTP(w, r, next) + } + } } type middlewareResponseWriter struct { diff --git a/modules/caddyhttp/server.go b/modules/caddyhttp/server.go index fbbdae4fa..dea34fb87 100644 --- a/modules/caddyhttp/server.go +++ b/modules/caddyhttp/server.go @@ -32,14 +32,18 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } - // set up the replacer - repl := newReplacer(r, w) + // set up the context for the request + repl := caddy2.NewReplacer() ctx := context.WithValue(r.Context(), caddy2.ReplacerCtxKey, repl) ctx = context.WithValue(ctx, TableCtxKey, make(map[string]interface{})) // TODO: Implement this r = r.WithContext(ctx) + // once the pointer to the request won't change + // anymore, finish setting up the replacer + addHTTPVarsToReplacer(repl, r, w) + // build and execute the main handler chain - stack := s.Routes.BuildCompositeRoute(w, r) + stack, w := s.Routes.BuildCompositeRoute(w, r) err := s.executeCompositeRoute(w, r, stack) if err != nil { // add the raw error value to the request context @@ -64,7 +68,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { w.WriteHeader(handlerErr.StatusCode) } } else { - errStack := s.Errors.Routes.BuildCompositeRoute(w, r) + errStack, w := s.Errors.Routes.BuildCompositeRoute(w, r) err := s.executeCompositeRoute(w, r, errStack) if err != nil { // TODO: what should we do if the error handler has an error?