Merge lp:~rvb/gwacl/tls-fix into lp:gwacl

[Raphaël Badin]

Use a forked version of crypto/tls and net/http.

This branch adds a forked version of crypto/tls and net/http (crypto/tls is patched to add support for TLS renegociation and net/http is patched to use the forked version of crypto/tls).

It includes jtv's branch (lp:~jtv/gwacl/curlless) which switches from using go-curl to using the standard library's tls. (But that change is then modified to use the forked version of net/http and crypto/tls instead of the standard library.)

We forked from Go version 1.0.2 in order to support both Go 1.0.2 and Go 1.1.1 (I tried forking from crypto/tls and net/http version 1.1.1 but I was quickly overwhelmed by the number of libraries needing to be backported and the code made heavy use of Go 1.1.1-only features).

This was tested (unit tests run + script example run) with both Go 1.0.2 and Go 1.1.1.

[lp:~rvb/gwacl/tls-fix]

197. By Raphaël Badin on 2013-07-22

Remove last mention of go-curl.

[Gavin Panella (allenap)]

Looks good!

[1]

--- fork/README 1970-01-01 00:00:00 +0000
+++ fork/README 2013-07-22 12:54:30 +0000
@@ -0,0 +1,7 @@
+This directory contains a fork of Go's standard libraries net/http and crypto/tls.
...

Please wrap lines in here at no more than 80 columns. I suggest 72.

[2]

=== added file 'fork/go-use-patched-tls.patch'
--- fork/go-use-patched-tls.patch       1970-01-01 00:00:00 +0000
+++ fork/go-use-patched-tls.patch       2013-07-22 13:11:27 +0000
@@ -0,0 +1,5 @@
+15c15
+<         "launchpad.net/gwacl/fork/tls"
+---
+>      "crypto/tls"
+

I'm not sure this is useful. Without context it's not very
informative. It's also in the wrong direction. I suggest omitting it.

[3]

