1 files changed, 441 insertions, 0 deletions
diff --git a/libgo/go/http/transfer.go b/libgo/go/http/transfer.go
new file mode 100644
index 000000000..e62885d62
--- /dev/null
+++ b/libgo/go/http/transfer.go
@@ -0,0 +1,441 @@
+// 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"
+	"io"
+	"os"
+	"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 {
+	Body             io.ReadCloser
+	ResponseToHEAD   bool
+	ContentLength    int64
+	Close            bool
+	TransferEncoding []string
+	Trailer          map[string]string
+}
+
+func newTransferWriter(r interface{}) (t *transferWriter, err os.Error) {
+	t = &transferWriter{}
+
+	// Extract relevant fields
+	atLeastHTTP11 := false
+	switch rr := r.(type) {
+	case *Request:
+		t.Body = rr.Body
+		t.ContentLength = rr.ContentLength
+		t.Close = rr.Close
+		t.TransferEncoding = rr.TransferEncoding
+		t.Trailer = rr.Trailer
+		atLeastHTTP11 = rr.ProtoAtLeast(1, 1)
+	case *Response:
+		t.Body = 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(rr.RequestMethod)
+	}
+
+	// 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) WriteHeader(w io.Writer) (err os.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 chunked(t.TransferEncoding) {
+		_, err = io.WriteString(w, "Transfer-Encoding: chunked\r\n")
+		if err != nil {
+			return
+		}
+	} else if t.ContentLength > 0 || t.ResponseToHEAD {
+		io.WriteString(w, "Content-Length: ")
+		_, err = io.WriteString(w, strconv.Itoa64(t.ContentLength)+"\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 os.Error) {
+	// 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 {
+			_, err = io.Copy(w, t.Body)
+		} else {
+			_, err = io.Copy(w, io.LimitReader(t.Body, t.ContentLength))
+		}
+		if err != nil {
+			return err
+		}
+		if err = t.Body.Close(); err != nil {
+			return err
+		}
+	}
+
+	// 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        map[string]string
+	StatusCode    int
+	RequestMethod string
+	ProtoMajor    int
+	ProtoMinor    int
+	// Output
+	Body             io.ReadCloser
+	ContentLength    int64
+	TransferEncoding []string
+	Close            bool
+	Trailer          map[string]string
+}
+
+// msg is *Request or *Response.
+func readTransfer(msg interface{}, r *bufio.Reader) (err os.Error) {
+	t := &transferReader{}
+
+	// Unify input
+	switch rr := msg.(type) {
+	case *Response:
+		t.Header = rr.Header
+		t.StatusCode = rr.StatusCode
+		t.RequestMethod = rr.RequestMethod
+		t.ProtoMajor = rr.ProtoMajor
+		t.ProtoMinor = rr.ProtoMinor
+		t.Close = shouldClose(t.ProtoMajor, t.ProtoMinor, t.Header)
+	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 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.Header)
+	if err != nil {
+		return err
+	}
+
+	t.ContentLength, err = fixLength(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
+	}
+
+	// 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}
+		}
+		// TODO(petar): It may be a good idea, for extra robustness, to
+		// assume ContentLength=0 for GET requests (and other special
+		// cases?). This logic should be in fixLength().
+	}
+
+	// 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" }
+
+// Sanitize transfer encoding
+func fixTransferEncoding(header map[string]string) ([]string, os.Error) {
+	raw, present := header["Transfer-Encoding"]
+	if !present {
+		return nil, nil
+	}
+
+	header["Transfer-Encoding"] = "", false
+	encodings := strings.Split(raw, ",", -1)
+	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 recored
+		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.
+		header["Content-Length"] = "", false
+		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(status int, requestMethod string, header map[string]string, te []string) (int64, os.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
+	if cl, present := header["Content-Length"]; present {
+		cl = strings.TrimSpace(cl)
+		if cl != "" {
+			n, err := strconv.Atoi64(cl)
+			if err != nil || n < 0 {
+				return -1, &badStringError{"bad Content-Length", cl}
+			}
+			return n, nil
+		} else {
+			header["Content-Length"] = "", false
+		}
+	}
+
+	// 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["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 map[string]string) bool {
+	if major < 1 {
+		return true
+	} else if major == 1 && minor == 0 {
+		v, present := header["Connection"]
+		if !present {
+			return true
+		}
+		v = strings.ToLower(v)
+		if !strings.Contains(v, "keep-alive") {
+			return true
+		}
+		return false
+	} else if v, present := header["Connection"]; present {
+		// TODO: Should split on commas, toss surrounding white space,
+		// and check each field.
+		if v == "close" {
+			header["Connection"] = "", false
+			return true
+		}
+	}
+	return false
+}
+
+// Parse the trailer header
+func fixTrailer(header map[string]string, te []string) (map[string]string, os.Error) {
+	raw, present := header["Trailer"]
+	if !present {
+		return nil, nil
+	}
+
+	header["Trailer"] = "", false
+	trailer := make(map[string]string)
+	keys := strings.Split(raw, ",", -1)
+	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[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?
+}
+
+func (b *body) Close() os.Error {
+	if b.hdr == nil && b.closing {
+		// no trailer and closing the connection next.
+		// no point in reading to EOF.
+		return nil
+	}
+
+	trashBuf := make([]byte, 1024) // local for thread safety
+	for {
+		_, err := b.Read(trashBuf)
+		if err == nil {
+			continue
+		}
+		if err == os.EOF {
+			break
+		}
+		return err
+	}
+	if b.hdr == nil { // not reading trailer
+		return nil
+	}
+
+	// TODO(petar): Put trailer reader code here
+
+	return nil
+}