code review 4789042: http: make serveFile redirects relative to work with St...

src/pkg/http/fs.go

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 // HTTP file system request handler
 
 package http
 
 import (
         "fmt"
@@ skipping 83 matching lines @@
                 }
         }
         fmt.Fprintf(w, "</pre>\n")
 }
 
 // name is '/'-separated, not filepath.Separator.
 func serveFile(w ResponseWriter, r *Request, fs FileSystem, name string, redirect bool) {
         const indexPage = "/index.html"
 
         // redirect .../index.html to .../
+        // can't use Redirect() because that would make the path absolute,
+        // which would be a problem running under StripPrefix
         if strings.HasSuffix(r.URL.Path, indexPage) {
-                Redirect(w, r, r.URL.Path[0:len(r.URL.Path)-len(indexPage)+1], StatusMovedPermanently)
+                localRedirect(w, r, "./")
                 return
         }
 
         f, err := fs.Open(name)
         if err != nil {
                 // TODO expose actual error?
                 NotFound(w, r)
                 return
         }
         defer f.Close()
 
         d, err1 := f.Stat()
         if err1 != nil {
                 // TODO expose actual error?
                 NotFound(w, r)
                 return
         }
 
         if redirect {
                 // redirect to canonical path: / at end of directory url
                 // r.URL.Path always begins with /
                 url := r.URL.Path
                 if d.IsDirectory() {
                         if url[len(url)-1] != '/' {
-                                Redirect(w, r, url+"/", StatusMovedPermanently)
+                                localRedirect(w, r, path.Base(url)+"/")
                                 return
                         }
                 } else {
                         if url[len(url)-1] == '/' {
-                                Redirect(w, r, url[0:len(url)-1], StatusMovedPermanently)
+                                localRedirect(w, r, "../"+path.Base(url))
                                 return
                         }
                 }
         }
 
         if t, _ := time.Parse(TimeFormat, r.Header.Get("If-Modified-Since")); t != nil && d.Mtime_ns/1e9 <= t.Seconds() {
                 w.WriteHeader(StatusNotModified)
                 return
         }
         w.Header().Set("Last-Modified", time.SecondsToUTC(d.Mtime_ns/1e9).Format(TimeFormat))
@@ skipping 67 matching lines @@
                 w.Header().Set("Content-Length", strconv.Itoa64(size))
         }
 
         w.WriteHeader(code)
 
         if r.Method != "HEAD" {
                 io.Copyn(w, f, size)
         }
 }
 
+// localRedirect gives a Moved Permanently response.
+// It does not convert relative paths to absolute paths like Redirect does.
+func localRedirect(w ResponseWriter, r *Request, newPath string) {
+        if q := r.URL.RawQuery; q != "" {
+                newPath += "?" + q
+        }
+        w.Header().Set("Location", newPath)
+        w.WriteHeader(StatusMovedPermanently)
+}
+
 // ServeFile replies to the request with the contents of the named file or directory.
 func ServeFile(w ResponseWriter, r *Request, name string) {
         dir, file := filepath.Split(name)
         serveFile(w, r, Dir(dir), file, false)
 }
 
 type fileHandler struct {
         root FileSystem
 }
 
@@ skipping 68 matching lines @@
                                 if i >= size {
                                         i = size - 1
                                 }
                                 r.length = i - r.start + 1
                         }
                 }
                 ranges = append(ranges, r)
         }
         return ranges, nil
 }