+func performX509Request(session *x509Session, request *X509Request) (*x509Response, error) {
...
+    response.Header = httpResponse.Header
+    if err != nil {
+        return nil, err
+    }

I don't think that condition is needed here. Could this be one of
those Go-boilerplate-confuses-DVCS moments?

review: Approve

[Gavin Panella (allenap)]

Before landing, do you know if licensing is okay?

review: Needs Information

[lp:~rvb/gwacl/tls-fix]

198. By Raphaël Badin on 2013-07-22

Review fixes.

[Raphaël Badin (rvb)]

> Looks good!
>
>
> [1]
>
> --- fork/README 1970-01-01 00:00:00 +0000
> +++ fork/README 2013-07-22 12:54:30 +0000
> @@ -0,0 +1,7 @@
> +This directory contains a fork of Go's standard libraries net/http and
> crypto/tls.
> ...
>
> Please wrap lines in here at no more than 80 columns. I suggest 72.

Okay, done.

> [2]
>
> === added file 'fork/go-use-patched-tls.patch'
> --- fork/go-use-patched-tls.patch       1970-01-01 00:00:00 +0000
> +++ fork/go-use-patched-tls.patch       2013-07-22 13:11:27 +0000
> @@ -0,0 +1,5 @@
> +15c15
> +<         "launchpad.net/gwacl/fork/tls"
> +---
> +>      "crypto/tls"
> +
>
> I'm not sure this is useful. Without context it's not very
> informative. It's also in the wrong direction. I suggest omitting it.

You're right, fixed.

> [3]
>
> +func performX509Request(session *x509Session, request *X509Request)
> (*x509Response, error) {
> ...
> +    response.Header = httpResponse.Header
> +    if err != nil {
> +        return nil, err
> +    }
>
> I don't think that condition is needed here. Could this be one of
> those Go-boilerplate-confuses-DVCS moments?

Just a left-over from the recent refactoring, fixed.

[lp:~rvb/gwacl/tls-fix]

199. By Raphaël Badin on 2013-07-22

Rename files

200. By Raphaël Badin on 2013-07-22

Add LICENSE file.

[Raphaël Badin (rvb)]

After consulting with James Page, we got confirmation that the licencing is okay: BSD-licensed code can be included in gwacl, which is a AGPL3-licensed project. I'll add a LICENSE file in /fork and we will (in another branch) add proper COPYING/COPYING.LESSER licenses files for the gwacl project itself.

[lp:~rvb/gwacl/tls-fix]

201. By Raphaël Badin on 2013-07-22

Fix license file.

[Gavin Panella (allenap)]

review: Approve

[lp:~rvb/gwacl/tls-fix]

202. By Raphaël Badin on 2013-07-22

Make format.

[Julian Edwards (julian-edwards)]

On 23/07/13 00:03, Raphaël Badin wrote:
> After consulting with James Page, we got confirmation that the licencing is okay: BSD-licensed code can be included in gwacl, which is a AGPL3-licensed project. I'll add a LICENSE file in /fork and we will (in another branch) add proper COPYING/COPYING.LESSER licenses files for the gwacl project itself.
>

It's actually LGPL but I think it still works though.

=== modified file 'HACKING.txt'
--- HACKING.txt	2013-06-24 00:39:08 +0000
+++ HACKING.txt	2013-07-22 14:27:42 +0000
@@ -20,30 +20,6 @@
 .. _Bazaar: http://bazaar.canonical.com/
 
 
-Prerequisites
--------------
-
-The code that communicates with Azure's management API uses *libcurl*, through
-a Go language binding called *go-curl*.  You need to install the libcurl
-headers for your OS.  On Ubuntu this is::
-
-   sudo apt-get install libcurl4-openssl-dev
-
-If you didn't ``go get`` gwacl you may also need to install go-curl::
-
-   go get github.com/andelf/go-curl
-
-On Ubuntu 12.10 at least, you specifically need the given version of libcurl.
-With other versions you will receive unexpected "403" HTTP status codes
-("Forbidden") from the Azure server.
-
-Why use libcurl?  At the time of writing, Go's built-in http package does not
-support TLS renegotiation.  We find that Azure forces such a renegotiation
-when we access the management API.  The use of libcurl is embedded so that
-future implementations can swap it out for a different http library without
-breaking compatibility.
-
-
 API philosophy
 --------------
 

=== added directory 'fork'
=== added file 'fork/LICENSE'
--- fork/LICENSE	1970-01-01 00:00:00 +0000
+++ fork/LICENSE	2013-07-22 14:27:42 +0000
@@ -0,0 +1,27 @@
+Copyright (c) 2012 The Go Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

=== added file 'fork/README'
--- fork/README	1970-01-01 00:00:00 +0000
+++ fork/README	2013-07-22 14:27:42 +0000
@@ -0,0 +1,11 @@
+This directory contains a fork of Go's standard libraries net/http and
+crypto/tls.
+
+This fork is required to support the TLS renegociation which is triggered by
+the Windows Azure Server when establishing an https connexion.  TLS
+renegociation is currently not supported by Go's standard library.
+
+The fork is based on go version 2:1.0.2-2.
+The library crypto/tls is patched to support TLS renegociation (see the patch
+file "go-tls-renegotiation.patch").
+The library net/http is patched to use the forked version of crypto/tls.

=== added file 'fork/go-tls-renegotiation.patch'
--- fork/go-tls-renegotiation.patch	1970-01-01 00:00:00 +0000
+++ fork/go-tls-renegotiation.patch	2013-07-22 14:27:42 +0000
@@ -0,0 +1,113 @@
+diff -r c242bbf5fa8c src/pkg/crypto/tls/common.go
+--- a/src/pkg/crypto/tls/common.go	Wed Jul 17 14:03:27 2013 -0400
++++ b/src/pkg/crypto/tls/common.go	Thu Jul 18 13:45:43 2013 -0400
+@@ -44,6 +44,7 @@
+ 
+ // TLS handshake message types.
+ const (
++	typeHelloRequest       uint8 = 0
+ 	typeClientHello        uint8 = 1
+ 	typeServerHello        uint8 = 2
+ 	typeNewSessionTicket   uint8 = 4
+diff -r c242bbf5fa8c src/pkg/crypto/tls/conn.go
+--- a/src/pkg/crypto/tls/conn.go	Wed Jul 17 14:03:27 2013 -0400
++++ b/src/pkg/crypto/tls/conn.go	Thu Jul 18 13:45:43 2013 -0400
+@@ -146,6 +146,9 @@
+ 	hc.mac = hc.nextMac
+ 	hc.nextCipher = nil
+ 	hc.nextMac = nil
++	for i := range hc.seq {
++		hc.seq[i] = 0
++	}
+ 	return nil
+ }
+ 
+@@ -478,7 +481,7 @@
+ func (c *Conn) readRecord(want recordType) error {
+ 	// Caller must be in sync with connection:
+ 	// handshake data if handshake not yet completed,
+-	// else application data.  (We don't support renegotiation.)
++	// else application data.
+ 	switch want {
+ 	default:
+ 		return c.sendAlert(alertInternalError)
+@@ -611,7 +614,7 @@
+ 
+ 	case recordTypeHandshake:
+ 		// TODO(rsc): Should at least pick off connection close.
+-		if typ != want {
++		if typ != want && !c.isClient {
+ 			return c.sendAlert(alertNoRenegotiation)
+ 		}
+ 		c.hand.Write(data)
+@@ -741,6 +744,8 @@
+ 	data = c.hand.Next(4 + n)
+ 	var m handshakeMessage
+ 	switch data[0] {
++	case typeHelloRequest:
++		m = new(helloRequestMsg)
+ 	case typeClientHello:
+ 		m = new(clientHelloMsg)
+ 	case typeServerHello:
+@@ -825,6 +830,25 @@
+ 	return n + m, c.setError(err)
+ }
+ 
++func (c *Conn) handleRenegotiation() error {
++	c.handshakeComplete = false
++	if !c.isClient {
++		panic("renegotiation should only happen for a client")
++	}
++
++	msg, err := c.readHandshake()
++	if err != nil {
++		return err
++	}
++	_, ok := msg.(*helloRequestMsg)
++	if !ok {
++		c.sendAlert(alertUnexpectedMessage)
++		return alertUnexpectedMessage
++	}
++
++	return c.Handshake()
++}
++
+ // Read can be made to time out and return a net.Error with Timeout() == true
+ // after a fixed time limit; see SetDeadline and SetReadDeadline.
+ func (c *Conn) Read(b []byte) (n int, err error) {
+@@ -844,6 +868,14 @@
+ 				// Soft error, like EAGAIN
+ 				return 0, err
+ 			}
++			if c.hand.Len() > 0 {
++				// We received handshake bytes, indicating the start of
++				// a renegotiation.
++				if err := c.handleRenegotiation(); err != nil {
++					return 0, err
++				}
++				continue
++			}
+ 		}
+ 		if err := c.error(); err != nil {
+ 			return 0, err
+diff -r c242bbf5fa8c src/pkg/crypto/tls/handshake_messages.go
+--- a/src/pkg/crypto/tls/handshake_messages.go	Wed Jul 17 14:03:27 2013 -0400
++++ b/src/pkg/crypto/tls/handshake_messages.go	Thu Jul 18 13:45:43 2013 -0400
+@@ -1243,6 +1243,17 @@
+ 	return true
+ }
+ 
++type helloRequestMsg struct {
++}
++
++func (*helloRequestMsg) marshal() []byte {
++	return []byte{typeHelloRequest, 0, 0, 0}
++}
++
++func (*helloRequestMsg) unmarshal(data []byte) bool {
++	return len(data) == 4
++}
++
+ func eqUint16s(x, y []uint16) bool {
+ 	if len(x) != len(y) {
+ 		return false

=== added directory 'fork/http'
=== added file 'fork/http/chunked.go'
--- fork/http/chunked.go	1970-01-01 00:00:00 +0000
+++ fork/http/chunked.go	2013-07-22 14:27:42 +0000
@@ -0,0 +1,170 @@
+// 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.
+
+// The wire protocol for HTTP's "chunked" Transfer-Encoding.
+
+// This code is duplicated in httputil/chunked.go.
+// Please make any changes in both files.
+
+package http
+
+import (
+    "bufio"
+    "bytes"
+    "errors"
+    "io"
+    "strconv"
+)
+
+const maxLineLength = 4096 // assumed <= bufio.defaultBufSize
+
+var ErrLineTooLong = errors.New("header line too long")
+
+// newChunkedReader returns a new chunkedReader that translates the data read from r
+// out of HTTP "chunked" format before returning it.
+// The chunkedReader returns io.EOF when the final 0-length chunk is read.
+//
+// newChunkedReader is not needed by normal applications. The http package
+// automatically decodes chunking when reading response bodies.
+func newChunkedReader(r io.Reader) io.Reader {
+    br, ok := r.(*bufio.Reader)
+    if !ok {
+        br = bufio.NewReader(r)
+    }
+    return &chunkedReader{r: br}
+}
+
+type chunkedReader struct {
+    r   *bufio.Reader
+    n   uint64 // unread bytes in chunk
+    err error
+}
+
+func (cr *chunkedReader) beginChunk() {
+    // chunk-size CRLF
+    var line string
+    line, cr.err = readLine(cr.r)
+    if cr.err != nil {
+        return
+    }
+    cr.n, cr.err = strconv.ParseUint(line, 16, 64)
+    if cr.err != nil {
+        return
+    }
+    if cr.n == 0 {
+        cr.err = io.EOF
+    }
+}
+
+func (cr *chunkedReader) Read(b []uint8) (n int, err error) {
+    if cr.err != nil {
+        return 0, cr.err
+    }
+    if cr.n == 0 {
+        cr.beginChunk()
+        if cr.err != nil {
+            return 0, cr.err
+        }
+    }
+    if uint64(len(b)) > cr.n {
+        b = b[0:cr.n]
+    }
+    n, cr.err = cr.r.Read(b)
+    cr.n -= uint64(n)
+    if cr.n == 0 && cr.err == nil {
+        // end of chunk (CRLF)
+        b := make([]byte, 2)
+        if _, cr.err = io.ReadFull(cr.r, b); cr.err == nil {
+            if b[0] != '\r' || b[1] != '\n' {
+                cr.err = errors.New("malformed chunked encoding")
+            }
+        }
+    }
+    return n, cr.err
+}
+
+// Read a line of bytes (up to \n) from b.
+// Give up if the line exceeds maxLineLength.
+// The returned bytes are a pointer into storage in
+// the bufio, so they are only valid until the next bufio read.
+func readLineBytes(b *bufio.Reader) (p []byte, err error) {
+    if p, err = b.ReadSlice('\n'); err != nil {
+        // We always know when EOF is coming.
+        // If the caller asked for a line, there should be a line.
+        if err == io.EOF {
+            err = io.ErrUnexpectedEOF
+        } else if err == bufio.ErrBufferFull {
+            err = ErrLineTooLong
+        }
+        return nil, err
+    }
+    if len(p) >= maxLineLength {
+        return nil, ErrLineTooLong
+    }
+
+    // Chop off trailing white space.
+    p = bytes.TrimRight(p, " \r\t\n")
+
+    return p, nil
+}
+
+// readLineBytes, but convert the bytes into a string.
+func readLine(b *bufio.Reader) (s string, err error) {
+    p, e := readLineBytes(b)
+    if e != nil {
+        return "", e
+    }
+    return string(p), nil
+}
+
+// newChunkedWriter returns a new chunkedWriter that translates writes into HTTP
+// "chunked" format before writing them to w. Closing the returned chunkedWriter
+// sends the final 0-length chunk that marks the end of the stream.
+//
+// newChunkedWriter is not needed by normal applications. The http
+// package adds chunking automatically if handlers don't set a
+// Content-Length header. Using newChunkedWriter inside a handler
+// would result in double chunking or chunking with a Content-Length
+// length, both of which are wrong.
+func newChunkedWriter(w io.Writer) io.WriteCloser {
+    return &chunkedWriter{w}
+}
+
+// Writing to chunkedWriter translates to writing in HTTP chunked Transfer
+// Encoding wire format to the underlying Wire chunkedWriter.
+type chunkedWriter struct {
+    Wire io.Writer
+}
+
+// Write the contents of data as one chunk to Wire.
+// NOTE: Note that the corresponding chunk-writing procedure in Conn.Write has
+// a bug since it does not check for success of io.WriteString
+func (cw *chunkedWriter) Write(data []byte) (n int, err error) {
+
+    // Don't send 0-length data. It looks like EOF for chunked encoding.
+    if len(data) == 0 {
+        return 0, nil
+    }
+
+    head := strconv.FormatInt(int64(len(data)), 16) + "\r\n"
+
+    if _, err = io.WriteString(cw.Wire, head); err != nil {
+        return 0, err
+    }
+    if n, err = cw.Wire.Write(data); err != nil {
+        return
+    }
+    if n != len(data) {
+        err = io.ErrShortWrite
+        return
+    }
+    _, err = io.WriteString(cw.Wire, "\r\n")
+
+    return
+}
+
+func (cw *chunkedWriter) Close() error {
+    _, err := io.WriteString(cw.Wire, "0\r\n")
+    return err
+}

=== added file 'fork/http/client.go'
--- fork/http/client.go	1970-01-01 00:00:00 +0000
+++ fork/http/client.go	2013-07-22 14:27:42 +0000
@@ -0,0 +1,339 @@
+// 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 client. See RFC 2616.
+//
+// This is the high-level Client interface.
+// The low-level implementation is in transport.go.
+
+package http
+
+import (
+    "encoding/base64"
+    "errors"
+    "fmt"
+    "io"
+    "net/url"
+    "strings"
+)
+
+// A Client is an HTTP client. Its zero value (DefaultClient) is a usable client
+// that uses DefaultTransport.
+//
+// The Client's Transport typically has internal state (cached
+// TCP connections), so Clients should be reused instead of created as
+// needed. Clients are safe for concurrent use by multiple goroutines.
+type Client struct {
+    // Transport specifies the mechanism by which individual
+    // HTTP requests are made.
+    // If nil, DefaultTransport is used.
+    Transport RoundTripper
+
+    // CheckRedirect specifies the policy for handling redirects.
+    // If CheckRedirect is not nil, the client calls it before
+    // following an HTTP redirect. The arguments req and via
+    // are the upcoming request and the requests made already,
+    // oldest first. If CheckRedirect returns an error, the client
+    // returns that error instead of issue the Request req.
+    //
+    // If CheckRedirect is nil, the Client uses its default policy,
+    // which is to stop after 10 consecutive requests.
+    CheckRedirect func(req *Request, via []*Request) error
+
+    // Jar specifies the cookie jar.
+    // If Jar is nil, cookies are not sent in requests and ignored
+    // in responses.
+    Jar CookieJar
+}
+
+// DefaultClient is the default Client and is used by Get, Head, and Post.
+var DefaultClient = &Client{}
+
+// RoundTripper is an interface representing the ability to execute a
+// single HTTP transaction, obtaining the Response for a given Request.
+//
+// A RoundTripper must be safe for concurrent use by multiple
+// goroutines.
+type RoundTripper interface {
+    // RoundTrip executes a single HTTP transaction, returning
+    // the Response for the request req.  RoundTrip should not
+    // attempt to interpret the response.  In particular,
+    // RoundTrip must return err == nil if it obtained a response,
+    // regardless of the response's HTTP status code.  A non-nil
+    // err should be reserved for failure to obtain a response.
+    // Similarly, RoundTrip should not attempt to handle
+    // higher-level protocol details such as redirects,
+    // authentication, or cookies.
+    //
+    // RoundTrip should not modify the request, except for
+    // consuming the Body.  The request's URL and Header fields
+    // are guaranteed to be initialized.
+    RoundTrip(*Request) (*Response, error)
+}
+
+// Given a string of the form "host", "host:port", or "[ipv6::address]:port",
+// return true if the string includes a port.
+func hasPort(s string) bool { return strings.LastIndex(s, ":") > strings.LastIndex(s, "]") }
+
+// Used in Send to implement io.ReadCloser by bundling together the
+// bufio.Reader through which we read the response, and the underlying
+// network connection.
+type readClose struct {
+    io.Reader
+    io.Closer
+}
+
+// Do sends an HTTP request and returns an HTTP response, following
+// policy (e.g. redirects, cookies, auth) as configured on the client.
+//
+// A non-nil response always contains a non-nil resp.Body.
+//
+// Callers should close resp.Body when done reading from it. If
+// resp.Body is not closed, the Client's underlying RoundTripper
+// (typically Transport) may not be able to re-use a persistent TCP
+// connection to the server for a subsequent "keep-alive" request.
+//
+// Generally Get, Post, or PostForm will be used instead of Do.
+func (c *Client) Do(req *Request) (resp *Response, err error) {
+    if req.Method == "GET" || req.Method == "HEAD" {
+        return c.doFollowingRedirects(req)
+    }
+    return send(req, c.Transport)
+}
+
+// send issues an HTTP request.  Caller should close resp.Body when done reading from it.
+func send(req *Request, t RoundTripper) (resp *Response, err error) {
+    if t == nil {
+        t = DefaultTransport
+        if t == nil {
+            err = errors.New("http: no Client.Transport or DefaultTransport")
+            return
+        }
+    }
+
+    if req.URL == nil {
+        return nil, errors.New("http: nil Request.URL")
+    }
+
+    if req.RequestURI != "" {
+        return nil, errors.New("http: Request.RequestURI can't be set in client requests.")
+    }
+
+    // Most the callers of send (Get, Post, et al) don't need
+    // Headers, leaving it uninitialized.  We guarantee to the
+    // Transport that this has been initialized, though.
+    if req.Header == nil {
+        req.Header = make(Header)
+    }
+
+    if u := req.URL.User; u != nil {
+        req.Header.Set("Authorization", "Basic "+base64.URLEncoding.EncodeToString([]byte(u.String())))
+    }
+    return t.RoundTrip(req)
+}
+
+// True if the specified HTTP status code is one for which the Get utility should
+// automatically redirect.
+func shouldRedirect(statusCode int) bool {
+    switch statusCode {
+    case StatusMovedPermanently, StatusFound, StatusSeeOther, StatusTemporaryRedirect:
+        return true
+    }
+    return false
+}
+
+// Get issues a GET to the specified URL.  If the response is one of the following
+// redirect codes, Get follows the redirect, up to a maximum of 10 redirects:
+//
+//    301 (Moved Permanently)
+//    302 (Found)
+//    303 (See Other)
+//    307 (Temporary Redirect)
+//
+// Caller should close r.Body when done reading from it.
+//
+// Get is a wrapper around DefaultClient.Get.
+func Get(url string) (r *Response, err error) {
+    return DefaultClient.Get(url)
+}
+
+// Get issues a GET to the specified URL.  If the response is one of the
+// following redirect codes, Get follows the redirect after calling the
+// Client's CheckRedirect function.
+//
+//    301 (Moved Permanently)
+//    302 (Found)
+//    303 (See Other)
+//    307 (Temporary Redirect)
+//
+// Caller should close r.Body when done reading from it.
+func (c *Client) Get(url string) (r *Response, err error) {
+    req, err := NewRequest("GET", url, nil)
+    if err != nil {
+        return nil, err
+    }
+    return c.doFollowingRedirects(req)
+}
+
+func (c *Client) doFollowingRedirects(ireq *Request) (r *Response, err error) {
+    // TODO: if/when we add cookie support, the redirected request shouldn't
+    // necessarily supply the same cookies as the original.
+    var base *url.URL
+    redirectChecker := c.CheckRedirect
+    if redirectChecker == nil {
+        redirectChecker = defaultCheckRedirect
+    }
+    var via []*Request
+
+    if ireq.URL == nil {
+        return nil, errors.New("http: nil Request.URL")
+    }
+
+    jar := c.Jar
+    if jar == nil {
+        jar = blackHoleJar{}
+    }
+
+    req := ireq
+    urlStr := "" // next relative or absolute URL to fetch (after first request)
+    for redirect := 0; ; redirect++ {
+        if redirect != 0 {
+            req = new(Request)
+            req.Method = ireq.Method
+            req.Header = make(Header)
+            req.URL, err = base.Parse(urlStr)
+            if err != nil {
+                break
+            }
+            if len(via) > 0 {
+                // Add the Referer header.
+                lastReq := via[len(via)-1]
+                if lastReq.URL.Scheme != "https" {
+                    req.Header.Set("Referer", lastReq.URL.String())
+                }
+
+                err = redirectChecker(req, via)
+                if err != nil {
+                    break
+                }
+            }
+        }
+
+        for _, cookie := range jar.Cookies(req.URL) {
+            req.AddCookie(cookie)
+        }
+        urlStr = req.URL.String()
+        if r, err = send(req, c.Transport); err != nil {
+            break
+        }
+        if c := r.Cookies(); len(c) > 0 {
+            jar.SetCookies(req.URL, c)
+        }
+
+        if shouldRedirect(r.StatusCode) {
+            r.Body.Close()
+            if urlStr = r.Header.Get("Location"); urlStr == "" {
+                err = errors.New(fmt.Sprintf("%d response missing Location header", r.StatusCode))
+                break
+            }
+            base = req.URL
+            via = append(via, req)
+            continue
+        }
+        return
+    }
+
+    method := ireq.Method
+    err = &url.Error{
+        Op:  method[0:1] + strings.ToLower(method[1:]),
+        URL: urlStr,
+        Err: err,
+    }
+    return
+}
+
+func defaultCheckRedirect(req *Request, via []*Request) error {
+    if len(via) >= 10 {
+        return errors.New("stopped after 10 redirects")
+    }
+    return nil
+}
+
+// Post issues a POST to the specified URL.
+//
+// Caller should close r.Body when done reading from it.
+//
+// Post is a wrapper around DefaultClient.Post
+func Post(url string, bodyType string, body io.Reader) (r *Response, err error) {
+    return DefaultClient.Post(url, bodyType, body)
+}
+
+// Post issues a POST to the specified URL.
+//
+// Caller should close r.Body when done reading from it.
+func (c *Client) Post(url string, bodyType string, body io.Reader) (r *Response, err error) {
+    req, err := NewRequest("POST", url, body)
+    if err != nil {
+        return nil, err
+    }
+    req.Header.Set("Content-Type", bodyType)
+    if c.Jar != nil {
+        for _, cookie := range c.Jar.Cookies(req.URL) {
+            req.AddCookie(cookie)
+        }
+    }
+    r, err = send(req, c.Transport)
+    if err == nil && c.Jar != nil {
+        c.Jar.SetCookies(req.URL, r.Cookies())
+    }
+    return r, err
+}
+
+// PostForm issues a POST to the specified URL,
+// with data's keys and values urlencoded as the request body.
+//
+// Caller should close r.Body when done reading from it.
+//
+// PostForm is a wrapper around DefaultClient.PostForm
+func PostForm(url string, data url.Values) (r *Response, err error) {
+    return DefaultClient.PostForm(url, data)
+}
+
+// PostForm issues a POST to the specified URL,
+// with data's keys and values urlencoded as the request body.
+//
+// Caller should close r.Body when done reading from it.
+func (c *Client) PostForm(url string, data url.Values) (r *Response, err error) {
+    return c.Post(url, "application/x-www-form-urlencoded", strings.NewReader(data.Encode()))
+}
+
+// Head issues a HEAD to the specified URL.  If the response is one of the
+// following redirect codes, Head follows the redirect after calling the
+// Client's CheckRedirect function.
+//
+//    301 (Moved Permanently)
+//    302 (Found)
+//    303 (See Other)
+//    307 (Temporary Redirect)
+//
+// Head is a wrapper around DefaultClient.Head
+func Head(url string) (r *Response, err error) {
+    return DefaultClient.Head(url)
+}
+
+// Head issues a HEAD to the specified URL.  If the response is one of the
+// following redirect codes, Head follows the redirect after calling the
+// Client's CheckRedirect function.
+//
+//    301 (Moved Permanently)
+//    302 (Found)
+//    303 (See Other)
+//    307 (Temporary Redirect)
+func (c *Client) Head(url string) (r *Response, err error) {
+    req, err := NewRequest("HEAD", url, nil)
+    if err != nil {
+        return nil, err
+    }
+    return c.doFollowingRedirects(req)
+}

=== added file 'fork/http/cookie.go'
--- fork/http/cookie.go	1970-01-01 00:00:00 +0000
+++ fork/http/cookie.go	2013-07-22 14:27:42 +0000
@@ -0,0 +1,267 @@
+// 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.
+
+package http
+
+import (
+    "bytes"
+    "fmt"
+    "strconv"
+    "strings"
+    "time"
+)
+
+// This implementation is done according to RFC 6265:
+//
+//    http://tools.ietf.org/html/rfc6265
+
+// A Cookie represents an HTTP cookie as sent in the Set-Cookie header of an
+// HTTP response or the Cookie header of an HTTP request.
+type Cookie struct {
+    Name       string
+    Value      string
+    Path       string
+    Domain     string
+    Expires    time.Time
+    RawExpires string
+
+    // MaxAge=0 means no 'Max-Age' attribute specified.
+    // MaxAge<0 means delete cookie now, equivalently 'Max-Age: 0'
+    // MaxAge>0 means Max-Age attribute present and given in seconds
+    MaxAge   int
+    Secure   bool
+    HttpOnly bool
+    Raw      string
+    Unparsed []string // Raw text of unparsed attribute-value pairs
+}
+
+// readSetCookies parses all "Set-Cookie" values from
+// the header h and returns the successfully parsed Cookies.
+func readSetCookies(h Header) []*Cookie {
+    cookies := []*Cookie{}
+    for _, line := range h["Set-Cookie"] {
+        parts := strings.Split(strings.TrimSpace(line), ";")
+        if len(parts) == 1 && parts[0] == "" {
+            continue
+        }
+        parts[0] = strings.TrimSpace(parts[0])
+        j := strings.Index(parts[0], "=")
+        if j < 0 {
+            continue
+        }
+        name, value := parts[0][:j], parts[0][j+1:]
+        if !isCookieNameValid(name) {
+            continue
+        }
+        value, success := parseCookieValue(value)
+        if !success {
+            continue
+        }
+        c := &Cookie{
+            Name:  name,
+            Value: value,
+            Raw:   line,
+        }
+        for i := 1; i < len(parts); i++ {
+            parts[i] = strings.TrimSpace(parts[i])
+            if len(parts[i]) == 0 {
+                continue
+            }
+
+            attr, val := parts[i], ""
+            if j := strings.Index(attr, "="); j >= 0 {
+                attr, val = attr[:j], attr[j+1:]
+            }
+            lowerAttr := strings.ToLower(attr)
+            parseCookieValueFn := parseCookieValue
+            if lowerAttr == "expires" {
+                parseCookieValueFn = parseCookieExpiresValue
+            }
+            val, success = parseCookieValueFn(val)
+            if !success {
+                c.Unparsed = append(c.Unparsed, parts[i])
+                continue
+            }
+            switch lowerAttr {
+            case "secure":
+                c.Secure = true
+                continue
+            case "httponly":
+                c.HttpOnly = true
+                continue
+            case "domain":
+                c.Domain = val
+                // TODO: Add domain parsing
+                continue
+            case "max-age":
+                secs, err := strconv.Atoi(val)
+                if err != nil || secs != 0 && val[0] == '0' {
+                    break
+                }
+                if secs <= 0 {
+                    c.MaxAge = -1
+                } else {
+                    c.MaxAge = secs
+                }
+                continue
+            case "expires":
+                c.RawExpires = val
+                exptime, err := time.Parse(time.RFC1123, val)
+                if err != nil {
+                    exptime, err = time.Parse("Mon, 02-Jan-2006 15:04:05 MST", val)
+                    if err != nil {
+                        c.Expires = time.Time{}
+                        break
+                    }
+                }
+                c.Expires = exptime.UTC()
+                continue
+            case "path":
+                c.Path = val
+                // TODO: Add path parsing
+                continue
+            }
+            c.Unparsed = append(c.Unparsed, parts[i])
+        }
+        cookies = append(cookies, c)
+    }
+    return cookies
+}
+
+// SetCookie adds a Set-Cookie header to the provided ResponseWriter's headers.
+func SetCookie(w ResponseWriter, cookie *Cookie) {
+    w.Header().Add("Set-Cookie", cookie.String())
+}
+
+// String returns the serialization of the cookie for use in a Cookie
+// header (if only Name and Value are set) or a Set-Cookie response
+// header (if other fields are set).
+func (c *Cookie) String() string {
+    var b bytes.Buffer
+    fmt.Fprintf(&b, "%s=%s", sanitizeName(c.Name), sanitizeValue(c.Value))
+    if len(c.Path) > 0 {
+        fmt.Fprintf(&b, "; Path=%s", sanitizeValue(c.Path))
+    }
+    if len(c.Domain) > 0 {
+        fmt.Fprintf(&b, "; Domain=%s", sanitizeValue(c.Domain))
+    }
+    if c.Expires.Unix() > 0 {
+        fmt.Fprintf(&b, "; Expires=%s", c.Expires.UTC().Format(time.RFC1123))
+    }
+    if c.MaxAge > 0 {
+        fmt.Fprintf(&b, "; Max-Age=%d", c.MaxAge)
+    } else if c.MaxAge < 0 {
+        fmt.Fprintf(&b, "; Max-Age=0")
+    }
+    if c.HttpOnly {
+        fmt.Fprintf(&b, "; HttpOnly")
+    }
+    if c.Secure {
+        fmt.Fprintf(&b, "; Secure")
+    }
+    return b.String()
+}
+
+// readCookies parses all "Cookie" values from the header h and
+// returns the successfully parsed Cookies.
+//
+// if filter isn't empty, only cookies of that name are returned
+func readCookies(h Header, filter string) []*Cookie {
+    cookies := []*Cookie{}
+    lines, ok := h["Cookie"]
+    if !ok {
+        return cookies
+    }
+
+    for _, line := range lines {
+        parts := strings.Split(strings.TrimSpace(line), ";")
+        if len(parts) == 1 && parts[0] == "" {
+            continue
+        }
+        // Per-line attributes
+        parsedPairs := 0
+        for i := 0; i < len(parts); i++ {
+            parts[i] = strings.TrimSpace(parts[i])
+            if len(parts[i]) == 0 {
+                continue
+            }
+            name, val := parts[i], ""
+            if j := strings.Index(name, "="); j >= 0 {
+                name, val = name[:j], name[j+1:]
+            }
+            if !isCookieNameValid(name) {
+                continue
+            }
+            if filter != "" && filter != name {
+                continue
+            }
+            val, success := parseCookieValue(val)
+            if !success {
+                continue
+            }
+            cookies = append(cookies, &Cookie{Name: name, Value: val})
+            parsedPairs++
+        }
+    }
+    return cookies
+}
+
+var cookieNameSanitizer = strings.NewReplacer("\n", "-", "\r", "-")
+
+func sanitizeName(n string) string {
+    return cookieNameSanitizer.Replace(n)
+}
+
+var cookieValueSanitizer = strings.NewReplacer("\n", " ", "\r", " ", ";", " ")
+
+func sanitizeValue(v string) string {
+    return cookieValueSanitizer.Replace(v)
+}
+
+func unquoteCookieValue(v string) string {
+    if len(v) > 1 && v[0] == '"' && v[len(v)-1] == '"' {
+        return v[1 : len(v)-1]
+    }
+    return v
+}
+
+func isCookieByte(c byte) bool {
+    switch {
+    case c == 0x21, 0x23 <= c && c <= 0x2b, 0x2d <= c && c <= 0x3a,
+        0x3c <= c && c <= 0x5b, 0x5d <= c && c <= 0x7e:
+        return true
+    }
+    return false
+}
+
+func isCookieExpiresByte(c byte) (ok bool) {
+    return isCookieByte(c) || c == ',' || c == ' '
+}
+
+func parseCookieValue(raw string) (string, bool) {
+    return parseCookieValueUsing(raw, isCookieByte)
+}
+
+func parseCookieExpiresValue(raw string) (string, bool) {
+    return parseCookieValueUsing(raw, isCookieExpiresByte)
+}
+
+func parseCookieValueUsing(raw string, validByte func(byte) bool) (string, bool) {
+    raw = unquoteCookieValue(raw)
+    for i := 0; i < len(raw); i++ {
+        if !validByte(raw[i]) {
+            return "", false
+        }
+    }
+    return raw, true
+}
+
+func isCookieNameValid(raw string) bool {
+    for _, c := range raw {
+        if !isToken(byte(c)) {
+            return false
+        }
+    }
+    return true
+}

=== added file 'fork/http/doc.go'
--- fork/http/doc.go	1970-01-01 00:00:00 +0000
+++ fork/http/doc.go	2013-07-22 14:27:42 +0000
@@ -0,0 +1,80 @@
+// Copyright 2011 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.
+
+/*
+Package http provides HTTP client and server implementations.
+
+Get, Head, Post, and PostForm make HTTP requests:
+
+	resp, err := http.Get("http://example.com/")
+	...
+	resp, err := http.Post("http://example.com/upload", "image/jpeg", &buf)
+	...
+	resp, err := http.PostForm("http://example.com/form",
+		url.Values{"key": {"Value"}, "id": {"123"}})
+
+The client must close the response body when finished with it:
+
+	resp, err := http.Get("http://example.com/")
+	if err != nil {
+		// handle error
+	}
+	defer resp.Body.Close()
+	body, err := ioutil.ReadAll(resp.Body)
+	// ...
+
+For control over HTTP client headers, redirect policy, and other
+settings, create a Client:
+
+	client := &http.Client{
+		CheckRedirect: redirectPolicyFunc,
+	}
+
+	resp, err := client.Get("http://example.com")
+	// ...
+
+	req, err := http.NewRequest("GET", "http://example.com", nil)
+	// ...
+	req.Header.Add("If-None-Match", `W/"wyzzy"`)
+	resp, err := client.Do(req)
+	// ...
+
+For control over proxies, TLS configuration, keep-alives,
+compression, and other settings, create a Transport:
+
+	tr := &http.Transport{
+		TLSClientConfig:    &tls.Config{RootCAs: pool},
+		DisableCompression: true,
+	}
+	client := &http.Client{Transport: tr}
+	resp, err := client.Get("https://example.com")
+
+Clients and Transports are safe for concurrent use by multiple
+goroutines and for efficiency should only be created once and re-used.
+
+ListenAndServe starts an HTTP server with a given address and handler.
+The handler is usually nil, which means to use DefaultServeMux.
+Handle and HandleFunc add handlers to DefaultServeMux:
+
+	http.Handle("/foo", fooHandler)
+
+	http.HandleFunc("/bar", func(w http.ResponseWriter, r *http.Request) {
+		fmt.Fprintf(w, "Hello, %q", html.EscapeString(r.URL.Path))
+	})
+
+	log.Fatal(http.ListenAndServe(":8080", nil))
+
+More control over the server's behavior is available by creating a
+custom Server:
+
+	s := &http.Server{
+		Addr:           ":8080",
+		Handler:        myHandler,
+		ReadTimeout:    10 * time.Second,
+		WriteTimeout:   10 * time.Second,
+		MaxHeaderBytes: 1 << 20,
+	}
+	log.Fatal(s.ListenAndServe())
+*/
+package http

=== added file 'fork/http/filetransport.go'
--- fork/http/filetransport.go	1970-01-01 00:00:00 +0000
+++ fork/http/filetransport.go	2013-07-22 14:27:42 +0000
@@ -0,0 +1,123 @@
+// Copyright 2011 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.
+
+package http
+
+import (
+    "fmt"
+    "io"
+)
+
+// fileTransport implements RoundTripper for the 'file' protocol.
+type fileTransport struct {
+    fh fileHandler
+}
+
+// NewFileTransport returns a new RoundTripper, serving the provided
+// FileSystem. The returned RoundTripper ignores the URL host in its
+// incoming requests, as well as most other properties of the
+// request.
+//
+// The typical use case for NewFileTransport is to register the "file"
+// protocol with a Transport, as in:
+//
+//   t := &http.Transport{}
+//   t.RegisterProtocol("file", http.NewFileTransport(http.Dir("/")))
+//   c := &http.Client{Transport: t}
+//   res, err := c.Get("file:///etc/passwd")
+//   ...
+func NewFileTransport(fs FileSystem) RoundTripper {
+    return fileTransport{fileHandler{fs}}
+}
+
+func (t fileTransport) RoundTrip(req *Request) (resp *Response, err error) {
+    // We start ServeHTTP in a goroutine, which may take a long
+    // time if the file is large.  The newPopulateResponseWriter
+    // call returns a channel which either ServeHTTP or finish()
+    // sends our *Response on, once the *Response itself has been
+    // populated (even if the body itself is still being
+    // written to the res.Body, a pipe)
+    rw, resc := newPopulateResponseWriter()
+    go func() {
+        t.fh.ServeHTTP(rw, req)
+        rw.finish()
+    }()
+    return <-resc, nil
+}
+
+func newPopulateResponseWriter() (*populateResponse, <-chan *Response) {
+    pr, pw := io.Pipe()
+    rw := &populateResponse{
+        ch: make(chan *Response),
+        pw: pw,
+        res: &Response{
+            Proto:      "HTTP/1.0",
+            ProtoMajor: 1,
+            Header:     make(Header),
+            Close:      true,
+            Body:       pr,
+        },
+    }
+    return rw, rw.ch
+}
+
+// populateResponse is a ResponseWriter that populates the *Response
+// in res, and writes its body to a pipe connected to the response
+// body. Once writes begin or finish() is called, the response is sent
+// on ch.
+type populateResponse struct {
+    res          *Response
+    ch           chan *Response
+    wroteHeader  bool
+    hasContent   bool
+    sentResponse bool
+    pw           *io.PipeWriter
+}
+
+func (pr *populateResponse) finish() {
+    if !pr.wroteHeader {
+        pr.WriteHeader(500)
+    }
+    if !pr.sentResponse {
+        pr.sendResponse()
+    }
+    pr.pw.Close()
+}
+
+func (pr *populateResponse) sendResponse() {
+    if pr.sentResponse {
+        return
+    }
+    pr.sentResponse = true
+
+    if pr.hasContent {
+        pr.res.ContentLength = -1
+    }
+    pr.ch <- pr.res
+}
+
+func (pr *populateResponse) Header() Header {
+    return pr.res.Header
+}
+
+func (pr *populateResponse) WriteHeader(code int) {
+    if pr.wroteHeader {
+        return
+    }
+    pr.wroteHeader = true
+
+    pr.res.StatusCode = code
+    pr.res.Status = fmt.Sprintf("%d %s", code, StatusText(code))
+}
+
+func (pr *populateResponse) Write(p []byte) (n int, err error) {
+    if !pr.wroteHeader {
+        pr.WriteHeader(StatusOK)
+    }
+    pr.hasContent = true
+    if !pr.sentResponse {
+        pr.sendResponse()
+    }
+    return pr.pw.Write(p)
+}

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

=== added file 'fork/http/header.go'
--- fork/http/header.go	1970-01-01 00:00:00 +0000
+++ fork/http/header.go	2013-07-22 14:27:42 +0000
@@ -0,0 +1,78 @@
+// Copyright 2010 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.
+
+package http
+
+import (
+    "fmt"
+    "io"
+    "net/textproto"
+    "sort"
+    "strings"
+)
+
+// A Header represents the key-value pairs in an HTTP header.
+type Header map[string][]string
+
+// Add adds the key, value pair to the header.
+// It appends to any existing values associated with key.
+func (h Header) Add(key, value string) {
+    textproto.MIMEHeader(h).Add(key, value)
+}
+
+// Set sets the header entries associated with key to
+// the single element value.  It replaces any existing
+// values associated with key.
+func (h Header) Set(key, value string) {
+    textproto.MIMEHeader(h).Set(key, value)
+}
+
+// Get gets the first value associated with the given key.
+// If there are no values associated with the key, Get returns "".
+// To access multiple values of a key, access the map directly
+// with CanonicalHeaderKey.
+func (h Header) Get(key string) string {
+    return textproto.MIMEHeader(h).Get(key)
+}
+
+// Del deletes the values associated with key.
+func (h Header) Del(key string) {
+    textproto.MIMEHeader(h).Del(key)
+}
+
+// Write writes a header in wire format.
+func (h Header) Write(w io.Writer) error {
+    return h.WriteSubset(w, nil)
+}
+
+var headerNewlineToSpace = strings.NewReplacer("\n", " ", "\r", " ")
+
+// WriteSubset writes a header in wire format.
+// If exclude is not nil, keys where exclude[key] == true are not written.
+func (h Header) WriteSubset(w io.Writer, exclude map[string]bool) error {
+    keys := make([]string, 0, len(h))
+    for k := range h {
+        if exclude == nil || !exclude[k] {
+            keys = append(keys, k)
+        }
+    }
+    sort.Strings(keys)
+    for _, k := range keys {
+        for _, v := range h[k] {
+            v = headerNewlineToSpace.Replace(v)
+            v = strings.TrimSpace(v)
+            if _, err := fmt.Fprintf(w, "%s: %s\r\n", k, v); err != nil {
+                return err
+            }
+        }
+    }
+    return nil
+}
+
+// CanonicalHeaderKey returns the canonical format of the
+// header key s.  The canonicalization converts the first
+// letter and any letter following a hyphen to upper case;
+// the rest are converted to lowercase.  For example, the
+// canonical key for "accept-encoding" is "Accept-Encoding".
+func CanonicalHeaderKey(s string) string { return textproto.CanonicalMIMEHeaderKey(s) }

=== added file 'fork/http/jar.go'
--- fork/http/jar.go	1970-01-01 00:00:00 +0000
+++ fork/http/jar.go	2013-07-22 14:27:42 +0000
@@ -0,0 +1,30 @@
+// Copyright 2011 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.
+
+package http
+
+import (
+    "net/url"
+)
+
+// A CookieJar manages storage and use of cookies in HTTP requests.
+//
+// Implementations of CookieJar must be safe for concurrent use by multiple
+// goroutines.
+type CookieJar interface {
+    // SetCookies handles the receipt of the cookies in a reply for the
+    // given URL.  It may or may not choose to save the cookies, depending
+    // on the jar's policy and implementation.
+    SetCookies(u *url.URL, cookies []*Cookie)
+
+    // Cookies returns the cookies to send in a request for the given URL.
+    // It is up to the implementation to honor the standard cookie use
+    // restrictions such as in RFC 6265.
+    Cookies(u *url.URL) []*Cookie
+}
+
+type blackHoleJar struct{}
+
+func (blackHoleJar) SetCookies(u *url.URL, cookies []*Cookie) {}
+func (blackHoleJar) Cookies(u *url.URL) []*Cookie             { return nil }

=== added file 'fork/http/lex.go'
--- fork/http/lex.go	1970-01-01 00:00:00 +0000
+++ fork/http/lex.go	2013-07-22 14:27:42 +0000
@@ -0,0 +1,136 @@
+// 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.
+
+package http
+
+// This file deals with lexical matters of HTTP
+
+func isSeparator(c byte) bool {
+    switch c {
+    case '(', ')', '<', '>', '@', ',', ';', ':', '\\', '"', '/', '[', ']', '?', '=', '{', '}', ' ', '\t':
+        return true
+    }
+    return false
+}
+
+func isCtl(c byte) bool { return (0 <= c && c <= 31) || c == 127 }
+
+func isChar(c byte) bool { return 0 <= c && c <= 127 }
+
+func isAnyText(c byte) bool { return !isCtl(c) }
+
+func isQdText(c byte) bool { return isAnyText(c) && c != '"' }
+
+func isToken(c byte) bool { return isChar(c) && !isCtl(c) && !isSeparator(c) }
+
+// Valid escaped sequences are not specified in RFC 2616, so for now, we assume
+// that they coincide with the common sense ones used by GO. Malformed
+// characters should probably not be treated as errors by a robust (forgiving)
+// parser, so we replace them with the '?' character.
+func httpUnquotePair(b byte) byte {
+    // skip the first byte, which should always be '\'
+    switch b {
+    case 'a':
+        return '\a'
+    case 'b':
+        return '\b'
+    case 'f':
+        return '\f'
+    case 'n':
+        return '\n'
+    case 'r':
+        return '\r'
+    case 't':
+        return '\t'
+    case 'v':
+        return '\v'
+    case '\\':
+        return '\\'
+    case '\'':
+        return '\''
+    case '"':
+        return '"'
+    }
+    return '?'
+}
+
+// raw must begin with a valid quoted string. Only the first quoted string is
+// parsed and is unquoted in result. eaten is the number of bytes parsed, or -1
+// upon failure.
+func httpUnquote(raw []byte) (eaten int, result string) {
+    buf := make([]byte, len(raw))
+    if raw[0] != '"' {
+        return -1, ""
+    }
+    eaten = 1
+    j := 0 // # of bytes written in buf
+    for i := 1; i < len(raw); i++ {
+        switch b := raw[i]; b {
+        case '"':
+            eaten++
+            buf = buf[0:j]
+            return i + 1, string(buf)
+        case '\\':
+            if len(raw) < i+2 {
+                return -1, ""
+            }
+            buf[j] = httpUnquotePair(raw[i+1])
+            eaten += 2
+            j++
+            i++
+        default:
+            if isQdText(b) {
+                buf[j] = b
+            } else {
+                buf[j] = '?'
+            }
+            eaten++
+            j++
+        }
+    }
+    return -1, ""
+}
+
+// This is a best effort parse, so errors are not returned, instead not all of
+// the input string might be parsed. result is always non-nil.
+func httpSplitFieldValue(fv string) (eaten int, result []string) {
+    result = make([]string, 0, len(fv))
+    raw := []byte(fv)
+    i := 0
+    chunk := ""
+    for i < len(raw) {
+        b := raw[i]
+        switch {
+        case b == '"':
+            eaten, unq := httpUnquote(raw[i:])
+            if eaten < 0 {
+                return i, result
+            } else {
+                i += eaten
+                chunk += unq
+            }
+        case isSeparator(b):
+            if chunk != "" {
+                result = result[0 : len(result)+1]
+                result[len(result)-1] = chunk
+                chunk = ""
+            }
+            i++
+        case isToken(b):
+            chunk += string(b)
+            i++
+        case b == '\n' || b == '\r':
+            i++
+        default:
+            chunk += "?"
+            i++
+        }
+    }
+    if chunk != "" {
+        result = result[0 : len(result)+1]
+        result[len(result)-1] = chunk
+        chunk = ""
+    }
+    return i, result
+}

=== added file 'fork/http/request.go'
--- fork/http/request.go	1970-01-01 00:00:00 +0000
+++ fork/http/request.go	2013-07-22 14:27:42 +0000
@@ -0,0 +1,743 @@
+// 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 Request reading and parsing.
+
+package http
+
+import (
+    "bufio"
+    "bytes"
+    "crypto/tls"
+    "encoding/base64"
+    "errors"
+    "fmt"
+    "io"
+    "io/ioutil"
+    "mime"
+    "mime/multipart"
+    "net/textproto"
+    "net/url"
+    "strings"
+)
+
+const (
+    maxValueLength   = 4096
+    maxHeaderLines   = 1024
+    chunkSize        = 4 << 10  // 4 KB chunks
+    defaultMaxMemory = 32 << 20 // 32 MB
+)
+
+// ErrMissingFile is returned by FormFile when the provided file field name
+// is either not present in the request or not a file field.
+var ErrMissingFile = errors.New("http: no such file")
+
+// HTTP request parsing errors.
+type ProtocolError struct {
+    ErrorString string
+}
+
+func (err *ProtocolError) Error() string { return err.ErrorString }
+
+var (
+    ErrHeaderTooLong        = &ProtocolError{"header too long"}
+    ErrShortBody            = &ProtocolError{"entity body too short"}
+    ErrNotSupported         = &ProtocolError{"feature not supported"}
+    ErrUnexpectedTrailer    = &ProtocolError{"trailer header without chunked transfer encoding"}
+    ErrMissingContentLength = &ProtocolError{"missing ContentLength in HEAD response"}
+    ErrNotMultipart         = &ProtocolError{"request Content-Type isn't multipart/form-data"}
+    ErrMissingBoundary      = &ProtocolError{"no multipart boundary param Content-Type"}
+)
+
+type badStringError struct {
+    what string
+    str  string
+}
+
+func (e *badStringError) Error() string { return fmt.Sprintf("%s %q", e.what, e.str) }
+
+// Headers that Request.Write handles itself and should be skipped.
+var reqWriteExcludeHeader = map[string]bool{
+    "Host":              true, // not in Header map anyway
+    "User-Agent":        true,
+    "Content-Length":    true,
+    "Transfer-Encoding": true,
+    "Trailer":           true,
+}
+
+// A Request represents an HTTP request received by a server
+// or to be sent by a client.
+type Request struct {
+    Method string // GET, POST, PUT, etc.
+    URL    *url.URL
+
+    // The protocol version for incoming requests.
+    // Outgoing requests always use HTTP/1.1.
+    Proto      string // "HTTP/1.0"
+    ProtoMajor int    // 1
+    ProtoMinor int    // 0
+
+    // A header maps request lines to their values.
+    // If the header says
+    //
+    //	accept-encoding: gzip, deflate
+    //	Accept-Language: en-us
+    //	Connection: keep-alive
+    //
+    // then
+    //
+    //	Header = map[string][]string{
+    //		"Accept-Encoding": {"gzip, deflate"},
+    //		"Accept-Language": {"en-us"},
+    //		"Connection": {"keep-alive"},
+    //	}
+    //
+    // HTTP defines that header names are case-insensitive.
+    // The request parser implements this by canonicalizing the
+    // name, making the first character and any characters
+    // following a hyphen uppercase and the rest lowercase.
+    Header Header
+
+    // The message body.
+    Body io.ReadCloser
+
+    // ContentLength records the length of the associated content.
+    // The value -1 indicates that the length is unknown.
+    // Values >= 0 indicate that the given number of bytes may
+    // be read from Body.
+    // For outgoing requests, a value of 0 means unknown if Body is not nil.
+    ContentLength int64
+
+    // TransferEncoding lists the transfer encodings from outermost to
+    // innermost. An empty list denotes the "identity" encoding.
+    // TransferEncoding can usually be ignored; chunked encoding is
+    // automatically added and removed as necessary when sending and
+    // receiving requests.
+    TransferEncoding []string
+
+    // Close indicates whether to close the connection after
+    // replying to this request.
+    Close bool
+
+    // The host on which the URL is sought.
+    // Per RFC 2616, this is either the value of the Host: header
+    // or the host name given in the URL itself.
+    Host string
+
+    // Form contains the parsed form data, including both the URL
+    // field's query parameters and the POST or PUT form data.
+    // This field is only available after ParseForm is called.
+    // The HTTP client ignores Form and uses Body instead.
+    Form url.Values
+
+    // MultipartForm is the parsed multipart form, including file uploads.
+    // This field is only available after ParseMultipartForm is called.
+    // The HTTP client ignores MultipartForm and uses Body instead.
+    MultipartForm *multipart.Form
+
+    // Trailer maps trailer keys to values.  Like for Header, if the
+    // response has multiple trailer lines with the same key, they will be
+    // concatenated, delimited by commas.
+    // For server requests, Trailer is only populated after Body has been
+    // closed or fully consumed.
+    // Trailer support is only partially complete.
+    Trailer Header
+
+    // RemoteAddr allows HTTP servers and other software to record
+    // the network address that sent the request, usually for
+    // logging. This field is not filled in by ReadRequest and
+    // has no defined format. The HTTP server in this package
+    // sets RemoteAddr to an "IP:port" address before invoking a
+    // handler.
+    // This field is ignored by the HTTP client.
+    RemoteAddr string
+
+    // RequestURI is the unmodified Request-URI of the
+    // Request-Line (RFC 2616, Section 5.1) as sent by the client
+    // to a server. Usually the URL field should be used instead.
+    // It is an error to set this field in an HTTP client request.
+    RequestURI string
+
+    // TLS allows HTTP servers and other software to record
+    // information about the TLS connection on which the request
+    // was received. This field is not filled in by ReadRequest.
+    // The HTTP server in this package sets the field for
+    // TLS-enabled connections before invoking a handler;
+    // otherwise it leaves the field nil.
+    // This field is ignored by the HTTP client.
+    TLS *tls.ConnectionState
+}
+
+// ProtoAtLeast returns whether the HTTP protocol used
+// in the request is at least major.minor.
+func (r *Request) ProtoAtLeast(major, minor int) bool {
+    return r.ProtoMajor > major ||
+        r.ProtoMajor == major && r.ProtoMinor >= minor
+}
+
+// UserAgent returns the client's User-Agent, if sent in the request.
+func (r *Request) UserAgent() string {
+    return r.Header.Get("User-Agent")
+}
+
+// Cookies parses and returns the HTTP cookies sent with the request.
+func (r *Request) Cookies() []*Cookie {
+    return readCookies(r.Header, "")
+}
+
+var ErrNoCookie = errors.New("http: named cookie not present")
+
+// Cookie returns the named cookie provided in the request or
+// ErrNoCookie if not found.
+func (r *Request) Cookie(name string) (*Cookie, error) {
+    for _, c := range readCookies(r.Header, name) {
+        return c, nil
+    }
+    return nil, ErrNoCookie
+}
+
+// AddCookie adds a cookie to the request.  Per RFC 6265 section 5.4,
+// AddCookie does not attach more than one Cookie header field.  That
+// means all cookies, if any, are written into the same line,
+// separated by semicolon.
+func (r *Request) AddCookie(c *Cookie) {
+    s := fmt.Sprintf("%s=%s", sanitizeName(c.Name), sanitizeValue(c.Value))
+    if c := r.Header.Get("Cookie"); c != "" {
+        r.Header.Set("Cookie", c+"; "+s)
+    } else {
+        r.Header.Set("Cookie", s)
+    }
+}
+
+// Referer returns the referring URL, if sent in the request.
+//
+// Referer is misspelled as in the request itself, a mistake from the
+// earliest days of HTTP.  This value can also be fetched from the
+// Header map as Header["Referer"]; the benefit of making it available
+// as a method is that the compiler can diagnose programs that use the
+// alternate (correct English) spelling req.Referrer() but cannot
+// diagnose programs that use Header["Referrer"].
+func (r *Request) Referer() string {
+    return r.Header.Get("Referer")
+}
+
+// multipartByReader is a sentinel value.
+// Its presence in Request.MultipartForm indicates that parsing of the request
+// body has been handed off to a MultipartReader instead of ParseMultipartFrom.
+var multipartByReader = &multipart.Form{
+    Value: make(map[string][]string),
+    File:  make(map[string][]*multipart.FileHeader),
+}
+
+// MultipartReader returns a MIME multipart reader if this is a
+// multipart/form-data POST request, else returns nil and an error.
+// Use this function instead of ParseMultipartForm to
+// process the request body as a stream.
+func (r *Request) MultipartReader() (*multipart.Reader, error) {
+    if r.MultipartForm == multipartByReader {
+        return nil, errors.New("http: MultipartReader called twice")
+    }
+    if r.MultipartForm != nil {
+        return nil, errors.New("http: multipart handled by ParseMultipartForm")
+    }
+    r.MultipartForm = multipartByReader
+    return r.multipartReader()
+}
+
+func (r *Request) multipartReader() (*multipart.Reader, error) {
+    v := r.Header.Get("Content-Type")
+    if v == "" {
+        return nil, ErrNotMultipart
+    }
+    d, params, err := mime.ParseMediaType(v)
+    if err != nil || d != "multipart/form-data" {
+        return nil, ErrNotMultipart
+    }
+    boundary, ok := params["boundary"]
+    if !ok {
+        return nil, ErrMissingBoundary
+    }
+    return multipart.NewReader(r.Body, boundary), nil
+}
+
+// Return value if nonempty, def otherwise.
+func valueOrDefault(value, def string) string {
+    if value != "" {
+        return value
+    }
+    return def
+}
+
+const defaultUserAgent = "Go http package"
+
+// Write writes an HTTP/1.1 request -- header and body -- in wire format.
+// This method consults the following fields of the request:
+//	Host
+//	URL
+//	Method (defaults to "GET")
+//	Header
+//	ContentLength
+//	TransferEncoding
+//	Body
+//
+// If Body is present, Content-Length is <= 0 and TransferEncoding
+// hasn't been set to "identity", Write adds "Transfer-Encoding:
+// chunked" to the header. Body is closed after it is sent.
+func (r *Request) Write(w io.Writer) error {
+    return r.write(w, false, nil)
+}
+
+// WriteProxy is like Write but writes the request in the form
+// expected by an HTTP proxy.  In particular, WriteProxy writes the
+// initial Request-URI line of the request with an absolute URI, per
+// section 5.1.2 of RFC 2616, including the scheme and host.
+// In either case, WriteProxy also writes a Host header, using
+// either r.Host or r.URL.Host.
+func (r *Request) WriteProxy(w io.Writer) error {
+    return r.write(w, true, nil)
+}
+
+// extraHeaders may be nil
+func (req *Request) write(w io.Writer, usingProxy bool, extraHeaders Header) error {
+    host := req.Host
+    if host == "" {
+        if req.URL == nil {
+            return errors.New("http: Request.Write on Request with no Host or URL set")
+        }
+        host = req.URL.Host
+    }
+
+    ruri := req.URL.RequestURI()
+    if usingProxy && req.URL.Scheme != "" && req.URL.Opaque == "" {
+        ruri = req.URL.Scheme + "://" + host + ruri
+    } else if req.Method == "CONNECT" && req.URL.Path == "" {
+        // CONNECT requests normally give just the host and port, not a full URL.
+        ruri = host
+    }
+    // TODO(bradfitz): escape at least newlines in ruri?
+
+    bw := bufio.NewWriter(w)
+    fmt.Fprintf(bw, "%s %s HTTP/1.1\r\n", valueOrDefault(req.Method, "GET"), ruri)
+
+    // Header lines
+    fmt.Fprintf(bw, "Host: %s\r\n", host)
+
+    // Use the defaultUserAgent unless the Header contains one, which
+    // may be blank to not send the header.
+    userAgent := defaultUserAgent
+    if req.Header != nil {
+        if ua := req.Header["User-Agent"]; len(ua) > 0 {
+            userAgent = ua[0]
+        }
+    }
+    if userAgent != "" {
+        fmt.Fprintf(bw, "User-Agent: %s\r\n", userAgent)
+    }
+
+    // Process Body,ContentLength,Close,Trailer
+    tw, err := newTransferWriter(req)
+    if err != nil {
+        return err
+    }
+    err = tw.WriteHeader(bw)
+    if err != nil {
+        return err
+    }
+
+    // TODO: split long values?  (If so, should share code with Conn.Write)
+    err = req.Header.WriteSubset(bw, reqWriteExcludeHeader)
+    if err != nil {
+        return err
+    }
+
+    if extraHeaders != nil {
+        err = extraHeaders.Write(bw)
+        if err != nil {
+            return err
+        }
+    }
+
+    io.WriteString(bw, "\r\n")
+
+    // Write body and trailer
+    err = tw.WriteBody(bw)
+    if err != nil {
+        return err
+    }
+
+    return bw.Flush()
+}
+
+// Convert decimal at s[i:len(s)] to integer,
+// returning value, string position where the digits stopped,
+// and whether there was a valid number (digits, not too big).
+func atoi(s string, i int) (n, i1 int, ok bool) {
+    const Big = 1000000
+    if i >= len(s) || s[i] < '0' || s[i] > '9' {
+        return 0, 0, false
+    }
+    n = 0
+    for ; i < len(s) && '0' <= s[i] && s[i] <= '9'; i++ {
+        n = n*10 + int(s[i]-'0')
+        if n > Big {
+            return 0, 0, false
+        }
+    }
+    return n, i, true
+}
+
+// ParseHTTPVersion parses a HTTP version string.
+// "HTTP/1.0" returns (1, 0, true).
+func ParseHTTPVersion(vers string) (major, minor int, ok bool) {
+    if len(vers) < 5 || vers[0:5] != "HTTP/" {
+        return 0, 0, false
+    }
+    major, i, ok := atoi(vers, 5)
+    if !ok || i >= len(vers) || vers[i] != '.' {
+        return 0, 0, false
+    }
+    minor, i, ok = atoi(vers, i+1)
+    if !ok || i != len(vers) {
+        return 0, 0, false
+    }
+    return major, minor, true
+}
+
+// NewRequest returns a new Request given a method, URL, and optional body.
+func NewRequest(method, urlStr string, body io.Reader) (*Request, error) {
+    u, err := url.Parse(urlStr)
+    if err != nil {
+        return nil, err
+    }
+    rc, ok := body.(io.ReadCloser)
+    if !ok && body != nil {
+        rc = ioutil.NopCloser(body)
+    }
+    req := &Request{
+        Method:     method,
+        URL:        u,
+        Proto:      "HTTP/1.1",
+        ProtoMajor: 1,
+        ProtoMinor: 1,
+        Header:     make(Header),
+        Body:       rc,
+        Host:       u.Host,
+    }
+    if body != nil {
+        switch v := body.(type) {
+        case *strings.Reader:
+            req.ContentLength = int64(v.Len())
+        case *bytes.Buffer:
+            req.ContentLength = int64(v.Len())
+        }
+    }
+
+    return req, nil
+}
+
+// SetBasicAuth sets the request's Authorization header to use HTTP
+// Basic Authentication with the provided username and password.
+//
+// With HTTP Basic Authentication the provided username and password
+// are not encrypted.
+func (r *Request) SetBasicAuth(username, password string) {
+    s := username + ":" + password
+    r.Header.Set("Authorization", "Basic "+base64.StdEncoding.EncodeToString([]byte(s)))
+}
+
+// ReadRequest reads and parses a request from b.
+func ReadRequest(b *bufio.Reader) (req *Request, err error) {
+
+    tp := textproto.NewReader(b)
+    req = new(Request)
+
+    // First line: GET /index.html HTTP/1.0
+    var s string
+    if s, err = tp.ReadLine(); err != nil {
+        return nil, err
+    }
+    defer func() {
+        if err == io.EOF {
+            err = io.ErrUnexpectedEOF
+        }
+    }()
+
+    var f []string
+    if f = strings.SplitN(s, " ", 3); len(f) < 3 {
+        return nil, &badStringError{"malformed HTTP request", s}
+    }
+    req.Method, req.RequestURI, req.Proto = f[0], f[1], f[2]
+    rawurl := req.RequestURI
+    var ok bool
+    if req.ProtoMajor, req.ProtoMinor, ok = ParseHTTPVersion(req.Proto); !ok {
+        return nil, &badStringError{"malformed HTTP version", req.Proto}
+    }
+
+    // CONNECT requests are used two different ways, and neither uses a full URL:
+    // The standard use is to tunnel HTTPS through an HTTP proxy.
+    // It looks like "CONNECT www.google.com:443 HTTP/1.1", and the parameter is
+    // just the authority section of a URL. This information should go in req.URL.Host.
+    //
+    // The net/rpc package also uses CONNECT, but there the parameter is a path
+    // that starts with a slash. It can be parsed with the regular URL parser,
+    // and the path will end up in req.URL.Path, where it needs to be in order for
+    // RPC to work.
+    justAuthority := req.Method == "CONNECT" && !strings.HasPrefix(rawurl, "/")
+    if justAuthority {
+        rawurl = "http://" + rawurl
+    }
+
+    if req.URL, err = url.ParseRequestURI(rawurl); err != nil {
+        return nil, err
+    }
+
+    if justAuthority {
+        // Strip the bogus "http://" back off.
+        req.URL.Scheme = ""
+    }
+
+    // Subsequent lines: Key: value.
+    mimeHeader, err := tp.ReadMIMEHeader()
+    if err != nil {
+        return nil, err
+    }
+    req.Header = Header(mimeHeader)
+
+    // RFC2616: Must treat
+    //	GET /index.html HTTP/1.1
+    //	Host: www.google.com
+    // and
+    //	GET http://www.google.com/index.html HTTP/1.1
+    //	Host: doesntmatter
+    // the same.  In the second case, any Host line is ignored.
+    req.Host = req.URL.Host
+    if req.Host == "" {
+        req.Host = req.Header.Get("Host")
+    }
+    req.Header.Del("Host")
+
+    fixPragmaCacheControl(req.Header)
+
+    // TODO: Parse specific header values:
+    //	Accept
+    //	Accept-Encoding
+    //	Accept-Language
+    //	Authorization
+    //	Cache-Control
+    //	Connection
+    //	Date
+    //	Expect
+    //	From
+    //	If-Match
+    //	If-Modified-Since
+    //	If-None-Match
+    //	If-Range
+    //	If-Unmodified-Since
+    //	Max-Forwards
+    //	Proxy-Authorization
+    //	Referer [sic]
+    //	TE (transfer-codings)
+    //	Trailer
+    //	Transfer-Encoding
+    //	Upgrade
+    //	User-Agent
+    //	Via
+    //	Warning
+
+    err = readTransfer(req, b)
+    if err != nil {
+        return nil, err
+    }
+
+    return req, nil
+}
+
+// MaxBytesReader is similar to io.LimitReader but is intended for
+// limiting the size of incoming request bodies. In contrast to
+// io.LimitReader, MaxBytesReader's result is a ReadCloser, returns a
+// non-EOF error for a Read beyond the limit, and Closes the
+// underlying reader when its Close method is called.
+//
+// MaxBytesReader prevents clients from accidentally or maliciously
+// sending a large request and wasting server resources.
+func MaxBytesReader(w ResponseWriter, r io.ReadCloser, n int64) io.ReadCloser {
+    return &maxBytesReader{w: w, r: r, n: n}
+}
+
+type maxBytesReader struct {
+    w       ResponseWriter
+    r       io.ReadCloser // underlying reader
+    n       int64         // max bytes remaining
+    stopped bool
+}
+
+func (l *maxBytesReader) Read(p []byte) (n int, err error) {
+    if l.n <= 0 {
+        if !l.stopped {
+            l.stopped = true
+            if res, ok := l.w.(*response); ok {
+                res.requestTooLarge()
+            }
+        }
+        return 0, errors.New("http: request body too large")
+    }
+    if int64(len(p)) > l.n {
+        p = p[:l.n]
+    }
+    n, err = l.r.Read(p)
+    l.n -= int64(n)
+    return
+}
+
+func (l *maxBytesReader) Close() error {
+    return l.r.Close()
+}
+
+// ParseForm parses the raw query from the URL.
+//
+// For POST or PUT requests, it also parses the request body as a form.
+// If the request Body's size has not already been limited by MaxBytesReader,
+// the size is capped at 10MB.
+//
+// ParseMultipartForm calls ParseForm automatically.
+// It is idempotent.
+func (r *Request) ParseForm() (err error) {
+    if r.Form != nil {
+        return
+    }
+    if r.URL != nil {
+        r.Form, err = url.ParseQuery(r.URL.RawQuery)
+    }
+    if r.Method == "POST" || r.Method == "PUT" {
+        if r.Body == nil {
+            return errors.New("missing form body")
+        }
+        ct := r.Header.Get("Content-Type")
+        ct, _, err = mime.ParseMediaType(ct)
+        switch {
+        case ct == "application/x-www-form-urlencoded":
+            var reader io.Reader = r.Body
+            maxFormSize := int64(1<<63 - 1)
+            if _, ok := r.Body.(*maxBytesReader); !ok {
+                maxFormSize = int64(10 << 20) // 10 MB is a lot of text.
+                reader = io.LimitReader(r.Body, maxFormSize+1)
+            }
+            b, e := ioutil.ReadAll(reader)
+            if e != nil {
+                if err == nil {
+                    err = e
+                }
+                break
+            }
+            if int64(len(b)) > maxFormSize {
+                return errors.New("http: POST too large")
+            }
+            var newValues url.Values
+            newValues, e = url.ParseQuery(string(b))
+            if err == nil {
+                err = e
+            }
+            if r.Form == nil {
+                r.Form = make(url.Values)
+            }
+            // Copy values into r.Form. TODO: make this smoother.
+            for k, vs := range newValues {
+                for _, value := range vs {
+                    r.Form.Add(k, value)
+                }
+            }
+        case ct == "multipart/form-data":
+            // handled by ParseMultipartForm (which is calling us, or should be)
+            // TODO(bradfitz): there are too many possible
+            // orders to call too many functions here.
+            // Clean this up and write more tests.
+            // request_test.go contains the start of this,
+            // in TestRequestMultipartCallOrder.
+        }
+    }
+    return err
+}
+
+// ParseMultipartForm parses a request body as multipart/form-data.
+// The whole request body is parsed and up to a total of maxMemory bytes of
+// its file parts are stored in memory, with the remainder stored on
+// disk in temporary files.
+// ParseMultipartForm calls ParseForm if necessary.
+// After one call to ParseMultipartForm, subsequent calls have no effect.
+func (r *Request) ParseMultipartForm(maxMemory int64) error {
+    if r.MultipartForm == multipartByReader {
+        return errors.New("http: multipart handled by MultipartReader")
+    }
+    if r.Form == nil {
+        err := r.ParseForm()
+        if err != nil {
+            return err
+        }
+    }
+    if r.MultipartForm != nil {
+        return nil
+    }
+
+    mr, err := r.multipartReader()
+    if err == ErrNotMultipart {
+        return nil
+    } else if err != nil {
+        return err
+    }
+
+    f, err := mr.ReadForm(maxMemory)
+    if err != nil {
+        return err
+    }
+    for k, v := range f.Value {
+        r.Form[k] = append(r.Form[k], v...)
+    }
+    r.MultipartForm = f
+
+    return nil
+}
+
+// FormValue returns the first value for the named component of the query.
+// FormValue calls ParseMultipartForm and ParseForm if necessary.
+func (r *Request) FormValue(key string) string {
+    if r.Form == nil {
+        r.ParseMultipartForm(defaultMaxMemory)
+    }
+    if vs := r.Form[key]; len(vs) > 0 {
+        return vs[0]
+    }
+    return ""
+}
+
+// FormFile returns the first file for the provided form key.
+// FormFile calls ParseMultipartForm and ParseForm if necessary.
+func (r *Request) FormFile(key string) (multipart.File, *multipart.FileHeader, error) {
+    if r.MultipartForm == multipartByReader {
+        return nil, nil, errors.New("http: multipart handled by MultipartReader")
+    }
+    if r.MultipartForm == nil {
+        err := r.ParseMultipartForm(defaultMaxMemory)
+        if err != nil {
+            return nil, nil, err
+        }
+    }
+    if r.MultipartForm != nil && r.MultipartForm.File != nil {
+        if fhs := r.MultipartForm.File[key]; len(fhs) > 0 {
+            f, err := fhs[0].Open()
+            return f, fhs[0], err
+        }
+    }
+    return nil, nil, ErrMissingFile
+}
+
+func (r *Request) expectsContinue() bool {
+    return strings.ToLower(r.Header.Get("Expect")) == "100-continue"
+}
+
+func (r *Request) wantsHttp10KeepAlive() bool {
+    if r.ProtoMajor != 1 || r.ProtoMinor != 0 {
+        return false
+    }
+    return strings.Contains(strings.ToLower(r.Header.Get("Connection")), "keep-alive")
+}

=== added file 'fork/http/response.go'
--- fork/http/response.go	1970-01-01 00:00:00 +0000
+++ fork/http/response.go	2013-07-22 14:27:42 +0000
@@ -0,0 +1,239 @@
+// 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 Response reading and parsing.
+
+package http
+
+import (
+    "bufio"
+    "errors"
+    "io"
+    "net/textproto"
+    "net/url"
+    "strconv"
+    "strings"
+)
+
+var respExcludeHeader = map[string]bool{
+    "Content-Length":    true,
+    "Transfer-Encoding": true,
+    "Trailer":           true,
+}
+
+// Response represents the response from an HTTP request.
+//
+type Response struct {
+    Status     string // e.g. "200 OK"
+    StatusCode int    // e.g. 200
+    Proto      string // e.g. "HTTP/1.0"
+    ProtoMajor int    // e.g. 1
+    ProtoMinor int    // e.g. 0
+
+    // Header maps header keys to values.  If the response had multiple
+    // headers with the same key, they will be concatenated, with comma
+    // delimiters.  (Section 4.2 of RFC 2616 requires that multiple headers
+    // be semantically equivalent to a comma-delimited sequence.) Values
+    // duplicated by other fields in this struct (e.g., ContentLength) are
+    // omitted from Header.
+    //
+    // Keys in the map are canonicalized (see CanonicalHeaderKey).
+    Header Header
+
+    // Body represents the response body.
+    //
+    // The http Client and Transport guarantee that Body is always
+    // non-nil, even on responses without a body or responses with
+    // a zero-lengthed body.
+    Body io.ReadCloser
+
+    // ContentLength records the length of the associated content.  The
+    // value -1 indicates that the length is unknown.  Unless RequestMethod
+    // is "HEAD", values >= 0 indicate that the given number of bytes may
+    // be read from Body.
+    ContentLength int64
+
+    // Contains transfer encodings from outer-most to inner-most. Value is
+    // nil, means that "identity" encoding is used.
+    TransferEncoding []string
+
+    // Close records whether the header directed that the connection be
+    // closed after reading Body.  The value is advice for clients: neither
+    // ReadResponse nor Response.Write ever closes a connection.
+    Close bool
+
+    // Trailer maps trailer keys to values, in the same
+    // format as the header.
+    Trailer Header
+
+    // The Request that was sent to obtain this Response.
+    // Request's Body is nil (having already been consumed).
+    // This is only populated for Client requests.
+    Request *Request
+}
+
+// Cookies parses and returns the cookies set in the Set-Cookie headers.
+func (r *Response) Cookies() []*Cookie {
+    return readSetCookies(r.Header)
+}
+
+var ErrNoLocation = errors.New("http: no Location header in response")
+
+// Location returns the URL of the response's "Location" header,
+// if present.  Relative redirects are resolved relative to
+// the Response's Request.  ErrNoLocation is returned if no
+// Location header is present.
+func (r *Response) Location() (*url.URL, error) {
+    lv := r.Header.Get("Location")
+    if lv == "" {
+        return nil, ErrNoLocation
+    }
+    if r.Request != nil && r.Request.URL != nil {
+        return r.Request.URL.Parse(lv)
+    }
+    return url.Parse(lv)
+}
+
+// ReadResponse reads and returns an HTTP response from r.  The
+// req parameter specifies the Request that corresponds to
+// this Response.  Clients must call resp.Body.Close when finished
+// reading resp.Body.  After that call, clients can inspect
+// resp.Trailer to find key/value pairs included in the response
+// trailer.
+func ReadResponse(r *bufio.Reader, req *Request) (resp *Response, err error) {
+
+    tp := textproto.NewReader(r)
+    resp = new(Response)
+
+    resp.Request = req
+    resp.Request.Method = strings.ToUpper(resp.Request.Method)
+
+    // Parse the first line of the response.
+    line, err := tp.ReadLine()
+    if err != nil {
+        if err == io.EOF {
+            err = io.ErrUnexpectedEOF
+        }
+        return nil, err
+    }
+    f := strings.SplitN(line, " ", 3)
+    if len(f) < 2 {
+        return nil, &badStringError{"malformed HTTP response", line}
+    }
+    reasonPhrase := ""
+    if len(f) > 2 {
+        reasonPhrase = f[2]
+    }
+    resp.Status = f[1] + " " + reasonPhrase
+    resp.StatusCode, err = strconv.Atoi(f[1])
+    if err != nil {
+        return nil, &badStringError{"malformed HTTP status code", f[1]}
+    }
+
+    resp.Proto = f[0]
+    var ok bool
+    if resp.ProtoMajor, resp.ProtoMinor, ok = ParseHTTPVersion(resp.Proto); !ok {
+        return nil, &badStringError{"malformed HTTP version", resp.Proto}
+    }
+
+    // Parse the response headers.
+    mimeHeader, err := tp.ReadMIMEHeader()
+    if err != nil {
+        return nil, err
+    }
+    resp.Header = Header(mimeHeader)
+
+    fixPragmaCacheControl(resp.Header)
+
+    err = readTransfer(resp, r)
+    if err != nil {
+        return nil, err
+    }
+
+    return resp, nil
+}
+
+// RFC2616: Should treat
+//	Pragma: no-cache
+// like
+//	Cache-Control: no-cache
+func fixPragmaCacheControl(header Header) {
+    if hp, ok := header["Pragma"]; ok && len(hp) > 0 && hp[0] == "no-cache" {
+        if _, presentcc := header["Cache-Control"]; !presentcc {
+            header["Cache-Control"] = []string{"no-cache"}
+        }
+    }
+}
+
+// ProtoAtLeast returns whether the HTTP protocol used
+// in the response is at least major.minor.
+func (r *Response) ProtoAtLeast(major, minor int) bool {
+    return r.ProtoMajor > major ||
+        r.ProtoMajor == major && r.ProtoMinor >= minor
+}
+
+// Writes the response (header, body and trailer) in wire format. This method
+// consults the following fields of the response:
+//
+//  StatusCode
+//  ProtoMajor
+//  ProtoMinor
+//  RequestMethod
+//  TransferEncoding
+//  Trailer
+//  Body
+//  ContentLength
+//  Header, values for non-canonical keys will have unpredictable behavior
+//
+func (r *Response) Write(w io.Writer) error {
+
+    // RequestMethod should be upper-case
+    if r.Request != nil {
+        r.Request.Method = strings.ToUpper(r.Request.Method)
+    }
+
+    // Status line
+    text := r.Status
+    if text == "" {
+        var ok bool
+        text, ok = statusText[r.StatusCode]
+        if !ok {
+            text = "status code " + strconv.Itoa(r.StatusCode)
+        }
+    }
+    protoMajor, protoMinor := strconv.Itoa(r.ProtoMajor), strconv.Itoa(r.ProtoMinor)
+    statusCode := strconv.Itoa(r.StatusCode) + " "
+    if strings.HasPrefix(text, statusCode) {
+        text = text[len(statusCode):]
+    }
+    io.WriteString(w, "HTTP/"+protoMajor+"."+protoMinor+" "+statusCode+text+"\r\n")
+
+    // Process Body,ContentLength,Close,Trailer
+    tw, err := newTransferWriter(r)
+    if err != nil {
+        return err
+    }
+    err = tw.WriteHeader(w)
+    if err != nil {
+        return err
+    }
+
+    // Rest of header
+    err = r.Header.WriteSubset(w, respExcludeHeader)
+    if err != nil {
+        return err
+    }
+
+    // End-of-header
+    io.WriteString(w, "\r\n")
+
+    // Write body and trailer
+    err = tw.WriteBody(w)
+    if err != nil {
+        return err
+    }
+
+    // Success
+    return nil
+}

=== added file 'fork/http/server.go'
--- fork/http/server.go	1970-01-01 00:00:00 +0000
+++ fork/http/server.go	2013-07-22 14:27:42 +0000
@@ -0,0 +1,1234 @@
+// 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.
+
+// TODO(rsc):
+//	logging
+
+package http
+
+import (
+    "bufio"
+    "bytes"
+    "crypto/tls"
+    "errors"
+    "fmt"
+    "io"
+    "io/ioutil"
+    "log"
+    "net"
+    "net/url"
+    "path"
+    "runtime/debug"
+    "strconv"
+    "strings"
+    "sync"
+    "time"
+)
+
+// Errors introduced by the HTTP server.
+var (
+    ErrWriteAfterFlush = errors.New("Conn.Write called after Flush")
+    ErrBodyNotAllowed  = errors.New("http: request method or response status code does not allow body")
+    ErrHijacked        = errors.New("Conn has been hijacked")
+    ErrContentLength   = errors.New("Conn.Write wrote more than the declared Content-Length")
+)
+
+// Objects implementing the Handler interface can be
+// registered to serve a particular path or subtree
+// in the HTTP server.
+//
+// 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(ResponseWriter, *Request)
+}
+
+// A ResponseWriter interface is used by an HTTP handler to
+// construct an HTTP response.
+type ResponseWriter interface {
+    // Header returns the header map that will be sent by WriteHeader.
+    // Changing the header after a call to WriteHeader (or Write) has
+    // no effect.
+    Header() Header
+
+    // 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.  If the Header does not contain a
+    // Content-Type line, Write adds a Content-Type set to the result of passing
+    // the initial 512 bytes of written data to DetectContentType.
+    Write([]byte) (int, 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)
+}
+
+// The Flusher interface is implemented by ResponseWriters that allow
+// an HTTP handler to flush buffered data to the client.
+//
+// Note that even for ResponseWriters that support Flush,
+// if the client is connected through an HTTP proxy,
+// the buffered data may not reach the client until the response
+// completes.
+type Flusher interface {
+    // Flush sends any buffered data to the client.
+    Flush()
+}
+
+// The Hijacker interface is implemented by ResponseWriters that allow
+// an HTTP handler to take over the connection.
+type Hijacker interface {
+    // 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() (net.Conn, *bufio.ReadWriter, error)
+}
+
+// A conn represents the server side of an HTTP connection.
+type conn struct {
+    remoteAddr string               // network address of remote side
+    server     *Server              // the Server on which the connection arrived
+    rwc        net.Conn             // i/o connection
+    lr         *io.LimitedReader    // io.LimitReader(rwc)
+    buf        *bufio.ReadWriter    // buffered(lr,rwc), reading from bufio->limitReader->rwc
+    hijacked   bool                 // connection has been hijacked by handler
+    tlsState   *tls.ConnectionState // or nil when not using TLS
+    body       []byte
+}
+
+// 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        Header   // reply header parameters
+    written       int64    // number of bytes written in body
+    contentLength int64    // explicitly-declared Content-Length; or -1
+    status        int      // status code passed to WriteHeader
+    needSniff     bool     // need to sniff to find Content-Type
+
+    // close connection after this reply.  set on request and
+    // updated after response from handler if there's a
+    // "Connection: keep-alive" response header and a
+    // Content-Length.
+    closeAfterReply bool
+
+    // requestBodyLimitHit is set by requestTooLarge when
+    // maxBytesReader hits its max size. It is checked in
+    // WriteHeader, to make sure we don't consume the the
+    // remaining request body to try to advance to the next HTTP
+    // request. Instead, when this is set, we stop doing
+    // subsequent requests on this connection and stop reading
+    // input from it.
+    requestBodyLimitHit bool
+}
+
+// requestTooLarge is called by maxBytesReader when too much input has
+// been read from the client.
+func (w *response) requestTooLarge() {
+    w.closeAfterReply = true
+    w.requestBodyLimitHit = true
+    if !w.wroteHeader {
+        w.Header().Set("Connection", "close")
+    }
+}
+
+type writerOnly struct {
+    io.Writer
+}
+
+func (w *response) ReadFrom(src io.Reader) (n int64, err error) {
+    // Call WriteHeader before checking w.chunking if it hasn't
+    // been called yet, since WriteHeader is what sets w.chunking.
+    if !w.wroteHeader {
+        w.WriteHeader(StatusOK)
+    }
+    if !w.chunking && w.bodyAllowed() && !w.needSniff {
+        w.Flush()
+        if rf, ok := w.conn.rwc.(io.ReaderFrom); ok {
+            n, err = rf.ReadFrom(src)
+            w.written += n
+            return
+        }
+    }
+    // Fall back to default io.Copy implementation.
+    // Use wrapper to hide w.ReadFrom from io.Copy.
+    return io.Copy(writerOnly{w}, src)
+}
+
+// noLimit is an effective infinite upper bound for io.LimitedReader
+const noLimit int64 = (1 << 63) - 1
+
+// Create new connection from rwc.
+func (srv *Server) newConn(rwc net.Conn) (c *conn, err error) {
+    c = new(conn)
+    c.remoteAddr = rwc.RemoteAddr().String()
+    c.server = srv
+    c.rwc = rwc
+    c.body = make([]byte, sniffLen)
+    c.lr = io.LimitReader(rwc, noLimit).(*io.LimitedReader)
+    br := bufio.NewReader(c.lr)
+    bw := bufio.NewWriter(rwc)
+    c.buf = bufio.NewReadWriter(br, bw)
+    return c, nil
+}
+
+// DefaultMaxHeaderBytes is the maximum permitted size of the headers
+// in an HTTP request.
+// This can be overridden by setting Server.MaxHeaderBytes.
+const DefaultMaxHeaderBytes = 1 << 20 // 1 MB
+
+func (srv *Server) maxHeaderBytes() int {
+    if srv.MaxHeaderBytes > 0 {
+        return srv.MaxHeaderBytes
+    }
+    return DefaultMaxHeaderBytes
+}
+
+// wrapper around io.ReaderCloser which on first read, sends an
+// HTTP/1.1 100 Continue header
+type expectContinueReader struct {
+    resp       *response
+    readCloser io.ReadCloser
+    closed     bool
+}
+
+func (ecr *expectContinueReader) Read(p []byte) (n int, err error) {
+    if ecr.closed {
+        return 0, errors.New("http: Read after Close on request Body")
+    }
+    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)
+}
+
+func (ecr *expectContinueReader) Close() error {
+    ecr.closed = true
+    return ecr.readCloser.Close()
+}
+
+// TimeFormat is the time format to use with
+// time.Parse and time.Time.Format when parsing
+// or generating times in HTTP headers.
+// It is like time.RFC1123 but hard codes GMT as the time zone.
+const TimeFormat = "Mon, 02 Jan 2006 15:04:05 GMT"
+
+var errTooLarge = errors.New("http: request too large")
+
+// Read next request from connection.
+func (c *conn) readRequest() (w *response, err error) {
+    if c.hijacked {
+        return nil, ErrHijacked
+    }
+    c.lr.N = int64(c.server.maxHeaderBytes()) + 4096 /* bufio slop */
+    var req *Request
+    if req, err = ReadRequest(c.buf.Reader); err != nil {
+        if c.lr.N == 0 {
+            return nil, errTooLarge
+        }
+        return nil, err
+    }
+    c.lr.N = noLimit
+
+    req.RemoteAddr = c.remoteAddr
+    req.TLS = c.tlsState
+
+    w = new(response)
+    w.conn = c
+    w.req = req
+    w.header = make(Header)
+    w.contentLength = -1
+    c.body = c.body[:0]
+    return w, nil
+}
+
+func (w *response) Header() Header {
+    return w.header
+}
+
+// maxPostHandlerReadBytes is the max number of Request.Body bytes not
+// consumed by a handler that the server will read from the client
+// in order to keep a connection alive.  If there are more bytes than
+// this then the server to be paranoid instead sends a "Connection:
+// close" response.
+//
+// This number is approximately what a typical machine's TCP buffer
+// size is anyway.  (if we have the bytes on the machine, we might as
+// well read them)
+const maxPostHandlerReadBytes = 256 << 10
+
+func (w *response) WriteHeader(code int) {
+    if w.conn.hijacked {
+        log.Print("http: response.WriteHeader on hijacked connection")
+        return
+    }
+    if w.wroteHeader {
+        log.Print("http: multiple response.WriteHeader calls")
+        return
+    }
+    w.wroteHeader = true
+    w.status = code
+
+    // Check for a explicit (and valid) Content-Length header.
+    var hasCL bool
+    var contentLength int64
+    if clenStr := w.header.Get("Content-Length"); clenStr != "" {
+        var err error
+        contentLength, err = strconv.ParseInt(clenStr, 10, 64)
+        if err == nil {
+            hasCL = true
+        } else {
+            log.Printf("http: invalid Content-Length of %q sent", clenStr)
+            w.header.Del("Content-Length")
+        }
+    }
+
+    if w.req.wantsHttp10KeepAlive() && (w.req.Method == "HEAD" || hasCL) {
+        _, connectionHeaderSet := w.header["Connection"]
+        if !connectionHeaderSet {
+            w.header.Set("Connection", "keep-alive")
+        }
+    } else if !w.req.ProtoAtLeast(1, 1) {
+        // Client did not ask to keep connection alive.
+        w.closeAfterReply = true
+    }
+
+    if w.header.Get("Connection") == "close" {
+        w.closeAfterReply = true
+    }
+
+    // Per RFC 2616, we should consume the request body before
+    // replying, if the handler hasn't already done so.  But we
+    // don't want to do an unbounded amount of reading here for
+    // DoS reasons, so we only try up to a threshold.
+    if w.req.ContentLength != 0 && !w.closeAfterReply {
+        ecr, isExpecter := w.req.Body.(*expectContinueReader)
+        if !isExpecter || ecr.resp.wroteContinue {
+            n, _ := io.CopyN(ioutil.Discard, w.req.Body, maxPostHandlerReadBytes+1)
+            if n >= maxPostHandlerReadBytes {
+                w.requestTooLarge()
+                w.header.Set("Connection", "close")
+            } else {
+                w.req.Body.Close()
+            }
+        }
+    }
+
+    if code == StatusNotModified {
+        // Must not have body.
+        for _, header := range []string{"Content-Type", "Content-Length", "Transfer-Encoding"} {
+            if w.header.Get(header) != "" {
+                // TODO: return an error if WriteHeader gets a return parameter
+                // or set a flag on w to make future Writes() write an error page?
+                // for now just log and drop the header.
+                log.Printf("http: StatusNotModified response with header %q defined", header)
+                w.header.Del(header)
+            }
+        }
+    } else {
+        // If no content type, apply sniffing algorithm to body.
+        if w.header.Get("Content-Type") == "" && w.req.Method != "HEAD" {
+            w.needSniff = true
+        }
+    }
+
+    if _, ok := w.header["Date"]; !ok {
+        w.Header().Set("Date", time.Now().UTC().Format(TimeFormat))
+    }
+
+    te := w.header.Get("Transfer-Encoding")
+    hasTE := te != ""
+    if hasCL && hasTE && te != "identity" {
+        // TODO: return an error if WriteHeader gets a return parameter
+        // For now just ignore the Content-Length.
+        log.Printf("http: WriteHeader called with both Transfer-Encoding of %q and a Content-Length of %d",
+            te, contentLength)
+        w.header.Del("Content-Length")
+        hasCL = false
+    }
+
+    if w.req.Method == "HEAD" || code == StatusNotModified {
+        // do nothing
+    } else if hasCL {
+        w.contentLength = contentLength
+        w.header.Del("Transfer-Encoding")
+    } else if w.req.ProtoAtLeast(1, 1) {
+        // HTTP/1.1 or greater: use chunked transfer encoding
+        // to avoid closing the connection at EOF.
+        // TODO: this blows away any custom or stacked Transfer-Encoding they
+        // might have set.  Deal with that as need arises once we have a valid
+        // use case.
+        w.chunking = true
+        w.header.Set("Transfer-Encoding", "chunked")
+    } else {
+        // HTTP version < 1.1: cannot do chunked transfer
+        // encoding and we don't know the Content-Length so
+        // signal EOF by closing connection.
+        w.closeAfterReply = true
+        w.header.Del("Transfer-Encoding") // in case already set
+    }
+
+    // Cannot use Content-Length with non-identity Transfer-Encoding.
+    if w.chunking {
+        w.header.Del("Content-Length")
+    }
+    if !w.req.ProtoAtLeast(1, 0) {
+        return
+    }
+    proto := "HTTP/1.0"
+    if w.req.ProtoAtLeast(1, 1) {
+        proto = "HTTP/1.1"
+    }
+    codestring := strconv.Itoa(code)
+    text, ok := statusText[code]
+    if !ok {
+        text = "status code " + codestring
+    }
+    io.WriteString(w.conn.buf, proto+" "+codestring+" "+text+"\r\n")
+    w.header.Write(w.conn.buf)
+
+    // If we need to sniff the body, leave the header open.
+    // Otherwise, end it here.
+    if !w.needSniff {
+        io.WriteString(w.conn.buf, "\r\n")
+    }
+}
+
+// sniff uses the first block of written data,
+// stored in w.conn.body, to decide the Content-Type
+// for the HTTP body.
+func (w *response) sniff() {
+    if !w.needSniff {
+        return
+    }
+    w.needSniff = false
+
+    data := w.conn.body
+    fmt.Fprintf(w.conn.buf, "Content-Type: %s\r\n\r\n", DetectContentType(data))
+
+    if len(data) == 0 {
+        return
+    }
+    if w.chunking {
+        fmt.Fprintf(w.conn.buf, "%x\r\n", len(data))
+    }
+    _, err := w.conn.buf.Write(data)
+    if w.chunking && err == nil {
+        io.WriteString(w.conn.buf, "\r\n")
+    }
+}
+
+// bodyAllowed returns true if a Write is allowed for this response type.
+// It's illegal to call this before the header has been flushed.
+func (w *response) bodyAllowed() bool {
+    if !w.wroteHeader {
+        panic("")
+    }
+    return w.status != StatusNotModified && w.req.Method != "HEAD"
+}
+
+func (w *response) Write(data []byte) (n int, err error) {
+    if w.conn.hijacked {
+        log.Print("http: response.Write on hijacked connection")
+        return 0, ErrHijacked
+    }
+    if !w.wroteHeader {
+        w.WriteHeader(StatusOK)
+    }
+    if len(data) == 0 {
+        return 0, nil
+    }
+    if !w.bodyAllowed() {
+        return 0, ErrBodyNotAllowed
+    }
+
+    w.written += int64(len(data)) // ignoring errors, for errorKludge
+    if w.contentLength != -1 && w.written > w.contentLength {
+        return 0, ErrContentLength
+    }
+
+    var m int
+    if w.needSniff {
+        // We need to sniff the beginning of the output to
+        // determine the content type.  Accumulate the
+        // initial writes in w.conn.body.
+        // Cap m so that append won't allocate.
+        m = cap(w.conn.body) - len(w.conn.body)
+        if m > len(data) {
+            m = len(data)
+        }
+        w.conn.body = append(w.conn.body, data[:m]...)
+        data = data[m:]
+        if len(data) == 0 {
+            // Copied everything into the buffer.
+            // Wait for next write.
+            return m, nil
+        }
+
+        // Filled the buffer; more data remains.
+        // Sniff the content (flushes the buffer)
+        // and then proceed with the remainder
+        // of the data as a normal Write.
+        // Calling sniff clears needSniff.
+        w.sniff()
+    }
+
+    // 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 w.chunking {
+        fmt.Fprintf(w.conn.buf, "%x\r\n", len(data)) // TODO(rsc): use strconv not fmt
+    }
+    n, err = w.conn.buf.Write(data)
+    if err == nil && w.chunking {
+        if n != len(data) {
+            err = io.ErrShortWrite
+        }
+        if err == nil {
+            io.WriteString(w.conn.buf, "\r\n")
+        }
+    }
+
+    return m + n, err
+}
+
+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 w.req.wantsHttp10KeepAlive() {
+        sentLength := w.header.Get("Content-Length") != ""
+        if sentLength && w.header.Get("Connection") == "keep-alive" {
+            w.closeAfterReply = false
+        }
+    }
+    if !w.wroteHeader {
+        w.WriteHeader(StatusOK)
+    }
+    if w.needSniff {
+        w.sniff()
+    }
+    if w.chunking {
+        io.WriteString(w.conn.buf, "0\r\n")
+        // trailer key/value pairs, followed by blank line
+        io.WriteString(w.conn.buf, "\r\n")
+    }
+    w.conn.buf.Flush()
+    // Close the body, unless we're about to close the whole TCP connection
+    // anyway.
+    if !w.closeAfterReply {
+        w.req.Body.Close()
+    }
+    if w.req.MultipartForm != nil {
+        w.req.MultipartForm.RemoveAll()
+    }
+
+    if w.contentLength != -1 && w.contentLength != w.written {
+        // Did not write enough. Avoid getting out of sync.
+        w.closeAfterReply = true
+    }
+}
+
+func (w *response) Flush() {
+    if !w.wroteHeader {
+        w.WriteHeader(StatusOK)
+    }
+    w.sniff()
+    w.conn.buf.Flush()
+}
+
+// Close the connection.
+func (c *conn) close() {
+    if c.buf != nil {
+        c.buf.Flush()
+        c.buf = nil
+    }
+    if c.rwc != nil {
+        c.rwc.Close()
+        c.rwc = nil
+    }
+}
+
+// Serve a new connection.
+func (c *conn) serve() {
+    defer func() {
+        err := recover()
+        if err == nil {
+            return
+        }
+
+        var buf bytes.Buffer
+        fmt.Fprintf(&buf, "http: panic serving %v: %v\n", c.remoteAddr, err)
+        buf.Write(debug.Stack())
+        log.Print(buf.String())
+
+        if c.rwc != nil { // may be nil if connection hijacked
+            c.rwc.Close()
+        }
+    }()
+
+    if tlsConn, ok := c.rwc.(*tls.Conn); ok {
+        if err := tlsConn.Handshake(); err != nil {
+            c.close()
+            return
+        }
+        c.tlsState = new(tls.ConnectionState)
+        *c.tlsState = tlsConn.ConnectionState()
+    }
+
+    for {
+        w, err := c.readRequest()
+        if err != nil {
+            msg := "400 Bad Request"
+            if err == errTooLarge {
+                // Their HTTP client may or may not be
+                // able to read this if we're
+                // responding to them and hanging up
+                // while they're still writing their
+                // request.  Undefined behavior.
+                msg = "413 Request Entity Too Large"
+            } else if err == io.EOF {
+                break // Don't reply
+            } else if neterr, ok := err.(net.Error); ok && neterr.Timeout() {
+                break // Don't reply
+            }
+            fmt.Fprintf(c.rwc, "HTTP/1.1 %s\r\n\r\n", msg)
+            break
+        }
+
+        // Expect 100 Continue support
+        req := w.req
+        if req.expectsContinue() {
+            if req.ProtoAtLeast(1, 1) {
+                // Wrap the Body reader with one that replies on the connection
+                req.Body = &expectContinueReader{readCloser: req.Body, resp: w}
+            }
+            if req.ContentLength == 0 {
+                w.Header().Set("Connection", "close")
+                w.WriteHeader(StatusBadRequest)
+                w.finishRequest()
+                break
+            }
+            req.Header.Del("Expect")
+        } else if req.Header.Get("Expect") != "" {
+            // TODO(bradfitz): let ServeHTTP handlers handle
+            // requests with non-standard expectation[s]? Seems
+            // theoretical at best, and doesn't fit into the
+            // current ServeHTTP model anyway.  We'd need to
+            // make the ResponseWriter an optional
+            // "ExpectReplier" interface or something.
+            //
+            // For now we'll just obey RFC 2616 14.20 which says
+            // "If a server receives a request containing an
+            // Expect field that includes an expectation-
+            // extension that it does not support, it MUST
+            // respond with a 417 (Expectation Failed) status."
+            w.Header().Set("Connection", "close")
+            w.WriteHeader(StatusExpectationFailed)
+            w.finishRequest()
+            break
+        }
+
+        handler := c.server.Handler
+        if handler == nil {
+            handler = DefaultServeMux
+        }
+
+        // HTTP cannot have multiple simultaneous active requests.[*]
+        // Until the server replies to this request, it can't read another,
+        // 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.
+        handler.ServeHTTP(w, w.req)
+        if c.hijacked {
+            return
+        }
+        w.finishRequest()
+        if w.closeAfterReply {
+            break
+        }
+    }
+    c.close()
+}
+
+// Hijack implements the Hijacker.Hijack method. Our response is both a ResponseWriter
+// and a Hijacker.
+func (w *response) Hijack() (rwc net.Conn, buf *bufio.ReadWriter, err error) {
+    if w.conn.hijacked {
+        return nil, nil, ErrHijacked
+    }
+    w.conn.hijacked = true
+    rwc = w.conn.rwc
+    buf = w.conn.buf
+    w.conn.rwc = nil
+    w.conn.buf = nil
+    return
+}
+
+// The HandlerFunc type is an adapter to allow the use of
+// 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(ResponseWriter, *Request)
+
+// ServeHTTP calls f(w, r).
+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(w ResponseWriter, error string, code int) {
+    w.Header().Set("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(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.
+func NotFoundHandler() Handler { return HandlerFunc(NotFound) }
+
+// StripPrefix returns a handler that serves HTTP requests
+// by removing the given prefix from the request URL's Path
+// and invoking the handler h. StripPrefix handles a
+// request for a path that doesn't begin with prefix by
+// replying with an HTTP 404 not found error.
+func StripPrefix(prefix string, h Handler) Handler {
+    return HandlerFunc(func(w ResponseWriter, r *Request) {
+        if !strings.HasPrefix(r.URL.Path, prefix) {
+            NotFound(w, r)
+            return
+        }
+        r.URL.Path = r.URL.Path[len(prefix):]
+        h.ServeHTTP(w, r)
+    })
+}
+
+// Redirect replies to the request with a redirect to url,
+// which may be a path relative to the request path.
+func Redirect(w ResponseWriter, r *Request, urlStr string, code int) {
+    if u, err := url.Parse(urlStr); err == nil {
+        // If url was relative, make absolute by
+        // combining with request path.
+        // The browser would probably do this for us,
+        // but doing it ourselves is more reliable.
+
+        // NOTE(rsc): RFC 2616 says that the Location
+        // line must be an absolute URI, like
+        // "http://www.google.com/redirect/",
+        // not a path like "/redirect/".
+        // Unfortunately, we don't know what to
+        // put in the host name section to get the
+        // client to connect to us again, so we can't
+        // know the right absolute URI to send back.
+        // Because of this problem, no one pays attention
+        // to the RFC; they all send back just a new path.
+        // So do we.
+        oldpath := r.URL.Path
+        if oldpath == "" { // should not happen, but avoid a crash if it does
+            oldpath = "/"
+        }
+        if u.Scheme == "" {
+            // no leading http://server
+            if urlStr == "" || urlStr[0] != '/' {
+                // make relative path absolute
+                olddir, _ := path.Split(oldpath)
+                urlStr = olddir + urlStr
+            }
+
+            var query string
+            if i := strings.Index(urlStr, "?"); i != -1 {
+                urlStr, query = urlStr[:i], urlStr[i:]
+            }
+
+            // clean up but preserve trailing slash
+            trailing := urlStr[len(urlStr)-1] == '/'
+            urlStr = path.Clean(urlStr)
+            if trailing && urlStr[len(urlStr)-1] != '/' {
+                urlStr += "/"
+            }
+            urlStr += query
+        }
+    }
+
+    w.Header().Set("Location", urlStr)
+    w.WriteHeader(code)
+
+    // RFC2616 recommends that a short note "SHOULD" be included in the
+    // response because older user agents may not understand 301/307.
+    // Shouldn't send the response for POST or HEAD; that leaves GET.
+    if r.Method == "GET" {
+        note := "<a href=\"" + htmlEscape(urlStr) + "\">" + statusText[code] + "</a>.\n"
+        fmt.Fprintln(w, note)
+    }
+}
+
+var htmlReplacer = strings.NewReplacer(
+    "&", "&amp;",
+    "<", "&lt;",
+    ">", "&gt;",
+    // "&#34;" is shorter than "&quot;".
+    `"`, "&#34;",
+    // "&#39;" is shorter than "&apos;" and apos was not in HTML until HTML5.
+    "'", "&#39;",
+)
+
+func htmlEscape(s string) string {
+    return htmlReplacer.Replace(s)
+}
+
+// Redirect to a fixed URL
+type redirectHandler struct {
+    url  string
+    code int
+}
+
+func (rh *redirectHandler) ServeHTTP(w ResponseWriter, r *Request) {
+    Redirect(w, r, rh.url, rh.code)
+}
+
+// RedirectHandler returns a request handler that redirects
+// each request it receives to the given url using the given
+// status code.
+func RedirectHandler(url string, code int) Handler {
+    return &redirectHandler{url, code}
+}
+
+// ServeMux is an HTTP request multiplexer.
+// It matches the URL of each incoming request against a list of registered
+// patterns and calls the handler for the pattern that
+// most closely matches the URL.
+//
+// Patterns named fixed, rooted paths, like "/favicon.ico",
+// or rooted subtrees, like "/images/" (note the trailing slash).
+// Longer patterns take precedence over shorter ones, so that
+// if there are handlers registered for both "/images/"
+// and "/images/thumbnails/", the latter handler will be
+// called for paths beginning "/images/thumbnails/" and the
+// former will receiver requests for any other paths in the
+// "/images/" subtree.
+//
+// Patterns may optionally begin with a host name, restricting matches to
+// URLs on that host only.  Host-specific patterns take precedence over
+// general patterns, so that a handler might register for the two patterns
+// "/codesearch" and "codesearch.google.com/" without also taking over
+// requests for "http://www.google.com/".
+//
+// ServeMux also takes care of sanitizing the URL request path,
+// redirecting any request containing . or .. elements to an
+// equivalent .- and ..-free URL.
+type ServeMux struct {
+    mu  sync.RWMutex
+    m   map[string]muxEntry
+}
+
+type muxEntry struct {
+    explicit bool
+    h        Handler
+}
+
+// NewServeMux allocates and returns a new ServeMux.
+func NewServeMux() *ServeMux { return &ServeMux{m: make(map[string]muxEntry)} }
+
+// DefaultServeMux is the default ServeMux used by Serve.
+var DefaultServeMux = NewServeMux()
+
+// Does path match pattern?
+func pathMatch(pattern, path string) bool {
+    if len(pattern) == 0 {
+        // should not happen
+        return false
+    }
+    n := len(pattern)
+    if pattern[n-1] != '/' {
+        return pattern == path
+    }
+    return len(path) >= n && path[0:n] == pattern
+}
+
+// Return the canonical path for p, eliminating . and .. elements.
+func cleanPath(p string) string {
+    if p == "" {
+        return "/"
+    }
+    if p[0] != '/' {
+        p = "/" + p
+    }
+    np := path.Clean(p)
+    // path.Clean removes trailing slash except for root;
+    // put the trailing slash back if necessary.
+    if p[len(p)-1] == '/' && np != "/" {
+        np += "/"
+    }
+    return np
+}
+
+// Find a handler on a handler map given a path string
+// Most-specific (longest) pattern wins
+func (mux *ServeMux) match(path string) Handler {
+    var h Handler
+    var n = 0
+    for k, v := range mux.m {
+        if !pathMatch(k, path) {
+            continue
+        }
+        if h == nil || len(k) > n {
+            n = len(k)
+            h = v.h
+        }
+    }
+    return h
+}
+
+// handler returns the handler to use for the request r.
+func (mux *ServeMux) handler(r *Request) Handler {
+    mux.mu.RLock()
+    defer mux.mu.RUnlock()
+
+    // Host-specific pattern takes precedence over generic ones
+    h := mux.match(r.Host + r.URL.Path)
+    if h == nil {
+        h = mux.match(r.URL.Path)
+    }
+    if h == nil {
+        h = NotFoundHandler()
+    }
+    return h
+}
+
+// ServeHTTP dispatches the request to the handler whose
+// pattern most closely matches the request URL.
+func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request) {
+    // Clean path to canonical form and redirect.
+    if p := cleanPath(r.URL.Path); p != r.URL.Path {
+        w.Header().Set("Location", p)
+        w.WriteHeader(StatusMovedPermanently)
+        return
+    }
+    mux.handler(r).ServeHTTP(w, r)
+}
+
+// Handle registers the handler for the given pattern.
+// If a handler already exists for pattern, Handle panics.
+func (mux *ServeMux) Handle(pattern string, handler Handler) {
+    mux.mu.Lock()
+    defer mux.mu.Unlock()
+
+    if pattern == "" {
+        panic("http: invalid pattern " + pattern)
+    }
+    if handler == nil {
+        panic("http: nil handler")
+    }
+    if mux.m[pattern].explicit {
+        panic("http: multiple registrations for " + pattern)
+    }
+
+    mux.m[pattern] = muxEntry{explicit: true, h: handler}
+
+    // Helpful behavior:
+    // If pattern is /tree/, insert an implicit permanent redirect for /tree.
+    // It can be overridden by an explicit registration.
+    n := len(pattern)
+    if n > 0 && pattern[n-1] == '/' && !mux.m[pattern[0:n-1]].explicit {
+        mux.m[pattern[0:n-1]] = muxEntry{h: RedirectHandler(pattern, StatusMovedPermanently)}
+    }
+}
+
+// HandleFunc registers the handler function for the given pattern.
+func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
+    mux.Handle(pattern, HandlerFunc(handler))
+}
+
+// Handle registers the handler for the given pattern
+// in the DefaultServeMux.
+// The documentation for ServeMux explains how patterns are matched.
+func Handle(pattern string, handler Handler) { DefaultServeMux.Handle(pattern, handler) }
+
+// HandleFunc registers the handler function for the given pattern
+// in the DefaultServeMux.
+// The documentation for ServeMux explains how patterns are matched.
+func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
+    DefaultServeMux.HandleFunc(pattern, handler)
+}
+
+// Serve accepts incoming HTTP connections on the listener l,
+// creating a new service thread for each.  The service threads
+// read requests and then call handler to reply to them.
+// Handler is typically nil, in which case the DefaultServeMux is used.
+func Serve(l net.Listener, handler Handler) error {
+    srv := &Server{Handler: handler}
+    return srv.Serve(l)
+}
+
+// A Server defines parameters for running an HTTP server.
+type Server struct {
+    Addr           string        // TCP address to listen on, ":http" if empty
+    Handler        Handler       // handler to invoke, http.DefaultServeMux if nil
+    ReadTimeout    time.Duration // maximum duration before timing out read of the request
+    WriteTimeout   time.Duration // maximum duration before timing out write of the response
+    MaxHeaderBytes int           // maximum size of request headers, DefaultMaxHeaderBytes if 0
+    TLSConfig      *tls.Config   // optional TLS config, used by ListenAndServeTLS
+}
+
+// ListenAndServe listens on the TCP network address srv.Addr and then
+// calls Serve to handle requests on incoming connections.  If
+// srv.Addr is blank, ":http" is used.
+func (srv *Server) ListenAndServe() error {
+    addr := srv.Addr
+    if addr == "" {
+        addr = ":http"
+    }
+    l, e := net.Listen("tcp", addr)
+    if e != nil {
+        return e
+    }
+    return srv.Serve(l)
+}
+
+// Serve accepts incoming connections on the Listener l, creating a
+// new service thread for each.  The service threads read requests and
+// then call srv.Handler to reply to them.
+func (srv *Server) Serve(l net.Listener) error {
+    defer l.Close()
+    var tempDelay time.Duration // how long to sleep on accept failure
+    for {
+        rw, e := l.Accept()
+        if e != nil {
+            if ne, ok := e.(net.Error); ok && ne.Temporary() {
+                if tempDelay == 0 {
+                    tempDelay = 5 * time.Millisecond
+                } else {
+                    tempDelay *= 2
+                }
+                if max := 1 * time.Second; tempDelay > max {
+                    tempDelay = max
+                }
+                log.Printf("http: Accept error: %v; retrying in %v", e, tempDelay)
+                time.Sleep(tempDelay)
+                continue
+            }
+            return e
+        }
+        tempDelay = 0
+        if srv.ReadTimeout != 0 {
+            rw.SetReadDeadline(time.Now().Add(srv.ReadTimeout))
+        }
+        if srv.WriteTimeout != 0 {
+            rw.SetWriteDeadline(time.Now().Add(srv.WriteTimeout))
+        }
+        c, err := srv.newConn(rw)
+        if err != nil {
+            continue
+        }
+        go c.serve()
+    }
+    panic("not reached")
+}
+
+// ListenAndServe listens on the TCP network address addr
+// and then calls Serve with handler to handle requests
+// on incoming connections.  Handler is typically nil,
+// in which case the DefaultServeMux is used.
+//
+// A trivial example server is:
+//
+//	package main
+//
+//	import (
+//		"io"
+//		"net/http"
+//		"log"
+//	)
+//
+//	// hello world, the web server
+//	func HelloServer(w http.ResponseWriter, req *http.Request) {
+//		io.WriteString(w, "hello, world!\n")
+//	}
+//
+//	func main() {
+//		http.HandleFunc("/hello", HelloServer)
+//		err := http.ListenAndServe(":12345", nil)
+//		if err != nil {
+//			log.Fatal("ListenAndServe: ", err)
+//		}
+//	}
+func ListenAndServe(addr string, handler Handler) error {
+    server := &Server{Addr: addr, Handler: handler}
+    return server.ListenAndServe()
+}
+
+// ListenAndServeTLS acts identically to ListenAndServe, except that it
+// expects HTTPS connections. Additionally, files containing a certificate and
+// matching private key for the server must be provided. If the certificate
+// is signed by a certificate authority, the certFile should be the concatenation
+// of the server's certificate followed by the CA's certificate.
+//
+// A trivial example server is:
+//
+//	import (
+//		"log"
+//		"net/http"
+//	)
+//
+//	func handler(w http.ResponseWriter, req *http.Request) {
+//		w.Header().Set("Content-Type", "text/plain")
+//		w.Write([]byte("This is an example server.\n"))
+//	}
+//
+//	func main() {
+//		http.HandleFunc("/", handler)
+//		log.Printf("About to listen on 10443. Go to https://127.0.0.1:10443/")
+//		err := http.ListenAndServeTLS(":10443", "cert.pem", "key.pem", nil)
+//		if err != nil {
+//			log.Fatal(err)
+//		}
+//	}
+//
+// One can use generate_cert.go in crypto/tls to generate cert.pem and key.pem.
+func ListenAndServeTLS(addr string, certFile string, keyFile string, handler Handler) error {
+    server := &Server{Addr: addr, Handler: handler}
+    return server.ListenAndServeTLS(certFile, keyFile)
+}
+
+// ListenAndServeTLS listens on the TCP network address srv.Addr and
+// then calls Serve to handle requests on incoming TLS connections.
+//
+// Filenames containing a certificate and matching private key for
+// the server must be provided. If the certificate is signed by a
+// certificate authority, the certFile should be the concatenation
+// of the server's certificate followed by the CA's certificate.
+//
+// If srv.Addr is blank, ":https" is used.
+func (srv *Server) ListenAndServeTLS(certFile, keyFile string) error {
+    addr := srv.Addr
+    if addr == "" {
+        addr = ":https"
+    }
+    config := &tls.Config{}
+    if srv.TLSConfig != nil {
+        *config = *srv.TLSConfig
+    }
+    if config.NextProtos == nil {
+        config.NextProtos = []string{"http/1.1"}
+    }
+
+    var err error
+    config.Certificates = make([]tls.Certificate, 1)
+    config.Certificates[0], err = tls.LoadX509KeyPair(certFile, keyFile)
+    if err != nil {
+        return err
+    }
+
+    conn, err := net.Listen("tcp", addr)
+    if err != nil {
+        return err
+    }
+
+    tlsListener := tls.NewListener(conn, config)
+    return srv.Serve(tlsListener)
+}
+
+// TimeoutHandler returns a Handler that runs h with the given time limit.
+//
+// The new Handler calls h.ServeHTTP to handle each request, but if a
+// call runs for more than ns nanoseconds, the handler responds with
+// a 503 Service Unavailable error and the given message in its body.
+// (If msg is empty, a suitable default message will be sent.)
+// After such a timeout, writes by h to its ResponseWriter will return
+// ErrHandlerTimeout.
+func TimeoutHandler(h Handler, dt time.Duration, msg string) Handler {
+    f := func() <-chan time.Time {
+        return time.After(dt)
+    }
+    return &timeoutHandler{h, f, msg}
+}
+
+// ErrHandlerTimeout is returned on ResponseWriter Write calls
+// in handlers which have timed out.
+var ErrHandlerTimeout = errors.New("http: Handler timeout")
+
+type timeoutHandler struct {
+    handler Handler
+    timeout func() <-chan time.Time // returns channel producing a timeout
+    body    string
+}
+
+func (h *timeoutHandler) errorBody() string {
+    if h.body != "" {
+        return h.body
+    }
+    return "<html><head><title>Timeout</title></head><body><h1>Timeout</h1></body></html>"
+}
+
+func (h *timeoutHandler) ServeHTTP(w ResponseWriter, r *Request) {
+    done := make(chan bool)
+    tw := &timeoutWriter{w: w}
+    go func() {
+        h.handler.ServeHTTP(tw, r)
+        done <- true
+    }()
+    select {
+    case <-done:
+        return
+    case <-h.timeout():
+        tw.mu.Lock()
+        defer tw.mu.Unlock()
+        if !tw.wroteHeader {
+            tw.w.WriteHeader(StatusServiceUnavailable)
+            tw.w.Write([]byte(h.errorBody()))
+        }
+        tw.timedOut = true
+    }
+}
+
+type timeoutWriter struct {
+    w   ResponseWriter
+
+    mu          sync.Mutex
+    timedOut    bool
+    wroteHeader bool
+}
+
+func (tw *timeoutWriter) Header() Header {
+    return tw.w.Header()
+}
+
+func (tw *timeoutWriter) Write(p []byte) (int, error) {
+    tw.mu.Lock()
+    timedOut := tw.timedOut
+    tw.mu.Unlock()
+    if timedOut {
+        return 0, ErrHandlerTimeout
+    }
+    return tw.w.Write(p)
+}
+
+func (tw *timeoutWriter) WriteHeader(code int) {
+    tw.mu.Lock()
+    if tw.timedOut || tw.wroteHeader {
+        tw.mu.Unlock()
+        return
+    }
+    tw.wroteHeader = true
+    tw.mu.Unlock()
+    tw.w.WriteHeader(code)
+}

