Golang multipart.Reader类代码示例

func LargeFileStream(r *multipart.Reader) {
	p, err := r.NextPart()
	if err == io.EOF {
		return
	}

	file, err := os.OpenFile(p.FileName(), os.O_CREATE|os.O_TRUNC|os.O_RDWR, 0644)
	if err != nil {
		return
	}
	defer file.Close()

	for {
		err := WriteFileChunk(p, file)
		if err == io.EOF {
			return
		}
	}

	for {
		p, err := r.NextPart()
		if err == io.EOF {
			return
		}

		for {
			err := WriteFileChunk(p, file)
			if err == io.EOF {
				break
			}
		}
	}
	return
}

func extractHTTPFormValues(reader *multipart.Reader) (io.Reader, map[string]string, *probe.Error) {
	/// HTML Form values
	formValues := make(map[string]string)
	filePart := new(bytes.Buffer)
	var err error
	for err == nil {
		var part *multipart.Part
		part, err = reader.NextPart()
		if part != nil {
			if part.FileName() == "" {
				buffer, err := ioutil.ReadAll(part)
				if err != nil {
					return nil, nil, probe.NewError(err)
				}
				formValues[http.CanonicalHeaderKey(part.FormName())] = string(buffer)
			} else {
				_, err := io.Copy(filePart, part)
				if err != nil {
					return nil, nil, probe.NewError(err)
				}
			}
		}
	}
	return filePart, formValues, nil
}

// Extract form fields and file data from a HTTP POST Policy
func extractPostPolicyFormValues(reader *multipart.Reader) (filePart io.Reader, fileName string, formValues map[string]string, err error) {
	/// HTML Form values
	formValues = make(map[string]string)
	fileName = ""
	for err == nil {
		var part *multipart.Part
		part, err = reader.NextPart()
		if part != nil {
			canonicalFormName := http.CanonicalHeaderKey(part.FormName())
			if canonicalFormName != "File" {
				var buffer []byte
				limitReader := io.LimitReader(part, maxFormFieldSize+1)
				buffer, err = ioutil.ReadAll(limitReader)
				if err != nil {
					return nil, "", nil, err
				}
				if int64(len(buffer)) > maxFormFieldSize {
					return nil, "", nil, errSizeUnexpected
				}
				formValues[canonicalFormName] = string(buffer)
			} else {
				filePart = part
				fileName = part.FileName()
				// As described in S3 spec, we expect file to be the last form field
				break
			}
		}
	}
	return filePart, fileName, formValues, nil
}

func parseMultipartContent(content, boundary string) (Content, error) {
	var (
		reader *multipart.Reader = multipart.NewReader(strings.NewReader(content),
			boundary)
		part       *multipart.Part
		mailParts  Content = make(Content, 1)
		partHeader PMIMEHeader
		err        error
	)
	for {
		if part, err = reader.NextPart(); err == io.EOF {
			// 1) EOF error means, we're finished reading the multiparts
			break
		} else if err != nil {
			// 2) other errors are real => print a warning for that part and continue with the next
			fmt.Printf("[watney] WARNING: Couldn't parse multipart 'Part' Header & Content: %s\n",
				err.Error())
			continue
		}
		// 3) Try to read the content of this multipart body ...
		if readBytes, err := ioutil.ReadAll(part); err != nil {
			fmt.Printf("[watney] WARNING: Couldn't read multipart body content: %s\n", err.Error())
			continue
		} else {
			// 4) The body of this part has been successfully parsed => extract content
			if partHeader = parseMIMEHeader(part.Header); len(partHeader.ContentType) > 0 {
				// 5) We got a Content-Type, check if that one is multipart again
				if strings.Contains(partHeader.ContentType, "multipart") {
					// 5a) It is multipart => recursively add its parts
					if innerParts, err := parseMultipartContent(string(readBytes),
						partHeader.MultipartBoundary); err != nil {
						fmt.Printf("[watney] WARNING: Couldn't parse inner multipart body: %s\n",
							err.Error())
						continue
					} else {
						for key, value := range innerParts {
							mailParts[key] = value
						}
					}
				} else {
					// 5b) We have a content type other than multipart, just add it
					mailParts[partHeader.ContentType] = ContentPart{
						Encoding: partHeader.Encoding,
						Charset:  "UTF-8",
						Body:     string(readBytes),
					}
				}
			} else {
				// 4b) This part has no MIME information -> assume text/plain
				// ATTENTION: We're overwriting previously parsed text/plain parts
				mailParts["text/plain"] = ContentPart{
					Encoding: "quoted-printable",
					Charset:  "UTF-8",
					Body:     string(readBytes),
				}
			}
		}
	}
	return mailParts, nil
}

