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         w.Header().Set("Content-Length", strconv.FormatInt(sendSize, 10))
 347
 348         w.WriteHeader(code)
 349
 350         if r.Method != "HEAD" {
 351                 io.CopyN(w, sendContent, sendSize)
 352         }
 353 }
 354
 355 // scanETag determines if a syntactically valid ETag is present at s. If so,
 356 // the ETag and remaining text after consuming ETag is returned. Otherwise,
 357 // it returns "", "".
 358 func scanETag(s string) (etag string, remain string) {
 359         s = textproto.TrimString(s)
 360         start := 0
 361         if strings.HasPrefix(s, "W/") {
 362                 start = 2
 363         }
 364         if len(s[start:]) < 2 || s[start] != '"' {
 365                 return "", ""
 366         }
 367         // ETag is either W/"text" or "text".
 368         // See RFC 7232 2.3.
 369         for i := start + 1; i < len(s); i++ {
 370                 c := s[i]
 371                 switch {
 372                 // Character values allowed in ETags.
 373                 case c == 0x21 || c >= 0x23 && c <= 0x7E || c >= 0x80:
 374                 case c == '"':
 375                         return s[:i+1], s[i+1:]
 376                 default:
 377                         return "", ""
 378                 }
 379         }
 380         return "", ""
 381 }
 382
 383 // etagStrongMatch reports whether a and b match using strong ETag comparison.
 384 // Assumes a and b are valid ETags.
 385 func etagStrongMatch(a, b string) bool {
 386         return a == b && a != "" && a[0] == '"'
 387 }
 388
 389 // etagWeakMatch reports whether a and b match using weak ETag comparison.
 390 // Assumes a and b are valid ETags.
 391 func etagWeakMatch(a, b string) bool {
 392         return strings.TrimPrefix(a, "W/") == strings.TrimPrefix(b, "W/")
 393 }
 394
 395 // condResult is the result of an HTTP request precondition check.
 396 // See https://tools.ietf.org/html/rfc7232 section 3.
 397 type condResult int
 398
 399 const (
 400         condNone condResult = iota
 401         condTrue
 402         condFalse
 403 )
 404
 405 func checkIfMatch(w ResponseWriter, r *Request) condResult {
 406         im := r.Header.Get("If-Match")
 407         if im == "" {
 408                 return condNone
 409         }
 410         for {
 411                 im = textproto.TrimString(im)
 412                 if len(im) == 0 {
 413                         break
 414                 }
 415                 if im[0] == ',' {
 416                         im = im[1:]
 417                         continue
 418                 }
 419                 if im[0] == '*' {
 420                         return condTrue
 421                 }
 422                 etag, remain := scanETag(im)
 423                 if etag == "" {
 424                         break
 425                 }
 426                 if etagStrongMatch(etag, w.Header().get("Etag")) {
 427                         return condTrue
 428                 }
 429                 im = remain
 430         }
 431
 432         return condFalse
 433 }
 434
 435 func checkIfUnmodifiedSince(r *Request, modtime time.Time) condResult {
 436         ius := r.Header.Get("If-Unmodified-Since")
 437         if ius == "" || isZeroTime(modtime) {
 438                 return condNone
 439         }
 440         t, err := ParseTime(ius)
 441         if err != nil {
 442                 return condNone
 443         }
 444
 445         // The Last-Modified header truncates sub-second precision so
 446         // the modtime needs to be truncated too.
 447         modtime = modtime.Truncate(time.Second)
 448         if ret := modtime.Compare(t); ret <= 0 {
 449                 return condTrue
 450         }
 451         return condFalse
 452 }
 453
 454 func checkIfNoneMatch(w ResponseWriter, r *Request) condResult {
 455         inm := r.Header.get("If-None-Match")
 456         if inm == "" {
 457                 return condNone
 458         }
 459         buf := inm
 460         for {
 461                 buf = textproto.TrimString(buf)
 462                 if len(buf) == 0 {
 463                         break
 464                 }
 465                 if buf[0] == ',' {
 466                         buf = buf[1:]
 467                         continue
 468                 }
 469                 if buf[0] == '*' {
 470                         return condFalse
 471                 }
 472                 etag, remain := scanETag(buf)
 473                 if etag == "" {
 474                         break
 475                 }
 476                 if etagWeakMatch(etag, w.Header().get("Etag")) {
 477                         return condFalse
 478                 }
 479                 buf = remain
 480         }
 481         return condTrue
 482 }
 483
 484 func checkIfModifiedSince(r *Request, modtime time.Time) condResult {
 485         if r.Method != "GET" && r.Method != "HEAD" {
 486                 return condNone
 487         }
 488         ims := r.Header.Get("If-Modified-Since")
 489         if ims == "" || isZeroTime(modtime) {
 490                 return condNone
 491         }
 492         t, err := ParseTime(ims)
 493         if err != nil {
 494                 return condNone
 495         }
 496         // The Last-Modified header truncates sub-second precision so
 497         // the modtime needs to be truncated too.
 498         modtime = modtime.Truncate(time.Second)
 499         if ret := modtime.Compare(t); ret <= 0 {
 500                 return condFalse
 501         }
 502         return condTrue
 503 }
 504
 505 func checkIfRange(w ResponseWriter, r *Request, modtime time.Time) condResult {
 506         if r.Method != "GET" && r.Method != "HEAD" {
 507                 return condNone
 508         }
 509         ir := r.Header.get("If-Range")
 510         if ir == "" {
 511                 return condNone
 512         }
 513         etag, _ := scanETag(ir)
 514         if etag != "" {
 515                 if etagStrongMatch(etag, w.Header().Get("Etag")) {
 516                         return condTrue
 517                 } else {
 518                         return condFalse
 519                 }
 520         }
 521         // The If-Range value is typically the ETag value, but it may also be
 522         // the modtime date. See golang.org/issue/8367.
 523         if modtime.IsZero() {
 524                 return condFalse
 525         }
 526         t, err := ParseTime(ir)
 527         if err != nil {
 528                 return condFalse
 529         }
 530         if t.Unix() == modtime.Unix() {
 531                 return condTrue
 532         }
 533         return condFalse
 534 }
 535
 536 var unixEpochTime = time.Unix(0, 0)
 537
 538 // isZeroTime reports whether t is obviously unspecified (either zero or Unix()=0).
 539 func isZeroTime(t time.Time) bool {
 540         return t.IsZero() || t.Equal(unixEpochTime)
 541 }
 542
 543 func setLastModified(w ResponseWriter, modtime time.Time) {
 544         if !isZeroTime(modtime) {
 545                 w.Header().Set("Last-Modified", modtime.UTC().Format(TimeFormat))
 546         }
 547 }
 548
 549 func writeNotModified(w ResponseWriter) {
 550         // RFC 7232 section 4.1:
 551         // a sender SHOULD NOT generate representation metadata other than the
 552         // above listed fields unless said metadata exists for the purpose of
 553         // guiding cache updates (e.g., Last-Modified might be useful if the
 554         // response does not have an ETag field).
 555         h := w.Header()
 556         delete(h, "Content-Type")
 557         delete(h, "Content-Length")
 558         delete(h, "Content-Encoding")
 559         if h.Get("Etag") != "" {
 560                 delete(h, "Last-Modified")
 561         }
 562         w.WriteHeader(StatusNotModified)
 563 }
 564
 565 // checkPreconditions evaluates request preconditions and reports whether a precondition
 566 // resulted in sending StatusNotModified or StatusPreconditionFailed.
 567 func checkPreconditions(w ResponseWriter, r *Request, modtime time.Time) (done bool, rangeHeader string) {
 568         // This function carefully follows RFC 7232 section 6.
 569         ch := checkIfMatch(w, r)
 570         if ch == condNone {
 571                 ch = checkIfUnmodifiedSince(r, modtime)
 572         }
 573         if ch == condFalse {
 574                 w.WriteHeader(StatusPreconditionFailed)
 575                 return true, ""
 576         }
 577         switch checkIfNoneMatch(w, r) {
 578         case condFalse:
 579                 if r.Method == "GET" || r.Method == "HEAD" {
 580                         writeNotModified(w)
 581                         return true, ""
 582                 } else {
 583                         w.WriteHeader(StatusPreconditionFailed)
 584                         return true, ""
 585                 }
 586         case condNone:
 587                 if checkIfModifiedSince(r, modtime) == condFalse {
 588                         writeNotModified(w)
 589                         return true, ""
 590                 }
 591         }
 592
 593         rangeHeader = r.Header.get("Range")
 594         if rangeHeader != "" && checkIfRange(w, r, modtime) == condFalse {
 595                 rangeHeader = ""
 596         }
 597         return false, rangeHeader
 598 }
 599
 600 // name is '/'-separated, not filepath.Separator.
 601 func serveFile(w ResponseWriter, r *Request, fs FileSystem, name string, redirect bool) {
 602         const indexPage = "/index.html"
 603
 604         // redirect .../index.html to .../
 605         // can't use Redirect() because that would make the path absolute,
 606         // which would be a problem running under StripPrefix
 607         if strings.HasSuffix(r.URL.Path, indexPage) {
 608                 localRedirect(w, r, "./")
 609                 return
 610         }
 611
 612         f, err := fs.Open(name)
 613         if err != nil {
 614                 msg, code := toHTTPError(err)
 615                 Error(w, msg, code)
 616                 return
 617         }
 618         defer f.Close()
 619
 620         d, err := f.Stat()
 621         if err != nil {
 622                 msg, code := toHTTPError(err)
 623                 Error(w, msg, code)
 624                 return
 625         }
 626
 627         if redirect {
 628                 // redirect to canonical path: / at end of directory url
 629                 // r.URL.Path always begins with /
 630                 url := r.URL.Path
 631                 if d.IsDir() {
 632                         if url[len(url)-1] != '/' {
 633                                 localRedirect(w, r, path.Base(url)+"/")
 634                                 return
 635                         }
 636                 } else {
 637                         if url[len(url)-1] == '/' {
 638                                 localRedirect(w, r, "../"+path.Base(url))
 639                                 return
 640                         }
 641                 }
 642         }
 643
 644         if d.IsDir() {
 645                 url := r.URL.Path
 646                 // redirect if the directory name doesn't end in a slash
 647                 if url == "" || url[len(url)-1] != '/' {
 648                         localRedirect(w, r, path.Base(url)+"/")
 649                         return
 650                 }
 651
 652                 // use contents of index.html for directory, if present
 653                 index := strings.TrimSuffix(name, "/") + indexPage
 654                 ff, err := fs.Open(index)
 655                 if err == nil {
 656                         defer ff.Close()
 657                         dd, err := ff.Stat()
 658                         if err == nil {
 659                                 d = dd
 660                                 f = ff
 661                         }
 662                 }
 663         }
 664
 665         // Still a directory? (we didn't find an index.html file)
 666         if d.IsDir() {
 667                 if checkIfModifiedSince(r, d.ModTime()) == condFalse {
 668                         writeNotModified(w)
 669                         return
 670                 }
 671                 setLastModified(w, d.ModTime())
 672                 dirList(w, r, f)
 673                 return
 674         }
 675
 676         // serveContent will check modification time
 677         sizeFunc := func() (int64, error) { return d.Size(), nil }
 678         serveContent(w, r, d.Name(), d.ModTime(), sizeFunc, f)
 679 }
 680
 681 // toHTTPError returns a non-specific HTTP error message and status code
 682 // for a given non-nil error value. It's important that toHTTPError does not
 683 // actually return err.Error(), since msg and httpStatus are returned to users,
 684 // and historically Go's ServeContent always returned just "404 Not Found" for
 685 // all errors. We don't want to start leaking information in error messages.
 686 func toHTTPError(err error) (msg string, httpStatus int) {
 687         if errors.Is(err, fs.ErrNotExist) {
 688                 return "404 page not found", StatusNotFound
 689         }
 690         if errors.Is(err, fs.ErrPermission) {
 691                 return "403 Forbidden", StatusForbidden
 692         }
 693         // Default:
 694         return "500 Internal Server Error", StatusInternalServerError
 695 }
 696
 697 // localRedirect gives a Moved Permanently response.
 698 // It does not convert relative paths to absolute paths like Redirect does.
 699 func localRedirect(w ResponseWriter, r *Request, newPath string) {
 700         if q := r.URL.RawQuery; q != "" {
 701                 newPath += "?" + q
 702         }
 703         w.Header().Set("Location", newPath)
 704         w.WriteHeader(StatusMovedPermanently)
 705 }
 706
 707 // ServeFile replies to the request with the contents of the named
 708 // file or directory.
 709 //
 710 // If the provided file or directory name is a relative path, it is
 711 // interpreted relative to the current directory and may ascend to
 712 // parent directories. If the provided name is constructed from user
 713 // input, it should be sanitized before calling ServeFile.
 714 //
 715 // As a precaution, ServeFile will reject requests where r.URL.Path
 716 // contains a ".." path element; this protects against callers who
 717 // might unsafely use filepath.Join on r.URL.Path without sanitizing
 718 // it and then use that filepath.Join result as the name argument.
 719 //
 720 // As another special case, ServeFile redirects any request where r.URL.Path
 721 // ends in "/index.html" to the same path, without the final
 722 // "index.html". To avoid such redirects either modify the path or
 723 // use ServeContent.
 724 //
 725 // Outside of those two special cases, ServeFile does not use
 726 // r.URL.Path for selecting the file or directory to serve; only the
 727 // file or directory provided in the name argument is used.
 728 func ServeFile(w ResponseWriter, r *Request, name string) {
 729         if containsDotDot(r.URL.Path) {
 730                 // Too many programs use r.URL.Path to construct the argument to
 731                 // serveFile. Reject the request under the assumption that happened
 732                 // here and ".." may not be wanted.
 733                 // Note that name might not contain "..", for example if code (still
 734                 // incorrectly) used filepath.Join(myDir, r.URL.Path).
 735                 Error(w, "invalid URL path", StatusBadRequest)
 736                 return
 737         }
 738         dir, file := filepath.Split(name)
 739         serveFile(w, r, Dir(dir), file, false)
 740 }
 741
 742 // ServeFileFS replies to the request with the contents
 743 // of the named file or directory from the file system fsys.
 744 //
 745 // If the provided file or directory name is a relative path, it is
 746 // interpreted relative to the current directory and may ascend to
 747 // parent directories. If the provided name is constructed from user
 748 // input, it should be sanitized before calling ServeFile.
 749 //
 750 // As a precaution, ServeFile will reject requests where r.URL.Path
 751 // contains a ".." path element; this protects against callers who
 752 // might unsafely use filepath.Join on r.URL.Path without sanitizing
 753 // it and then use that filepath.Join result as the name argument.
 754 //
 755 // As another special case, ServeFile redirects any request where r.URL.Path
 756 // ends in "/index.html" to the same path, without the final
 757 // "index.html". To avoid such redirects either modify the path or
 758 // use ServeContent.
 759 //
 760 // Outside of those two special cases, ServeFile does not use
 761 // r.URL.Path for selecting the file or directory to serve; only the
 762 // file or directory provided in the name argument is used.
 763 func ServeFileFS(w ResponseWriter, r *Request, fsys fs.FS, name string) {
 764         if containsDotDot(r.URL.Path) {
 765                 // Too many programs use r.URL.Path to construct the argument to
 766                 // serveFile. Reject the request under the assumption that happened
 767                 // here and ".." may not be wanted.
 768                 // Note that name might not contain "..", for example if code (still
 769                 // incorrectly) used filepath.Join(myDir, r.URL.Path).
 770                 Error(w, "invalid URL path", StatusBadRequest)
 771                 return
 772         }
 773         serveFile(w, r, FS(fsys), name, false)
 774 }
 775
 776 func containsDotDot(v string) bool {
 777         if !strings.Contains(v, "..") {
 778                 return false
 779         }
 780         for _, ent := range strings.FieldsFunc(v, isSlashRune) {
 781                 if ent == ".." {
 782                         return true
 783                 }
 784         }
 785         return false
 786 }
 787
 788 func isSlashRune(r rune) bool { return r == '/' || r == '\\' }
 789
 790 type fileHandler struct {
 791         root FileSystem
 792 }
 793
 794 type ioFS struct {
 795         fsys fs.FS
 796 }
 797
 798 type ioFile struct {
 799         file fs.File
 800 }
 801
 802 func (f ioFS) Open(name string) (File, error) {
 803         if name == "/" {
 804                 name = "."
 805         } else {
 806                 name = strings.TrimPrefix(name, "/")
 807         }
 808         file, err := f.fsys.Open(name)
 809         if err != nil {
 810                 return nil, mapOpenError(err, name, '/', func(path string) (fs.FileInfo, error) {
 811                         return fs.Stat(f.fsys, path)
 812                 })
 813         }
 814         return ioFile{file}, nil
 815 }
 816
 817 func (f ioFile) Close() error               { return f.file.Close() }
 818 func (f ioFile) Read(b []byte) (int, error) { return f.file.Read(b) }
 819 func (f ioFile) Stat() (fs.FileInfo, error) { return f.file.Stat() }
 820
 821 var errMissingSeek = errors.New("io.File missing Seek method")
 822 var errMissingReadDir = errors.New("io.File directory missing ReadDir method")
 823
 824 func (f ioFile) Seek(offset int64, whence int) (int64, error) {
 825         s, ok := f.file.(io.Seeker)
 826         if !ok {
 827                 return 0, errMissingSeek
 828         }
 829         return s.Seek(offset, whence)
 830 }
 831
 832 func (f ioFile) ReadDir(count int) ([]fs.DirEntry, error) {
 833         d, ok := f.file.(fs.ReadDirFile)
 834         if !ok {
 835                 return nil, errMissingReadDir
 836         }
 837         return d.ReadDir(count)
 838 }
 839
 840 func (f ioFile) Readdir(count int) ([]fs.FileInfo, error) {
 841         d, ok := f.file.(fs.ReadDirFile)
 842         if !ok {
 843                 return nil, errMissingReadDir
 844         }
 845         var list []fs.FileInfo
 846         for {
 847                 dirs, err := d.ReadDir(count - len(list))
 848                 for _, dir := range dirs {
 849                         info, err := dir.Info()
 850                         if err != nil {
 851                                 // Pretend it doesn't exist, like (*os.File).Readdir does.
 852                                 continue
 853                         }
 854                         list = append(list, info)
 855                 }
 856                 if err != nil {
 857                         return list, err
 858                 }
 859                 if count < 0 || len(list) >= count {
 860                         break
 861                 }
 862         }
 863         return list, nil
 864 }
 865
 866 // FS converts fsys to a FileSystem implementation,
 867 // for use with FileServer and NewFileTransport.
 868 // The files provided by fsys must implement io.Seeker.
 869 func FS(fsys fs.FS) FileSystem {
 870         return ioFS{fsys}
 871 }
 872
 873 // FileServer returns a handler that serves HTTP requests
 874 // with the contents of the file system rooted at root.
 875 //
 876 // As a special case, the returned file server redirects any request
 877 // ending in "/index.html" to the same path, without the final
 878 // "index.html".
 879 //
 880 // To use the operating system's file system implementation,
 881 // use http.Dir:
 882 //
 883 //      http.Handle("/", http.FileServer(http.Dir("/tmp")))
 884 //
 885 // To use an fs.FS implementation, use http.FileServerFS instead.
 886 func FileServer(root FileSystem) Handler {
 887         return &fileHandler{root}
 888 }
 889
 890 // FileServerFS returns a handler that serves HTTP requests
 891 // with the contents of the file system fsys.
 892 //
 893 // As a special case, the returned file server redirects any request
 894 // ending in "/index.html" to the same path, without the final
 895 // "index.html".
 896 //
 897 //      http.Handle("/", http.FileServerFS(fsys))
 898 func FileServerFS(root fs.FS) Handler {
 899         return FileServer(FS(root))
 900 }
 901
 902 func (f *fileHandler) ServeHTTP(w ResponseWriter, r *Request) {
 903         upath := r.URL.Path
 904         if !strings.HasPrefix(upath, "/") {
 905                 upath = "/" + upath
 906                 r.URL.Path = upath
 907         }
 908         serveFile(w, r, f.root, path.Clean(upath), true)
 909 }
 910
 911 // httpRange specifies the byte range to be sent to the client.
 912 type httpRange struct {
 913         start, length int64
 914 }
 915
 916 func (r httpRange) contentRange(size int64) string {
 917         return fmt.Sprintf("bytes %d-%d/%d", r.start, r.start+r.length-1, size)
 918 }
 919
 920 func (r httpRange) mimeHeader(contentType string, size int64) textproto.MIMEHeader {
 921         return textproto.MIMEHeader{
 922                 "Content-Range": {r.contentRange(size)},
 923                 "Content-Type":  {contentType},
 924         }
 925 }
 926
 927 // parseRange parses a Range header string as per RFC 7233.
 928 // errNoOverlap is returned if none of the ranges overlap.
 929 func parseRange(s string, size int64) ([]httpRange, error) {
 930         if s == "" {
 931                 return nil, nil // header not present
 932         }
 933         const b = "bytes="
 934         if !strings.HasPrefix(s, b) {
 935                 return nil, errors.New("invalid range")
 936         }
 937         var ranges []httpRange
 938         noOverlap := false
 939         for _, ra := range strings.Split(s[len(b):], ",") {
 940                 ra = textproto.TrimString(ra)
 941                 if ra == "" {
 942                         continue
 943                 }
 944                 start, end, ok := strings.Cut(ra, "-")
 945                 if !ok {
 946                         return nil, errors.New("invalid range")
 947                 }
 948                 start, end = textproto.TrimString(start), textproto.TrimString(end)
 949                 var r httpRange
 950                 if start == "" {
 951                         // If no start is specified, end specifies the
 952                         // range start relative to the end of the file,
 953                         // and we are dealing with <suffix-length>
 954                         // which has to be a non-negative integer as per
 955                         // RFC 7233 Section 2.1 "Byte-Ranges".
 956                         if end == "" || end[0] == '-' {
 957                                 return nil, errors.New("invalid range")
 958                         }
 959                         i, err := strconv.ParseInt(end, 10, 64)
 960                         if i < 0 || err != nil {
 961                                 return nil, errors.New("invalid range")
 962                         }
 963                         if i > size {
 964                                 i = size
 965                         }
 966                         r.start = size - i
 967                         r.length = size - r.start
 968                 } else {
 969                         i, err := strconv.ParseInt(start, 10, 64)
 970                         if err != nil || i < 0 {
 971                                 return nil, errors.New("invalid range")
 972                         }
 973                         if i >= size {
 974                                 // If the range begins after the size of the content,
 975                                 // then it does not overlap.
 976                                 noOverlap = true
 977                                 continue
 978                         }
 979                         r.start = i
 980                         if end == "" {
 981                                 // If no end is specified, range extends to end of the file.
 982                                 r.length = size - r.start
 983                         } else {
 984                                 i, err := strconv.ParseInt(end, 10, 64)
 985                                 if err != nil || r.start > i {
 986                                         return nil, errors.New("invalid range")
 987                                 }
 988                                 if i >= size {
 989                                         i = size - 1
 990                                 }
 991                                 r.length = i - r.start + 1
 992                         }
 993                 }
 994                 ranges = append(ranges, r)
 995         }
 996         if noOverlap && len(ranges) == 0 {
 997                 // The specified ranges did not overlap with the content.
 998                 return nil, errNoOverlap
 999         }
1000         return ranges, nil
1001 }
1002
1003 // countingWriter counts how many bytes have been written to it.
1004 type countingWriter int64
1005
1006 func (w *countingWriter) Write(p []byte) (n int, err error) {
1007         *w += countingWriter(len(p))
1008         return len(p), nil
1009 }
1010
1011 // rangesMIMESize returns the number of bytes it takes to encode the
1012 // provided ranges as a multipart response.
1013 func rangesMIMESize(ranges []httpRange, contentType string, contentSize int64) (encSize int64) {
1014         var w countingWriter
1015         mw := multipart.NewWriter(&w)
1016         for _, ra := range ranges {
1017                 mw.CreatePart(ra.mimeHeader(contentType, contentSize))
1018                 encSize += ra.length
1019         }
1020         mw.Close()
1021         encSize += int64(w)
1022         return
1023 }
1024
1025 func sumRangesSize(ranges []httpRange) (size int64) {
1026         for _, ra := range ranges {
1027                 size += ra.length
1028         }
1029         return
1030 }