=== added file 'fork/http/sniff.go'
--- fork/http/sniff.go	1970-01-01 00:00:00 +0000
+++ fork/http/sniff.go	2013-07-22 14:27:42 +0000
@@ -0,0 +1,214 @@
+// Copyright 2011 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.
+
+package http
+
+import (
+    "bytes"
+    "encoding/binary"
+)
+
+// The algorithm uses at most sniffLen bytes to make its decision.
+const sniffLen = 512
+
+// DetectContentType implements the algorithm described
+// at http://mimesniff.spec.whatwg.org/ to determine the
+// Content-Type of the given data.  It considers at most the
+// first 512 bytes of data.  DetectContentType always returns
+// a valid MIME type: if it cannot determine a more specific one, it
+// returns "application/octet-stream".
+func DetectContentType(data []byte) string {
+    if len(data) > sniffLen {
+        data = data[:sniffLen]
+    }
+
+    // Index of the first non-whitespace byte in data.
+    firstNonWS := 0
+    for ; firstNonWS < len(data) && isWS(data[firstNonWS]); firstNonWS++ {
+    }
+
+    for _, sig := range sniffSignatures {
+        if ct := sig.match(data, firstNonWS); ct != "" {
+            return ct
+        }
+    }
+
+    return "application/octet-stream" // fallback
+}
+
+func isWS(b byte) bool {
+    return bytes.IndexByte([]byte("\t\n\x0C\r "), b) != -1
+}
+
+type sniffSig interface {
+    // match returns the MIME type of the data, or "" if unknown.
+    match(data []byte, firstNonWS int) string
+}
+
+// Data matching the table in section 6.
+var sniffSignatures = []sniffSig{
+    htmlSig("<!DOCTYPE HTML"),
+    htmlSig("<HTML"),
+    htmlSig("<HEAD"),
+    htmlSig("<SCRIPT"),
+    htmlSig("<IFRAME"),
+    htmlSig("<H1"),
+    htmlSig("<DIV"),
+    htmlSig("<FONT"),
+    htmlSig("<TABLE"),
+    htmlSig("<A"),
+    htmlSig("<STYLE"),
+    htmlSig("<TITLE"),
+    htmlSig("<B"),
+    htmlSig("<BODY"),
+    htmlSig("<BR"),
+    htmlSig("<P"),
+    htmlSig("<!--"),
+
+    &maskedSig{mask: []byte("\xFF\xFF\xFF\xFF\xFF"), pat: []byte("<?xml"), skipWS: true, ct: "text/xml; charset=utf-8"},
+
+    &exactSig{[]byte("%PDF-"), "application/pdf"},
+    &exactSig{[]byte("%!PS-Adobe-"), "application/postscript"},
+
+    // UTF BOMs.
+    &maskedSig{mask: []byte("\xFF\xFF\x00\x00"), pat: []byte("\xFE\xFF\x00\x00"), ct: "text/plain; charset=utf-16be"},
+    &maskedSig{mask: []byte("\xFF\xFF\x00\x00"), pat: []byte("\xFF\xFE\x00\x00"), ct: "text/plain; charset=utf-16le"},
+    &maskedSig{mask: []byte("\xFF\xFF\xFF\x00"), pat: []byte("\xEF\xBB\xBF\x00"), ct: "text/plain; charset=utf-8"},
+
+    &exactSig{[]byte("GIF87a"), "image/gif"},
+    &exactSig{[]byte("GIF89a"), "image/gif"},
+    &exactSig{[]byte("\x89\x50\x4E\x47\x0D\x0A\x1A\x0A"), "image/png"},
+    &exactSig{[]byte("\xFF\xD8\xFF"), "image/jpeg"},
+    &exactSig{[]byte("BM"), "image/bmp"},
+    &maskedSig{
+        mask: []byte("\xFF\xFF\xFF\xFF\x00\x00\x00\x00\xFF\xFF\xFF\xFF\xFF\xFF"),
+        pat:  []byte("RIFF\x00\x00\x00\x00WEBPVP"),
+        ct:   "image/webp",
+    },
+    &exactSig{[]byte("\x00\x00\x01\x00"), "image/vnd.microsoft.icon"},
+    &exactSig{[]byte("\x4F\x67\x67\x53\x00"), "application/ogg"},
+    &maskedSig{
+        mask: []byte("\xFF\xFF\xFF\xFF\x00\x00\x00\x00\xFF\xFF\xFF\xFF"),
+        pat:  []byte("RIFF\x00\x00\x00\x00WAVE"),
+        ct:   "audio/wave",
+    },
+    &exactSig{[]byte("\x1A\x45\xDF\xA3"), "video/webm"},
+    &exactSig{[]byte("\x52\x61\x72\x20\x1A\x07\x00"), "application/x-rar-compressed"},
+    &exactSig{[]byte("\x50\x4B\x03\x04"), "application/zip"},
+    &exactSig{[]byte("\x1F\x8B\x08"), "application/x-gzip"},
+
+    // TODO(dsymonds): Re-enable this when the spec is sorted w.r.t. MP4.
+    //mp4Sig(0),
+
+    textSig(0), // should be last
+}
+
+type exactSig struct {
+    sig []byte
+    ct  string
+}
+
+func (e *exactSig) match(data []byte, firstNonWS int) string {
+    if bytes.HasPrefix(data, e.sig) {
+        return e.ct
+    }
+    return ""
+}
+
+type maskedSig struct {
+    mask, pat []byte
+    skipWS    bool
+    ct        string
+}
+
+func (m *maskedSig) match(data []byte, firstNonWS int) string {
+    if m.skipWS {
+        data = data[firstNonWS:]
+    }
+    if len(data) < len(m.mask) {
+        return ""
+    }
+    for i, mask := range m.mask {
+        db := data[i] & mask
+        if db != m.pat[i] {
+            return ""
+        }
+    }
+    return m.ct
+}
+
+type htmlSig []byte
+
+func (h htmlSig) match(data []byte, firstNonWS int) string {
+    data = data[firstNonWS:]
+    if len(data) < len(h)+1 {
+        return ""
+    }
+    for i, b := range h {
+        db := data[i]
+        if 'A' <= b && b <= 'Z' {
+            db &= 0xDF
+        }
+        if b != db {
+            return ""
+        }
+    }
+    // Next byte must be space or right angle bracket.
+    if db := data[len(h)]; db != ' ' && db != '>' {
+        return ""
+    }
+    return "text/html; charset=utf-8"
+}
+
+type mp4Sig int
+
+func (mp4Sig) match(data []byte, firstNonWS int) string {
+    // c.f. section 6.1.
+    if len(data) < 8 {
+        return ""
+    }
+    boxSize := int(binary.BigEndian.Uint32(data[:4]))
+    if boxSize%4 != 0 || len(data) < boxSize {
+        return ""
+    }
+    if !bytes.Equal(data[4:8], []byte("ftyp")) {
+        return ""
+    }
+    for st := 8; st < boxSize; st += 4 {
+        if st == 12 {
+            // minor version number
+            continue
+        }
+        seg := string(data[st : st+3])
+        switch seg {
+        case "mp4", "iso", "M4V", "M4P", "M4B":
+            return "video/mp4"
+            /* The remainder are not in the spec.
+               case "M4A":
+               	return "audio/mp4"
+               case "3gp":
+               	return "video/3gpp"
+               case "jp2":
+               	return "image/jp2" // JPEG 2000
+            */
+        }
+    }
+    return ""
+}
+
+type textSig int
+
+func (textSig) match(data []byte, firstNonWS int) string {
+    // c.f. section 5, step 4.
+    for _, b := range data[firstNonWS:] {
+        switch {
+        case 0x00 <= b && b <= 0x08,
+            b == 0x0B,
+            0x0E <= b && b <= 0x1A,
+            0x1C <= b && b <= 0x1F:
+            return ""
+        }
+    }
+    return "text/plain; charset=utf-8"
+}