func (r *Resumable) MakeChunk(reader *multipart.Reader) (*Chunk, error) {
	var total int64 = 0
	chunk := &Chunk{Body: make([]byte, 0), Extra: make(map[string]string)}
	for {
		part, err := reader.NextPart()
		if err == io.EOF {
			break
		}
		if err != nil {
			return nil, err
		}
		name := part.FormName()
		switch name {
		case r.OffsetParamName:
			v, err := ConsumePart(part, 8, ConsumeInt)
			if err != nil {
				return nil, errors.New(err.Error() + " (" + name + ")")
			}
			chunk.Offset = v.(int64)
			break
		case r.TotalParamName:
			v, err := ConsumePart(part, 8, ConsumeInt)
			if err != nil {
				return nil, errors.New(err.Error() + " (" + name + ")")
			}
			total = v.(int64)
			break
		case r.UploadIdParamName:
			v, err := ConsumePart(part, 1024, ConsumeString)
			if err != nil {
				return nil, errors.New(err.Error() + " (" + name + ")")
			}
			chunk.UploadId = v.(string)
			break
		case r.FileParamName:
			chunk.Filename = part.FileName()
			err = r.ReadBody(part, chunk)
			if err != nil {
				return nil, errors.New(err.Error() + " (" + name + ")")
			}
			break
		default:
			v, err := ConsumePart(part, 1024, ConsumeString)
			if err != nil {
				return nil, errors.New(err.Error() + " (" + name + ")")
			}
			chunk.Extra[name] = v.(string)
			break
		}
	}
	if len(chunk.UploadId) == 0 {
		return nil, errors.New("empty" + " (" + r.UploadIdParamName + ")")
	}
	if len(chunk.Filename) == 0 {
		return nil, errors.New("empty" + " (filename)")
	}
	chunk.Final = chunk.Offset+int64(len(chunk.Body)) >= total
	return chunk, nil
}

func formToMap(c *check.C, mr *multipart.Reader) map[string]string {
	formData := map[string]string{}
	for {
		p, err := mr.NextPart()
		if err == io.EOF {
			break
		}
		c.Assert(err, check.IsNil)
		slurp, err := ioutil.ReadAll(p)
		c.Assert(err, check.IsNil)
		formData[p.FormName()] = string(slurp)
	}
	return formData
}

