Imported Upstream version 58upstream/58

7 files changed, 303 insertions, 45 deletions

diff --git a/src/pkg/mime/multipart/Makefile b/src/pkg/mime/multipart/Makefile
index 5051f0df1..de1a439f2 100644
--- a/src/pkg/mime/multipart/Makefile
+++ b/src/pkg/mime/multipart/Makefile
@@ -8,5 +8,6 @@ TARG=mime/multipart
 GOFILES=\
 	formdata.go\
 	multipart.go\
+	writer.go\
 
 include ../../../Make.pkg
diff --git a/src/pkg/mime/multipart/formdata.go b/src/pkg/mime/multipart/formdata.go
index 287938557..5f3286565 100644
--- a/src/pkg/mime/multipart/formdata.go
+++ b/src/pkg/mime/multipart/formdata.go
@@ -30,21 +30,18 @@ func (r *multiReader) ReadForm(maxMemory int64) (f *Form, err os.Error) {
 	maxValueBytes := int64(10 << 20) // 10 MB is a lot of text.
 	for {
 		p, err := r.NextPart()
+		if err == os.EOF {
+			break
+		}
 		if err != nil {
 			return nil, err
 		}
-		if p == nil {
-			break
-		}
 
 		name := p.FormName()
 		if name == "" {
 			continue
 		}
-		var filename string
-		if p.dispositionParams != nil {
-			filename = p.dispositionParams["filename"]
-		}
+		filename := p.FileName()
 
 		var b bytes.Buffer
 
diff --git a/src/pkg/mime/multipart/formdata_test.go b/src/pkg/mime/multipart/formdata_test.go
index b56e2a430..9424c3778 100644
--- a/src/pkg/mime/multipart/formdata_test.go
+++ b/src/pkg/mime/multipart/formdata_test.go
@@ -33,7 +33,7 @@ func TestReadForm(t *testing.T) {
 	}
 	fd = testFile(t, f.File["fileb"][0], "fileb.txt", filebContents)
 	if _, ok := fd.(*os.File); !ok {
-		t.Error("file has unexpected underlying type %T", fd)
+		t.Errorf("file has unexpected underlying type %T", fd)
 	}
 }
 
diff --git a/src/pkg/mime/multipart/multipart.go b/src/pkg/mime/multipart/multipart.go
index 60329fe17..9affa1126 100644
--- a/src/pkg/mime/multipart/multipart.go
+++ b/src/pkg/mime/multipart/multipart.go
@@ -26,14 +26,14 @@ import (
 
 var headerRegexp *regexp.Regexp = regexp.MustCompile("^([a-zA-Z0-9\\-]+): *([^\r\n]+)")
 
+var emptyParams = make(map[string]string)
+
 // Reader is an iterator over parts in a MIME multipart body.
 // Reader's underlying parser consumes its input as needed.  Seeking
 // isn't supported.
 type Reader interface {
-	// NextPart returns the next part in the multipart, or (nil,
-	// nil) on EOF.  An error is returned if the underlying reader
-	// reports errors, or on truncated or otherwise malformed
-	// input.
+	// NextPart returns the next part in the multipart or an error.
+	// When there are no more parts, the error os.EOF is returned.
 	NextPart() (*Part, os.Error)
 
 	// ReadForm parses an entire multipart message whose parts have
@@ -53,6 +53,7 @@ type Part struct {
 	buffer *bytes.Buffer
 	mr     *multiReader
 
+	disposition       string
 	dispositionParams map[string]string
 }
 
@@ -61,21 +62,33 @@ type Part struct {
 func (p *Part) FormName() string {
 	// See http://tools.ietf.org/html/rfc2183 section 2 for EBNF
 	// of Content-Disposition value format.
-	if p.dispositionParams != nil {
-		return p.dispositionParams["name"]
-	}
-	v := p.Header.Get("Content-Disposition")
-	if v == "" {
-		return ""
+	if p.dispositionParams == nil {
+		p.parseContentDisposition()
 	}
-	if d, params := mime.ParseMediaType(v); d != "form-data" {
+	if p.disposition != "form-data" {
 		return ""
-	} else {
-		p.dispositionParams = params
 	}
 	return p.dispositionParams["name"]
 }
 
+
+// FileName returns the filename parameter of the Part's
+// Content-Disposition header.
+func (p *Part) FileName() string {
+	if p.dispositionParams == nil {
+		p.parseContentDisposition()
+	}
+	return p.dispositionParams["filename"]
+}
+
+func (p *Part) parseContentDisposition() {
+	v := p.Header.Get("Content-Disposition")
+	p.disposition, p.dispositionParams = mime.ParseMediaType(v)
+	if p.dispositionParams == nil {
+		p.dispositionParams = emptyParams
+	}
+}
+
 // NewReader creates a new multipart Reader reading from r using the
 // given MIME boundary.
 func NewReader(reader io.Reader, boundary string) Reader {
@@ -207,9 +220,8 @@ func (mr *multiReader) NextPart() (*Part, os.Error) {
 		}
 
 		if hasPrefixThenNewline(line, mr.dashBoundaryDash) {
-			// Expected EOF (no error)
-			// TODO(bradfitz): should return an os.EOF error here, not using nil for errors
-			return nil, nil
+			// Expected EOF
+			return nil, os.EOF
 		}
 
 		if expectNewPart {
diff --git a/src/pkg/mime/multipart/multipart_test.go b/src/pkg/mime/multipart/multipart_test.go
index 16249146c..4ec3d30bd 100644
--- a/src/pkg/mime/multipart/multipart_test.go
+++ b/src/pkg/mime/multipart/multipart_test.go
@@ -56,24 +56,25 @@ func expectEq(t *testing.T, expected, actual, what string) {
 		what, escapeString(actual), len(actual), escapeString(expected), len(expected))
 }
 
-func TestFormName(t *testing.T) {
-	p := new(Part)
-	p.Header = make(map[string][]string)
-	tests := [...][2]string{
-		{`form-data; name="foo"`, "foo"},
-		{` form-data ; name=foo`, "foo"},
-		{`FORM-DATA;name="foo"`, "foo"},
-		{` FORM-DATA ; name="foo"`, "foo"},
-		{` FORM-DATA ; name="foo"`, "foo"},
-		{` FORM-DATA ; name=foo`, "foo"},
-		{` FORM-DATA ; filename="foo.txt"; name=foo; baz=quux`, "foo"},
-	}
-	for _, test := range tests {
+func TestNameAccessors(t *testing.T) {
+	tests := [...][3]string{
+		{`form-data; name="foo"`, "foo", ""},
+		{` form-data ; name=foo`, "foo", ""},
+		{`FORM-DATA;name="foo"`, "foo", ""},
+		{` FORM-DATA ; name="foo"`, "foo", ""},
+		{` FORM-DATA ; name="foo"`, "foo", ""},
+		{` FORM-DATA ; name=foo`, "foo", ""},
+		{` FORM-DATA ; filename="foo.txt"; name=foo; baz=quux`, "foo", "foo.txt"},
+		{` not-form-data ; filename="bar.txt"; name=foo; baz=quux`, "", "bar.txt"},
+	}
+	for i, test := range tests {
+		p := &Part{Header: make(map[string][]string)}
 		p.Header.Set("Content-Disposition", test[0])
-		expected := test[1]
-		actual := p.FormName()
-		if actual != expected {
-			t.Errorf("expected \"%s\"; got: \"%s\"", expected, actual)
+		if g, e := p.FormName(), test[1]; g != e {
+			t.Errorf("test %d: FormName() = %q; want %q", i, g, e)
+		}
+		if g, e := p.FileName(), test[2]; g != e {
+			t.Errorf("test %d: FileName() = %q; want %q", i, g, e)
 		}
 	}
 }
@@ -201,8 +202,8 @@ func testMultipart(t *testing.T, r io.Reader) {
 	if part != nil {
 		t.Error("Didn't expect a fifth part.")
 	}
-	if err != nil {
-		t.Errorf("Unexpected error getting fifth part: %v", err)
+	if err != os.EOF {
+		t.Errorf("On fifth part expected os.EOF; got %v", err)
 	}
 }
 
@@ -246,8 +247,8 @@ func TestVariousTextLineEndings(t *testing.T) {
 		if part != nil {
 			t.Errorf("Unexpected part in test %d", testNum)
 		}
-		if err != nil {
-			t.Errorf("Unexpected error in test %d: %v", testNum, err)
+		if err != os.EOF {
+			t.Errorf("On test %d expected os.EOF; got %v", testNum, err)
 		}
 
 	}
@@ -306,6 +307,29 @@ Oh no, premature EOF!
 	}
 }
 
+func TestZeroLengthBody(t *testing.T) {
+	testBody := strings.Replace(`
+This is a multi-part message.  This line is ignored.
+--MyBoundary
+foo: bar
+
+
+--MyBoundary--
+`, "\n", "\r\n", -1)
+	r := NewReader(strings.NewReader(testBody), "MyBoundary")
+	part, err := r.NextPart()
+	if err != nil {
+		t.Fatalf("didn't get a part")
+	}
+	n, err := io.Copy(ioutil.Discard, part)
+	if err != nil {
+		t.Errorf("error reading part: %v", err)
+	}
+	if n != 0 {
+		t.Errorf("read %d bytes; expected 0", n)
+	}
+}
+
 type slowReader struct {
 	r io.Reader
 }
diff --git a/src/pkg/mime/multipart/writer.go b/src/pkg/mime/multipart/writer.go
new file mode 100644
index 000000000..b436dd012
--- /dev/null
+++ b/src/pkg/mime/multipart/writer.go
@@ -0,0 +1,153 @@
+// 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 multipart
+
+import (
+	"bytes"
+	"crypto/rand"
+	"fmt"
+	"io"
+	"net/textproto"
+	"os"
+	"strings"
+)
+
+// A Writer generates multipart messages.
+type Writer struct {
+	w        io.Writer
+	boundary string
+	lastpart *part
+}
+
+// NewWriter returns a new multipart Writer with a random boundary,
+// writing to w.
+func NewWriter(w io.Writer) *Writer {
+	return &Writer{
+		w:        w,
+		boundary: randomBoundary(),
+	}
+}
+
+// Boundary returns the Writer's randomly selected boundary string.
+func (w *Writer) Boundary() string {
+	return w.boundary
+}
+
+// FormDataContentType returns the Content-Type for an HTTP
+// multipart/form-data with this Writer's Boundary.
+func (w *Writer) FormDataContentType() string {
+	return "multipart/form-data; boundary=" + w.boundary
+}
+
+func randomBoundary() string {
+	var buf [30]byte
+	_, err := io.ReadFull(rand.Reader, buf[:])
+	if err != nil {
+		panic(err)
+	}
+	return fmt.Sprintf("%x", buf[:])
+}
+
+// CreatePart creates a new multipart section with the provided
+// header. The body of the part should be written to the returned
+// Writer. After calling CreatePart, any previous part may no longer
+// be written to.
+func (w *Writer) CreatePart(header textproto.MIMEHeader) (io.Writer, os.Error) {
+	if w.lastpart != nil {
+		if err := w.lastpart.close(); err != nil {
+			return nil, err
+		}
+	}
+	var b bytes.Buffer
+	fmt.Fprintf(&b, "\r\n--%s\r\n", w.boundary)
+	// TODO(bradfitz): move this to textproto.MimeHeader.Write(w), have it sort
+	// and clean, like http.Header.Write(w) does.
+	for k, vv := range header {
+		for _, v := range vv {
+			fmt.Fprintf(&b, "%s: %s\r\n", k, v)
+		}
+	}
+	fmt.Fprintf(&b, "\r\n")
+	_, err := io.Copy(w.w, &b)
+	if err != nil {
+		return nil, err
+	}
+	p := &part{
+		mw: w,
+	}
+	w.lastpart = p
+	return p, nil
+}
+
+func escapeQuotes(s string) string {
+	s = strings.Replace(s, "\\", "\\\\", -1)
+	s = strings.Replace(s, "\"", "\\\"", -1)
+	return s
+}
+
+// CreateFormFile is a convenience wrapper around CreatePart. It creates
+// a new form-data header with the provided field name and file name.
+func (w *Writer) CreateFormFile(fieldname, filename string) (io.Writer, os.Error) {
+	h := make(textproto.MIMEHeader)
+	h.Set("Content-Disposition",
+		fmt.Sprintf(`form-data; name="%s"; filename="%s"`,
+			escapeQuotes(fieldname), escapeQuotes(filename)))
+	h.Set("Content-Type", "application/octet-stream")
+	return w.CreatePart(h)
+}
+
+// CreateFormField calls CreatePart with a header using the
+// given field name.
+func (w *Writer) CreateFormField(fieldname string) (io.Writer, os.Error) {
+	h := make(textproto.MIMEHeader)
+	h.Set("Content-Disposition",
+		fmt.Sprintf(`form-data; name="%s"`, escapeQuotes(fieldname)))
+	return w.CreatePart(h)
+}
+
+// WriteField calls CreateFormField and then writes the given value.
+func (w *Writer) WriteField(fieldname, value string) os.Error {
+	p, err := w.CreateFormField(fieldname)
+	if err != nil {
+		return err
+	}
+	_, err = p.Write([]byte(value))
+	return err
+}
+
+// Close finishes the multipart message and writes the trailing
+// boundary end line to the output.
+func (w *Writer) Close() os.Error {
+	if w.lastpart != nil {
+		if err := w.lastpart.close(); err != nil {
+			return err
+		}
+		w.lastpart = nil
+	}
+	_, err := fmt.Fprintf(w.w, "\r\n--%s--\r\n", w.boundary)
+	return err
+}
+
+type part struct {
+	mw     *Writer
+	closed bool
+	we     os.Error // last error that occurred writing
+}
+
+func (p *part) close() os.Error {
+	p.closed = true
+	return p.we
+}
+
+func (p *part) Write(d []byte) (n int, err os.Error) {
+	if p.closed {
+		return 0, os.NewError("multipart: can't write to finished part")
+	}
+	n, err = p.mw.w.Write(d)
+	if err != nil {
+		p.we = err
+	}
+	return
+}
diff --git a/src/pkg/mime/multipart/writer_test.go b/src/pkg/mime/multipart/writer_test.go
new file mode 100644
index 000000000..e6a04c388
--- /dev/null
+++ b/src/pkg/mime/multipart/writer_test.go
@@ -0,0 +1,71 @@
+// 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 multipart
+
+import (
+	"bytes"
+	"io/ioutil"
+	"testing"
+)
+
+func TestWriter(t *testing.T) {
+	fileContents := []byte("my file contents")
+
+	var b bytes.Buffer
+	w := NewWriter(&b)
+	{
+		part, err := w.CreateFormFile("myfile", "my-file.txt")
+		if err != nil {
+			t.Fatalf("CreateFormFile: %v", err)
+		}
+		part.Write(fileContents)
+		err = w.WriteField("key", "val")
+		if err != nil {
+			t.Fatalf("WriteField: %v", err)
+		}
+		part.Write([]byte("val"))
+		err = w.Close()
+		if err != nil {
+			t.Fatalf("Close: %v", err)
+		}
+	}
+
+	r := NewReader(&b, w.Boundary())
+
+	part, err := r.NextPart()
+	if err != nil {
+		t.Fatalf("part 1: %v", err)
+	}
+	if g, e := part.FormName(), "myfile"; g != e {
+		t.Errorf("part 1: want form name %q, got %q", e, g)
+	}
+	slurp, err := ioutil.ReadAll(part)
+	if err != nil {
+		t.Fatalf("part 1: ReadAll: %v", err)
+	}
+	if e, g := string(fileContents), string(slurp); e != g {
+		t.Errorf("part 1: want contents %q, got %q", e, g)
+	}
+
+	part, err = r.NextPart()
+	if err != nil {
+		t.Fatalf("part 2: %v", err)
+	}
+	if g, e := part.FormName(), "key"; g != e {
+		t.Errorf("part 2: want form name %q, got %q", e, g)
+	}
+	slurp, err = ioutil.ReadAll(part)
+	if err != nil {
+		t.Fatalf("part 2: ReadAll: %v", err)
+	}
+	if e, g := "val", string(slurp); e != g {
+		t.Errorf("part 2: want contents %q, got %q", e, g)
+	}
+
+	part, err = r.NextPart()
+	if part != nil || err == nil {
+		t.Fatalf("expected end of parts; got %v, %v", part, err)
+	}
+}