=== added file 'fork/http/status.go'
--- fork/http/status.go	1970-01-01 00:00:00 +0000
+++ fork/http/status.go	2013-07-22 14:27:42 +0000
@@ -0,0 +1,108 @@
+// 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.
+
+package http
+
+// HTTP status codes, defined in RFC 2616.
+const (
+    StatusContinue           = 100
+    StatusSwitchingProtocols = 101
+
+    StatusOK                   = 200
+    StatusCreated              = 201
+    StatusAccepted             = 202
+    StatusNonAuthoritativeInfo = 203
+    StatusNoContent            = 204
+    StatusResetContent         = 205
+    StatusPartialContent       = 206
+
+    StatusMultipleChoices   = 300
+    StatusMovedPermanently  = 301
+    StatusFound             = 302
+    StatusSeeOther          = 303
+    StatusNotModified       = 304
+    StatusUseProxy          = 305
+    StatusTemporaryRedirect = 307
+
+    StatusBadRequest                   = 400
+    StatusUnauthorized                 = 401
+    StatusPaymentRequired              = 402
+    StatusForbidden                    = 403
+    StatusNotFound                     = 404
+    StatusMethodNotAllowed             = 405
+    StatusNotAcceptable                = 406
+    StatusProxyAuthRequired            = 407
+    StatusRequestTimeout               = 408
+    StatusConflict                     = 409
+    StatusGone                         = 410
+    StatusLengthRequired               = 411
+    StatusPreconditionFailed           = 412
+    StatusRequestEntityTooLarge        = 413
+    StatusRequestURITooLong            = 414
+    StatusUnsupportedMediaType         = 415
+    StatusRequestedRangeNotSatisfiable = 416
+    StatusExpectationFailed            = 417
+    StatusTeapot                       = 418
+
+    StatusInternalServerError     = 500
+    StatusNotImplemented          = 501
+    StatusBadGateway              = 502
+    StatusServiceUnavailable      = 503
+    StatusGatewayTimeout          = 504
+    StatusHTTPVersionNotSupported = 505
+)
+
+var statusText = map[int]string{
+    StatusContinue:           "Continue",
+    StatusSwitchingProtocols: "Switching Protocols",
+
+    StatusOK:                   "OK",
+    StatusCreated:              "Created",
+    StatusAccepted:             "Accepted",
+    StatusNonAuthoritativeInfo: "Non-Authoritative Information",
+    StatusNoContent:            "No Content",
+    StatusResetContent:         "Reset Content",
+    StatusPartialContent:       "Partial Content",
+
+    StatusMultipleChoices:   "Multiple Choices",
+    StatusMovedPermanently:  "Moved Permanently",
+    StatusFound:             "Found",
+    StatusSeeOther:          "See Other",
+    StatusNotModified:       "Not Modified",
+    StatusUseProxy:          "Use Proxy",
+    StatusTemporaryRedirect: "Temporary Redirect",
+
+    StatusBadRequest:                   "Bad Request",
+    StatusUnauthorized:                 "Unauthorized",
+    StatusPaymentRequired:              "Payment Required",
+    StatusForbidden:                    "Forbidden",
+    StatusNotFound:                     "Not Found",
+    StatusMethodNotAllowed:             "Method Not Allowed",
+    StatusNotAcceptable:                "Not Acceptable",
+    StatusProxyAuthRequired:            "Proxy Authentication Required",
+    StatusRequestTimeout:               "Request Timeout",
+    StatusConflict:                     "Conflict",
+    StatusGone:                         "Gone",
+    StatusLengthRequired:               "Length Required",
+    StatusPreconditionFailed:           "Precondition Failed",
+    StatusRequestEntityTooLarge:        "Request Entity Too Large",
+    StatusRequestURITooLong:            "Request URI Too Long",
+    StatusUnsupportedMediaType:         "Unsupported Media Type",
+    StatusRequestedRangeNotSatisfiable: "Requested Range Not Satisfiable",
+    StatusExpectationFailed:            "Expectation Failed",
+    StatusTeapot:                       "I'm a teapot",
+
+    StatusInternalServerError:     "Internal Server Error",
+    StatusNotImplemented:          "Not Implemented",
+    StatusBadGateway:              "Bad Gateway",
+    StatusServiceUnavailable:      "Service Unavailable",
+    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]
+}

