Subversion Repositories openrisc

// 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"
        "errors"
        "io"
        "io/ioutil"
        "net/textproto"
        "os"
)

// TODO(adg,bradfitz): find a way to unify the DoS-prevention strategy here
// with that of the http package's ParseForm.

// ReadForm parses an entire multipart message whose parts have
// a Content-Disposition of "form-data".
// It stores up to maxMemory bytes of the file parts in memory
// and the remainder on disk in temporary files.
func (r *Reader) ReadForm(maxMemory int64) (f *Form, err error) {
        form := &Form{make(map[string][]string), make(map[string][]*FileHeader)}
        defer func() {
                if err != nil {
                        form.RemoveAll()
                }
        }()

        maxValueBytes := int64(10 << 20) // 10 MB is a lot of text.
        for {
                p, err := r.NextPart()
                if err == io.EOF {
                        break
                }
                if err != nil {
                        return nil, err
                }

                name := p.FormName()
                if name == "" {
                        continue
                }
                filename := p.FileName()

                var b bytes.Buffer

                if filename == "" {
                        // value, store as string in memory
                        n, err := io.CopyN(&b, p, maxValueBytes)
                        if err != nil && err != io.EOF {
                                return nil, err
                        }
                        maxValueBytes -= n
                        if maxValueBytes == 0 {
                                return nil, errors.New("multipart: message too large")
                        }
                        form.Value[name] = append(form.Value[name], b.String())
                        continue
                }

                // file, store in memory or on disk
                fh := &FileHeader{
                        Filename: filename,
                        Header:   p.Header,
                }
                n, err := io.CopyN(&b, p, maxMemory+1)
                if err != nil && err != io.EOF {
                        return nil, err
                }
                if n > maxMemory {
                        // too big, write to disk and flush buffer
                        file, err := ioutil.TempFile("", "multipart-")
                        if err != nil {
                                return nil, err
                        }
                        defer file.Close()
                        _, err = io.Copy(file, io.MultiReader(&b, p))
                        if err != nil {
                                os.Remove(file.Name())
                                return nil, err
                        }
                        fh.tmpfile = file.Name()
                } else {
                        fh.content = b.Bytes()
                        maxMemory -= n
                }
                form.File[name] = append(form.File[name], fh)
        }

        return form, nil
}

// 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
}

// RemoveAll removes any temporary files associated with a Form.
func (f *Form) RemoveAll() error {
        var err error
        for _, fhs := range f.File {
                for _, fh := range fhs {
                        if fh.tmpfile != "" {
                                e := os.Remove(fh.tmpfile)
                                if e != nil && err == nil {
                                        err = e
                                }
                        }
                }
        }
        return err
}

// A FileHeader describes a file part of a multipart request.
type FileHeader struct {
        Filename string
        Header   textproto.MIMEHeader

        content []byte
        tmpfile string
}

// Open opens and returns the FileHeader's associated File.
func (fh *FileHeader) Open() (File, error) {
        if b := fh.content; b != nil {
                r := io.NewSectionReader(sliceReaderAt(b), 0, int64(len(b)))
                return sectionReadCloser{r}, nil
        }
        return os.Open(fh.tmpfile)
}

// 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.
type File interface {
        io.Reader
        io.ReaderAt
        io.Seeker
        io.Closer
}

// helper types to turn a []byte into a File

type sectionReadCloser struct {
        *io.SectionReader
}

func (rc sectionReadCloser) Close() error {
        return nil
}

type sliceReaderAt []byte

func (r sliceReaderAt) ReadAt(b []byte, off int64) (int, error) {
        if int(off) >= len(r) || off < 0 {
                return 0, io.ErrUnexpectedEOF
        }
        n := copy(b, r[int(off):])
        return n, nil
}