src/net/http/fs.go

   1 // Copyright 2009 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 // HTTP file system request handler
   6
   7 package http
   8
   9 import (
  10         "errors"
  11         "fmt"
  12         "internal/safefilepath"
  13         "io"
  14         "io/fs"
  15         "mime"
  16         "mime/multipart"
  17         "net/textproto"
  18         "net/url"
  19         "os"
  20         "path"
  21         "path/filepath"
  22         "sort"
  23         "strconv"
  24         "strings"
  25         "time"
  26 )
  27
  28 // A Dir implements FileSystem using the native file system restricted to a
  29 // specific directory tree.
  30 //
  31 // While the FileSystem.Open method takes '/'-separated paths, a Dir's string
  32 // value is a filename on the native file system, not a URL, so it is separated
  33 // by filepath.Separator, which isn't necessarily '/'.
  34 //
  35 // Note that Dir could expose sensitive files and directories. Dir will follow
  36 // symlinks pointing out of the directory tree, which can be especially dangerous
  37 // if serving from a directory in which users are able to create arbitrary symlinks.
  38 // Dir will also allow access to files and directories starting with a period,
  39 // which could expose sensitive directories like .git or sensitive files like
  40 // .htpasswd. To exclude files with a leading period, remove the files/directories
  41 // from the server or create a custom FileSystem implementation.
  42 //
  43 // An empty Dir is treated as ".".
  44 type Dir string
  45
  46 // mapOpenError maps the provided non-nil error from opening name
  47 // to a possibly better non-nil error. In particular, it turns OS-specific errors
  48 // about opening files in non-directories into fs.ErrNotExist. See Issues 18984 and 49552.
  49 func mapOpenError(originalErr error, name string, sep rune, stat func(string) (fs.FileInfo, error)) error {
  50         if errors.Is(originalErr, fs.ErrNotExist) || errors.Is(originalErr, fs.ErrPermission) {
  51                 return originalErr
  52         }
  53
  54         parts := strings.Split(name, string(sep))
  55         for i := range parts {
  56                 if parts[i] == "" {
  57                         continue
  58                 }
  59                 fi, err := stat(strings.Join(parts[:i+1], string(sep)))
  60                 if err != nil {
  61                         return originalErr
  62                 }
  63                 if !fi.IsDir() {
  64                         return fs.ErrNotExist
  65                 }
  66         }
  67         return originalErr
  68 }
  69
  70 // Open implements FileSystem using os.Open, opening files for reading rooted
  71 // and relative to the directory d.
  72 func (d Dir) Open(name string) (File, error) {
  73         path, err := safefilepath.FromFS(path.Clean("/" + name))
  74         if err != nil {
  75                 return nil, errors.New("http: invalid or unsafe file path")
  76         }
  77         dir := string(d)
  78         if dir == "" {
  79                 dir = "."
  80         }
  81         fullName := filepath.Join(dir, path)
  82         f, err := os.Open(fullName)
  83         if err != nil {
  84                 return nil, mapOpenError(err, fullName, filepath.Separator, os.Stat)
  85         }
  86         return f, nil
  87 }
  88
  89 // A FileSystem implements access to a collection of named files.
  90 // The elements in a file path are separated by slash ('/', U+002F)
  91 // characters, regardless of host operating system convention.
  92 // See the FileServer function to convert a FileSystem to a Handler.
  93 //
  94 // This interface predates the fs.FS interface, which can be used instead:
  95 // the FS adapter function converts an fs.FS to a FileSystem.
  96 type FileSystem interface {
  97         Open(name string) (File, error)
  98 }
  99
 100 // A File is returned by a FileSystem's Open method and can be
 101 // served by the FileServer implementation.
 102 //
 103 // The methods should behave the same as those on an *os.File.
 104 type File interface {
 105         io.Closer
 106         io.Reader
 107         io.Seeker
 108         Readdir(count int) ([]fs.FileInfo, error)
 109         Stat() (fs.FileInfo, error)
 110 }
 111
 112 type anyDirs interface {
 113         len() int
 114         name(i int) string
 115         isDir(i int) bool
 116 }
 117
 118 type fileInfoDirs []fs.FileInfo
 119
 120 func (d fileInfoDirs) len() int          { return len(d) }
 121 func (d fileInfoDirs) isDir(i int) bool  { return d[i].IsDir() }
 122 func (d fileInfoDirs) name(i int) string { return d[i].Name() }
 123
 124 type dirEntryDirs []fs.DirEntry
 125
 126 func (d dirEntryDirs) len() int          { return len(d) }
 127 func (d dirEntryDirs) isDir(i int) bool  { return d[i].IsDir() }
 128 func (d dirEntryDirs) name(i int) string { return d[i].Name() }
 129
 130 func dirList(w ResponseWriter, r *Request, f File) {
 131         // Prefer to use ReadDir instead of Readdir,
 132         // because the former doesn't require calling
 133         // Stat on every entry of a directory on Unix.
 134         var dirs anyDirs
 135         var err error
 136         if d, ok := f.(fs.ReadDirFile); ok {
 137                 var list dirEntryDirs
 138                 list, err = d.ReadDir(-1)
 139                 dirs = list
 140         } else {
 141                 var list fileInfoDirs
 142                 list, err = f.Readdir(-1)
 143                 dirs = list
 144         }
 145
 146         if err != nil {
 147                 logf(r, "http: error reading directory: %v", err)
 148                 Error(w, "Error reading directory", StatusInternalServerError)
 149                 return
 150         }
 151         sort.Slice(dirs, func(i, j int) bool { return dirs.name(i) < dirs.name(j) })
 152
 153         w.Header().Set("Content-Type", "text/html; charset=utf-8")
 154         fmt.Fprintf(w, "<pre>\n")
 155         for i, n := 0, dirs.len(); i < n; i++ {
 156                 name := dirs.name(i)
 157                 if dirs.isDir(i) {
 158                         name += "/"
 159                 }
 160                 // name may contain '?' or '#', which must be escaped to remain
 161                 // part of the URL path, and not indicate the start of a query
 162                 // string or fragment.
 163                 url := url.URL{Path: name}
 164                 fmt.Fprintf(w, "<a href=\"%s\">%s</a>\n", url.String(), htmlReplacer.Replace(name))
 165         }
 166         fmt.Fprintf(w, "</pre>\n")
 167 }
 168
 169 // ServeContent replies to the request using the content in the
 170 // provided ReadSeeker. The main benefit of ServeContent over io.Copy
 171 // is that it handles Range requests properly, sets the MIME type, and
 172 // handles If-Match, If-Unmodified-Since, If-None-Match, If-Modified-Since,
 173 // and If-Range requests.
 174 //
 175 // If the response's Content-Type header is not set, ServeContent
 176 // first tries to deduce the type from name's file extension and,
 177 // if that fails, falls back to reading the first block of the content
 178 // and passing it to DetectContentType.
 179 // The name is otherwise unused; in particular it can be empty and is
 180 // never sent in the response.
 181 //
 182 // If modtime is not the zero time or Unix epoch, ServeContent
 183 // includes it in a Last-Modified header in the response. If the
 184 // request includes an If-Modified-Since header, ServeContent uses
 185 // modtime to decide whether the content needs to be sent at all.
 186 //
 187 // The content's Seek method must work: ServeContent uses
 188 // a seek to the end of the content to determine its size.
 189 //
 190 // If the caller has set w's ETag header formatted per RFC 7232, section 2.3,
 191 // ServeContent uses it to handle requests using If-Match, If-None-Match, or If-Range.
 192 //
 193 // Note that *os.File implements the io.ReadSeeker interface.
 194 func ServeContent(w ResponseWriter, req *Request, name string, modtime time.Time, content io.ReadSeeker) {
 195         sizeFunc := func() (int64, error) {
 196                 size, err := content.Seek(0, io.SeekEnd)
 197                 if err != nil {
 198                         return 0, errSeeker
 199                 }
 200                 _, err = content.Seek(0, io.SeekStart)
 201                 if err != nil {
 202                         return 0, errSeeker
 203                 }
 204                 return size, nil
 205         }
 206         serveContent(w, req, name, modtime, sizeFunc, content)
 207 }
 208
 209 // errSeeker is returned by ServeContent's sizeFunc when the content
 210 // doesn't seek properly. The underlying Seeker's error text isn't
 211 // included in the sizeFunc reply so it's not sent over HTTP to end
 212 // users.
 213 var errSeeker = errors.New("seeker can't seek")
 214
 215 // errNoOverlap is returned by serveContent's parseRange if first-byte-pos of
 216 // all of the byte-range-spec values is greater than the content size.
 217 var errNoOverlap = errors.New("invalid range: failed to overlap")
 218
 219 // if name is empty, filename is unknown. (used for mime type, before sniffing)
 220 // if modtime.IsZero(), modtime is unknown.
 221 // content must be seeked to the beginning of the file.
 222 // The sizeFunc is called at most once. Its error, if any, is sent in the HTTP response.
 223 func serveContent(w ResponseWriter, r *Request, name string, modtime time.Time, sizeFunc func() (int64, error), content io.ReadSeeker) {
 224         setLastModified(w, modtime)
 225         done, rangeReq := checkPreconditions(w, r, modtime)
 226         if done {
 227                 return
 228         }
 229
 230         code := StatusOK
 231
 232         // If Content-Type isn't set, use the file's extension to find it, but
 233         // if the Content-Type is unset explicitly, do not sniff the type.
 234         ctypes, haveType := w.Header()["Content-Type"]
 235         var ctype string
 236         if !haveType {
 237                 ctype = mime.TypeByExtension(filepath.Ext(name))
 238                 if ctype == "" {
 239                         // read a chunk to decide between utf-8 text and binary
 240                         var buf [sniffLen]byte
 241                         n, _ := io.ReadFull(content, buf[:])
 242                         ctype = DetectContentType(buf[:n])
 243                         _, err := content.Seek(0, io.SeekStart) // rewind to output whole file
 244                         if err != nil {
 245                                 Error(w, "seeker can't seek", StatusInternalServerError)
 246                                 return
 247                         }
 248                 }
 249                 w.Header().Set("Content-Type", ctype)
 250         } else if len(ctypes) > 0 {
 251                 ctype = ctypes[0]
 252         }
 253
 254         size, err := sizeFunc()
 255         if err != nil {
 256                 Error(w, err.Error(), StatusInternalServerError)
 257                 return
 258         }
 259         if size < 0 {
 260                 // Should never happen but just to be sure
 261                 Error(w, "negative content size computed", StatusInternalServerError)
 262                 return
 263         }
 264
 265         // handle Content-Range header.
 266         sendSize := size
 267         var sendContent io.Reader = content
 268         ranges, err := parseRange(rangeReq, size)
 269         switch err {
 270         case nil:
 271         case errNoOverlap:
 272                 if size == 0 {
 273                         // Some clients add a Range header to all requests to
 274                         // limit the size of the response. If the file is empty,
 275                         // ignore the range header and respond with a 200 rather
 276                         // than a 416.
 277                         ranges = nil
 278                         break
 279                 }
 280                 w.Header().Set("Content-Range", fmt.Sprintf("bytes */%d", size))
 281                 fallthrough
 282         default:
 283                 Error(w, err.Error(), StatusRequestedRangeNotSatisfiable)
 284                 return
 285         }
 286
 287         if sumRangesSize(ranges) > size {
 288                 // The total number of bytes in all the ranges
 289                 // is larger than the size of the file by
 290                 // itself, so this is probably an attack, or a
 291                 // dumb client. Ignore the range request.
 292                 ranges = nil
 293         }
 294         switch {
 295         case len(ranges) == 1:
 296                 // RFC 7233, Section 4.1:
 297                 // "If a single part is being transferred, the server
 298                 // generating the 206 response MUST generate a
 299                 // Content-Range header field, describing what range
 300                 // of the selected representation is enclosed, and a
 301                 // payload consisting of the range.
 302                 // ...
 303                 // A server MUST NOT generate a multipart response to
 304                 // a request for a single range, since a client that
 305                 // does not request multiple parts might not support
 306                 // multipart responses."
 307                 ra := ranges[0]
 308                 if _, err := content.Seek(ra.start, io.SeekStart); err != nil {
 309                         Error(w, err.Error(), StatusRequestedRangeNotSatisfiable)
 310                         return
 311                 }
 312                 sendSize = ra.length
 313                 code = StatusPartialContent
 314                 w.Header().Set("Content-Range", ra.contentRange(size))
 315         case len(ranges) > 1:
 316                 sendSize = rangesMIMESize(ranges, ctype, size)
 317                 code = StatusPartialContent
 318
 319                 pr, pw := io.Pipe()
 320                 mw := multipart.NewWriter(pw)
 321                 w.Header().Set("Content-Type", "multipart/byteranges; boundary="+mw.Boundary())
 322                 sendContent = pr
 323                 defer pr.Close() // cause writing goroutine to fail and exit if CopyN doesn't finish.
 324                 go func() {
 325                         for _, ra := range ranges {
 326                                 part, err := mw.CreatePart(ra.mimeHeader(ctype, size))
 327                                 if err != nil {
 328                                         pw.CloseWithError(err)
 329                                         return
 330                                 }
 331                                 if _, err := content.Seek(ra.start, io.SeekStart); err != nil {
 332                                         pw.CloseWithError(err)
 333                                         return
 334                                 }
 335                                 if _, err := io.CopyN(part, content, ra.length); err != nil {
 336                                         pw.CloseWithError(err)
 337                                         return
 338                                 }
 339                         }
 340                         mw.Close()
 341                         pw.Close()
 342                 }()
 343         }
 344
 345         w.Header().Set("Accept-Ranges", "bytes")
 346         if w.Header().Get("Content-Encoding") == "" {
 347                 w.Header().Set("Content-Length", strconv.FormatInt(sendSize, 10))
 348         }
 349
 350         w.WriteHeader(code)
 351
 352         if r.Method != "HEAD" {
 353                 io.CopyN(w, sendContent, sendSize)
 354         }
 355 }
 356
 357 // scanETag determines if a syntactically valid ETag is present at s. If so,
 358 // the ETag and remaining text after consuming ETag is returned. Otherwise,
 359 // it returns "", "".
 360 func scanETag(s string) (etag string, remain string) {
 361         s = textproto.TrimString(s)
 362         start := 0
 363         if strings.HasPrefix(s, "W/") {
 364                 start = 2
 365         }
 366         if len(s[start:]) < 2 || s[start] != '"' {
 367                 return "", ""
 368         }
 369         // ETag is either W/"text" or "text".
 370         // See RFC 7232 2.3.
 371         for i := start + 1; i < len(s); i++ {
 372                 c := s[i]
 373                 switch {
 374                 // Character values allowed in ETags.
 375                 case c == 0x21 || c >= 0x23 && c <= 0x7E || c >= 0x80:
 376                 case c == '"':
 377                         return s[:i+1], s[i+1:]
 378                 default:
 379                         return "", ""
 380                 }
 381         }
 382         return "", ""
 383 }
 384
 385 // etagStrongMatch reports whether a and b match using strong ETag comparison.
 386 // Assumes a and b are valid ETags.
 387 func etagStrongMatch(a, b string) bool {
 388         return a == b && a != "" && a[0] == '"'
 389 }
 390
 391 // etagWeakMatch reports whether a and b match using weak ETag comparison.
 392 // Assumes a and b are valid ETags.
 393 func etagWeakMatch(a, b string) bool {
 394         return strings.TrimPrefix(a, "W/") == strings.TrimPrefix(b, "W/")
 395 }
 396
 397 // condResult is the result of an HTTP request precondition check.
 398 // See https://tools.ietf.org/html/rfc7232 section 3.
 399 type condResult int
 400
 401 const (
 402         condNone condResult = iota
 403         condTrue
 404         condFalse
 405 )
 406
 407 func checkIfMatch(w ResponseWriter, r *Request) condResult {
 408         im := r.Header.Get("If-Match")
 409         if im == "" {
 410                 return condNone
 411         }
 412         for {
 413                 im = textproto.TrimString(im)
 414                 if len(im) == 0 {
 415                         break
 416                 }
 417                 if im[0] == ',' {
 418                         im = im[1:]
 419                         continue
 420                 }
 421                 if im[0] == '*' {
 422                         return condTrue
 423                 }
 424                 etag, remain := scanETag(im)
 425                 if etag == "" {
 426                         break
 427                 }
 428                 if etagStrongMatch(etag, w.Header().get("Etag")) {
 429                         return condTrue
 430                 }
 431                 im = remain
 432         }
 433
 434         return condFalse
 435 }
 436
 437 func checkIfUnmodifiedSince(r *Request, modtime time.Time) condResult {
 438         ius := r.Header.Get("If-Unmodified-Since")
 439         if ius == "" || isZeroTime(modtime) {
 440                 return condNone
 441         }
 442         t, err := ParseTime(ius)
 443         if err != nil {
 444                 return condNone
 445         }
 446
 447         // The Last-Modified header truncates sub-second precision so
 448         // the modtime needs to be truncated too.
 449         modtime = modtime.Truncate(time.Second)
 450         if ret := modtime.Compare(t); ret <= 0 {
 451                 return condTrue
 452         }
 453         return condFalse
 454 }
 455
 456 func checkIfNoneMatch(w ResponseWriter, r *Request) condResult {
 457         inm := r.Header.get("If-None-Match")
 458         if inm == "" {
 459                 return condNone
 460         }
 461         buf := inm
 462         for {
 463                 buf = textproto.TrimString(buf)
 464                 if len(buf) == 0 {
 465                         break
 466                 }
 467                 if buf[0] == ',' {
 468                         buf = buf[1:]
 469                         continue
 470                 }
 471                 if buf[0] == '*' {
 472                         return condFalse
 473                 }
 474                 etag, remain := scanETag(buf)
 475                 if etag == "" {
 476                         break
 477                 }
 478                 if etagWeakMatch(etag, w.Header().get("Etag")) {
 479                         return condFalse
 480                 }
 481                 buf = remain
 482         }
 483         return condTrue
 484 }
 485
 486 func checkIfModifiedSince(r *Request, modtime time.Time) condResult {
 487         if r.Method != "GET" && r.Method != "HEAD" {
 488                 return condNone
 489         }
 490         ims := r.Header.Get("If-Modified-Since")
 491         if ims == "" || isZeroTime(modtime) {
 492                 return condNone
 493         }
 494         t, err := ParseTime(ims)
 495         if err != nil {
 496                 return condNone
 497         }
 498         // The Last-Modified header truncates sub-second precision so
 499         // the modtime needs to be truncated too.
 500         modtime = modtime.Truncate(time.Second)
 501         if ret := modtime.Compare(t); ret <= 0 {
 502                 return condFalse
 503         }
 504         return condTrue
 505 }
 506
 507 func checkIfRange(w ResponseWriter, r *Request, modtime time.Time) condResult {
 508         if r.Method != "GET" && r.Method != "HEAD" {
 509                 return condNone
 510         }
 511         ir := r.Header.get("If-Range")
 512         if ir == "" {
 513                 return condNone
 514         }
 515         etag, _ := scanETag(ir)
 516         if etag != "" {
 517                 if etagStrongMatch(etag, w.Header().Get("Etag")) {
 518                         return condTrue
 519                 } else {
 520                         return condFalse
 521                 }
 522         }
 523         // The If-Range value is typically the ETag value, but it may also be
 524         // the modtime date. See golang.org/issue/8367.
 525         if modtime.IsZero() {
 526                 return condFalse
 527         }
 528         t, err := ParseTime(ir)
 529         if err != nil {
 530                 return condFalse
 531         }
 532         if t.Unix() == modtime.Unix() {
 533                 return condTrue
 534         }
 535         return condFalse
 536 }
 537
 538 var unixEpochTime = time.Unix(0, 0)
 539
 540 // isZeroTime reports whether t is obviously unspecified (either zero or Unix()=0).
 541 func isZeroTime(t time.Time) bool {
 542         return t.IsZero() || t.Equal(unixEpochTime)
 543 }
 544
 545 func setLastModified(w ResponseWriter, modtime time.Time) {
 546         if !isZeroTime(modtime) {
 547                 w.Header().Set("Last-Modified", modtime.UTC().Format(TimeFormat))
 548         }
 549 }
 550
 551 func writeNotModified(w ResponseWriter) {
 552         // RFC 7232 section 4.1:
 553         // a sender SHOULD NOT generate representation metadata other than the
 554         // above listed fields unless said metadata exists for the purpose of
 555         // guiding cache updates (e.g., Last-Modified might be useful if the
 556         // response does not have an ETag field).
 557         h := w.Header()
 558         delete(h, "Content-Type")
 559         delete(h, "Content-Length")
 560         delete(h, "Content-Encoding")
 561         if h.Get("Etag") != "" {
 562                 delete(h, "Last-Modified")
 563         }
 564         w.WriteHeader(StatusNotModified)
 565 }
 566
 567 // checkPreconditions evaluates request preconditions and reports whether a precondition
 568 // resulted in sending StatusNotModified or StatusPreconditionFailed.
 569 func checkPreconditions(w ResponseWriter, r *Request, modtime time.Time) (done bool, rangeHeader string) {
 570         // This function carefully follows RFC 7232 section 6.
 571         ch := checkIfMatch(w, r)
 572         if ch == condNone {
 573                 ch = checkIfUnmodifiedSince(r, modtime)
 574         }
 575         if ch == condFalse {
 576                 w.WriteHeader(StatusPreconditionFailed)
 577                 return true, ""
 578         }
 579         switch checkIfNoneMatch(w, r) {
 580         case condFalse:
 581                 if r.Method == "GET" || r.Method == "HEAD" {
 582                         writeNotModified(w)
 583                         return true, ""
 584                 } else {
 585                         w.WriteHeader(StatusPreconditionFailed)
 586                         return true, ""
 587                 }
 588         case condNone:
 589                 if checkIfModifiedSince(r, modtime) == condFalse {
 590                         writeNotModified(w)
 591                         return true, ""
 592                 }
 593         }
 594
 595         rangeHeader = r.Header.get("Range")
 596         if rangeHeader != "" && checkIfRange(w, r, modtime) == condFalse {
 597                 rangeHeader = ""
 598         }
 599         return false, rangeHeader
 600 }
 601
 602 // name is '/'-separated, not filepath.Separator.
 603 func serveFile(w ResponseWriter, r *Request, fs FileSystem, name string, redirect bool) {
 604         const indexPage = "/index.html"
 605
 606         // redirect .../index.html to .../
 607         // can't use Redirect() because that would make the path absolute,
 608         // which would be a problem running under StripPrefix
 609         if strings.HasSuffix(r.URL.Path, indexPage) {
 610                 localRedirect(w, r, "./")
 611                 return
 612         }
 613
 614         f, err := fs.Open(name)
 615         if err != nil {
 616                 msg, code := toHTTPError(err)
 617                 Error(w, msg, code)
 618                 return
 619         }
 620         defer f.Close()
 621
 622         d, err := f.Stat()
 623         if err != nil {
 624                 msg, code := toHTTPError(err)
 625                 Error(w, msg, code)
 626                 return
 627         }
 628
 629         if redirect {
 630                 // redirect to canonical path: / at end of directory url
 631                 // r.URL.Path always begins with /
 632                 url := r.URL.Path
 633                 if d.IsDir() {
 634                         if url[len(url)-1] != '/' {
 635                                 localRedirect(w, r, path.Base(url)+"/")
 636                                 return
 637                         }
 638                 } else {
 639                         if url[len(url)-1] == '/' {
 640                                 localRedirect(w, r, "../"+path.Base(url))
 641                                 return
 642                         }
 643                 }
 644         }
 645
 646         if d.IsDir() {
 647                 url := r.URL.Path
 648                 // redirect if the directory name doesn't end in a slash
 649                 if url == "" || url[len(url)-1] != '/' {
 650                         localRedirect(w, r, path.Base(url)+"/")
 651                         return
 652                 }
 653
 654                 // use contents of index.html for directory, if present
 655                 index := strings.TrimSuffix(name, "/") + indexPage
 656                 ff, err := fs.Open(index)
 657                 if err == nil {
 658                         defer ff.Close()
 659                         dd, err := ff.Stat()
 660                         if err == nil {
 661                                 d = dd
 662                                 f = ff
 663                         }
 664                 }
 665         }
 666
 667         // Still a directory? (we didn't find an index.html file)
 668         if d.IsDir() {
 669                 if checkIfModifiedSince(r, d.ModTime()) == condFalse {
 670                         writeNotModified(w)
 671                         return
 672                 }
 673                 setLastModified(w, d.ModTime())
 674                 dirList(w, r, f)
 675                 return
 676         }
 677
 678         // serveContent will check modification time
 679         sizeFunc := func() (int64, error) { return d.Size(), nil }
 680         serveContent(w, r, d.Name(), d.ModTime(), sizeFunc, f)
 681 }
 682
 683 // toHTTPError returns a non-specific HTTP error message and status code
 684 // for a given non-nil error value. It's important that toHTTPError does not
 685 // actually return err.Error(), since msg and httpStatus are returned to users,
 686 // and historically Go's ServeContent always returned just "404 Not Found" for
 687 // all errors. We don't want to start leaking information in error messages.
 688 func toHTTPError(err error) (msg string, httpStatus int) {
 689         if errors.Is(err, fs.ErrNotExist) {
 690                 return "404 page not found", StatusNotFound
 691         }
 692         if errors.Is(err, fs.ErrPermission) {
 693                 return "403 Forbidden", StatusForbidden
 694         }
 695         // Default:
 696         return "500 Internal Server Error", StatusInternalServerError
 697 }
 698
 699 // localRedirect gives a Moved Permanently response.
 700 // It does not convert relative paths to absolute paths like Redirect does.
 701 func localRedirect(w ResponseWriter, r *Request, newPath string) {
 702         if q := r.URL.RawQuery; q != "" {
 703                 newPath += "?" + q
 704         }
 705         w.Header().Set("Location", newPath)
 706         w.WriteHeader(StatusMovedPermanently)
 707 }
 708
 709 // ServeFile replies to the request with the contents of the named
 710 // file or directory.
 711 //
 712 // If the provided file or directory name is a relative path, it is
 713 // interpreted relative to the current directory and may ascend to
 714 // parent directories. If the provided name is constructed from user
 715 // input, it should be sanitized before calling ServeFile.
 716 //
 717 // As a precaution, ServeFile will reject requests where r.URL.Path
 718 // contains a ".." path element; this protects against callers who
 719 // might unsafely use filepath.Join on r.URL.Path without sanitizing
 720 // it and then use that filepath.Join result as the name argument.
 721 //
 722 // As another special case, ServeFile redirects any request where r.URL.Path
 723 // ends in "/index.html" to the same path, without the final
 724 // "index.html". To avoid such redirects either modify the path or
 725 // use ServeContent.
 726 //
 727 // Outside of those two special cases, ServeFile does not use
 728 // r.URL.Path for selecting the file or directory to serve; only the
 729 // file or directory provided in the name argument is used.
 730 func ServeFile(w ResponseWriter, r *Request, name string) {
 731         if containsDotDot(r.URL.Path) {
 732                 // Too many programs use r.URL.Path to construct the argument to
 733                 // serveFile. Reject the request under the assumption that happened
 734                 // here and ".." may not be wanted.
 735                 // Note that name might not contain "..", for example if code (still
 736                 // incorrectly) used filepath.Join(myDir, r.URL.Path).
 737                 Error(w, "invalid URL path", StatusBadRequest)
 738                 return
 739         }
 740         dir, file := filepath.Split(name)
 741         serveFile(w, r, Dir(dir), file, false)
 742 }
 743
 744 // ServeFileFS replies to the request with the contents
 745 // of the named file or directory from the file system fsys.
 746 //
 747 // If the provided file or directory name is a relative path, it is
 748 // interpreted relative to the current directory and may ascend to
 749 // parent directories. If the provided name is constructed from user
 750 // input, it should be sanitized before calling ServeFile.
 751 //
 752 // As a precaution, ServeFile will reject requests where r.URL.Path
 753 // contains a ".." path element; this protects against callers who
 754 // might unsafely use filepath.Join on r.URL.Path without sanitizing
 755 // it and then use that filepath.Join result as the name argument.
 756 //
 757 // As another special case, ServeFile redirects any request where r.URL.Path
 758 // ends in "/index.html" to the same path, without the final
 759 // "index.html". To avoid such redirects either modify the path or
 760 // use ServeContent.
 761 //
 762 // Outside of those two special cases, ServeFile does not use
 763 // r.URL.Path for selecting the file or directory to serve; only the
 764 // file or directory provided in the name argument is used.
 765 func ServeFileFS(w ResponseWriter, r *Request, fsys fs.FS, name string) {
 766         if containsDotDot(r.URL.Path) {
 767                 // Too many programs use r.URL.Path to construct the argument to
 768                 // serveFile. Reject the request under the assumption that happened
 769                 // here and ".." may not be wanted.
 770                 // Note that name might not contain "..", for example if code (still
 771                 // incorrectly) used filepath.Join(myDir, r.URL.Path).
 772                 Error(w, "invalid URL path", StatusBadRequest)
 773                 return
 774         }
 775         serveFile(w, r, FS(fsys), name, false)
 776 }
 777
 778 func containsDotDot(v string) bool {
 779         if !strings.Contains(v, "..") {
 780                 return false
 781         }
 782         for _, ent := range strings.FieldsFunc(v, isSlashRune) {
 783                 if ent == ".." {
 784                         return true
 785                 }
 786         }
 787         return false
 788 }
 789
 790 func isSlashRune(r rune) bool { return r == '/' || r == '\\' }
 791
 792 type fileHandler struct {
 793         root FileSystem
 794 }
 795
 796 type ioFS struct {
 797         fsys fs.FS
 798 }
 799
 800 type ioFile struct {
 801         file fs.File
 802 }
 803
 804 func (f ioFS) Open(name string) (File, error) {
 805         if name == "/" {
 806                 name = "."
 807         } else {
 808                 name = strings.TrimPrefix(name, "/")
 809         }
 810         file, err := f.fsys.Open(name)
 811         if err != nil {
 812                 return nil, mapOpenError(err, name, '/', func(path string) (fs.FileInfo, error) {
 813                         return fs.Stat(f.fsys, path)
 814                 })
 815         }
 816         return ioFile{file}, nil
 817 }
 818
 819 func (f ioFile) Close() error               { return f.file.Close() }
 820 func (f ioFile) Read(b []byte) (int, error) { return f.file.Read(b) }
 821 func (f ioFile) Stat() (fs.FileInfo, error) { return f.file.Stat() }
 822
 823 var errMissingSeek = errors.New("io.File missing Seek method")
 824 var errMissingReadDir = errors.New("io.File directory missing ReadDir method")
 825
 826 func (f ioFile) Seek(offset int64, whence int) (int64, error) {
 827         s, ok := f.file.(io.Seeker)
 828         if !ok {
 829                 return 0, errMissingSeek
 830         }
 831         return s.Seek(offset, whence)
 832 }
 833
 834 func (f ioFile) ReadDir(count int) ([]fs.DirEntry, error) {
 835         d, ok := f.file.(fs.ReadDirFile)
 836         if !ok {
 837                 return nil, errMissingReadDir
 838         }
 839         return d.ReadDir(count)
 840 }
 841
 842 func (f ioFile) Readdir(count int) ([]fs.FileInfo, error) {
 843         d, ok := f.file.(fs.ReadDirFile)
 844         if !ok {
 845                 return nil, errMissingReadDir
 846         }
 847         var list []fs.FileInfo
 848         for {
 849                 dirs, err := d.ReadDir(count - len(list))
 850                 for _, dir := range dirs {
 851                         info, err := dir.Info()
 852                         if err != nil {
 853                                 // Pretend it doesn't exist, like (*os.File).Readdir does.
 854                                 continue
 855                         }
 856                         list = append(list, info)
 857                 }
 858                 if err != nil {
 859                         return list, err
 860                 }
 861                 if count < 0 || len(list) >= count {
 862                         break
 863                 }
 864         }
 865         return list, nil
 866 }
 867
 868 // FS converts fsys to a FileSystem implementation,
 869 // for use with FileServer and NewFileTransport.
 870 // The files provided by fsys must implement io.Seeker.
 871 func FS(fsys fs.FS) FileSystem {
 872         return ioFS{fsys}
 873 }
 874
 875 // FileServer returns a handler that serves HTTP requests
 876 // with the contents of the file system rooted at root.
 877 //
 878 // As a special case, the returned file server redirects any request
 879 // ending in "/index.html" to the same path, without the final
 880 // "index.html".
 881 //
 882 // To use the operating system's file system implementation,
 883 // use http.Dir:
 884 //
 885 //      http.Handle("/", http.FileServer(http.Dir("/tmp")))
 886 //
 887 // To use an fs.FS implementation, use http.FileServerFS instead.
 888 func FileServer(root FileSystem) Handler {
 889         return &fileHandler{root}
 890 }
 891
 892 // FileServerFS returns a handler that serves HTTP requests
 893 // with the contents of the file system fsys.
 894 //
 895 // As a special case, the returned file server redirects any request
 896 // ending in "/index.html" to the same path, without the final
 897 // "index.html".
 898 //
 899 //      http.Handle("/", http.FileServerFS(fsys))
 900 func FileServerFS(root fs.FS) Handler {
 901         return FileServer(FS(root))
 902 }
 903
 904 func (f *fileHandler) ServeHTTP(w ResponseWriter, r *Request) {
 905         upath := r.URL.Path
 906         if !strings.HasPrefix(upath, "/") {
 907                 upath = "/" + upath
 908                 r.URL.Path = upath
 909         }
 910         serveFile(w, r, f.root, path.Clean(upath), true)
 911 }
 912
 913 // httpRange specifies the byte range to be sent to the client.
 914 type httpRange struct {
 915         start, length int64
 916 }
 917
 918 func (r httpRange) contentRange(size int64) string {
 919         return fmt.Sprintf("bytes %d-%d/%d", r.start, r.start+r.length-1, size)
 920 }
 921
 922 func (r httpRange) mimeHeader(contentType string, size int64) textproto.MIMEHeader {
 923         return textproto.MIMEHeader{
 924                 "Content-Range": {r.contentRange(size)},
 925                 "Content-Type":  {contentType},
 926         }
 927 }
 928
 929 // parseRange parses a Range header string as per RFC 7233.
 930 // errNoOverlap is returned if none of the ranges overlap.
 931 func parseRange(s string, size int64) ([]httpRange, error) {
 932         if s == "" {
 933                 return nil, nil // header not present
 934         }
 935         const b = "bytes="
 936         if !strings.HasPrefix(s, b) {
 937                 return nil, errors.New("invalid range")
 938         }
 939         var ranges []httpRange
 940         noOverlap := false
 941         for _, ra := range strings.Split(s[len(b):], ",") {
 942                 ra = textproto.TrimString(ra)
 943                 if ra == "" {
 944                         continue
 945                 }
 946                 start, end, ok := strings.Cut(ra, "-")
 947                 if !ok {
 948                         return nil, errors.New("invalid range")
 949                 }
 950                 start, end = textproto.TrimString(start), textproto.TrimString(end)
 951                 var r httpRange
 952                 if start == "" {
 953                         // If no start is specified, end specifies the
 954                         // range start relative to the end of the file,
 955                         // and we are dealing with <suffix-length>
 956                         // which has to be a non-negative integer as per
 957                         // RFC 7233 Section 2.1 "Byte-Ranges".
 958                         if end == "" || end[0] == '-' {
 959                                 return nil, errors.New("invalid range")
 960                         }
 961                         i, err := strconv.ParseInt(end, 10, 64)
 962                         if i < 0 || err != nil {
 963                                 return nil, errors.New("invalid range")
 964                         }
 965                         if i > size {
 966                                 i = size
 967                         }
 968                         r.start = size - i
 969                         r.length = size - r.start
 970                 } else {
 971                         i, err := strconv.ParseInt(start, 10, 64)
 972                         if err != nil || i < 0 {
 973                                 return nil, errors.New("invalid range")
 974                         }
 975                         if i >= size {
 976                                 // If the range begins after the size of the content,
 977                                 // then it does not overlap.
 978                                 noOverlap = true
 979                                 continue
 980                         }
 981                         r.start = i
 982                         if end == "" {
 983                                 // If no end is specified, range extends to end of the file.
 984                                 r.length = size - r.start
 985                         } else {
 986                                 i, err := strconv.ParseInt(end, 10, 64)
 987                                 if err != nil || r.start > i {
 988                                         return nil, errors.New("invalid range")
 989                                 }
 990                                 if i >= size {
 991                                         i = size - 1
 992                                 }
 993                                 r.length = i - r.start + 1
 994                         }
 995                 }
 996                 ranges = append(ranges, r)
 997         }
 998         if noOverlap && len(ranges) == 0 {
 999                 // The specified ranges did not overlap with the content.
1000                 return nil, errNoOverlap
1001         }
1002         return ranges, nil
1003 }
1004
1005 // countingWriter counts how many bytes have been written to it.
1006 type countingWriter int64
1007
1008 func (w *countingWriter) Write(p []byte) (n int, err error) {
1009         *w += countingWriter(len(p))
1010         return len(p), nil
1011 }
1012
1013 // rangesMIMESize returns the number of bytes it takes to encode the
1014 // provided ranges as a multipart response.
1015 func rangesMIMESize(ranges []httpRange, contentType string, contentSize int64) (encSize int64) {
1016         var w countingWriter
1017         mw := multipart.NewWriter(&w)
1018         for _, ra := range ranges {
1019                 mw.CreatePart(ra.mimeHeader(contentType, contentSize))
1020                 encSize += ra.length
1021         }
1022         mw.Close()
1023         encSize += int64(w)
1024         return
1025 }
1026
1027 func sumRangesSize(ranges []httpRange) (size int64) {
1028         for _, ra := range ranges {
1029                 size += ra.length
1030         }
1031         return
1032 }