=== added file 'fork/http/transfer.go'
--- fork/http/transfer.go	1970-01-01 00:00:00 +0000
+++ fork/http/transfer.go	2013-07-22 14:27:42 +0000
@@ -0,0 +1,632 @@
+// 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.
+
+package http
+
+import (
+    "bufio"
+    "bytes"
+    "errors"
+    "fmt"
+    "io"
+    "io/ioutil"
+    "net/textproto"
+    "strconv"
+    "strings"
+)
+
+// transferWriter inspects the fields of a user-supplied Request or Response,
+// sanitizes them without changing the user object and provides methods for
+// writing the respective header, body and trailer in wire format.
+type transferWriter struct {
+    Method           string
+    Body             io.Reader
+    BodyCloser       io.Closer
+    ResponseToHEAD   bool
+    ContentLength    int64 // -1 means unknown, 0 means exactly none
+    Close            bool
+    TransferEncoding []string
+    Trailer          Header
+}
+
+func newTransferWriter(r interface{}) (t *transferWriter, err error) {
+    t = &transferWriter{}
+
+    // Extract relevant fields
+    atLeastHTTP11 := false
+    switch rr := r.(type) {
+    case *Request:
+        if rr.ContentLength != 0 && rr.Body == nil {
+            return nil, fmt.Errorf("http: Request.ContentLength=%d with nil Body", rr.ContentLength)
+        }
+        t.Method = rr.Method
+        t.Body = rr.Body
+        t.BodyCloser = rr.Body
+        t.ContentLength = rr.ContentLength
+        t.Close = rr.Close
+        t.TransferEncoding = rr.TransferEncoding
+        t.Trailer = rr.Trailer
+        atLeastHTTP11 = rr.ProtoAtLeast(1, 1)
+        if t.Body != nil && len(t.TransferEncoding) == 0 && atLeastHTTP11 {
+            if t.ContentLength == 0 {
+                // Test to see if it's actually zero or just unset.
+                var buf [1]byte
+                n, _ := io.ReadFull(t.Body, buf[:])
+                if n == 1 {
+                    // Oh, guess there is data in this Body Reader after all.
+                    // The ContentLength field just wasn't set.
+                    // Stich the Body back together again, re-attaching our
+                    // consumed byte.
+                    t.ContentLength = -1
+                    t.Body = io.MultiReader(bytes.NewBuffer(buf[:]), t.Body)
+                } else {
+                    // Body is actually empty.
+                    t.Body = nil
+                    t.BodyCloser = nil
+                }
+            }
+            if t.ContentLength < 0 {
+                t.TransferEncoding = []string{"chunked"}
+            }
+        }
+    case *Response:
+        if rr.Request != nil {
+            t.Method = rr.Request.Method
+        }
+        t.Body = rr.Body
+        t.BodyCloser = rr.Body
+        t.ContentLength = rr.ContentLength
+        t.Close = rr.Close
+        t.TransferEncoding = rr.TransferEncoding
+        t.Trailer = rr.Trailer
+        atLeastHTTP11 = rr.ProtoAtLeast(1, 1)
+        t.ResponseToHEAD = noBodyExpected(t.Method)
+    }
+
+    // Sanitize Body,ContentLength,TransferEncoding
+    if t.ResponseToHEAD {
+        t.Body = nil
+        t.TransferEncoding = nil
+        // ContentLength is expected to hold Content-Length
+        if t.ContentLength < 0 {
+            return nil, ErrMissingContentLength
+        }
+    } else {
+        if !atLeastHTTP11 || t.Body == nil {
+            t.TransferEncoding = nil
+        }
+        if chunked(t.TransferEncoding) {
+            t.ContentLength = -1
+        } else if t.Body == nil { // no chunking, no body
+            t.ContentLength = 0
+        }
+    }
+
+    // Sanitize Trailer
+    if !chunked(t.TransferEncoding) {
+        t.Trailer = nil
+    }
+
+    return t, nil
+}
+
+func noBodyExpected(requestMethod string) bool {
+    return requestMethod == "HEAD"
+}
+
+func (t *transferWriter) shouldSendContentLength() bool {
+    if chunked(t.TransferEncoding) {
+        return false
+    }
+    if t.ContentLength > 0 {
+        return true
+    }
+    if t.ResponseToHEAD {
+        return true
+    }
+    // Many servers expect a Content-Length for these methods
+    if t.Method == "POST" || t.Method == "PUT" {
+        return true
+    }
+    if t.ContentLength == 0 && isIdentity(t.TransferEncoding) {
+        return true
+    }
+
+    return false
+}
+
+func (t *transferWriter) WriteHeader(w io.Writer) (err error) {
+    if t.Close {
+        _, err = io.WriteString(w, "Connection: close\r\n")
+        if err != nil {
+            return
+        }
+    }
+
+    // Write Content-Length and/or Transfer-Encoding whose values are a
+    // function of the sanitized field triple (Body, ContentLength,
+    // TransferEncoding)
+    if t.shouldSendContentLength() {
+        io.WriteString(w, "Content-Length: ")
+        _, err = io.WriteString(w, strconv.FormatInt(t.ContentLength, 10)+"\r\n")
+        if err != nil {
+            return
+        }
+    } else if chunked(t.TransferEncoding) {
+        _, err = io.WriteString(w, "Transfer-Encoding: chunked\r\n")
+        if err != nil {
+            return
+        }
+    }
+
+    // Write Trailer header
+    if t.Trailer != nil {
+        // TODO: At some point, there should be a generic mechanism for
+        // writing long headers, using HTTP line splitting
+        io.WriteString(w, "Trailer: ")
+        needComma := false
+        for k := range t.Trailer {
+            k = CanonicalHeaderKey(k)
+            switch k {
+            case "Transfer-Encoding", "Trailer", "Content-Length":
+                return &badStringError{"invalid Trailer key", k}
+            }
+            if needComma {
+                io.WriteString(w, ",")
+            }
+            io.WriteString(w, k)
+            needComma = true
+        }
+        _, err = io.WriteString(w, "\r\n")
+    }
+
+    return
+}
+
+func (t *transferWriter) WriteBody(w io.Writer) (err error) {
+    var ncopy int64
+
+    // Write body
+    if t.Body != nil {
+        if chunked(t.TransferEncoding) {
+            cw := newChunkedWriter(w)
+            _, err = io.Copy(cw, t.Body)
+            if err == nil {
+                err = cw.Close()
+            }
+        } else if t.ContentLength == -1 {
+            ncopy, err = io.Copy(w, t.Body)
+        } else {
+            ncopy, err = io.Copy(w, io.LimitReader(t.Body, t.ContentLength))
+            nextra, err := io.Copy(ioutil.Discard, t.Body)
+            if err != nil {
+                return err
+            }
+            ncopy += nextra
+        }
+        if err != nil {
+            return err
+        }
+        if err = t.BodyCloser.Close(); err != nil {
+            return err
+        }
+    }
+
+    if t.ContentLength != -1 && t.ContentLength != ncopy {
+        return fmt.Errorf("http: Request.ContentLength=%d with Body length %d",
+            t.ContentLength, ncopy)
+    }
+
+    // TODO(petar): Place trailer writer code here.
+    if chunked(t.TransferEncoding) {
+        // Last chunk, empty trailer
+        _, err = io.WriteString(w, "\r\n")
+    }
+
+    return
+}
+
+type transferReader struct {
+    // Input
+    Header        Header
+    StatusCode    int
+    RequestMethod string
+    ProtoMajor    int
+    ProtoMinor    int
+    // Output
+    Body             io.ReadCloser
+    ContentLength    int64
+    TransferEncoding []string
+    Close            bool
+    Trailer          Header
+}
+
+// bodyAllowedForStatus returns whether a given response status code
+// permits a body.  See RFC2616, section 4.4.
+func bodyAllowedForStatus(status int) bool {
+    switch {
+    case status >= 100 && status <= 199:
+        return false
+    case status == 204:
+        return false
+    case status == 304:
+        return false
+    }
+    return true
+}
+
+// msg is *Request or *Response.
+func readTransfer(msg interface{}, r *bufio.Reader) (err error) {
+    t := &transferReader{}
+
+    // Unify input
+    isResponse := false
+    switch rr := msg.(type) {
+    case *Response:
+        t.Header = rr.Header
+        t.StatusCode = rr.StatusCode
+        t.RequestMethod = rr.Request.Method
+        t.ProtoMajor = rr.ProtoMajor
+        t.ProtoMinor = rr.ProtoMinor
+        t.Close = shouldClose(t.ProtoMajor, t.ProtoMinor, t.Header)
+        isResponse = true
+    case *Request:
+        t.Header = rr.Header
+        t.ProtoMajor = rr.ProtoMajor
+        t.ProtoMinor = rr.ProtoMinor
+        // Transfer semantics for Requests are exactly like those for
+        // Responses with status code 200, responding to a GET method
+        t.StatusCode = 200
+        t.RequestMethod = "GET"
+    default:
+        panic("unexpected type")
+    }
+
+    // Default to HTTP/1.1
+    if t.ProtoMajor == 0 && t.ProtoMinor == 0 {
+        t.ProtoMajor, t.ProtoMinor = 1, 1
+    }
+
+    // Transfer encoding, content length
+    t.TransferEncoding, err = fixTransferEncoding(t.RequestMethod, t.Header)
+    if err != nil {
+        return err
+    }
+
+    t.ContentLength, err = fixLength(isResponse, t.StatusCode, t.RequestMethod, t.Header, t.TransferEncoding)
+    if err != nil {
+        return err
+    }
+
+    // Trailer
+    t.Trailer, err = fixTrailer(t.Header, t.TransferEncoding)
+    if err != nil {
+        return err
+    }
+
+    // If there is no Content-Length or chunked Transfer-Encoding on a *Response
+    // and the status is not 1xx, 204 or 304, then the body is unbounded.
+    // See RFC2616, section 4.4.
+    switch msg.(type) {
+    case *Response:
+        if t.ContentLength == -1 &&
+            !chunked(t.TransferEncoding) &&
+            bodyAllowedForStatus(t.StatusCode) {
+            // Unbounded body.
+            t.Close = true
+        }
+    }
+
+    // Prepare body reader.  ContentLength < 0 means chunked encoding
+    // or close connection when finished, since multipart is not supported yet
+    switch {
+    case chunked(t.TransferEncoding):
+        t.Body = &body{Reader: newChunkedReader(r), hdr: msg, r: r, closing: t.Close}
+    case t.ContentLength >= 0:
+        // TODO: limit the Content-Length. This is an easy DoS vector.
+        t.Body = &body{Reader: io.LimitReader(r, t.ContentLength), closing: t.Close}
+    default:
+        // t.ContentLength < 0, i.e. "Content-Length" not mentioned in header
+        if t.Close {
+            // Close semantics (i.e. HTTP/1.0)
+            t.Body = &body{Reader: r, closing: t.Close}
+        } else {
+            // Persistent connection (i.e. HTTP/1.1)
+            t.Body = &body{Reader: io.LimitReader(r, 0), closing: t.Close}
+        }
+    }
+
+    // Unify output
+    switch rr := msg.(type) {
+    case *Request:
+        rr.Body = t.Body
+        rr.ContentLength = t.ContentLength
+        rr.TransferEncoding = t.TransferEncoding
+        rr.Close = t.Close
+        rr.Trailer = t.Trailer
+    case *Response:
+        rr.Body = t.Body
+        rr.ContentLength = t.ContentLength
+        rr.TransferEncoding = t.TransferEncoding
+        rr.Close = t.Close
+        rr.Trailer = t.Trailer
+    }
+
+    return nil
+}
+
+// Checks whether chunked is part of the encodings stack
+func chunked(te []string) bool { return len(te) > 0 && te[0] == "chunked" }
+
+// Checks whether the encoding is explicitly "identity".
+func isIdentity(te []string) bool { return len(te) == 1 && te[0] == "identity" }
+
+// Sanitize transfer encoding
+func fixTransferEncoding(requestMethod string, header Header) ([]string, error) {
+    raw, present := header["Transfer-Encoding"]
+    if !present {
+        return nil, nil
+    }
+
+    delete(header, "Transfer-Encoding")
+
+    // Head responses have no bodies, so the transfer encoding
+    // should be ignored.
+    if requestMethod == "HEAD" {
+        return nil, nil
+    }
+
+    encodings := strings.Split(raw[0], ",")
+    te := make([]string, 0, len(encodings))
+    // TODO: Even though we only support "identity" and "chunked"
+    // encodings, the loop below is designed with foresight. One
+    // invariant that must be maintained is that, if present,
+    // chunked encoding must always come first.
+    for _, encoding := range encodings {
+        encoding = strings.ToLower(strings.TrimSpace(encoding))
+        // "identity" encoding is not recorded
+        if encoding == "identity" {
+            break
+        }
+        if encoding != "chunked" {
+            return nil, &badStringError{"unsupported transfer encoding", encoding}
+        }
+        te = te[0 : len(te)+1]
+        te[len(te)-1] = encoding
+    }
+    if len(te) > 1 {
+        return nil, &badStringError{"too many transfer encodings", strings.Join(te, ",")}
+    }
+    if len(te) > 0 {
+        // Chunked encoding trumps Content-Length. See RFC 2616
+        // Section 4.4. Currently len(te) > 0 implies chunked
+        // encoding.
+        delete(header, "Content-Length")
+        return te, nil
+    }
+
+    return nil, nil
+}
+
+// Determine the expected body length, using RFC 2616 Section 4.4. This
+// function is not a method, because ultimately it should be shared by
+// ReadResponse and ReadRequest.
+func fixLength(isResponse bool, status int, requestMethod string, header Header, te []string) (int64, error) {
+
+    // Logic based on response type or status
+    if noBodyExpected(requestMethod) {
+        return 0, nil
+    }
+    if status/100 == 1 {
+        return 0, nil
+    }
+    switch status {
+    case 204, 304:
+        return 0, nil
+    }
+
+    // Logic based on Transfer-Encoding
+    if chunked(te) {
+        return -1, nil
+    }
+
+    // Logic based on Content-Length
+    cl := strings.TrimSpace(header.Get("Content-Length"))
+    if cl != "" {
+        n, err := strconv.ParseInt(cl, 10, 64)
+        if err != nil || n < 0 {
+            return -1, &badStringError{"bad Content-Length", cl}
+        }
+        return n, nil
+    } else {
+        header.Del("Content-Length")
+    }
+
+    if !isResponse && requestMethod == "GET" {
+        // RFC 2616 doesn't explicitly permit nor forbid an
+        // entity-body on a GET request so we permit one if
+        // declared, but we default to 0 here (not -1 below)
+        // if there's no mention of a body.
+        return 0, nil
+    }
+
+    // Logic based on media type. The purpose of the following code is just
+    // to detect whether the unsupported "multipart/byteranges" is being
+    // used. A proper Content-Type parser is needed in the future.
+    if strings.Contains(strings.ToLower(header.Get("Content-Type")), "multipart/byteranges") {
+        return -1, ErrNotSupported
+    }
+
+    // Body-EOF logic based on other methods (like closing, or chunked coding)
+    return -1, nil
+}
+
+// Determine whether to hang up after sending a request and body, or
+// receiving a response and body
+// 'header' is the request headers
+func shouldClose(major, minor int, header Header) bool {
+    if major < 1 {
+        return true
+    } else if major == 1 && minor == 0 {
+        if !strings.Contains(strings.ToLower(header.Get("Connection")), "keep-alive") {
+            return true
+        }
+        return false
+    } else {
+        // TODO: Should split on commas, toss surrounding white space,
+        // and check each field.
+        if strings.ToLower(header.Get("Connection")) == "close" {
+            header.Del("Connection")
+            return true
+        }
+    }
+    return false
+}
+
+// Parse the trailer header
+func fixTrailer(header Header, te []string) (Header, error) {
+    raw := header.Get("Trailer")
+    if raw == "" {
+        return nil, nil
+    }
+
+    header.Del("Trailer")
+    trailer := make(Header)
+    keys := strings.Split(raw, ",")
+    for _, key := range keys {
+        key = CanonicalHeaderKey(strings.TrimSpace(key))
+        switch key {
+        case "Transfer-Encoding", "Trailer", "Content-Length":
+            return nil, &badStringError{"bad trailer key", key}
+        }
+        trailer.Del(key)
+    }
+    if len(trailer) == 0 {
+        return nil, nil
+    }
+    if !chunked(te) {
+        // Trailer and no chunking
+        return nil, ErrUnexpectedTrailer
+    }
+    return trailer, nil
+}
+
+// body turns a Reader into a ReadCloser.
+// Close ensures that the body has been fully read
+// and then reads the trailer if necessary.
+type body struct {
+    io.Reader
+    hdr     interface{}   // non-nil (Response or Request) value means read trailer
+    r       *bufio.Reader // underlying wire-format reader for the trailer
+    closing bool          // is the connection to be closed after reading body?
+    closed  bool
+
+    res *response // response writer for server requests, else nil
+}
+
+// ErrBodyReadAfterClose is returned when reading a Request Body after
+// the body has been closed. This typically happens when the body is
+// read after an HTTP Handler calls WriteHeader or Write on its
+// ResponseWriter.
+var ErrBodyReadAfterClose = errors.New("http: invalid Read on closed request Body")
+
+func (b *body) Read(p []byte) (n int, err error) {
+    if b.closed {
+        return 0, ErrBodyReadAfterClose
+    }
+    n, err = b.Reader.Read(p)
+
+    // Read the final trailer once we hit EOF.
+    if err == io.EOF && b.hdr != nil {
+        if e := b.readTrailer(); e != nil {
+            err = e
+        }
+        b.hdr = nil
+    }
+    return n, err
+}
+
+var (
+    singleCRLF = []byte("\r\n")
+    doubleCRLF = []byte("\r\n\r\n")
+)
+
+func seeUpcomingDoubleCRLF(r *bufio.Reader) bool {
+    for peekSize := 4; ; peekSize++ {
+        // This loop stops when Peek returns an error,
+        // which it does when r's buffer has been filled.
+        buf, err := r.Peek(peekSize)
+        if bytes.HasSuffix(buf, doubleCRLF) {
+            return true
+        }
+        if err != nil {
+            break
+        }
+    }
+    return false
+}
+
+func (b *body) readTrailer() error {
+    // The common case, since nobody uses trailers.
+    buf, _ := b.r.Peek(2)
+    if bytes.Equal(buf, singleCRLF) {
+        b.r.ReadByte()
+        b.r.ReadByte()
+        return nil
+    }
+
+    // Make sure there's a header terminator coming up, to prevent
+    // a DoS with an unbounded size Trailer.  It's not easy to
+    // slip in a LimitReader here, as textproto.NewReader requires
+    // a concrete *bufio.Reader.  Also, we can't get all the way
+    // back up to our conn's LimitedReader that *might* be backing
+    // this bufio.Reader.  Instead, a hack: we iteratively Peek up
+    // to the bufio.Reader's max size, looking for a double CRLF.
+    // This limits the trailer to the underlying buffer size, typically 4kB.
+    if !seeUpcomingDoubleCRLF(b.r) {
+        return errors.New("http: suspiciously long trailer after chunked body")
+    }
+
+    hdr, err := textproto.NewReader(b.r).ReadMIMEHeader()
+    if err != nil {
+        return err
+    }
+    switch rr := b.hdr.(type) {