package multipart
Import Path
mime/multipart (on go.dev)
Dependency Relation
imports 17 packages, and imported by one package
Involved Source Files
formdata.go
Package multipart implements MIME multipart parsing, as defined in RFC
2046.
The implementation is sufficient for HTTP (RFC 2388) and the multipart
bodies generated by popular browsers.
# Limits
To protect against malicious inputs, this package sets limits on the size
of the MIME data it processes.
[Reader.NextPart] and [Reader.NextRawPart] limit the number of headers in a
part to 10000 and [Reader.ReadForm] limits the total number of headers in all
FileHeaders to 10000.
These limits may be adjusted with the GODEBUG=multipartmaxheaders=<values>
setting.
Reader.ReadForm further limits the number of parts in a form to 1000.
This limit may be adjusted with the GODEBUG=multipartmaxparts=<value>
setting.
readmimeheader.go
writer.go
Code Examples
package main
import (
"fmt"
"io"
"log"
"mime"
"mime/multipart"
"net/mail"
"strings"
)
func main() {
msg := &mail.Message{
Header: map[string][]string{
"Content-Type": {"multipart/mixed; boundary=foo"},
},
Body: strings.NewReader(
"--foo\r\nFoo: one\r\n\r\nA section\r\n" +
"--foo\r\nFoo: two\r\n\r\nAnd another\r\n" +
"--foo--\r\n"),
}
mediaType, params, err := mime.ParseMediaType(msg.Header.Get("Content-Type"))
if err != nil {
log.Fatal(err)
}
if strings.HasPrefix(mediaType, "multipart/") {
mr := multipart.NewReader(msg.Body, params["boundary"])
for {
p, err := mr.NextPart()
if err == io.EOF {
return
}
if err != nil {
log.Fatal(err)
}
slurp, err := io.ReadAll(p)
if err != nil {
log.Fatal(err)
}
fmt.Printf("Part %q: %q\n", p.Header.Get("Foo"), slurp)
}
}
}
Package-Level Type Names (total 6)
File is an interface to access the file part of a multipart message.
Its contents may be either stored in memory or on disk.
If stored on disk, the File's underlying concrete type will be an *os.File.
( File) Close() error
( File) Read(p []byte) (n int, err error)
( File) ReadAt(p []byte, off int64) (n int, err error)
( File) Seek(offset int64, whence int) (int64, error)
*os.File
File : io.Closer
File : io.ReadCloser
File : io.Reader
File : io.ReaderAt
File : io.ReadSeekCloser
File : io.ReadSeeker
File : io.Seeker
func (*FileHeader).Open() (File, error)
func net/http.(*Request).FormFile(key string) (File, *FileHeader, error)
A FileHeader describes a file part of a multipart request.
Filename string
Header textproto.MIMEHeader
Size int64
Open opens and returns the [FileHeader]'s associated File.
func net/http.(*Request).FormFile(key string) (File, *FileHeader, error)
Form is a parsed multipart form.
Its File parts are stored either in memory or on disk,
and are accessible via the [*FileHeader]'s Open method.
Its Value parts are stored as strings.
Both are keyed by field name.
File map[string][]*FileHeader
Value map[string][]string
RemoveAll removes any temporary files associated with a [Form].
func (*Reader).ReadForm(maxMemory int64) (*Form, error)
A Part represents a single part in a multipart body.
The headers of the body, if any, with the keys canonicalized
in the same fashion that the Go http.Request headers are.
For example, "foo-bar" changes case to "Foo-Bar"
(*Part) Close() error
FileName returns the filename parameter of the [Part]'s Content-Disposition
header. If not empty, the filename is passed through filepath.Base (which is
platform dependent) before being returned.
FormName returns the name parameter if p has a Content-Disposition
of type "form-data". Otherwise it returns the empty string.
Read reads the body of a part, after its headers and before the
next part (if any) begins.
*Part : io.Closer
*Part : io.ReadCloser
*Part : io.Reader
func (*Reader).NextPart() (*Part, error)
func (*Reader).NextRawPart() (*Part, error)
Reader is an iterator over parts in a MIME multipart body.
Reader's underlying parser consumes its input as needed. Seeking
isn't supported.
NextPart returns the next part in the multipart or an error.
When there are no more parts, the error [io.EOF] is returned.
As a special case, if the "Content-Transfer-Encoding" header
has a value of "quoted-printable", that header is instead
hidden and the body is transparently decoded during Read calls.
NextRawPart returns the next part in the multipart or an error.
When there are no more parts, the error [io.EOF] is returned.
Unlike [Reader.NextPart], it does not have special handling for
"Content-Transfer-Encoding: quoted-printable".
ReadForm parses an entire multipart message whose parts have
a Content-Disposition of "form-data".
It stores up to maxMemory bytes + 10MB (reserved for non-file parts)
in memory. File parts which can't be stored in memory will be stored on
disk in temporary files.
It returns [ErrMessageTooLarge] if all non-file parts can't be stored in
memory.
func NewReader(r io.Reader, boundary string) *Reader
func net/http.(*Request).MultipartReader() (*Reader, error)
A Writer generates multipart messages.
Boundary returns the [Writer]'s boundary.
Close finishes the multipart message and writes the trailing
boundary end line to the output.
CreateFormField calls [Writer.CreatePart] with a header using the
given field name.
CreateFormFile is a convenience wrapper around [Writer.CreatePart]. It creates
a new form-data header with the provided field name and file name.
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.
FormDataContentType returns the Content-Type for an HTTP
multipart/form-data with this [Writer]'s Boundary.
SetBoundary overrides the [Writer]'s default randomly-generated
boundary separator with an explicit value.
SetBoundary must be called before any parts are created, may only
contain certain ASCII characters, and must be non-empty and
at most 70 bytes long.
WriteField calls [Writer.CreateFormField] and then writes the given value.
*Writer : io.Closer
func NewWriter(w io.Writer) *Writer
Package-Level Functions (total 2)
NewReader creates a new multipart [Reader] reading from r using the
given MIME boundary.
The boundary is usually obtained from the "boundary" parameter of
the message's "Content-Type" header. Use [mime.ParseMediaType] to
parse such headers.
NewWriter returns a new multipart [Writer] with a random boundary,
writing to w.
Package-Level Variables (only one)
ErrMessageTooLarge is returned by ReadForm if the message form
data is too large to be processed.
 |
The pages are generated with Golds v0.7.0-preview. (GOOS=linux GOARCH=amd64) Golds is a Go 101 project developed by Tapir Liu. PR and bug reports are welcome and can be submitted to the issue list. Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds. |