Method writeBody

transfer.go:298–384

always closes t.BodyCloser

(w io.Writer, dumps []*dump.Dumper)

// always closes t.BodyCloser
func (t *transferWriter) writeBody(w io.Writer, dumps []*dump.Dumper) (err error) {
	var ncopy int64
	closed := false
	defer func() {
		if closed || t.BodyCloser == nil {
			return
		}
		if closeErr := t.BodyCloser.Close(); closeErr != nil && err == nil {
			err = closeErr
		}
	}()

	rw := w // raw writer
	for _, dump := range dumps {
		if dump.RequestBody() {
			w = dump.WrapRequestBodyWriter(w)
		}
	}

	// Write body. We "unwrap" the body first if it was wrapped in a
	// nopCloser or readTrackingBody. This is to ensure that we can take advantage of
	// OS-level optimizations in the event that the body is an
	// *os.File.
	if t.Body != nil {
		body := t.unwrapBody()
		if chunked(t.TransferEncoding) {
			if bw, ok := rw.(*bufio.Writer); ok {
				rw = &internal.FlushAfterChunkWriter{Writer: bw}
			}
			cw := internal.NewChunkedWriter(rw)
			for _, dump := range dumps {
				if dump.RequestBody() {
					cw = dump.WrapRequestBodyWriteCloser(cw)
				}
			}
			_, err = t.doBodyCopy(cw, body)
			if err == nil {
				err = cw.Close()
			}
		} else if t.ContentLength == -1 {
			dst := w
			if t.Method == "CONNECT" {
				dst = bufioFlushWriter{dst}
			}
			ncopy, err = t.doBodyCopy(dst, body)
		} else {
			ncopy, err = t.doBodyCopy(w, io.LimitReader(body, t.ContentLength))
			if err != nil {
				return err
			}
			var nextra int64
			nextra, err = t.doBodyCopy(io.Discard, body)
			ncopy += nextra
		}
		if err != nil {
			return err
		}
		for _, dump := range dumps {