// OpenStream sends request to target and handles
// response. It opens MJPEG-stream and copies received
// frame to m.curImg. It closes stream if m.CloseStream()
// is called or if difference between current time and
// time of last request to ServeHTTP is bigger than timeout.
func (m *Mjpegproxy) openstream(mjpegStream, user, pass string, timeout time.Duration) {
	m.setRunning(true)
	m.conChan = make(chan time.Time)
	m.mjpegStream = mjpegStream
	var lastconn time.Time
	var img *multipart.Part

	request, err := http.NewRequest("GET", mjpegStream, nil)
	if err != nil {
		log.Fatal(m.mjpegStream, err)
	}
	if user != "" && pass != "" {
		request.SetBasicAuth(user, pass)
	}
	var response *http.Response
	var boundary string
	var mpread *multipart.Reader
	var starttime time.Time
	buf := new(bytes.Buffer)

	log.Println("Starting streaming from", mjpegStream)

	for m.GetRunning() {
		lastconn = <-m.conChan
		m.lastConnLock.Lock()
		m.lastConn = lastconn
		m.lastConnLock.Unlock()
		if !m.GetRunning() {
			continue
		}

		response, err = m.getresponse(request)
		if err != nil {
			log.Println(m.mjpegStream, err)
			time.Sleep(m.waittime)
			continue
		}
		starttime = time.Now()
		boundary, err = m.getboundary(response)

		if err != nil {
			log.Println(m.mjpegStream, err)
			response.Body.Close()
			time.Sleep(m.waittime)
			continue
		}
		mpread = multipart.NewReader(response.Body, boundary)
		for m.GetRunning() && (time.Since(lastconn) < timeout) && err == nil {
			if time.Since(starttime) > m.responseduration {
				break
			}
			if time.Since(lastconn) > timeout/2 {
				m.lastConnLock.RLock()
				lastconn = m.lastConn
				m.lastConnLock.RUnlock()
			}
			img, err = mpread.NextPart()
			if err != nil {
				log.Println(m.mjpegStream, err)
				break
			}
			// buf is an additional buffer that allows
			// serving curImg while loading next part.
			buf.Reset()
			_, err = buf.ReadFrom(io.LimitReader(img, m.partbufsize))
			if err != nil {
				img.Close()
				log.Println(m.mjpegStream, err)
				break
			}
			if m.caching {
				m.lastModLock.Lock()
				m.lastModified = time.Now().UTC()
				m.lastModLock.Unlock()
			}
			m.curImgLock.Lock()
			m.curImg.Reset()
			_, err = m.curImg.ReadFrom(buf)
			m.curImgLock.Unlock()
			img.Close()
			if err != nil {
				log.Println(m.mjpegStream, err)
				break
			}
		}
		response.Body.Close()
		time.Sleep(m.waittime)
	}
	log.Println("Stopped streaming from", mjpegStream)
}

func ReadMultipartDocument(reader *multipart.Reader) (Body, error) {
	// First read the main JSON document body:
	mainPart, err := reader.NextPart()
	if err != nil {
		return nil, err
	}
	var body Body
	err = ReadJSONFromMIME(http.Header(mainPart.Header), mainPart, &body)
	mainPart.Close()
	if err != nil {
		return nil, err
	}

	digestIndex := map[string]string{} // maps digests -> names

	// Now look for "following" attachments:
	attachments := BodyAttachments(body)
	for name, value := range attachments {
		meta := value.(map[string]interface{})
		if meta["follows"] == true {
			digest, ok := meta["digest"].(string)
			if !ok {
				return nil, &base.HTTPError{http.StatusBadRequest, "Missing digest in attachment"}
			}
			digestIndex[digest] = name
		}
	}

	// Read the parts one by one:
	for i := 0; i < len(digestIndex); i++ {
		part, err := reader.NextPart()
		if err != nil {
			if err == io.EOF {
				err = &base.HTTPError{http.StatusBadRequest, "Too few MIME parts"}
			}
			return nil, err
		}
		data, err := ioutil.ReadAll(part)
		part.Close()
		if err != nil {
			return nil, err
		}

		// Look up the attachment by its digest:
		digest := sha1DigestKey(data)
		name, ok := digestIndex[digest]
		if !ok {
			name, ok = digestIndex[md5DigestKey(data)]
		}
		if !ok {
			return nil, &base.HTTPError{http.StatusBadRequest,
				fmt.Sprintf("MIME part #%d doesn't match any attachment", i+2)}
		}

		meta := attachments[name].(map[string]interface{})
		length, ok := meta["encoded_length"].(float64)
		if !ok {
			length, ok = meta["length"].(float64)
		}
		if ok {
			if int(length) != len(data) {
				return nil, &base.HTTPError{http.StatusBadRequest, fmt.Sprintf("Attachment length mismatch for %q: read %d bytes, should be %g", name, len(data), length)}
			}
		}

		delete(meta, "follows")
		meta["data"] = data
		meta["digest"] = digest
	}

	// Make sure there are no unused MIME parts:
	_, err = reader.NextPart()
	if err != io.EOF {
		return nil, &base.HTTPError{http.StatusBadRequest, "Too many MIME parts"}
	}

	return body, nil
}

