"bytes"
"errors"
"internal/godebug"
"io"
"math"
"net/textproto"
"os"
"strconv"
"bufio"
"bytes"
"fmt"
"internal/godebug"
"io"
"mime"
"mime/quotedprintable"
"net/textproto"
"path/filepath"
"strconv"
"strings"
"net/textproto"
_ "unsafe"
"bytes"
"crypto/rand"
"errors"
"fmt"
"io"
"maps"
"net/textproto"
"slices"
"strings"
ErrMessageTooLarge is returned by ReadForm if the message form data is too large to be processed.
var ErrMessageTooLarge = *ast.CallExprvar emptyParams = *ast.CallExprmaxMIMEHeaderSize is the maximum size of a MIME header we will parse, including header keys, values, and map overhead.
const maxMIMEHeaderSize = *ast.BinaryExprvar multipartfiles = *ast.CallExprmultipartmaxheaders is the maximum number of header entries NextPart will return, as well as the maximum combined total of header entries Reader.ReadForm will return in FileHeaders.
var multipartmaxheaders = *ast.CallExprvar multipartmaxparts = *ast.CallExprThis constant needs to be at least 76 for this package to work correctly. This is because \r\n--separator_of_len_70- would fill the buffer and it wouldn't be safe to consume a single byte from it.
const peekBufferSize = 4096var quoteEscaper = *ast.CallExprFile 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.
type File interface {
io.Reader
io.ReaderAt
io.Seeker
io.Closer
}A FileHeader describes a file part of a multipart request.
type FileHeader struct {
Filename string
Header textproto.MIMEHeader
Size int64
content []byte
tmpfile string
tmpoff int64
tmpshared bool
}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.
type Form struct {
Value map[string][]string
File map[string][]*FileHeader
}A Part represents a single part in a multipart body.
type Part struct {
Header textproto.MIMEHeader
mr *Reader
disposition string
dispositionParams map[string]string
r io.Reader
n int
total int64
err error
readErr 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.
type Reader struct {
bufReader *bufio.Reader
tempDir string
currentPart *Part
partsRead int
nl []byte
nlDashBoundary []byte
dashBoundaryDash []byte
dashBoundary []byte
}A Writer generates multipart messages.
type Writer struct {
w io.Writer
boundary string
lastpart *part
}type part struct {
mw *Writer
closed bool
we error
}partReader implements io.Reader by reading raw bytes directly from the wrapped *Part, without doing any Transfer-Encoding decoding.
type partReader struct {
p *Part
}type sectionReadCloser struct {
*io.SectionReader
io.Closer
}stickyErrorReader is an io.Reader which never calls Read on its underlying Reader once an error has been seen. (the io.Reader interface's contract promises nothing about the return values of Read calls after an error, yet this package does do multiple Reads after error)
type stickyErrorReader struct {
r io.Reader
err error
}Boundary returns the [Writer]'s boundary.
func (w *Writer) Boundary() stringfunc (p *Part) Close() errorClose finishes the multipart message and writes the trailing boundary end line to the output.
func (w *Writer) Close() errorfunc (rc sectionReadCloser) Close() errorCreateFormField calls [Writer.CreatePart] with a header using the given field name.
func (w *Writer) CreateFormField(fieldname string) (io.Writer, error)CreateFormFile is a convenience wrapper around [Writer.CreatePart]. It creates a new form-data header with the provided field name and file name.
func (w *Writer) CreateFormFile(fieldname string, filename string) (io.Writer, error)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, 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.
func (p *Part) FileName() stringFormDataContentType returns the Content-Type for an HTTP multipart/form-data with this [Writer]'s Boundary.
func (w *Writer) FormDataContentType() stringFormName returns the name parameter if p has a Content-Disposition of type "form-data". Otherwise it returns the empty string.
func (p *Part) FormName() stringNewReader 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.
func NewReader(r io.Reader, boundary string) *ReaderNewWriter returns a new multipart [Writer] with a random boundary, writing to w.
func NewWriter(w io.Writer) *WriterNextPart 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.
func (r *Reader) NextPart() (*Part, error)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".
func (r *Reader) NextRawPart() (*Part, error)Open opens and returns the [FileHeader]'s associated File.
func (fh *FileHeader) Open() (File, error)Read reads the body of a part, after its headers and before the next part (if any) begins.
func (p *Part) Read(d []byte) (n int, err error)func (pr partReader) Read(d []byte) (int, error)func (r *stickyErrorReader) Read(p []byte) (n int, _ error)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 (r *Reader) ReadForm(maxMemory int64) (*Form, error)RemoveAll removes any temporary files associated with a [Form].
func (f *Form) RemoveAll() errorSetBoundary 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.
func (w *Writer) SetBoundary(boundary string) errorfunc (p *part) Write(d []byte) (n int, err error)WriteField calls [Writer.CreateFormField] and then writes the given value.
func (w *Writer) WriteField(fieldname string, value string) errorfunc (p *part) close() errorfunc escapeQuotes(s string) stringfunc (r *Reader) isBoundaryDelimiterLine(line []byte) (ret bool)isFinalBoundary reports whether line is the final boundary line indicating that all parts are over. It matches `^--boundary--[ \t]*(\r\n)?$`
func (r *Reader) isFinalBoundary(line []byte) boolmatchAfterPrefix checks whether buf should be considered to match the boundary. The prefix is "--boundary" or "\r\n--boundary" or "\n--boundary", and the caller has verified already that bytes.HasPrefix(buf, prefix) is true. matchAfterPrefix returns +1 if the buffer does match the boundary, meaning the prefix is followed by a double dash, space, tab, cr, nl, or end of input. It returns -1 if the buffer definitely does NOT match the boundary, meaning the prefix is followed by some other character. For example, "--foobar" does not match "--foo". It returns 0 more input needs to be read to make the decision, meaning that len(buf) == len(prefix) and readErr == nil.
func matchAfterPrefix(buf []byte, prefix []byte, readErr error) intfunc maxMIMEHeaders() int64func mimeHeaderSize(h textproto.MIMEHeader) (size int64)func newPart(mr *Reader, rawPart bool, maxMIMEHeaderSize int64, maxMIMEHeaders int64) (*Part, error)func (r *Reader) nextPart(rawPart bool, maxMIMEHeaderSize int64, maxMIMEHeaders int64) (*Part, error)func (p *Part) parseContentDisposition()func (p *Part) populateHeaders(maxMIMEHeaderSize int64, maxMIMEHeaders int64) errorfunc randomBoundary() stringfunc (r *Reader) readForm(maxMemory int64) (_ *Form, err error)readMIMEHeader is defined in package [net/textproto]. go:linkname readMIMEHeader net/textproto.readMIMEHeader
func readMIMEHeader(r *textproto.Reader, maxMemory int64, maxHeaders int64) (textproto.MIMEHeader, error)scanUntilBoundary scans buf to identify how much of it can be safely returned as part of the Part body. dashBoundary is "--boundary". nlDashBoundary is "\r\n--boundary" or "\n--boundary", depending on what mode we are in. The comments below (and the name) assume "\n--boundary", but either is accepted. total is the number of bytes read out so far. If total == 0, then a leading "--boundary" is recognized. readErr is the read error, if any, that followed reading the bytes in buf. scanUntilBoundary returns the number of data bytes from buf that can be returned as part of the Part body and also the error to return (if any) once those data bytes are done.
func scanUntilBoundary(buf []byte, dashBoundary []byte, nlDashBoundary []byte, total int64, readErr error) (int, error)skipLWSPChar returns b with leading spaces and tabs removed. RFC 822 defines: LWSP-char = SPACE / HTAB
func skipLWSPChar(b []byte) []byteGenerated with Arrow