// Handler for /doc/codewalk/ and below.
-func codewalk(c *http.Conn, r *http.Request) {
+func codewalk(w http.ResponseWriter, r *http.Request) {
relpath := r.URL.Path[len("/doc/codewalk/"):]
abspath := absolutePath(r.URL.Path[1:], *goroot)
r.ParseForm()
if f := r.FormValue("fileprint"); f != "" {
- codewalkFileprint(c, r, f)
+ codewalkFileprint(w, r, f)
return
}
// If directory exists, serve list of code walks.
dir, err := os.Lstat(abspath)
if err == nil && dir.IsDirectory() {
- codewalkDir(c, r, relpath, abspath)
+ codewalkDir(w, r, relpath, abspath)
return
}
// If file exists, serve using standard file server.
if err == nil {
- serveFile(c, r)
+ serveFile(w, r)
return
}
cw, err := loadCodewalk(abspath + ".xml")
if err != nil {
log.Stderr(err)
- serveError(c, r, relpath, err)
+ serveError(w, r, relpath, err)
return
}
// Canonicalize the path and redirect if changed
- if redirect(c, r) {
+ if redirect(w, r) {
return
}
b := applyTemplate(codewalkHTML, "codewalk", cw)
- servePage(c, "Codewalk: "+cw.Title, "", "", b)
+ servePage(w, "Codewalk: "+cw.Title, "", "", b)
}
// codewalkDir serves the codewalk directory listing.
// It scans the directory for subdirectories or files named *.xml
// and prepares a table.
-func codewalkDir(c *http.Conn, r *http.Request, relpath, abspath string) {
+func codewalkDir(w http.ResponseWriter, r *http.Request, relpath, abspath string) {
type elem struct {
Name string
Title string
dir, err := ioutil.ReadDir(abspath)
if err != nil {
log.Stderr(err)
- serveError(c, r, relpath, err)
+ serveError(w, r, relpath, err)
return
}
var v vector.Vector
}
b := applyTemplate(codewalkdirHTML, "codewalkdir", v)
- servePage(c, "Codewalks", "", "", b)
+ servePage(w, "Codewalks", "", "", b)
}
// in the response. This format is used for the middle window pane
// of the codewalk pages. It is a separate iframe and does not get
// the usual godoc HTML wrapper.
-func codewalkFileprint(c *http.Conn, r *http.Request, f string) {
+func codewalkFileprint(w http.ResponseWriter, r *http.Request, f string) {
abspath := absolutePath(f, *goroot)
data, err := ioutil.ReadFile(abspath)
if err != nil {
log.Stderr(err)
- serveError(c, r, f, err)
+ serveError(w, r, f, err)
return
}
lo, _ := strconv.Atoi(r.FormValue("lo"))
}
}
- io.WriteString(
c, `<style type="text/css">@import "/doc/codewalk/codewalk.css";</style><pre>`)
- template.HTMLEscape(c, data[0:mark])
- io.WriteString(
c, "<a name='mark'></a>")
- template.HTMLEscape(c, data[mark:lo])
+ io.WriteString(
w, `<style type="text/css">@import "/doc/codewalk/codewalk.css";</style><pre>`)
+ template.HTMLEscape(w, data[0:mark])
+ io.WriteString(
w, "<a name='mark'></a>")
+ template.HTMLEscape(w, data[mark:lo])
if lo < hi {
- io.WriteString(
c, "<div class='codewalkhighlight'>")
- template.HTMLEscape(c, data[lo:hi])
- io.WriteString(c, "</div>")
+ io.WriteString(
w, "<div class='codewalkhighlight'>")
+ template.HTMLEscape(w, data[lo:hi])
+ io.WriteString(w, "</div>")
}
- template.HTMLEscape(c, data[hi:])
- io.WriteString(c, "</pre>")
+ template.HTMLEscape(w, data[hi:])
+ io.WriteString(w, "</pre>")
}
// ----------------------------------------------------------------------------
// Generic HTML wrapper
-func servePage(c *http.Conn, title, subtitle, query string, content []byte) {
+func servePage(w http.ResponseWriter, title, subtitle, query string, content []byte) {
type Data struct {
Title string
Subtitle string
Content: content,
}
- if err := godocHTML.Execute(&d, c); err != nil {
+ if err := godocHTML.Execute(&d, w); err != nil {
log.Stderrf("godocHTML.Execute: %s", err)
}
}
-func serveText(c *http.Conn, text []byte) {
- c.SetHeader("Content-Type", "text/plain; charset=utf-8")
- c.Write(text)
+func serveText(w http.ResponseWriter, text []byte) {
+ w.SetHeader("Content-Type", "text/plain; charset=utf-8")
+ w.Write(text)
}
}
-func serveHTMLDoc(c *http.Conn, r *http.Request, abspath, relpath string) {
+func serveHTMLDoc(w http.ResponseWriter, r *http.Request, abspath, relpath string) {
// get HTML body contents
src, err := ioutil.ReadFile(abspath)
if err != nil {
log.Stderrf("ioutil.ReadFile: %s", err)
- serveError(c, r, relpath, err)
+ serveError(w, r, relpath, err)
return
}
// if it begins with "<!DOCTYPE " assume it is standalone
// html that doesn't need the template wrapping.
if bytes.HasPrefix(src, []byte("<!DOCTYPE ")) {
- c.Write(src)
+ w.Write(src)
return
}
}
subtitle := extractString(src, subtitleRx)
- servePage(c, title, subtitle, "", src)
+ servePage(w, title, subtitle, "", src)
}
}
-func serveGoSource(c *http.Conn, r *http.Request, abspath, relpath string) {
+func serveGoSource(w http.ResponseWriter, r *http.Request, abspath, relpath string) {
file, err := parser.ParseFile(abspath, nil, parser.ParseComments)
if err != nil {
log.Stderrf("parser.ParseFile: %s", err)
- serveError(c, r, relpath, err)
+ serveError(w, r, relpath, err)
return
}
info := &SourceInfo{styler.idList(), buf.Bytes()}
contents := applyTemplate(sourceHTML, "sourceHTML", info)
- servePage(c, "Source file "+relpath, "", "", contents)
+ servePage(w, "Source file "+relpath, "", "", contents)
}
-func redirect(c *http.Conn, r *http.Request) (redirected bool) {
+func redirect(w http.ResponseWriter, r *http.Request) (redirected bool) {
if canonical := pathutil.Clean(r.URL.Path) + "/"; r.URL.Path != canonical {
- http.Redirect(c, canonical, http.StatusMovedPermanently)
+ http.Redirect(w, r, canonical, http.StatusMovedPermanently)
redirected = true
}
return
}
-func serveTextFile(c *http.Conn, r *http.Request, abspath, relpath string) {
+func serveTextFile(w http.ResponseWriter, r *http.Request, abspath, relpath string) {
src, err := ioutil.ReadFile(abspath)
if err != nil {
log.Stderrf("ioutil.ReadFile: %s", err)
- serveError(c, r, relpath, err)
+ serveError(w, r, relpath, err)
return
}
template.HTMLEscape(&buf, src)
fmt.Fprintln(&buf, "</pre>")
- servePage(c, "Text file "+relpath, "", "", buf.Bytes())
+ servePage(w, "Text file "+relpath, "", "", buf.Bytes())
}
-func serveDirectory(c *http.Conn, r *http.Request, abspath, relpath string) {
- if redirect(c, r) {
+func serveDirectory(w http.ResponseWriter, r *http.Request, abspath, relpath string) {
+ if redirect(w, r) {
return
}
list, err := ioutil.ReadDir(abspath)
if err != nil {
log.Stderrf("ioutil.ReadDir: %s", err)
- serveError(c, r, relpath, err)
+ serveError(w, r, relpath, err)
return
}
}
contents := applyTemplate(dirlistHTML, "dirlistHTML", list)
- servePage(c, "Directory "+relpath, "", "", contents)
+ servePage(w, "Directory "+relpath, "", "", contents)
}
-func serveFile(c *http.Conn, r *http.Request) {
+func serveFile(w http.ResponseWriter, r *http.Request) {
relpath := r.URL.Path[1:] // serveFile URL paths start with '/'
abspath := absolutePath(relpath, *goroot)
// pick off special cases and hand the rest to the standard file server
switch r.URL.Path {
case "/":
- serveHTMLDoc(c, r, pathutil.Join(*goroot, "doc/root.html"), "doc/root.html")
+ serveHTMLDoc(w, r, pathutil.Join(*goroot, "doc/root.html"), "doc/root.html")
return
case "/doc/root.html":
// hide landing page from its real name
- http.Redirect(c, "/", http.StatusMovedPermanently)
+ http.Redirect(w, r, "/", http.StatusMovedPermanently)
return
}
if strings.HasSuffix(abspath, "/index.html") {
// We'll show index.html for the directory.
// Use the dir/ version as canonical instead of dir/index.html.
- http.Redirect(c, r.URL.Path[0:len(r.URL.Path)-len("index.html")], http.StatusMovedPermanently)
+ http.Redirect(w, r, r.URL.Path[0:len(r.URL.Path)-len("index.html")], http.StatusMovedPermanently)
return
}
- serveHTMLDoc(c, r, abspath, relpath)
+ serveHTMLDoc(w, r, abspath, relpath)
return
case ".go":
- serveGoSource(c, r, abspath, relpath)
+ serveGoSource(w, r, abspath, relpath)
return
}
dir, err := os.Lstat(abspath)
if err != nil {
log.Stderr(err)
- serveError(c, r, relpath, err)
+ serveError(w, r, relpath, err)
return
}
if dir != nil && dir.IsDirectory() {
- if redirect(c, r) {
+ if redirect(w, r) {
return
}
if index := abspath + "/index.html"; isTextFile(index) {
- serveHTMLDoc(c, r, index, relativePath(index))
+ serveHTMLDoc(w, r, index, relativePath(index))
return
}
- serveDirectory(c, r, abspath, relpath)
+ serveDirectory(w, r, abspath, relpath)
return
}
if isTextFile(abspath) {
- serveTextFile(c, r, abspath, relpath)
+ serveTextFile(w, r, abspath, relpath)
return
}
- fileServer.ServeHTTP(c, r)
+ fileServer.ServeHTTP(w, r)
}
}
-func (h *httpHandler) ServeHTTP(c *http.Conn, r *http.Request) {
- if redirect(c, r) {
+func (h *httpHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+ if redirect(w, r) {
return
}
info := h.getPageInfo(abspath, relpath, r.FormValue("p"), mode)
if info.Err != nil {
log.Stderr(info.Err)
- serveError(c, r, relpath, info.Err)
+ serveError(w, r, relpath, info.Err)
return
}
if r.FormValue("f") == "text" {
contents := applyTemplate(packageText, "packageText", info)
- serveText(c, contents)
+ serveText(w, contents)
return
}
}
contents := applyTemplate(packageHTML, "packageHTML", info)
- servePage(c, title, subtitle, "", contents)
+ servePage(w, title, subtitle, "", contents)
}
}
-func search(c *http.Conn, r *http.Request) {
+func search(w http.ResponseWriter, r *http.Request) {
query := strings.TrimSpace(r.FormValue("q"))
result := lookup(query)
if r.FormValue("f") == "text" {
contents := applyTemplate(searchText, "searchText", result)
- serveText(c, contents)
+ serveText(w, contents)
return
}
}
contents := applyTemplate(searchHTML, "searchHTML", result)
- servePage(c, title, "", query, contents)
+ servePage(w, title, "", query, contents)
}
)
-func serveError(c *http.Conn, r *http.Request, relpath string, err os.Error) {
+func serveError(w http.ResponseWriter, r *http.Request, relpath string, err os.Error) {
contents := applyTemplate(errorHTML, "errorHTML", err) // err may contain an absolute path!
- c.WriteHeader(http.StatusNotFound)
- servePage(c, "File "+relpath, "", "", contents)
+ w.WriteHeader(http.StatusNotFound)
+ servePage(w, "File "+relpath, "", "", contents)
}
-func exec(c *http.Conn, args []string) (status int) {
+func exec(rw http.ResponseWriter, args []string) (status int) {
r, w, err := os.Pipe()
if err != nil {
log.Stderrf("os.Pipe(): %v\n", err)
if *verbose {
os.Stderr.Write(buf.Bytes())
}
- if c != nil {
- c.SetHeader("content-type", "text/plain; charset=utf-8")
- c.Write(buf.Bytes())
+ if rw != nil {
+ rw.SetHeader("content-type", "text/plain; charset=utf-8")
+ rw.Write(buf.Bytes())
}
return
}
-func dosync(c *http.Conn, r *http.Request) {
+func dosync(w http.ResponseWriter, r *http.Request) {
args := []string{"/bin/sh", "-c", *syncCmd}
- switch exec(c, args) {
+ switch exec(w, args) {
case 0:
// sync succeeded and some files have changed;
// update package tree.
func loggingHandler(h http.Handler) http.Handler {
- return http.HandlerFunc(func(c *http.Conn, req *http.Request) {
- log.Stderrf("%s\t%s", c.RemoteAddr, req.URL)
- h.ServeHTTP(c, req)
+ return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
+ log.Stderrf("%s\t%s", w.RemoteAddr(), req.URL)
+ h.ServeHTTP(w, req)
})
}
return c
}
-func expvarHandler(c *http.Conn, req *http.Request) {
- c.SetHeader("content-type", "application/json; charset=utf-8")
- fmt.Fprintf(c, "{\n")
+func expvarHandler(w http.ResponseWriter, r *http.Request) {
+ w.SetHeader("content-type", "application/json; charset=utf-8")
+ fmt.Fprintf(w, "{\n")
first := true
for name, value := range vars {
if !first {
- fmt.Fprintf(c, ",\n")
+ fmt.Fprintf(w, ",\n")
}
first = false
- fmt.Fprintf(c, "%q: %s", name, value)
+ fmt.Fprintf(w, "%q: %s", name, value)
}
- fmt.Fprintf(c, "\n}\n")
+ fmt.Fprintf(w, "\n}\n")
}
func memstats() string {
return true
}
-func dirList(c *Conn, f *os.File) {
- fmt.Fprintf(
c, "<pre>\n")
+func dirList(w ResponseWriter, f *os.File) {
+ fmt.Fprintf(
w, "<pre>\n")
for {
dirs, err := f.Readdir(100)
if err != nil || len(dirs) == 0 {
name += "/"
}
// TODO htmlescape
- fmt.Fprintf(
c, "<a href=\"%s\">%s</a>\n", name, name)
+ fmt.Fprintf(
w, "<a href=\"%s\">%s</a>\n", name, name)
}
}
- fmt.Fprintf(c, "</pre>\n")
+ fmt.Fprintf(w, "</pre>\n")
}
-func serveFile(c *Conn, r *Request, name string, redirect bool) {
+func serveFile(w ResponseWriter, r *Request, name string, redirect bool) {
const indexPage = "/index.html"
// redirect .../index.html to .../
if strings.HasSuffix(r.URL.Path, indexPage) {
- Redirect(c, r.URL.Path[0:len(r.URL.Path)-len(indexPage)+1], StatusMovedPermanently)
+ Redirect(w, r, r.URL.Path[0:len(r.URL.Path)-len(indexPage)+1], StatusMovedPermanently)
return
}
f, err := os.Open(name, os.O_RDONLY, 0)
if err != nil {
// TODO expose actual error?
- NotFound(c, r)
+ NotFound(w, r)
return
}
defer f.Close()
d, err1 := f.Stat()
if err1 != nil {
// TODO expose actual error?
- NotFound(c, r)
+ NotFound(w, r)
return
}
url := r.URL.Path
if d.IsDirectory() {
if url[len(url)-1] != '/' {
- Redirect(c, url+"/", StatusMovedPermanently)
+ Redirect(w, r, url+"/", StatusMovedPermanently)
return
}
} else {
if url[len(url)-1] == '/' {
- Redirect(c, url[0:len(url)-1], StatusMovedPermanently)
+ Redirect(w, r, url[0:len(url)-1], StatusMovedPermanently)
return
}
}
}
if t, _ := time.Parse(TimeFormat, r.Header["If-Modified-Since"]); t != nil && d.Mtime_ns/1e9 <= t.Seconds() {
- c.WriteHeader(StatusNotModified)
+ w.WriteHeader(StatusNotModified)
return
}
- c.SetHeader("Last-Modified", time.SecondsToUTC(d.Mtime_ns/1e9).Format(TimeFormat))
+ w.SetHeader("Last-Modified", time.SecondsToUTC(d.Mtime_ns/1e9).Format(TimeFormat))
// use contents of index.html for directory, if present
if d.IsDirectory() {
}
if d.IsDirectory() {
- dirList(c, f)
+ dirList(w, f)
return
}
// use extension to find content type.
ext := path.Ext(name)
if ctype := mime.TypeByExtension(ext); ctype != "" {
- c.SetHeader("Content-Type", ctype)
+ w.SetHeader("Content-Type", ctype)
} else {
// read first chunk to decide between utf-8 text and binary
var buf [1024]byte
n, _ := io.ReadFull(f, buf[0:])
b := buf[0:n]
if isText(b) {
- c.SetHeader("Content-Type", "text-plain; charset=utf-8")
+ w.SetHeader("Content-Type", "text-plain; charset=utf-8")
} else {
- c.SetHeader("Content-Type", "application/octet-stream") // generic binary
+ w.SetHeader("Content-Type", "application/octet-stream") // generic binary
}
- c.Write(b)
+ w.Write(b)
}
- io.Copy(c, f)
+ io.Copy(w, f)
}
// ServeFile replies to the request with the contents of the named file or directory.
-func ServeFile(c *Conn, r *Request, name string) {
- serveFile(c, r, name, false)
+func ServeFile(w ResponseWriter, r *Request, name string) {
+ serveFile(w, r, name, false)
}
type fileHandler struct {
// looking up the file name in the file system.
func FileServer(root, prefix string) Handler { return &fileHandler{root, prefix} }
-func (f *fileHandler) ServeHTTP(c *Conn, r *Request) {
+func (f *fileHandler) ServeHTTP(w ResponseWriter, r *Request) {
path := r.URL.Path
if !strings.HasPrefix(path, f.prefix) {
- NotFound(c, r)
+ NotFound(w, r)
return
}
path = path[len(f.prefix):]
- serveFile(c, r, f.root+"/"+path, true)
+ serveFile(w, r, f.root+"/"+path, true)
}
// Cmdline responds with the running program's
// command line, with arguments separated by NUL bytes.
// The package initialization registers it as /debug/pprof/cmdline.
-func Cmdline(c *http.Conn, r *http.Request) {
- c.SetHeader("content-type", "text/plain; charset=utf-8")
- fmt.Fprintf(c, strings.Join(os.Args, "\x00"))
+func Cmdline(w http.ResponseWriter, r *http.Request) {
+ w.SetHeader("content-type", "text/plain; charset=utf-8")
+ fmt.Fprintf(w, strings.Join(os.Args, "\x00"))
}
// Heap responds with the pprof-formatted heap profile.
// The package initialization registers it as /debug/pprof/heap.
-func Heap(c *http.Conn, r *http.Request) {
- c.SetHeader("content-type", "text/plain; charset=utf-8")
- pprof.WriteHeapProfile(c)
+func Heap(w http.ResponseWriter, r *http.Request) {
+ w.SetHeader("content-type", "text/plain; charset=utf-8")
+ pprof.WriteHeapProfile(w)
}
// Symbol looks up the program counters listed in the request,
// responding with a table mapping program counters to function names.
// The package initialization registers it as /debug/pprof/symbol.
-func Symbol(c *http.Conn, r *http.Request) {
- c.SetHeader("content-type", "text/plain; charset=utf-8")
+func Symbol(w http.ResponseWriter, r *http.Request) {
+ w.SetHeader("content-type", "text/plain; charset=utf-8")
// We don't know how many symbols we have, but we
// do have symbol information. Pprof only cares whether
// this number is 0 (no symbols available) or > 0.
- fmt.Fprintf(c, "num_symbols: 1\n")
+ fmt.Fprintf(w, "num_symbols: 1\n")
var b *bufio.Reader
if r.Method == "POST" {
}
for {
- w, err := b.ReadSlice('+')
+ word, err := b.ReadSlice('+')
if err == nil {
- w = w[0 : len(w)-1] // trim +
+ word = word[0 : len(word)-1] // trim +
}
- pc, _ := strconv.Btoui64(string(w), 0)
+ pc, _ := strconv.Btoui64(string(word), 0)
if pc != 0 {
f := runtime.FuncForPC(uintptr(pc))
if f != nil {
- fmt.Fprintf(c, "%#x %s\n", pc, f.Name())
+ fmt.Fprintf(w, "%#x %s\n", pc, f.Name())
}
}
// registered to serve a particular path or subtree
// in the HTTP server.
//
-// ServeHTTP should write reply headers and data to the Conn
+// ServeHTTP should write reply headers and data to the ResponseWriter
// and then return. Returning signals that the request is finished
// and that the HTTP server can move on to the next request on
// the connection.
type Handler interface {
- ServeHTTP(*Conn, *Request)
-}
-
-// A Conn represents the server side of a single active HTTP connection.
-type Conn struct {
- RemoteAddr string // network address of remote side
- Req *Request // current HTTP request
-
- rwc io.ReadWriteCloser // i/o connection
- buf *bufio.ReadWriter // buffered rwc
- handler Handler // request handler
- hijacked bool // connection has been hijacked by handler
-
- // state for the current reply
+ ServeHTTP(ResponseWriter, *Request)
+}
+
+// A ResponseWriter interface is used by an HTTP handler to
+// construct an HTTP response.
+type ResponseWriter interface {
+ // RemoteAddr returns the address of the client that sent the current request
+ RemoteAddr() string
+
+ // UsingTLS returns true if the client is connected using TLS
+ UsingTLS() bool
+
+ // SetHeader sets a header line in the eventual response.
+ // For example, SetHeader("Content-Type", "text/html; charset=utf-8")
+ // will result in the header line
+ //
+ // Content-Type: text/html; charset=utf-8
+ //
+ // being sent. UTF-8 encoded HTML is the default setting for
+ // Content-Type in this library, so users need not make that
+ // particular call. Calls to SetHeader after WriteHeader (or Write)
+ // are ignored.
+ SetHeader(string, string)
+
+ // Write writes the data to the connection as part of an HTTP reply.
+ // If WriteHeader has not yet been called, Write calls WriteHeader(http.StatusOK)
+ // before writing the data.
+ Write([]byte) (int, os.Error)
+
+ // WriteHeader sends an HTTP response header with status code.
+ // If WriteHeader is not called explicitly, the first call to Write
+ // will trigger an implicit WriteHeader(http.StatusOK).
+ // Thus explicit calls to WriteHeader are mainly used to
+ // send error codes.
+ WriteHeader(int)
+
+ // Flush sends any buffered data to the client.
+ Flush()
+
+ // Hijack lets the caller take over the connection.
+ // After a call to Hijack(), the HTTP server library
+ // will not do anything else with the connection.
+ // It becomes the caller's responsibility to manage
+ // and close the connection.
+ Hijack() (io.ReadWriteCloser, *bufio.ReadWriter, os.Error)
+}
+
+// A conn represents the server side of an HTTP connection.
+type conn struct {
+ remoteAddr string // network address of remote side
+ handler Handler // request handler
+ rwc io.ReadWriteCloser // i/o connection
+ buf *bufio.ReadWriter // buffered rwc
+ hijacked bool // connection has been hijacked by handler
+ usingTLS bool // a flag indicating connection over TLS
+}
+
+// A response represents the server side of an HTTP response.
+type response struct {
+ conn *conn
+ req *Request // request for this response
chunking bool // using chunked transfer encoding for reply body
wroteHeader bool // reply header has been written
wroteContinue bool // 100 Continue response was written
header map[string]string // reply header parameters
written int64 // number of bytes written in body
status int // status code passed to WriteHeader
- usingTLS bool // a flag indicating connection over TLS
// close connection after this reply. set on request and
// updated after response from handler if there's a
}
// Create new connection from rwc.
-func newConn(rwc net.Conn, handler Handler) (c *Conn, err os.Error) {
- c = new(Conn)
- if a := rwc.RemoteAddr(); a != nil {
- c.RemoteAddr = a.String()
- }
+func newConn(rwc net.Conn, handler Handler) (c *conn, err os.Error) {
+ c = new(conn)
+ c.remoteAddr = rwc.RemoteAddr().String()
c.handler = handler
c.rwc = rwc
_, c.usingTLS = rwc.(*tls.Conn)
// wrapper around io.ReaderCloser which on first read, sends an
// HTTP/1.1 100 Continue header
type expectContinueReader struct {
- conn *Conn
+ resp *response
readCloser io.ReadCloser
}
func (ecr *expectContinueReader) Read(p []byte) (n int, err os.Error) {
- if !ecr.conn.wroteContinue && !ecr.conn.hijacked {
- ecr.conn.wroteContinue = true
- if ecr.conn.Req.ProtoAtLeast(1, 1) {
- io.WriteString(ecr.conn.buf, "HTTP/1.1 100 Continue\r\n\r\n")
- ecr.conn.buf.Flush()
- }
+ if !ecr.resp.wroteContinue && !ecr.resp.conn.hijacked {
+ ecr.resp.wroteContinue = true
+ io.WriteString(ecr.resp.conn.buf, "HTTP/1.1 100 Continue\r\n\r\n")
+ ecr.resp.conn.buf.Flush()
}
return ecr.readCloser.Read(p)
}
const TimeFormat = "Mon, 02 Jan 2006 15:04:05 GMT"
// Read next request from connection.
-func (c *Conn) readRequest() (req *Request, err os.Error) {
+func (c *conn) readRequest() (w *response, err os.Error) {
if c.hijacked {
return nil, ErrHijacked
}
+ var req *Request
if req, err = ReadRequest(c.buf.Reader); err != nil {
return nil, err
}
- // Reset per-request connection state.
- c.header = make(map[string]string)
- c.wroteHeader = false
- c.wroteContinue = false
- c.Req = req
+ w = new(response)
+ w.conn = c
+ w.req = req
+ w.header = make(map[string]string)
// Expect 100 Continue support
- if req.expectsContinue() {
+ if req.expectsContinue() && req.ProtoAtLeast(1, 1) {
// Wrap the Body reader with one that replies on the connection
- req.Body = &expectContinueReader{readCloser: req.Body, conn: c}
+ req.Body = &expectContinueReader{readCloser: req.Body, resp: w}
}
// Default output is HTML encoded in UTF-8.
- c.SetHeader("Content-Type", "text/html; charset=utf-8")
- c.SetHeader("Date", time.UTC().Format(TimeFormat))
+ w.SetHeader("Content-Type", "text/html; charset=utf-8")
+ w.SetHeader("Date", time.UTC().Format(TimeFormat))
if req.ProtoAtLeast(1, 1) {
// HTTP/1.1 or greater: use chunked transfer encoding
// to avoid closing the connection at EOF.
- c.chunking = true
- c.SetHeader("Transfer-Encoding", "chunked")
+ w.chunking = true
+ w.SetHeader("Transfer-Encoding", "chunked")
} else {
// HTTP version < 1.1: cannot do chunked transfer
// encoding, so signal EOF by closing connection.
// Will be overridden if the HTTP handler ends up
// writing a Content-Length and the client requested
// "Connection: keep-alive"
- c.closeAfterReply = true
- c.chunking = false
+ w.closeAfterReply = true
}
- return req, nil
+ return w, nil
}
-// UsingTLS returns true if the connection uses transport layer security (TLS).
-func (c *Conn) UsingTLS() bool {
- return c.usingTLS
+// UsingTLS implements the ResponseWriter.UsingTLS
+func (w *response) UsingTLS() bool {
+ return w.conn.usingTLS
}
-// SetHeader sets a header line in the eventual reply.
-// For example, SetHeader("Content-Type", "text/html; charset=utf-8")
-// will result in the header line
-//
-// Content-Type: text/html; charset=utf-8
-//
-// being sent. UTF-8 encoded HTML is the default setting for
-// Content-Type in this library, so users need not make that
-// particular call. Calls to SetHeader after WriteHeader (or Write)
-// are ignored.
-func (c *Conn) SetHeader(hdr, val string) { c.header[CanonicalHeaderKey(hdr)] = val }
-
-// WriteHeader sends an HTTP response header with status code.
-// If WriteHeader is not called explicitly, the first call to Write
-// will trigger an implicit WriteHeader(http.StatusOK).
-// Thus explicit calls to WriteHeader are mainly used to
-// send error codes.
-func (c *Conn) WriteHeader(code int) {
- if c.hijacked {
- log.Stderr("http: Conn.WriteHeader on hijacked connection")
+// RemoteAddr implements the ResponseWriter.RemoteAddr method
+func (w *response) RemoteAddr() string { return w.conn.remoteAddr }
+
+// SetHeader implements the ResponseWriter.SetHeader method
+func (w *response) SetHeader(hdr, val string) { w.header[CanonicalHeaderKey(hdr)] = val }
+
+// WriteHeader implements the ResponseWriter.WriteHeader method
+func (w *response) WriteHeader(code int) {
+ if w.conn.hijacked {
+ log.Stderr("http: response.WriteHeader on hijacked connection")
return
}
- if c.wroteHeader {
- log.Stderr("http: multiple Conn.WriteHeader calls")
+ if w.wroteHeader {
+ log.Stderr("http: multiple response.WriteHeader calls")
return
}
- c.wroteHeader = true
- c.status = code
+ w.wroteHeader = true
+ w.status = code
if code == StatusNotModified {
// Must not have body.
- c.header["Content-Type"] = "", false
- c.header["Transfer-Encoding"] = "", false
+ w.header["Content-Type"] = "", false
+ w.header["Transfer-Encoding"] = "", false
}
- c.written = 0
- if !c.Req.ProtoAtLeast(1, 0) {
+ if !w.req.ProtoAtLeast(1, 0) {
return
}
proto := "HTTP/1.0"
- if c.Req.ProtoAtLeast(1, 1) {
+ if w.req.ProtoAtLeast(1, 1) {
proto = "HTTP/1.1"
}
codestring := strconv.Itoa(code)
if !ok {
text = "status code " + codestring
}
- io.WriteString(c.buf, proto+" "+codestring+" "+text+"\r\n")
- for k, v := range c.header {
- io.WriteString(c.buf, k+": "+v+"\r\n")
+ io.WriteString(w.conn.buf, proto+" "+codestring+" "+text+"\r\n")
+ for k, v := range w.header {
+ io.WriteString(w.conn.buf, k+": "+v+"\r\n")
}
- io.WriteString(c.buf, "\r\n")
+ io.WriteString(w.conn.buf, "\r\n")
}
-// Write writes the data to the connection as part of an HTTP reply.
-// If WriteHeader has not yet been called, Write calls WriteHeader(http.StatusOK)
-// before writing the data.
-func (c *Conn) Write(data []byte) (n int, err os.Error) {
- if c.hijacked {
- log.Stderr("http: Conn.Write on hijacked connection")
+// Write implements the ResponseWriter.Write method
+func (w *response) Write(data []byte) (n int, err os.Error) {
+ if w.conn.hijacked {
+ log.Stderr("http: response.Write on hijacked connection")
return 0, ErrHijacked
}
- if !c.wroteHeader {
- if c.Req.wantsHttp10KeepAlive() {
- _, hasLength := c.header["Content-Length"]
+ if !w.wroteHeader {
+ if w.req.wantsHttp10KeepAlive() {
+ _, hasLength := w.header["Content-Length"]
if hasLength {
- _, connectionHeaderSet := c.header["Connection"]
+ _, connectionHeaderSet := w.header["Connection"]
if !connectionHeaderSet {
- c.header["Connection"] = "keep-alive"
+ w.header["Connection"] = "keep-alive"
}
}
}
- c.WriteHeader(StatusOK)
+ w.WriteHeader(StatusOK)
}
if len(data) == 0 {
return 0, nil
}
- if c.status == StatusNotModified {
+ if w.status == StatusNotModified {
// Must not have body.
return 0, ErrBodyNotAllowed
}
- c.written += int64(len(data)) // ignoring errors, for errorKludge
+ w.written += int64(len(data)) // ignoring errors, for errorKludge
// TODO(rsc): if chunking happened after the buffering,
// then there would be fewer chunk headers.
// On the other hand, it would make hijacking more difficult.
- if c.chunking {
- fmt.Fprintf(c.buf, "%x\r\n", len(data)) // TODO(rsc): use strconv not fmt
+ if w.chunking {
+ fmt.Fprintf(w.conn.buf, "%x\r\n", len(data)) // TODO(rsc): use strconv not fmt
}
- n, err = c.buf.Write(data)
- if err == nil && c.chunking {
+ n, err = w.conn.buf.Write(data)
+ if err == nil && w.chunking {
if n != len(data) {
err = io.ErrShortWrite
}
if err == nil {
- io.WriteString(c.buf, "\r\n")
+ io.WriteString(w.conn.buf, "\r\n")
}
}
// long enough. The minimum lengths used in those
// browsers are in the 256-512 range.
// Pad to 1024 bytes.
-func errorKludge(c *Conn, req *Request) {
+func errorKludge(w *response) {
const min = 1024
// Is this an error?
- if kind := c.status / 100; kind != 4 && kind != 5 {
+ if kind := w.status / 100; kind != 4 && kind != 5 {
return
}
// Did the handler supply any info? Enough?
- if c.written == 0 || c.written >= min {
+ if w.written == 0 || w.written >= min {
return
}
// Is it a broken browser?
var msg string
- switch agent := req.UserAgent; {
+ switch agent := w.req.UserAgent; {
case strings.Index(agent, "MSIE") >= 0:
msg = "Internet Explorer"
case strings.Index(agent, "Chrome/") >= 0:
msg += " would ignore this error page if this text weren't here.\n"
// Is it text? ("Content-Type" is always in the map)
- baseType := strings.Split(c.header["Content-Type"], ";", 2)[0]
+ baseType := strings.Split(w.header["Content-Type"], ";", 2)[0]
switch baseType {
case "text/html":
- io.WriteString(c, "<!-- ")
- for c.written < min {
- io.WriteString(c, msg)
+ io.WriteString(w, "<!-- ")
+ for w.written < min {
+ io.WriteString(w, msg)
}
- io.WriteString(c, " -->")
+ io.WriteString(w, " -->")
case "text/plain":
- io.WriteString(c, "\n")
- for c.written < min {
- io.WriteString(c, msg)
+ io.WriteString(w, "\n")
+ for w.written < min {
+ io.WriteString(w, msg)
}
}
}
-func (c *Conn) finishRequest() {
+func (w *response) finishRequest() {
// If this was an HTTP/1.0 request with keep-alive and we sent a Content-Length
// back, we can make this a keep-alive response ...
- if c.Req.wantsHttp10KeepAlive() {
- _, sentLength := c.header["Content-Length"]
- if sentLength && c.header["Connection"] == "keep-alive" {
- c.closeAfterReply = false
+ if w.req.wantsHttp10KeepAlive() {
+ _, sentLength := w.header["Content-Length"]
+ if sentLength && w.header["Connection"] == "keep-alive" {
+ w.closeAfterReply = false
}
}
- if !c.wroteHeader {
- c.WriteHeader(StatusOK)
+ if !w.wroteHeader {
+ w.WriteHeader(StatusOK)
}
- errorKludge(c, c.Req)
- if c.chunking {
- io.WriteString(c.buf, "0\r\n")
+ errorKludge(w)
+ if w.chunking {
+ io.WriteString(w.conn.buf, "0\r\n")
// trailer key/value pairs, followed by blank line
- io.WriteString(c.buf, "\r\n")
+ io.WriteString(w.conn.buf, "\r\n")
}
- c.buf.Flush()
+ w.conn.buf.Flush()
}
-// Flush sends any buffered data to the client.
-func (c *Conn) Flush() {
- if !c.wroteHeader {
- c.WriteHeader(StatusOK)
+// Flush implements the ResponseWriter.Flush method.
+func (w *response) Flush() {
+ if !w.wroteHeader {
+ w.WriteHeader(StatusOK)
}
- c.buf.Flush()
+ w.conn.buf.Flush()
}
// Close the connection.
-func (c *Conn) close() {
+func (c *conn) close() {
if c.buf != nil {
c.buf.Flush()
c.buf = nil
}
// Serve a new connection.
-func (c *Conn) serve() {
+func (c *conn) serve() {
for {
- req, err := c.readRequest()
+ w, err := c.readRequest()
if err != nil {
break
}
// so we might as well run the handler in this goroutine.
// [*] Not strictly true: HTTP pipelining. We could let them all process
// in parallel even if their responses need to be serialized.
- c.handler.ServeHTTP(c, req)
+ c.handler.ServeHTTP(w, w.req)
if c.hijacked {
return
}
- c.finishRequest()
- if c.closeAfterReply {
+ w.finishRequest()
+ if w.closeAfterReply {
break
}
}
c.close()
}
-// Hijack lets the caller take over the connection.
-// After a call to c.Hijack(), the HTTP server library
-// will not do anything else with the connection.
-// It becomes the caller's responsibility to manage
-// and close the connection.
-func (c *Conn) Hijack() (rwc io.ReadWriteCloser, buf *bufio.ReadWriter, err os.Error) {
- if c.hijacked {
+// Hijack impements the ResponseWriter.Hijack method.
+func (w *response) Hijack() (rwc io.ReadWriteCloser, buf *bufio.ReadWriter, err os.Error) {
+ if w.conn.hijacked {
return nil, nil, ErrHijacked
}
- c.hijacked = true
- rwc = c.rwc
- buf = c.buf
- c.rwc = nil
- c.buf = nil
+ w.conn.hijacked = true
+ rwc = w.conn.rwc
+ buf = w.conn.buf
+ w.conn.rwc = nil
+ w.conn.buf = nil
return
}
// ordinary functions as HTTP handlers. If f is a function
// with the appropriate signature, HandlerFunc(f) is a
// Handler object that calls f.
-type HandlerFunc func(*Conn, *Request)
+type HandlerFunc func(ResponseWriter, *Request)
// ServeHTTP calls f(c, req).
-func (f HandlerFunc) ServeHTTP(c *Conn, req *Request) {
- f(c, req)
+func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
+ f(w, r)
}
// Helper handlers
// Error replies to the request with the specified error message and HTTP code.
-func Error(c *Conn, error string, code int) {
- c.SetHeader("Content-Type", "text/plain; charset=utf-8")
- c.WriteHeader(code)
- fmt.Fprintln(c, error)
+func Error(w ResponseWriter, error string, code int) {
+ w.SetHeader("Content-Type", "text/plain; charset=utf-8")
+ w.WriteHeader(code)
+ fmt.Fprintln(w, error)
}
// NotFound replies to the request with an HTTP 404 not found error.
-func NotFound(c *Conn, req *Request) { Error(c, "404 page not found", StatusNotFound) }
+func NotFound(w ResponseWriter, r *Request) { Error(w, "404 page not found", StatusNotFound) }
// NotFoundHandler returns a simple request handler
// that replies to each request with a ``404 page not found'' reply.
// Redirect replies to the request with a redirect to url,
// which may be a path relative to the request path.
-func Redirect(c *Conn, url string, code int) {
+func Redirect(w ResponseWriter, r *Request, url string, code int) {
// RFC2616 recommends that a short note "SHOULD" be included in the
// response because older user agents may not understand 301/307.
note := "<a href=\"%v\">" + statusText[code] + "</a>.\n"
- if c.Req.Method == "POST" {
+ if r.Method == "POST" {
note = ""
}
// Because of this problem, no one pays attention
// to the RFC; they all send back just a new path.
// So do we.
- oldpath := c.Req.URL.Path
+ oldpath := r.URL.Path
if oldpath == "" { // should not happen, but avoid a crash if it does
oldpath = "/"
}
}
finish:
- c.SetHeader("Location", url)
- c.WriteHeader(code)
- fmt.Fprintf(c, note, url)
+ w.SetHeader("Location", url)
+ w.WriteHeader(code)
+ fmt.Fprintf(w, note, url)
}
// Redirect to a fixed URL
code int
}
-func (rh *redirectHandler) ServeHTTP(c *Conn, req *Request) {
- Redirect(c, rh.url, rh.code)
+func (rh *redirectHandler) ServeHTTP(w ResponseWriter, r *Request) {
+ Redirect(w, r, rh.url, rh.code)
}
// RedirectHandler returns a request handler that redirects
// ServeHTTP dispatches the request to the handler whose
// pattern most closely matches the request URL.
-func (mux *ServeMux) ServeHTTP(c *Conn, req *Request) {
+func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request) {
// Clean path to canonical form and redirect.
- if p := cleanPath(req.URL.Path); p != req.URL.Path {
- c.SetHeader("Location", p)
- c.WriteHeader(StatusMovedPermanently)
+ if p := cleanPath(r.URL.Path); p != r.URL.Path {
+ w.SetHeader("Location", p)
+ w.WriteHeader(StatusMovedPermanently)
return
}
var h Handler
var n = 0
for k, v := range mux.m {
- if !pathMatch(k, req.URL.Path) {
+ if !pathMatch(k, r.URL.Path) {
continue
}
if h == nil || len(k) > n {
if h == nil {
h = NotFoundHandler()
}
- h.ServeHTTP(c, req)
+ h.ServeHTTP(w, r)
}
// Handle registers the handler for the given pattern.
}
// HandleFunc registers the handler function for the given pattern.
-func (mux *ServeMux) HandleFunc(pattern string, handler func(*Conn, *Request)) {
+func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
mux.Handle(pattern, HandlerFunc(handler))
}
// HandleFunc registers the handler function for the given pattern
// in the DefaultServeMux.
-func HandleFunc(pattern string, handler func(*Conn, *Request)) {
+func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
DefaultServeMux.HandleFunc(pattern, handler)
}
// )
//
// // hello world, the web server
-// func HelloServer(c *http.Conn, req *http.Request) {
-// io.WriteString(c, "hello, world!\n")
+// func HelloServer(w http.ResponseWriter, req *http.Request) {
+// io.WriteString(w, "hello, world!\n")
// }
//
// func main() {
// "log"
// )
//
-// func handler(conn *http.Conn, req *http.Request) {
-// conn.SetHeader("Content-Type", "text/plain")
-// conn.Write([]byte("This is an example server.\n"))
+// func handler(w http.ResponseWriter, req *http.Request) {
+// w.SetHeader("Content-Type", "text/plain")
+// w.Write([]byte("This is an example server.\n"))
// }
//
// func main() {
StatusGatewayTimeout: "Gateway Timeout",
StatusHTTPVersionNotSupported: "HTTP Version Not Supported",
}
+
+// StatusText returns a text for the HTTP status code. It returns the empty
+// string if the code is unknown.
+func StatusText(code int) string {
+ return statusText[code]
+}
func (m methodArray) Swap(i, j int) { m[i], m[j] = m[j], m[i] }
// Runs at /debug/rpc
-func debugHTTP(c *http.Conn, req *http.Request) {
+func debugHTTP(w http.ResponseWriter, req *http.Request) {
// Build a sorted version of the data.
var services = make(serviceArray, len(server.serviceMap))
i := 0
}
server.Unlock()
sort.Sort(services)
- err := debug.Execute(services, c)
+ err := debug.Execute(services, w)
if err != nil {
- fmt.Fprintln(c, "rpc: error executing template:", err.String())
+ fmt.Fprintln(w, "rpc: error executing template:", err.String())
}
}
var debugPath string = "/debug/rpc"
var connected = "200 Connected to Go RPC"
-func serveHTTP(c *http.Conn, req *http.Request) {
+func serveHTTP(w http.ResponseWriter, req *http.Request) {
if req.Method != "CONNECT" {
- c.SetHeader("Content-Type", "text/plain; charset=utf-8")
- c.WriteHeader(http.StatusMethodNotAllowed)
- io.WriteString(c, "405 must CONNECT to "+rpcPath+"\n")
+ w.SetHeader("Content-Type", "text/plain; charset=utf-8")
+ w.WriteHeader(http.StatusMethodNotAllowed)
+ io.WriteString(w, "405 must CONNECT to "+rpcPath+"\n")
return
}
- conn, _, err := c.Hijack()
+ conn, _, err := w.Hijack()
if err != nil {
- log.Stderr("rpc hijacking ", c.RemoteAddr, ": ", err.String())
+ log.Stderr("rpc hijacking ", w.RemoteAddr(), ": ", err.String())
return
}
io.WriteString(conn, "HTTP/1.0 "+connected+"\n\n")
}
// ServeHTTP implements the http.Handler interface for a Web Socket
-func (f Handler) ServeHTTP(c *http.Conn, req *http.Request) {
- rwc, buf, err := c.Hijack()
+func (f Handler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
+ rwc, buf, err := w.Hijack()
if err != nil {
panic("Hijack failed: " + err.String())
return
}
var location string
- if c.UsingTLS() {
+ if w.UsingTLS() {
location = "wss://" + req.Host + req.URL.RawPath
} else {
location = "ws://" + req.Host + req.URL.RawPath
type Draft75Handler func(*Conn)
// ServeHTTP implements the http.Handler interface for a Web Socket.
-func (f Draft75Handler) ServeHTTP(c *http.Conn, req *http.Request) {
+func (f Draft75Handler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
if req.Method != "GET" || req.Proto != "HTTP/1.1" {
- c.WriteHeader(http.StatusBadRequest)
- io.WriteString(c, "Unexpected request")
+ w.WriteHeader(http.StatusBadRequest)
+ io.WriteString(w, "Unexpected request")
return
}
if req.Header["Upgrade"] != "WebSocket" {
- c.WriteHeader(http.StatusBadRequest)
- io.WriteString(c, "missing Upgrade: WebSocket header")
+ w.WriteHeader(http.StatusBadRequest)
+ io.WriteString(w, "missing Upgrade: WebSocket header")
return
}
if req.Header["Connection"] != "Upgrade" {
- c.WriteHeader(http.StatusBadRequest)
- io.WriteString(c, "missing Connection: Upgrade header")
+ w.WriteHeader(http.StatusBadRequest)
+ io.WriteString(w, "missing Connection: Upgrade header")
return
}
origin, found := req.Header["Origin"]
if !found {
- c.WriteHeader(http.StatusBadRequest)
- io.WriteString(c, "missing Origin header")
+ w.WriteHeader(http.StatusBadRequest)
+ io.WriteString(w, "missing Origin header")
return
}
- rwc, buf, err := c.Hijack()
+ rwc, buf, err := w.Hijack()
if err != nil {
panic("Hijack failed: " + err.String())
return
defer rwc.Close()
var location string
- if c.UsingTLS() {
+ if w.UsingTLS() {
location = "wss://" + req.Host + req.URL.RawPath
} else {
location = "ws://" + req.Host + req.URL.RawPath