func ReadMultipartDocument(reader *multipart.Reader) (Body, error) {
	// First read the main JSON document body:
	mainPart, err := reader.NextPart()
	if err != nil {
		return nil, err
	}
	var body Body
	err = ReadJSONFromMIME(http.Header(mainPart.Header), mainPart, &body)
	mainPart.Close()
	if err != nil {
		return nil, err
	}

	// Collect the attachments with a "follows" property, which will appear as MIME parts:
	followingAttachments := map[string]map[string]interface{}{}
	for name, value := range BodyAttachments(body) {
		if meta := value.(map[string]interface{}); meta["follows"] == true {
			followingAttachments[name] = meta
		}
	}

	// Subroutine to look up a following attachment given its digest. (I used to precompute a
	// map from digest->name, which was faster, but that broke down if there were multiple
	// attachments with the same contents! See #96)
	findFollowingAttachment := func(withDigest string) (string, map[string]interface{}) {
		for name, meta := range followingAttachments {
			if meta["follows"] == true {
				if digest, ok := meta["digest"].(string); ok && digest == withDigest {
					return name, meta
				}
			}
		}
		return "", nil
	}

	// Read the parts one by one:
	for i := 0; i < len(followingAttachments); i++ {
		part, err := reader.NextPart()
		if err != nil {
			if err == io.EOF {
				err = base.HTTPErrorf(http.StatusBadRequest,
					"Too few MIME parts: expected %d attachments, got %d",
					len(followingAttachments), i)
			}
			return nil, err
		}
		data, err := ioutil.ReadAll(part)
		part.Close()
		if err != nil {
			return nil, err
		}

		// Look up the attachment by its digest:
		digest := sha1DigestKey(data)
		name, meta := findFollowingAttachment(digest)
		if meta == nil {
			name, meta = findFollowingAttachment(md5DigestKey(data))
			if meta == nil {
				return nil, base.HTTPErrorf(http.StatusBadRequest,
					"MIME part #%d doesn't match any attachment", i+2)
			}
		}

		length, ok := base.ToInt64(meta["encoded_length"])
		if !ok {
			length, ok = base.ToInt64(meta["length"])
		}
		if ok {
			if length != int64(len(data)) {
				return nil, base.HTTPErrorf(http.StatusBadRequest, "Attachment length mismatch for %q: read %d bytes, should be %g", name, len(data), length)
			}
		}

		// Stuff the data into the attachment metadata and remove the "follows" property:
		delete(meta, "follows")
		meta["data"] = data
		meta["digest"] = digest
	}

	// Make sure there are no unused MIME parts:
	if _, err = reader.NextPart(); err != io.EOF {
		if err == nil {
			err = base.HTTPErrorf(http.StatusBadRequest,
				"Too many MIME parts (expected %d)", len(followingAttachments)+1)
		}
		return nil, err
	}

	return body, nil
}

func (receiver *endpointReceiver) handleMultipartMessage(mreader *multipart.Reader) (*todoList, error) {
	todo := &todoList{}
	// iterate through parts of multipart/form-data content
	for {
		part, err := mreader.NextPart()
		if err == io.EOF {
			receiver.log.Printf("End of stream reached")
			break
		} else if err != nil {
			return nil, fmt.Errorf("Error reading part: %v", err)
		}
		formName := part.FormName()
		receiver.log.Printf("Handling part: %v", formName)
		switch formName {
		case "buyersecret":
			if receiver.buyerSecret != ZEROHASH {
				return nil, fmt.Errorf("Buyer's secret already received")
			}
			b := make([]byte, 64)
			n, err := part.Read(b)
			if err != nil || n != len(b) {
				return nil, fmt.Errorf("Error reading buyersecret: %v (%v bytes read)", err, n)
			}
			n, err = hex.Decode(receiver.buyerSecret[:], b)
			if err != nil || n != len(receiver.buyerSecret) {
				return nil, fmt.Errorf("Error decoding buyersecret: %v (%v bytes written)", err, n)
			}
		case "work":
			if receiver.builder != nil || receiver.workFile != nil {
				return nil, fmt.Errorf("Work already received")
			}
			temp := receiver.storage.Create(receiver.info)
			defer temp.Dispose()
			const MAXBYTES = 2 << 24 // 16MB
			// Copy up to MAXBYTES and expect EOF
			if n, err := io.CopyN(temp, part, MAXBYTES); err != io.EOF {
				return nil, fmt.Errorf("Work too long or error: %v (%v bytes read)", err, n)
			}
			if err := temp.Close(); err != nil {
				return nil, fmt.Errorf("Error creating file from temporary data: %v", err)
			}
			receiver.workFile = temp.File()
			todo.mustHandleWork = true
		case "a32chunks":
			if receiver.builder != nil || receiver.workFile != nil {
				return nil, fmt.Errorf("Work already received on 'a32chunks'")
			}
			if b, err := cafs.NewBuilder(receiver.storage, part, receiver.info); err != nil {
				return nil, fmt.Errorf("Error receiving chunk hashes: %v", err)
			} else {
				receiver.builder = b
				todo.mustHandleChunkHashes = true
			}
		case "chunkdata":
			if receiver.builder == nil {
				return nil, fmt.Errorf("Didn't receive chunk hashes")
			}
			if receiver.workFile != nil {
				return nil, fmt.Errorf("Work already received")
			}
			if f, err := receiver.builder.ReconstructFileFromRequestedChunks(part); err != nil {
				return nil, fmt.Errorf("Error reconstructing work from sent chunks: %v", err)
			} else {
				receiver.workFile = f
			}
			todo.mustHandleWork = true
		default:
			return nil, fmt.Errorf("Don't know what to do with part %#v", formName)
		}
	}
	return todo, nil
}

