code review 12632043: net/http: fix early side effects in the ResponseWriter'...

src/pkg/net/http/server.go

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 // HTTP server.  See RFC 2616.
 
 package http
 
 import (
         "bufio"
         "crypto/tls"
         "errors"
         "fmt"
         "io"
         "io/ioutil"
         "log"
         "net"
         "net/url"
+        "os"
         "path"
         "runtime"
         "strconv"
         "strings"
         "sync"
         "time"
 )
 
 // Errors introduced by the HTTP server.
 var (
@@ skipping 309 matching lines @@
         if !w.wroteHeader {
                 w.Header().Set("Connection", "close")
         }
 }
 
 // needsSniff reports whether a Content-Type still needs to be sniffed.
 func (w *response) needsSniff() bool {
         return !w.cw.wroteHeader && w.handlerHeader.Get("Content-Type") == "" && w.written < sniffLen
 }
 
+// writerOnly hides an io.Writer value's optional ReadFrom method
+// from io.Copy.
 type writerOnly struct {
         io.Writer
 }
 
+func srcIsRegularFile(src io.Reader) (isRegular bool, err error) {
+        switch v := src.(type) {
+        case *os.File:
+                fi, err := v.Stat()
+                if err != nil {
+                        return false, err
+                }
+                return fi.Mode().IsRegular(), nil
+        case *io.LimitedReader:
+                return srcIsRegularFile(v.R)
+        default:
+                return
+        }
+}
+
+// ReadFrom is here to optimize copying from an *os.File regular file
+// to a *net.TCPConn with sendfile.
 func (w *response) ReadFrom(src io.Reader) (n int64, err error) {
+        // Our underlying w.conn.rwc is usually a *TCPConn (with its
+        // own ReadFrom method). If not, or if our src isn't a regular
+        // file, just fall back to the normal copy method.
+        rf, ok := w.conn.rwc.(io.ReaderFrom)
+        regFile, err := srcIsRegularFile(src)
+        if err != nil {
+                return 0, err
+        }
+        if !ok || !regFile {
+                return io.Copy(writerOnly{w}, src)
+        }
+
+        // sendfile path:
+
         if !w.wroteHeader {
                 w.WriteHeader(StatusOK)
         }
 
         if w.needsSniff() {
                 n0, err := io.Copy(writerOnly{w}, io.LimitReader(src, sniffLen))
                 n += n0
                 if err != nil {
                         return n, err
                 }
         }
 
         w.w.Flush()  // get rid of any previous writes
         w.cw.flush() // make sure Header is written; flush data to rwc
 
         // Now that cw has been flushed, its chunking field is guaranteed initialized.
         if !w.cw.chunking && w.bodyAllowed() {
-                if rf, ok := w.conn.rwc.(io.ReaderFrom); ok {
-                        n0, err := rf.ReadFrom(src)
-                        n += n0
-                        w.written += n0
-                        return n, err
-                }
-        }
-
-        // Fall back to default io.Copy implementation.
-        // Use wrapper to hide w.ReadFrom from io.Copy.
+                n0, err := rf.ReadFrom(src)
+                n += n0
+                w.written += n0
+                return n, err
+        }
+
         n0, err := io.Copy(writerOnly{w}, src)
         n += n0
         return n, err
 }
 
 // noLimit is an effective infinite upper bound for io.LimitedReader
 const noLimit int64 = (1 << 63) - 1
 
 // debugServerConnections controls whether all server connections are wrapped
 // with a verbose logging wrapper.
@@ skipping 1501 matching lines @@
         log.Printf("%s.Read(%d) = %d, %v", c.name, len(p), n, err)
         return
 }
 
 func (c *loggingConn) Close() (err error) {
         log.Printf("%s.Close() = ...", c.name)
         err = c.Conn.Close()
         log.Printf("%s.Close() = %v", c.name, err)
         return
 }