| // 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 ( | |
| "errors" | |
| "fmt" | |
| "io" | |
| "mime" | |
| "os" | |
| "path" | |
| "path/filepath" | |
| "strconv" | |
| "strings" | |
| "time" | |
| ) | |
| // A Dir implements http.FileSystem using the native file | |
| // system restricted to a specific directory tree. | |
| // | |
| // An empty Dir is treated as ".". | |
| type Dir string | |
| func (d Dir) Open(name string) (File, error) { | |
| if filepath.Separator != '/' && strings.IndexRune(name, filepath.Separator) >= 0 { | |
| return nil, errors.New("http: invalid character in file path") | |
| } | |
| dir := string(d) | |
| if dir == "" { | |
| dir = "." | |
| } | |
| f, err := os.Open(filepath.Join(dir, filepath.FromSlash(path.Clean("/"+name)))) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return f, nil | |
| } | |
| // A FileSystem implements access to a collection of named files. | |
| // The elements in a file path are separated by slash ('/', U+002F) | |
| // characters, regardless of host operating system convention. | |
| type FileSystem interface { | |
| Open(name string) (File, error) | |
| } | |
| // A File is returned by a FileSystem's Open method and can be | |
| // served by the FileServer implementation. | |
| type File interface { | |
| Close() error | |
| Stat() (os.FileInfo, error) | |
| Readdir(count int) ([]os.FileInfo, error) | |
| Read([]byte) (int, error) | |
| Seek(offset int64, whence int) (int64, error) | |
| } | |
| func dirList(w ResponseWriter, f File) { | |
| w.Header().Set("Content-Type", "text/html; charset=utf-8") | |
| fmt.Fprintf(w, "<pre>\n") | |
| for { | |
| dirs, err := f.Readdir(100) | |
| if err != nil || len(dirs) == 0 { | |
| break | |
| } | |
| for _, d := range dirs { | |
| name := d.Name() | |
| if d.IsDir() { | |
| name += "/" | |
| } | |
| // TODO htmlescape | |
| fmt.Fprintf(w, "<a href=\"%s\">%s</a>\n", name, name) | |
| } | |
| } | |
| fmt.Fprintf(w, "</pre>\n") | |
| } | |
| // ServeContent replies to the request using the content in the | |
| // provided ReadSeeker. The main benefit of ServeContent over io.Copy | |
| // is that it handles Range requests properly, sets the MIME type, and | |
| // handles If-Modified-Since requests. | |
| // | |
| // If the response's Content-Type header is not set, ServeContent | |
| // first tries to deduce the type from name's file extension and, | |
| // if that fails, falls back to reading the first block of the content | |
| // and passing it to DetectContentType. | |
| // The name is otherwise unused; in particular it can be empty and is | |
| // never sent in the response. | |
| // | |
| // If modtime is not the zero time, ServeContent includes it in a | |
| // Last-Modified header in the response. If the request includes an | |
| // If-Modified-Since header, ServeContent uses modtime to decide | |
| // whether the content needs to be sent at all. | |
| // | |
| // The content's Seek method must work: ServeContent uses | |
| // a seek to the end of the content to determine its size. | |
| // | |
| // Note that *os.File implements the io.ReadSeeker interface. | |
| func ServeContent(w ResponseWriter, req *Request, name string, modtime time.Time, content io.ReadSeeker) { | |
| size, err := content.Seek(0, os.SEEK_END) | |
| if err != nil { | |
| Error(w, "seeker can't seek", StatusInternalServerError) | |
| return | |
| } | |
| _, err = content.Seek(0, os.SEEK_SET) | |
| if err != nil { | |
| Error(w, "seeker can't seek", StatusInternalServerError) | |
| return | |
| } | |
| serveContent(w, req, name, modtime, size, content) | |
| } | |
| // if name is empty, filename is unknown. (used for mime type, before sniffing) | |
| // if modtime.IsZero(), modtime is unknown. | |
| // content must be seeked to the beginning of the file. | |
| func serveContent(w ResponseWriter, r *Request, name string, modtime time.Time, size int64, content io.ReadSeeker) { | |
| if checkLastModified(w, r, modtime) { | |
| return | |
| } | |
| code := StatusOK | |
| // If Content-Type isn't set, use the file's extension to find it. | |
| if w.Header().Get("Content-Type") == "" { | |
| ctype := mime.TypeByExtension(filepath.Ext(name)) | |
| if ctype == "" { | |
| // read a chunk to decide between utf-8 text and binary | |
| var buf [1024]byte | |
| n, _ := io.ReadFull(content, buf[:]) | |
| b := buf[:n] | |
| ctype = DetectContentType(b) | |
| _, err := content.Seek(0, os.SEEK_SET) // rewind to output whole file | |
| if err != nil { | |
| Error(w, "seeker can't seek", StatusInternalServerError) | |
| return | |
| } | |
| } | |
| w.Header().Set("Content-Type", ctype) | |
| } | |
| // handle Content-Range header. | |
| // TODO(adg): handle multiple ranges | |
| sendSize := size | |
| if size >= 0 { | |
| ranges, err := parseRange(r.Header.Get("Range"), size) | |
| if err == nil && len(ranges) > 1 { | |
| err = errors.New("multiple ranges not supported") | |
| } | |
| if err != nil { | |
| Error(w, err.Error(), StatusRequestedRangeNotSatisfiable) | |
| return | |
| } | |
| if len(ranges) == 1 { | |
| ra := ranges[0] | |
| if _, err := content.Seek(ra.start, os.SEEK_SET); err != nil { | |
| Error(w, err.Error(), StatusRequestedRangeNotSatisfiable) | |
| return | |
| } | |
| sendSize = ra.length | |
| code = StatusPartialContent | |
| w.Header().Set("Content-Range", fmt.Sprintf("bytes %d-%d/%d", ra.start, ra.start+ra.length-1, size)) | |
| } | |
| w.Header().Set("Accept-Ranges", "bytes") | |
| if w.Header().Get("Content-Encoding") == "" { | |
| w.Header().Set("Content-Length", strconv.FormatInt(sendSize, 10)) | |
| } | |
| } | |
| w.WriteHeader(code) | |
| if r.Method != "HEAD" { | |
| if sendSize == -1 { | |
| io.Copy(w, content) | |
| } else { | |
| io.CopyN(w, content, sendSize) | |
| } | |
| } | |
| } | |
| // modtime is the modification time of the resource to be served, or IsZero(). | |
| // return value is whether this request is now complete. | |
| func checkLastModified(w ResponseWriter, r *Request, modtime time.Time) bool { | |
| if modtime.IsZero() { | |
| return false | |
| } | |
| // The Date-Modified header truncates sub-second precision, so | |
| // use mtime < t+1s instead of mtime <= t to check for unmodified. | |
| if t, err := time.Parse(TimeFormat, r.Header.Get("If-Modified-Since")); err == nil && modtime.Before(t.Add(1*time.Second)) { | |
| w.WriteHeader(StatusNotModified) | |
| return true | |
| } | |
| w.Header().Set("Last-Modified", modtime.UTC().Format(TimeFormat)) | |
| return false | |
| } | |
| // 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) { | |
| 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.IsDir() { | |
| if url[len(url)-1] != '/' { | |
| localRedirect(w, r, path.Base(url)+"/") | |
| return | |
| } | |
| } else { | |
| if url[len(url)-1] == '/' { | |
| localRedirect(w, r, "../"+path.Base(url)) | |
| return | |
| } | |
| } | |
| } | |
| // use contents of index.html for directory, if present | |
| if d.IsDir() { | |
| index := name + indexPage | |
| ff, err := fs.Open(index) | |
| if err == nil { | |
| defer ff.Close() | |
| dd, err := ff.Stat() | |
| if err == nil { | |
| name = index | |
| d = dd | |
| f = ff | |
| } | |
| } | |
| } | |
| // Still a directory? (we didn't find an index.html file) | |
| if d.IsDir() { | |
| if checkLastModified(w, r, d.ModTime()) { | |
| return | |
| } | |
| dirList(w, f) | |
| return | |
| } | |
| // serverContent will check modification time | |
| serveContent(w, r, d.Name(), d.ModTime(), d.Size(), f) | |
| } | |
| // 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 | |
| } | |
| // FileServer returns a handler that serves HTTP requests | |
| // with the contents of the file system rooted at root. | |
| // | |
| // To use the operating system's file system implementation, | |
| // use http.Dir: | |
| // | |
| // http.Handle("/", http.FileServer(http.Dir("/tmp"))) | |
| func FileServer(root FileSystem) Handler { | |
| return &fileHandler{root} | |
| } | |
| func (f *fileHandler) ServeHTTP(w ResponseWriter, r *Request) { | |
| upath := r.URL.Path | |
| if !strings.HasPrefix(upath, "/") { | |
| upath = "/" + upath | |
| r.URL.Path = upath | |
| } | |
| serveFile(w, r, f.root, path.Clean(upath), true) | |
| } | |
| // httpRange specifies the byte range to be sent to the client. | |
| type httpRange struct { | |
| start, length int64 | |
| } | |
| // parseRange parses a Range header string as per RFC 2616. | |
| func parseRange(s string, size int64) ([]httpRange, error) { | |
| if s == "" { | |
| return nil, nil // header not present | |
| } | |
| const b = "bytes=" | |
| if !strings.HasPrefix(s, b) { | |
| return nil, errors.New("invalid range") | |
| } | |
| var ranges []httpRange | |
| for _, ra := range strings.Split(s[len(b):], ",") { | |
| i := strings.Index(ra, "-") | |
| if i < 0 { | |
| return nil, errors.New("invalid range") | |
| } | |
| start, end := ra[:i], ra[i+1:] | |
| var r httpRange | |
| if start == "" { | |
| // If no start is specified, end specifies the | |
| // range start relative to the end of the file. | |
| i, err := strconv.ParseInt(end, 10, 64) | |
| if err != nil { | |
| return nil, errors.New("invalid range") | |
| } | |
| if i > size { | |
| i = size | |
| } | |
| r.start = size - i | |
| r.length = size - r.start | |
| } else { | |
| i, err := strconv.ParseInt(start, 10, 64) | |
| if err != nil || i > size || i < 0 { | |
| return nil, errors.New("invalid range") | |
| } | |
| r.start = i | |
| if end == "" { | |
| // If no end is specified, range extends to end of the file. | |
| r.length = size - r.start | |
| } else { | |
| i, err := strconv.ParseInt(end, 10, 64) | |
| if err != nil || r.start > i { | |
| return nil, errors.New("invalid range") | |
| } | |
| if i >= size { | |
| i = size - 1 | |
| } | |
| r.length = i - r.start + 1 | |
| } | |
| } | |
| ranges = append(ranges, r) | |
| } | |
| return ranges, nil | |
| } |