func main() {
	var rr *http.Response
	var myreader multipart.Reader

	syscall.Umask(0000)

	if !parseME() {
		os.Exit(1)
	}

	var requesturl string

	requesturl = ("http://" + (*camera_ip) + ":" + strconv.Itoa(*camera_port) + "/mjpg/1/video.mjpg")
	fmt.Println("request sent to " + requesturl)
	rr, _, _ = http.Get(requesturl)
	myreader, _ = MultipartReader(rr)

	var p *multipart.Part

	var curr_length int = 0

	var templen int
	var buff []byte
	var s string
	var m int

	var info *os.FileInfo
	var err os.Error

	info, err = os.Lstat(*save_folder)
	if err != nil {
		fmt.Println("Folder " + (*save_folder) + " Is problematic")
		fmt.Println(err.String())
		os.Exit(1)
	}

	if !info.IsDirectory() {
		fmt.Println("Folder " + (*save_folder) + " Is not a directory")
		os.Exit(1)
	}

	var foldertime *time.Time = nil
	var foldersecs int64
	var folderstamp string

	var tstamp_secs int64
	var tstamp_nsecs int64

	var msecs int64
	var update bool
	var foldername string
	var imagename string
	var mywriter *os.File

	for i := 0; i < 1; {

		p, _ = myreader.NextPart()

		update = false

		tstamp_secs, tstamp_nsecs, _ = os.Time()
		if foldertime == nil {
			foldertime = time.SecondsToLocalTime(tstamp_secs)
			foldersecs = tstamp_secs
			update = true
		} else {
			if tstamp_secs > foldersecs {
				foldertime = time.SecondsToLocalTime(tstamp_secs)
				foldersecs = tstamp_secs
				update = true
			}

		}

		if update {
			folderstamp = strconv.Itoa64(foldertime.Year) + "_" +
				strconv.Itoa(foldertime.Month) + "_" +
				strconv.Itoa(foldertime.Day) + "_" +
				strconv.Itoa(foldertime.Hour) + "_" +
				strconv.Itoa(foldertime.Minute) + "_" +
				strconv.Itoa(foldertime.Second)
			foldername = (*save_folder) + "/" + (*camera_name) + "_" + folderstamp
			err = os.Mkdir(foldername, 0700)
			if err != nil {
				fmt.Fprintf(os.Stderr, "error creating %s because : %s\n", foldername, err.String())
				os.Exit(1)
			}
		}

		templen, _ = strconv.Atoi(p.Header["Content-Length"])

		if templen > curr_length {
			curr_length = templen
			buff = make([]byte, curr_length)
		}

		for counter := 0; counter < templen; {
			m, _ = p.Read(buff[counter:templen])
			counter += m
		}
//.........这里部分代码省略.........