Source file src/mime/multipart/multipart_test.go

Documentation: mime/multipart

		 1  // Copyright 2010 The Go Authors. All rights reserved.
		 2  // Use of this source code is governed by a BSD-style
		 3  // license that can be found in the LICENSE file.
		 4  
		 5  package multipart
		 6  
		 7  import (
		 8  	"bytes"
		 9  	"encoding/json"
		10  	"fmt"
		11  	"io"
		12  	"net/textproto"
		13  	"os"
		14  	"reflect"
		15  	"strings"
		16  	"testing"
		17  )
		18  
		19  func TestBoundaryLine(t *testing.T) {
		20  	mr := NewReader(strings.NewReader(""), "myBoundary")
		21  	if !mr.isBoundaryDelimiterLine([]byte("--myBoundary\r\n")) {
		22  		t.Error("expected")
		23  	}
		24  	if !mr.isBoundaryDelimiterLine([]byte("--myBoundary \r\n")) {
		25  		t.Error("expected")
		26  	}
		27  	if !mr.isBoundaryDelimiterLine([]byte("--myBoundary \n")) {
		28  		t.Error("expected")
		29  	}
		30  	if mr.isBoundaryDelimiterLine([]byte("--myBoundary bogus \n")) {
		31  		t.Error("expected fail")
		32  	}
		33  	if mr.isBoundaryDelimiterLine([]byte("--myBoundary bogus--")) {
		34  		t.Error("expected fail")
		35  	}
		36  }
		37  
		38  func escapeString(v string) string {
		39  	bytes, _ := json.Marshal(v)
		40  	return string(bytes)
		41  }
		42  
		43  func expectEq(t *testing.T, expected, actual, what string) {
		44  	if expected == actual {
		45  		return
		46  	}
		47  	t.Errorf("Unexpected value for %s; got %s (len %d) but expected: %s (len %d)",
		48  		what, escapeString(actual), len(actual), escapeString(expected), len(expected))
		49  }
		50  
		51  func TestNameAccessors(t *testing.T) {
		52  	tests := [...][3]string{
		53  		{`form-data; name="foo"`, "foo", ""},
		54  		{` form-data ; name=foo`, "foo", ""},
		55  		{`FORM-DATA;name="foo"`, "foo", ""},
		56  		{` FORM-DATA ; name="foo"`, "foo", ""},
		57  		{` FORM-DATA ; name="foo"`, "foo", ""},
		58  		{` FORM-DATA ; name=foo`, "foo", ""},
		59  		{` FORM-DATA ; filename="foo.txt"; name=foo; baz=quux`, "foo", "foo.txt"},
		60  		{` not-form-data ; filename="bar.txt"; name=foo; baz=quux`, "", "bar.txt"},
		61  	}
		62  	for i, test := range tests {
		63  		p := &Part{Header: make(map[string][]string)}
		64  		p.Header.Set("Content-Disposition", test[0])
		65  		if g, e := p.FormName(), test[1]; g != e {
		66  			t.Errorf("test %d: FormName() = %q; want %q", i, g, e)
		67  		}
		68  		if g, e := p.FileName(), test[2]; g != e {
		69  			t.Errorf("test %d: FileName() = %q; want %q", i, g, e)
		70  		}
		71  	}
		72  }
		73  
		74  var longLine = strings.Repeat("\n\n\r\r\r\n\r\000", (1<<20)/8)
		75  
		76  func testMultipartBody(sep string) string {
		77  	testBody := `
		78  This is a multi-part message.	This line is ignored.
		79  --MyBoundary
		80  Header1: value1
		81  HEADER2: value2
		82  foo-bar: baz
		83  
		84  My value
		85  The end.
		86  --MyBoundary
		87  name: bigsection
		88  
		89  [longline]
		90  --MyBoundary
		91  Header1: value1b
		92  HEADER2: value2b
		93  foo-bar: bazb
		94  
		95  Line 1
		96  Line 2
		97  Line 3 ends in a newline, but just one.
		98  
		99  --MyBoundary
	 100  
	 101  never read data
	 102  --MyBoundary--
	 103  
	 104  
	 105  useless trailer
	 106  `
	 107  	testBody = strings.ReplaceAll(testBody, "\n", sep)
	 108  	return strings.Replace(testBody, "[longline]", longLine, 1)
	 109  }
	 110  
	 111  func TestMultipart(t *testing.T) {
	 112  	bodyReader := strings.NewReader(testMultipartBody("\r\n"))
	 113  	testMultipart(t, bodyReader, false)
	 114  }
	 115  
	 116  func TestMultipartOnlyNewlines(t *testing.T) {
	 117  	bodyReader := strings.NewReader(testMultipartBody("\n"))
	 118  	testMultipart(t, bodyReader, true)
	 119  }
	 120  
	 121  func TestMultipartSlowInput(t *testing.T) {
	 122  	bodyReader := strings.NewReader(testMultipartBody("\r\n"))
	 123  	testMultipart(t, &slowReader{bodyReader}, false)
	 124  }
	 125  
	 126  func testMultipart(t *testing.T, r io.Reader, onlyNewlines bool) {
	 127  	t.Parallel()
	 128  	reader := NewReader(r, "MyBoundary")
	 129  	buf := new(bytes.Buffer)
	 130  
	 131  	// Part1
	 132  	part, err := reader.NextPart()
	 133  	if part == nil || err != nil {
	 134  		t.Error("Expected part1")
	 135  		return
	 136  	}
	 137  	if x := part.Header.Get("Header1"); x != "value1" {
	 138  		t.Errorf("part.Header.Get(%q) = %q, want %q", "Header1", x, "value1")
	 139  	}
	 140  	if x := part.Header.Get("foo-bar"); x != "baz" {
	 141  		t.Errorf("part.Header.Get(%q) = %q, want %q", "foo-bar", x, "baz")
	 142  	}
	 143  	if x := part.Header.Get("Foo-Bar"); x != "baz" {
	 144  		t.Errorf("part.Header.Get(%q) = %q, want %q", "Foo-Bar", x, "baz")
	 145  	}
	 146  	buf.Reset()
	 147  	if _, err := io.Copy(buf, part); err != nil {
	 148  		t.Errorf("part 1 copy: %v", err)
	 149  	}
	 150  
	 151  	adjustNewlines := func(s string) string {
	 152  		if onlyNewlines {
	 153  			return strings.ReplaceAll(s, "\r\n", "\n")
	 154  		}
	 155  		return s
	 156  	}
	 157  
	 158  	expectEq(t, adjustNewlines("My value\r\nThe end."), buf.String(), "Value of first part")
	 159  
	 160  	// Part2
	 161  	part, err = reader.NextPart()
	 162  	if err != nil {
	 163  		t.Fatalf("Expected part2; got: %v", err)
	 164  		return
	 165  	}
	 166  	if e, g := "bigsection", part.Header.Get("name"); e != g {
	 167  		t.Errorf("part2's name header: expected %q, got %q", e, g)
	 168  	}
	 169  	buf.Reset()
	 170  	if _, err := io.Copy(buf, part); err != nil {
	 171  		t.Errorf("part 2 copy: %v", err)
	 172  	}
	 173  	s := buf.String()
	 174  	if len(s) != len(longLine) {
	 175  		t.Errorf("part2 body expected long line of length %d; got length %d",
	 176  			len(longLine), len(s))
	 177  	}
	 178  	if s != longLine {
	 179  		t.Errorf("part2 long body didn't match")
	 180  	}
	 181  
	 182  	// Part3
	 183  	part, err = reader.NextPart()
	 184  	if part == nil || err != nil {
	 185  		t.Error("Expected part3")
	 186  		return
	 187  	}
	 188  	if part.Header.Get("foo-bar") != "bazb" {
	 189  		t.Error("Expected foo-bar: bazb")
	 190  	}
	 191  	buf.Reset()
	 192  	if _, err := io.Copy(buf, part); err != nil {
	 193  		t.Errorf("part 3 copy: %v", err)
	 194  	}
	 195  	expectEq(t, adjustNewlines("Line 1\r\nLine 2\r\nLine 3 ends in a newline, but just one.\r\n"),
	 196  		buf.String(), "body of part 3")
	 197  
	 198  	// Part4
	 199  	part, err = reader.NextPart()
	 200  	if part == nil || err != nil {
	 201  		t.Error("Expected part 4 without errors")
	 202  		return
	 203  	}
	 204  
	 205  	// Non-existent part5
	 206  	part, err = reader.NextPart()
	 207  	if part != nil {
	 208  		t.Error("Didn't expect a fifth part.")
	 209  	}
	 210  	if err != io.EOF {
	 211  		t.Errorf("On fifth part expected io.EOF; got %v", err)
	 212  	}
	 213  }
	 214  
	 215  func TestVariousTextLineEndings(t *testing.T) {
	 216  	tests := [...]string{
	 217  		"Foo\nBar",
	 218  		"Foo\nBar\n",
	 219  		"Foo\r\nBar",
	 220  		"Foo\r\nBar\r\n",
	 221  		"Foo\rBar",
	 222  		"Foo\rBar\r",
	 223  		"\x00\x01\x02\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10",
	 224  	}
	 225  
	 226  	for testNum, expectedBody := range tests {
	 227  		body := "--BOUNDARY\r\n" +
	 228  			"Content-Disposition: form-data; name=\"value\"\r\n" +
	 229  			"\r\n" +
	 230  			expectedBody +
	 231  			"\r\n--BOUNDARY--\r\n"
	 232  		bodyReader := strings.NewReader(body)
	 233  
	 234  		reader := NewReader(bodyReader, "BOUNDARY")
	 235  		buf := new(bytes.Buffer)
	 236  		part, err := reader.NextPart()
	 237  		if part == nil {
	 238  			t.Errorf("Expected a body part on text %d", testNum)
	 239  			continue
	 240  		}
	 241  		if err != nil {
	 242  			t.Errorf("Unexpected error on text %d: %v", testNum, err)
	 243  			continue
	 244  		}
	 245  		written, err := io.Copy(buf, part)
	 246  		expectEq(t, expectedBody, buf.String(), fmt.Sprintf("test %d", testNum))
	 247  		if err != nil {
	 248  			t.Errorf("Error copying multipart; bytes=%v, error=%v", written, err)
	 249  		}
	 250  
	 251  		part, err = reader.NextPart()
	 252  		if part != nil {
	 253  			t.Errorf("Unexpected part in test %d", testNum)
	 254  		}
	 255  		if err != io.EOF {
	 256  			t.Errorf("On test %d expected io.EOF; got %v", testNum, err)
	 257  		}
	 258  
	 259  	}
	 260  }
	 261  
	 262  type maliciousReader struct {
	 263  	t *testing.T
	 264  	n int
	 265  }
	 266  
	 267  const maxReadThreshold = 1 << 20
	 268  
	 269  func (mr *maliciousReader) Read(b []byte) (n int, err error) {
	 270  	mr.n += len(b)
	 271  	if mr.n >= maxReadThreshold {
	 272  		mr.t.Fatal("too much was read")
	 273  		return 0, io.EOF
	 274  	}
	 275  	return len(b), nil
	 276  }
	 277  
	 278  func TestLineLimit(t *testing.T) {
	 279  	mr := &maliciousReader{t: t}
	 280  	r := NewReader(mr, "fooBoundary")
	 281  	part, err := r.NextPart()
	 282  	if part != nil {
	 283  		t.Errorf("unexpected part read")
	 284  	}
	 285  	if err == nil {
	 286  		t.Errorf("expected an error")
	 287  	}
	 288  	if mr.n >= maxReadThreshold {
	 289  		t.Errorf("expected to read < %d bytes; read %d", maxReadThreshold, mr.n)
	 290  	}
	 291  }
	 292  
	 293  func TestMultipartTruncated(t *testing.T) {
	 294  	testBody := `
	 295  This is a multi-part message.	This line is ignored.
	 296  --MyBoundary
	 297  foo-bar: baz
	 298  
	 299  Oh no, premature EOF!
	 300  `
	 301  	body := strings.ReplaceAll(testBody, "\n", "\r\n")
	 302  	bodyReader := strings.NewReader(body)
	 303  	r := NewReader(bodyReader, "MyBoundary")
	 304  
	 305  	part, err := r.NextPart()
	 306  	if err != nil {
	 307  		t.Fatalf("didn't get a part")
	 308  	}
	 309  	_, err = io.Copy(io.Discard, part)
	 310  	if err != io.ErrUnexpectedEOF {
	 311  		t.Fatalf("expected error io.ErrUnexpectedEOF; got %v", err)
	 312  	}
	 313  }
	 314  
	 315  type slowReader struct {
	 316  	r io.Reader
	 317  }
	 318  
	 319  func (s *slowReader) Read(p []byte) (int, error) {
	 320  	if len(p) == 0 {
	 321  		return s.r.Read(p)
	 322  	}
	 323  	return s.r.Read(p[:1])
	 324  }
	 325  
	 326  type sentinelReader struct {
	 327  	// done is closed when this reader is read from.
	 328  	done chan struct{}
	 329  }
	 330  
	 331  func (s *sentinelReader) Read([]byte) (int, error) {
	 332  	if s.done != nil {
	 333  		close(s.done)
	 334  		s.done = nil
	 335  	}
	 336  	return 0, io.EOF
	 337  }
	 338  
	 339  // TestMultipartStreamReadahead tests that PartReader does not block
	 340  // on reading past the end of a part, ensuring that it can be used on
	 341  // a stream like multipart/x-mixed-replace. See golang.org/issue/15431
	 342  func TestMultipartStreamReadahead(t *testing.T) {
	 343  	testBody1 := `
	 344  This is a multi-part message.	This line is ignored.
	 345  --MyBoundary
	 346  foo-bar: baz
	 347  
	 348  Body
	 349  --MyBoundary
	 350  `
	 351  	testBody2 := `foo-bar: bop
	 352  
	 353  Body 2
	 354  --MyBoundary--
	 355  `
	 356  	done1 := make(chan struct{})
	 357  	reader := NewReader(
	 358  		io.MultiReader(
	 359  			strings.NewReader(testBody1),
	 360  			&sentinelReader{done1},
	 361  			strings.NewReader(testBody2)),
	 362  		"MyBoundary")
	 363  
	 364  	var i int
	 365  	readPart := func(hdr textproto.MIMEHeader, body string) {
	 366  		part, err := reader.NextPart()
	 367  		if part == nil || err != nil {
	 368  			t.Fatalf("Part %d: NextPart failed: %v", i, err)
	 369  		}
	 370  
	 371  		if !reflect.DeepEqual(part.Header, hdr) {
	 372  			t.Errorf("Part %d: part.Header = %v, want %v", i, part.Header, hdr)
	 373  		}
	 374  		data, err := io.ReadAll(part)
	 375  		expectEq(t, body, string(data), fmt.Sprintf("Part %d body", i))
	 376  		if err != nil {
	 377  			t.Fatalf("Part %d: ReadAll failed: %v", i, err)
	 378  		}
	 379  		i++
	 380  	}
	 381  
	 382  	readPart(textproto.MIMEHeader{"Foo-Bar": {"baz"}}, "Body")
	 383  
	 384  	select {
	 385  	case <-done1:
	 386  		t.Errorf("Reader read past second boundary")
	 387  	default:
	 388  	}
	 389  
	 390  	readPart(textproto.MIMEHeader{"Foo-Bar": {"bop"}}, "Body 2")
	 391  }
	 392  
	 393  func TestLineContinuation(t *testing.T) {
	 394  	// This body, extracted from an email, contains headers that span multiple
	 395  	// lines.
	 396  
	 397  	// TODO: The original mail ended with a double-newline before the
	 398  	// final delimiter; this was manually edited to use a CRLF.
	 399  	testBody :=
	 400  		"\n--Apple-Mail-2-292336769\nContent-Transfer-Encoding: 7bit\nContent-Type: text/plain;\n\tcharset=US-ASCII;\n\tdelsp=yes;\n\tformat=flowed\n\nI'm finding the same thing happening on my system (10.4.1).\n\n\n--Apple-Mail-2-292336769\nContent-Transfer-Encoding: quoted-printable\nContent-Type: text/html;\n\tcharset=ISO-8859-1\n\n<HTML><BODY>I'm finding the same thing =\nhappening on my system (10.4.1).=A0 But I built it with XCode =\n2.0.</BODY></=\nHTML>=\n\r\n--Apple-Mail-2-292336769--\n"
	 401  
	 402  	r := NewReader(strings.NewReader(testBody), "Apple-Mail-2-292336769")
	 403  
	 404  	for i := 0; i < 2; i++ {
	 405  		part, err := r.NextPart()
	 406  		if err != nil {
	 407  			t.Fatalf("didn't get a part")
	 408  		}
	 409  		var buf bytes.Buffer
	 410  		n, err := io.Copy(&buf, part)
	 411  		if err != nil {
	 412  			t.Errorf("error reading part: %v\nread so far: %q", err, buf.String())
	 413  		}
	 414  		if n <= 0 {
	 415  			t.Errorf("read %d bytes; expected >0", n)
	 416  		}
	 417  	}
	 418  }
	 419  
	 420  func TestQuotedPrintableEncoding(t *testing.T) {
	 421  	for _, cte := range []string{"quoted-printable", "Quoted-PRINTABLE"} {
	 422  		t.Run(cte, func(t *testing.T) {
	 423  			testQuotedPrintableEncoding(t, cte)
	 424  		})
	 425  	}
	 426  }
	 427  
	 428  func testQuotedPrintableEncoding(t *testing.T, cte string) {
	 429  	// From https://golang.org/issue/4411
	 430  	body := "--0016e68ee29c5d515f04cedf6733\r\nContent-Type: text/plain; charset=ISO-8859-1\r\nContent-Disposition: form-data; name=text\r\nContent-Transfer-Encoding: " + cte + "\r\n\r\nwords words words words words words words words words words words words wor=\r\nds words words words words words words words words words words words words =\r\nwords words words words words words words words words words words words wor=\r\nds words words words words words words words words words words words words =\r\nwords words words words words words words words words\r\n--0016e68ee29c5d515f04cedf6733\r\nContent-Type: text/plain; charset=ISO-8859-1\r\nContent-Disposition: form-data; name=submit\r\n\r\nSubmit\r\n--0016e68ee29c5d515f04cedf6733--"
	 431  	r := NewReader(strings.NewReader(body), "0016e68ee29c5d515f04cedf6733")
	 432  	part, err := r.NextPart()
	 433  	if err != nil {
	 434  		t.Fatal(err)
	 435  	}
	 436  	if te, ok := part.Header["Content-Transfer-Encoding"]; ok {
	 437  		t.Errorf("unexpected Content-Transfer-Encoding of %q", te)
	 438  	}
	 439  	var buf bytes.Buffer
	 440  	_, err = io.Copy(&buf, part)
	 441  	if err != nil {
	 442  		t.Error(err)
	 443  	}
	 444  	got := buf.String()
	 445  	want := "words words words words words words words words words words words words words words words words words words words words words words words words words words words words words words words words words words words words words words words words words words words words words words words words words words words words words words words words words words words"
	 446  	if got != want {
	 447  		t.Errorf("wrong part value:\n got: %q\nwant: %q", got, want)
	 448  	}
	 449  }
	 450  
	 451  func TestRawPart(t *testing.T) {
	 452  	// https://github.com/golang/go/issues/29090
	 453  
	 454  	body := strings.Replace(`--0016e68ee29c5d515f04cedf6733
	 455  Content-Type: text/plain; charset="utf-8"
	 456  Content-Transfer-Encoding: quoted-printable
	 457  
	 458  <div dir=3D"ltr">Hello World.</div>
	 459  --0016e68ee29c5d515f04cedf6733
	 460  Content-Type: text/plain; charset="utf-8"
	 461  Content-Transfer-Encoding: quoted-printable
	 462  
	 463  <div dir=3D"ltr">Hello World.</div>
	 464  --0016e68ee29c5d515f04cedf6733--`, "\n", "\r\n", -1)
	 465  
	 466  	r := NewReader(strings.NewReader(body), "0016e68ee29c5d515f04cedf6733")
	 467  
	 468  	// This part is expected to be raw, bypassing the automatic handling
	 469  	// of quoted-printable.
	 470  	part, err := r.NextRawPart()
	 471  	if err != nil {
	 472  		t.Fatal(err)
	 473  	}
	 474  	if _, ok := part.Header["Content-Transfer-Encoding"]; !ok {
	 475  		t.Errorf("missing Content-Transfer-Encoding")
	 476  	}
	 477  	var buf bytes.Buffer
	 478  	_, err = io.Copy(&buf, part)
	 479  	if err != nil {
	 480  		t.Error(err)
	 481  	}
	 482  	got := buf.String()
	 483  	// Data is still quoted-printable.
	 484  	want := `<div dir=3D"ltr">Hello World.</div>`
	 485  	if got != want {
	 486  		t.Errorf("wrong part value:\n got: %q\nwant: %q", got, want)
	 487  	}
	 488  
	 489  	// This part is expected to have automatic decoding of quoted-printable.
	 490  	part, err = r.NextPart()
	 491  	if err != nil {
	 492  		t.Fatal(err)
	 493  	}
	 494  	if te, ok := part.Header["Content-Transfer-Encoding"]; ok {
	 495  		t.Errorf("unexpected Content-Transfer-Encoding of %q", te)
	 496  	}
	 497  
	 498  	buf.Reset()
	 499  	_, err = io.Copy(&buf, part)
	 500  	if err != nil {
	 501  		t.Error(err)
	 502  	}
	 503  	got = buf.String()
	 504  	// QP data has been decoded.
	 505  	want = `<div dir="ltr">Hello World.</div>`
	 506  	if got != want {
	 507  		t.Errorf("wrong part value:\n got: %q\nwant: %q", got, want)
	 508  	}
	 509  }
	 510  
	 511  // Test parsing an image attachment from gmail, which previously failed.
	 512  func TestNested(t *testing.T) {
	 513  	// nested-mime is the body part of a multipart/mixed email
	 514  	// with boundary e89a8ff1c1e83553e304be640612
	 515  	f, err := os.Open("testdata/nested-mime")
	 516  	if err != nil {
	 517  		t.Fatal(err)
	 518  	}
	 519  	defer f.Close()
	 520  	mr := NewReader(f, "e89a8ff1c1e83553e304be640612")
	 521  	p, err := mr.NextPart()
	 522  	if err != nil {
	 523  		t.Fatalf("error reading first section (alternative): %v", err)
	 524  	}
	 525  
	 526  	// Read the inner text/plain and text/html sections of the multipart/alternative.
	 527  	mr2 := NewReader(p, "e89a8ff1c1e83553e004be640610")
	 528  	p, err = mr2.NextPart()
	 529  	if err != nil {
	 530  		t.Fatalf("reading text/plain part: %v", err)
	 531  	}
	 532  	if b, err := io.ReadAll(p); string(b) != "*body*\r\n" || err != nil {
	 533  		t.Fatalf("reading text/plain part: got %q, %v", b, err)
	 534  	}
	 535  	p, err = mr2.NextPart()
	 536  	if err != nil {
	 537  		t.Fatalf("reading text/html part: %v", err)
	 538  	}
	 539  	if b, err := io.ReadAll(p); string(b) != "<b>body</b>\r\n" || err != nil {
	 540  		t.Fatalf("reading text/html part: got %q, %v", b, err)
	 541  	}
	 542  
	 543  	p, err = mr2.NextPart()
	 544  	if err != io.EOF {
	 545  		t.Fatalf("final inner NextPart = %v; want io.EOF", err)
	 546  	}
	 547  
	 548  	// Back to the outer multipart/mixed, reading the image attachment.
	 549  	_, err = mr.NextPart()
	 550  	if err != nil {
	 551  		t.Fatalf("error reading the image attachment at the end: %v", err)
	 552  	}
	 553  
	 554  	_, err = mr.NextPart()
	 555  	if err != io.EOF {
	 556  		t.Fatalf("final outer NextPart = %v; want io.EOF", err)
	 557  	}
	 558  }
	 559  
	 560  type headerBody struct {
	 561  	header textproto.MIMEHeader
	 562  	body	 string
	 563  }
	 564  
	 565  func formData(key, value string) headerBody {
	 566  	return headerBody{
	 567  		textproto.MIMEHeader{
	 568  			"Content-Type":				{"text/plain; charset=ISO-8859-1"},
	 569  			"Content-Disposition": {"form-data; name=" + key},
	 570  		},
	 571  		value,
	 572  	}
	 573  }
	 574  
	 575  type parseTest struct {
	 576  	name		string
	 577  	in, sep string
	 578  	want		[]headerBody
	 579  }
	 580  
	 581  var parseTests = []parseTest{
	 582  	// Actual body from App Engine on a blob upload. The final part (the
	 583  	// Content-Type: message/external-body) is what App Engine replaces
	 584  	// the uploaded file with. The other form fields (prefixed with
	 585  	// "other" in their form-data name) are unchanged. A bug was
	 586  	// reported with blob uploads failing when the other fields were
	 587  	// empty. This was the MIME POST body that previously failed.
	 588  	{
	 589  		name: "App Engine post",
	 590  		sep:	"00151757727e9583fd04bfbca4c6",
	 591  		in:	 "--00151757727e9583fd04bfbca4c6\r\nContent-Type: text/plain; charset=ISO-8859-1\r\nContent-Disposition: form-data; name=otherEmpty1\r\n\r\n--00151757727e9583fd04bfbca4c6\r\nContent-Type: text/plain; charset=ISO-8859-1\r\nContent-Disposition: form-data; name=otherFoo1\r\n\r\nfoo\r\n--00151757727e9583fd04bfbca4c6\r\nContent-Type: text/plain; charset=ISO-8859-1\r\nContent-Disposition: form-data; name=otherFoo2\r\n\r\nfoo\r\n--00151757727e9583fd04bfbca4c6\r\nContent-Type: text/plain; charset=ISO-8859-1\r\nContent-Disposition: form-data; name=otherEmpty2\r\n\r\n--00151757727e9583fd04bfbca4c6\r\nContent-Type: text/plain; charset=ISO-8859-1\r\nContent-Disposition: form-data; name=otherRepeatFoo\r\n\r\nfoo\r\n--00151757727e9583fd04bfbca4c6\r\nContent-Type: text/plain; charset=ISO-8859-1\r\nContent-Disposition: form-data; name=otherRepeatFoo\r\n\r\nfoo\r\n--00151757727e9583fd04bfbca4c6\r\nContent-Type: text/plain; charset=ISO-8859-1\r\nContent-Disposition: form-data; name=otherRepeatEmpty\r\n\r\n--00151757727e9583fd04bfbca4c6\r\nContent-Type: text/plain; charset=ISO-8859-1\r\nContent-Disposition: form-data; name=otherRepeatEmpty\r\n\r\n--00151757727e9583fd04bfbca4c6\r\nContent-Type: text/plain; charset=ISO-8859-1\r\nContent-Disposition: form-data; name=submit\r\n\r\nSubmit\r\n--00151757727e9583fd04bfbca4c6\r\nContent-Type: message/external-body; charset=ISO-8859-1; blob-key=AHAZQqG84qllx7HUqO_oou5EvdYQNS3Mbbkb0RjjBoM_Kc1UqEN2ygDxWiyCPulIhpHRPx-VbpB6RX4MrsqhWAi_ZxJ48O9P2cTIACbvATHvg7IgbvZytyGMpL7xO1tlIvgwcM47JNfv_tGhy1XwyEUO8oldjPqg5Q\r\nContent-Disposition: form-data; name=file; filename=\"fall.png\"\r\n\r\nContent-Type: image/png\r\nContent-Length: 232303\r\nX-AppEngine-Upload-Creation: 2012-05-10 23:14:02.715173\r\nContent-MD5: MzRjODU1ZDZhZGU1NmRlOWEwZmMwMDdlODBmZTA0NzA=\r\nContent-Disposition: form-data; name=file; filename=\"fall.png\"\r\n\r\n\r\n--00151757727e9583fd04bfbca4c6--",
	 592  		want: []headerBody{
	 593  			formData("otherEmpty1", ""),
	 594  			formData("otherFoo1", "foo"),
	 595  			formData("otherFoo2", "foo"),
	 596  			formData("otherEmpty2", ""),
	 597  			formData("otherRepeatFoo", "foo"),
	 598  			formData("otherRepeatFoo", "foo"),
	 599  			formData("otherRepeatEmpty", ""),
	 600  			formData("otherRepeatEmpty", ""),
	 601  			formData("submit", "Submit"),
	 602  			{textproto.MIMEHeader{
	 603  				"Content-Type":				{"message/external-body; charset=ISO-8859-1; blob-key=AHAZQqG84qllx7HUqO_oou5EvdYQNS3Mbbkb0RjjBoM_Kc1UqEN2ygDxWiyCPulIhpHRPx-VbpB6RX4MrsqhWAi_ZxJ48O9P2cTIACbvATHvg7IgbvZytyGMpL7xO1tlIvgwcM47JNfv_tGhy1XwyEUO8oldjPqg5Q"},
	 604  				"Content-Disposition": {"form-data; name=file; filename=\"fall.png\""},
	 605  			}, "Content-Type: image/png\r\nContent-Length: 232303\r\nX-AppEngine-Upload-Creation: 2012-05-10 23:14:02.715173\r\nContent-MD5: MzRjODU1ZDZhZGU1NmRlOWEwZmMwMDdlODBmZTA0NzA=\r\nContent-Disposition: form-data; name=file; filename=\"fall.png\"\r\n\r\n"},
	 606  		},
	 607  	},
	 608  
	 609  	// Single empty part, ended with --boundary immediately after headers.
	 610  	{
	 611  		name: "single empty part, --boundary",
	 612  		sep:	"abc",
	 613  		in:	 "--abc\r\nFoo: bar\r\n\r\n--abc--",
	 614  		want: []headerBody{
	 615  			{textproto.MIMEHeader{"Foo": {"bar"}}, ""},
	 616  		},
	 617  	},
	 618  
	 619  	// Single empty part, ended with \r\n--boundary immediately after headers.
	 620  	{
	 621  		name: "single empty part, \r\n--boundary",
	 622  		sep:	"abc",
	 623  		in:	 "--abc\r\nFoo: bar\r\n\r\n\r\n--abc--",
	 624  		want: []headerBody{
	 625  			{textproto.MIMEHeader{"Foo": {"bar"}}, ""},
	 626  		},
	 627  	},
	 628  
	 629  	// Final part empty.
	 630  	{
	 631  		name: "final part empty",
	 632  		sep:	"abc",
	 633  		in:	 "--abc\r\nFoo: bar\r\n\r\n--abc\r\nFoo2: bar2\r\n\r\n--abc--",
	 634  		want: []headerBody{
	 635  			{textproto.MIMEHeader{"Foo": {"bar"}}, ""},
	 636  			{textproto.MIMEHeader{"Foo2": {"bar2"}}, ""},
	 637  		},
	 638  	},
	 639  
	 640  	// Final part empty with newlines after final separator.
	 641  	{
	 642  		name: "final part empty then crlf",
	 643  		sep:	"abc",
	 644  		in:	 "--abc\r\nFoo: bar\r\n\r\n--abc--\r\n",
	 645  		want: []headerBody{
	 646  			{textproto.MIMEHeader{"Foo": {"bar"}}, ""},
	 647  		},
	 648  	},
	 649  
	 650  	// Final part empty with lwsp-chars after final separator.
	 651  	{
	 652  		name: "final part empty then lwsp",
	 653  		sep:	"abc",
	 654  		in:	 "--abc\r\nFoo: bar\r\n\r\n--abc-- \t",
	 655  		want: []headerBody{
	 656  			{textproto.MIMEHeader{"Foo": {"bar"}}, ""},
	 657  		},
	 658  	},
	 659  
	 660  	// No parts (empty form as submitted by Chrome)
	 661  	{
	 662  		name: "no parts",
	 663  		sep:	"----WebKitFormBoundaryQfEAfzFOiSemeHfA",
	 664  		in:	 "------WebKitFormBoundaryQfEAfzFOiSemeHfA--\r\n",
	 665  		want: []headerBody{},
	 666  	},
	 667  
	 668  	// Part containing data starting with the boundary, but with additional suffix.
	 669  	{
	 670  		name: "fake separator as data",
	 671  		sep:	"sep",
	 672  		in:	 "--sep\r\nFoo: bar\r\n\r\n--sepFAKE\r\n--sep--",
	 673  		want: []headerBody{
	 674  			{textproto.MIMEHeader{"Foo": {"bar"}}, "--sepFAKE"},
	 675  		},
	 676  	},
	 677  
	 678  	// Part containing a boundary with whitespace following it.
	 679  	{
	 680  		name: "boundary with whitespace",
	 681  		sep:	"sep",
	 682  		in:	 "--sep \r\nFoo: bar\r\n\r\ntext\r\n--sep--",
	 683  		want: []headerBody{
	 684  			{textproto.MIMEHeader{"Foo": {"bar"}}, "text"},
	 685  		},
	 686  	},
	 687  
	 688  	// With ignored leading line.
	 689  	{
	 690  		name: "leading line",
	 691  		sep:	"MyBoundary",
	 692  		in: strings.Replace(`This is a multi-part message.	This line is ignored.
	 693  --MyBoundary
	 694  foo: bar
	 695  
	 696  
	 697  --MyBoundary--`, "\n", "\r\n", -1),
	 698  		want: []headerBody{
	 699  			{textproto.MIMEHeader{"Foo": {"bar"}}, ""},
	 700  		},
	 701  	},
	 702  
	 703  	// Issue 10616; minimal
	 704  	{
	 705  		name: "issue 10616 minimal",
	 706  		sep:	"sep",
	 707  		in: "--sep \r\nFoo: bar\r\n\r\n" +
	 708  			"a\r\n" +
	 709  			"--sep_alt\r\n" +
	 710  			"b\r\n" +
	 711  			"\r\n--sep--",
	 712  		want: []headerBody{
	 713  			{textproto.MIMEHeader{"Foo": {"bar"}}, "a\r\n--sep_alt\r\nb\r\n"},
	 714  		},
	 715  	},
	 716  
	 717  	// Issue 10616; full example from bug.
	 718  	{
	 719  		name: "nested separator prefix is outer separator",
	 720  		sep:	"----=_NextPart_4c2fbafd7ec4c8bf08034fe724b608d9",
	 721  		in: strings.Replace(`------=_NextPart_4c2fbafd7ec4c8bf08034fe724b608d9
	 722  Content-Type: multipart/alternative; boundary="----=_NextPart_4c2fbafd7ec4c8bf08034fe724b608d9_alt"
	 723  
	 724  ------=_NextPart_4c2fbafd7ec4c8bf08034fe724b608d9_alt
	 725  Content-Type: text/plain; charset="utf-8"
	 726  Content-Transfer-Encoding: 8bit
	 727  
	 728  This is a multi-part message in MIME format.
	 729  
	 730  ------=_NextPart_4c2fbafd7ec4c8bf08034fe724b608d9_alt
	 731  Content-Type: text/html; charset="utf-8"
	 732  Content-Transfer-Encoding: 8bit
	 733  
	 734  html things
	 735  ------=_NextPart_4c2fbafd7ec4c8bf08034fe724b608d9_alt--
	 736  ------=_NextPart_4c2fbafd7ec4c8bf08034fe724b608d9--`, "\n", "\r\n", -1),
	 737  		want: []headerBody{
	 738  			{textproto.MIMEHeader{"Content-Type": {`multipart/alternative; boundary="----=_NextPart_4c2fbafd7ec4c8bf08034fe724b608d9_alt"`}},
	 739  				strings.Replace(`------=_NextPart_4c2fbafd7ec4c8bf08034fe724b608d9_alt
	 740  Content-Type: text/plain; charset="utf-8"
	 741  Content-Transfer-Encoding: 8bit
	 742  
	 743  This is a multi-part message in MIME format.
	 744  
	 745  ------=_NextPart_4c2fbafd7ec4c8bf08034fe724b608d9_alt
	 746  Content-Type: text/html; charset="utf-8"
	 747  Content-Transfer-Encoding: 8bit
	 748  
	 749  html things
	 750  ------=_NextPart_4c2fbafd7ec4c8bf08034fe724b608d9_alt--`, "\n", "\r\n", -1),
	 751  			},
	 752  		},
	 753  	},
	 754  	// Issue 12662: Check that we don't consume the leading \r if the peekBuffer
	 755  	// ends in '\r\n--separator-'
	 756  	{
	 757  		name: "peek buffer boundary condition",
	 758  		sep:	"00ffded004d4dd0fdf945fbdef9d9050cfd6a13a821846299b27fc71b9db",
	 759  		in: strings.Replace(`--00ffded004d4dd0fdf945fbdef9d9050cfd6a13a821846299b27fc71b9db
	 760  Content-Disposition: form-data; name="block"; filename="block"
	 761  Content-Type: application/octet-stream
	 762  
	 763  `+strings.Repeat("A", peekBufferSize-65)+"\n--00ffded004d4dd0fdf945fbdef9d9050cfd6a13a821846299b27fc71b9db--", "\n", "\r\n", -1),
	 764  		want: []headerBody{
	 765  			{textproto.MIMEHeader{"Content-Type": {`application/octet-stream`}, "Content-Disposition": {`form-data; name="block"; filename="block"`}},
	 766  				strings.Repeat("A", peekBufferSize-65),
	 767  			},
	 768  		},
	 769  	},
	 770  	// Issue 12662: Same test as above with \r\n at the end
	 771  	{
	 772  		name: "peek buffer boundary condition",
	 773  		sep:	"00ffded004d4dd0fdf945fbdef9d9050cfd6a13a821846299b27fc71b9db",
	 774  		in: strings.Replace(`--00ffded004d4dd0fdf945fbdef9d9050cfd6a13a821846299b27fc71b9db
	 775  Content-Disposition: form-data; name="block"; filename="block"
	 776  Content-Type: application/octet-stream
	 777  
	 778  `+strings.Repeat("A", peekBufferSize-65)+"\n--00ffded004d4dd0fdf945fbdef9d9050cfd6a13a821846299b27fc71b9db--\n", "\n", "\r\n", -1),
	 779  		want: []headerBody{
	 780  			{textproto.MIMEHeader{"Content-Type": {`application/octet-stream`}, "Content-Disposition": {`form-data; name="block"; filename="block"`}},
	 781  				strings.Repeat("A", peekBufferSize-65),
	 782  			},
	 783  		},
	 784  	},
	 785  	// Issue 12662v2: We want to make sure that for short buffers that end with
	 786  	// '\r\n--separator-' we always consume at least one (valid) symbol from the
	 787  	// peekBuffer
	 788  	{
	 789  		name: "peek buffer boundary condition",
	 790  		sep:	"aaaaaaaaaa00ffded004d4dd0fdf945fbdef9d9050cfd6a13a821846299b27fc71b9db",
	 791  		in: strings.Replace(`--aaaaaaaaaa00ffded004d4dd0fdf945fbdef9d9050cfd6a13a821846299b27fc71b9db
	 792  Content-Disposition: form-data; name="block"; filename="block"
	 793  Content-Type: application/octet-stream
	 794  
	 795  `+strings.Repeat("A", peekBufferSize)+"\n--aaaaaaaaaa00ffded004d4dd0fdf945fbdef9d9050cfd6a13a821846299b27fc71b9db--", "\n", "\r\n", -1),
	 796  		want: []headerBody{
	 797  			{textproto.MIMEHeader{"Content-Type": {`application/octet-stream`}, "Content-Disposition": {`form-data; name="block"; filename="block"`}},
	 798  				strings.Repeat("A", peekBufferSize),
	 799  			},
	 800  		},
	 801  	},
	 802  	// Context: https://github.com/camlistore/camlistore/issues/642
	 803  	// If the file contents in the form happens to have a size such as:
	 804  	// size = peekBufferSize - (len("\n--") + len(boundary) + len("\r") + 1), (modulo peekBufferSize)
	 805  	// then peekBufferSeparatorIndex was wrongly returning (-1, false), which was leading to an nCopy
	 806  	// cut such as:
	 807  	// "somedata\r| |\n--Boundary\r" (instead of "somedata| |\r\n--Boundary\r"), which was making the
	 808  	// subsequent Read miss the boundary.
	 809  	{
	 810  		name: "safeCount off by one",
	 811  		sep:	"08b84578eabc563dcba967a945cdf0d9f613864a8f4a716f0e81caa71a74",
	 812  		in: strings.Replace(`--08b84578eabc563dcba967a945cdf0d9f613864a8f4a716f0e81caa71a74
	 813  Content-Disposition: form-data; name="myfile"; filename="my-file.txt"
	 814  Content-Type: application/octet-stream
	 815  
	 816  `, "\n", "\r\n", -1) +
	 817  			strings.Repeat("A", peekBufferSize-(len("\n--")+len("08b84578eabc563dcba967a945cdf0d9f613864a8f4a716f0e81caa71a74")+len("\r")+1)) +
	 818  			strings.Replace(`
	 819  --08b84578eabc563dcba967a945cdf0d9f613864a8f4a716f0e81caa71a74
	 820  Content-Disposition: form-data; name="key"
	 821  
	 822  val
	 823  --08b84578eabc563dcba967a945cdf0d9f613864a8f4a716f0e81caa71a74--
	 824  `, "\n", "\r\n", -1),
	 825  		want: []headerBody{
	 826  			{textproto.MIMEHeader{"Content-Type": {`application/octet-stream`}, "Content-Disposition": {`form-data; name="myfile"; filename="my-file.txt"`}},
	 827  				strings.Repeat("A", peekBufferSize-(len("\n--")+len("08b84578eabc563dcba967a945cdf0d9f613864a8f4a716f0e81caa71a74")+len("\r")+1)),
	 828  			},
	 829  			{textproto.MIMEHeader{"Content-Disposition": {`form-data; name="key"`}},
	 830  				"val",
	 831  			},
	 832  		},
	 833  	},
	 834  
	 835  	roundTripParseTest(),
	 836  }
	 837  
	 838  func TestParse(t *testing.T) {
	 839  Cases:
	 840  	for _, tt := range parseTests {
	 841  		r := NewReader(strings.NewReader(tt.in), tt.sep)
	 842  		got := []headerBody{}
	 843  		for {
	 844  			p, err := r.NextPart()
	 845  			if err == io.EOF {
	 846  				break
	 847  			}
	 848  			if err != nil {
	 849  				t.Errorf("in test %q, NextPart: %v", tt.name, err)
	 850  				continue Cases
	 851  			}
	 852  			pbody, err := io.ReadAll(p)
	 853  			if err != nil {
	 854  				t.Errorf("in test %q, error reading part: %v", tt.name, err)
	 855  				continue Cases
	 856  			}
	 857  			got = append(got, headerBody{p.Header, string(pbody)})
	 858  		}
	 859  		if !reflect.DeepEqual(tt.want, got) {
	 860  			t.Errorf("test %q:\n got: %v\nwant: %v", tt.name, got, tt.want)
	 861  			if len(tt.want) != len(got) {
	 862  				t.Errorf("test %q: got %d parts, want %d", tt.name, len(got), len(tt.want))
	 863  			} else if len(got) > 1 {
	 864  				for pi, wantPart := range tt.want {
	 865  					if !reflect.DeepEqual(wantPart, got[pi]) {
	 866  						t.Errorf("test %q, part %d:\n got: %v\nwant: %v", tt.name, pi, got[pi], wantPart)
	 867  					}
	 868  				}
	 869  			}
	 870  		}
	 871  	}
	 872  }
	 873  
	 874  func partsFromReader(r *Reader) ([]headerBody, error) {
	 875  	got := []headerBody{}
	 876  	for {
	 877  		p, err := r.NextPart()
	 878  		if err == io.EOF {
	 879  			return got, nil
	 880  		}
	 881  		if err != nil {
	 882  			return nil, fmt.Errorf("NextPart: %v", err)
	 883  		}
	 884  		pbody, err := io.ReadAll(p)
	 885  		if err != nil {
	 886  			return nil, fmt.Errorf("error reading part: %v", err)
	 887  		}
	 888  		got = append(got, headerBody{p.Header, string(pbody)})
	 889  	}
	 890  }
	 891  
	 892  func TestParseAllSizes(t *testing.T) {
	 893  	t.Parallel()
	 894  	maxSize := 5 << 10
	 895  	if testing.Short() {
	 896  		maxSize = 512
	 897  	}
	 898  	var buf bytes.Buffer
	 899  	body := strings.Repeat("a", maxSize)
	 900  	bodyb := []byte(body)
	 901  	for size := 0; size < maxSize; size++ {
	 902  		buf.Reset()
	 903  		w := NewWriter(&buf)
	 904  		part, _ := w.CreateFormField("f")
	 905  		part.Write(bodyb[:size])
	 906  		part, _ = w.CreateFormField("key")
	 907  		part.Write([]byte("val"))
	 908  		w.Close()
	 909  		r := NewReader(&buf, w.Boundary())
	 910  		got, err := partsFromReader(r)
	 911  		if err != nil {
	 912  			t.Errorf("For size %d: %v", size, err)
	 913  			continue
	 914  		}
	 915  		if len(got) != 2 {
	 916  			t.Errorf("For size %d, num parts = %d; want 2", size, len(got))
	 917  			continue
	 918  		}
	 919  		if got[0].body != body[:size] {
	 920  			t.Errorf("For size %d, got unexpected len %d: %q", size, len(got[0].body), got[0].body)
	 921  		}
	 922  	}
	 923  }
	 924  
	 925  func roundTripParseTest() parseTest {
	 926  	t := parseTest{
	 927  		name: "round trip",
	 928  		want: []headerBody{
	 929  			formData("empty", ""),
	 930  			formData("lf", "\n"),
	 931  			formData("cr", "\r"),
	 932  			formData("crlf", "\r\n"),
	 933  			formData("foo", "bar"),
	 934  		},
	 935  	}
	 936  	var buf bytes.Buffer
	 937  	w := NewWriter(&buf)
	 938  	for _, p := range t.want {
	 939  		pw, err := w.CreatePart(p.header)
	 940  		if err != nil {
	 941  			panic(err)
	 942  		}
	 943  		_, err = pw.Write([]byte(p.body))
	 944  		if err != nil {
	 945  			panic(err)
	 946  		}
	 947  	}
	 948  	w.Close()
	 949  	t.in = buf.String()
	 950  	t.sep = w.Boundary()
	 951  	return t
	 952  }
	 953  
	 954  func TestNoBoundary(t *testing.T) {
	 955  	mr := NewReader(strings.NewReader(""), "")
	 956  	_, err := mr.NextPart()
	 957  	if got, want := fmt.Sprint(err), "multipart: boundary is empty"; got != want {
	 958  		t.Errorf("NextPart error = %v; want %v", got, want)
	 959  	}
	 960  }
	 961  

View as plain text