func mwSet(mw *multipart.Writer, key, value string) error {
pw, err := mw.CreateFormField(key)
if err != nil {
return err
}
if _, err = pw.Write([]byte(value)); err != nil {
return err
}
return nil
}
// Write the attachment to the specified multipart writer.
func (a Attachment) Write(w *multipart.Writer) error {
headers := make(textproto.MIMEHeader)
if len(a.Filename) != 0 {
headers.Add("Content-Type", fmt.Sprintf("%s; name=%s", a.ContentType, a.Filename))
} else {
headers.Add("Content-Type", a.ContentType)
}
if a.Encoded {
headers.Add("Content-Transfer-Encoding", "base64")
} else {
headers.Add("Content-Transfer-Encoding", "quoted-printable")
}
p, err := w.CreatePart(headers)
if err != nil {
return err
}
if a.Encoded {
if _, err := p.Write([]byte(a.Content)); err != nil {
return err
}
} else {
q := quotedprintable.NewWriter(p)
if _, err := q.Write([]byte(a.Content)); err != nil {
return err
}
return q.Close()
}
return nil
}
func writeJSONPart(writer *multipart.Writer, contentType string, body Body, compressed bool) (err error) {
bytes, err := json.Marshal(body)
if err != nil {
return err
}
if len(bytes) < kMinCompressedJSONSize {
compressed = false
}
partHeaders := textproto.MIMEHeader{}
partHeaders.Set("Content-Type", contentType)
if compressed {
partHeaders.Set("Content-Encoding", "gzip")
}
part, err := writer.CreatePart(partHeaders)
if err != nil {
return err
}
if compressed {
gz := gzip.NewWriter(part)
_, err = gz.Write(bytes)
gz.Close()
} else {
_, err = part.Write(bytes)
}
return
}
func (m *Message) writeMultipartStart(b *bytes.Buffer, writer *multipart.Writer) error {
multipart := `
Content-Type: multipart/alternative; charset="UTF-8"; boundary="%s"
`
_, err := b.WriteString(fmt.Sprintf(multipart, writer.Boundary()))
return err
}
func Write(w *multipart.Writer, params map[string][]string) error {
for key, param1 := range params {
param := param1[0]
if len(param) > 0 && param[0] == '@' {
file := param[1:]
fw, err := w.CreateFormFile(key, file)
if err != nil {
log.Println("CreateFormFile failed:", err)
return err
}
fd, err := os.Open(file)
if err != nil {
log.Println("Open file failed:", err)
return err
} else {
_, err = io.Copy(fw, fd)
fd.Close()
if err != nil {
log.Println("Copy file failed:", err)
return err
}
}
} else {
err := w.WriteField(key, param)
if err != nil {
return err
}
}
}
return nil
}
// Adds a new part to the given multipart writer, containing the given revision.
// The revision will be written as a nested multipart body if it has attachments.
func (db *Database) WriteRevisionAsPart(revBody Body, isError bool, compressPart bool, writer *multipart.Writer) error {
partHeaders := textproto.MIMEHeader{}
docID, _ := revBody["_id"].(string)
revID, _ := revBody["_rev"].(string)
if len(docID) > 0 {
partHeaders.Set("X-Doc-ID", docID)
partHeaders.Set("X-Rev-ID", revID)
}
if hasInlineAttachments(revBody) {
// Write as multipart, including attachments:
// OPT: Find a way to do this w/o having to buffer the MIME body in memory!
var buffer bytes.Buffer
docWriter := multipart.NewWriter(&buffer)
contentType := fmt.Sprintf("multipart/related; boundary=%q",
docWriter.Boundary())
partHeaders.Set("Content-Type", contentType)
db.WriteMultipartDocument(revBody, docWriter, compressPart)
docWriter.Close()
content := bytes.TrimRight(buffer.Bytes(), "\r\n")
part, err := writer.CreatePart(partHeaders)
if err == nil {
_, err = part.Write(content)
}
return err
} else {
// Write as JSON:
contentType := "application/json"
if isError {
contentType += `; error="true"`
}
return writeJSONPart(writer, contentType, revBody, compressPart)
}
}
// Writes a revision to a MIME multipart writer, encoding large attachments as separate parts.
func (db *Database) WriteMultipartDocument(body Body, writer *multipart.Writer) {
// First extract the attachments that should follow:
following := []attInfo{}
for name, value := range BodyAttachments(body) {
meta := value.(map[string]interface{})
var info attInfo
info.contentType, _ = meta["content_type"].(string)
info.data, _ = decodeAttachment(meta["data"])
if info.data != nil && len(info.data) > kMaxInlineAttachmentSize {
info.name = name
following = append(following, info)
delete(meta, "data")
meta["follows"] = true
}
}
// Write the main JSON body:
jsonOut, _ := json.Marshal(body)
partHeaders := textproto.MIMEHeader{}
partHeaders.Set("Content-Type", "application/json")
part, _ := writer.CreatePart(partHeaders)
part.Write(jsonOut)
// Write the following attachments
for _, info := range following {
partHeaders := textproto.MIMEHeader{}
if info.contentType != "" {
partHeaders.Set("Content-Type", info.contentType)
}
partHeaders.Set("Content-Disposition", fmt.Sprintf("attachment; filename=%q", info.name))
part, _ := writer.CreatePart(partHeaders)
part.Write(info.data)
}
}
func createFormFile(writer *multipart.Writer, fieldname, filename string) {
// Try to open the file.
file, err := os.Open(filename)
if err != nil {
panic(err)
}
defer file.Close()
// Create a new form-data header with the provided field name and file name.
// Determine Content-Type of the file by its extension.
h := textproto.MIMEHeader{}
h.Set("Content-Disposition", fmt.Sprintf(
`form-data; name="%s"; filename="%s"`,
escapeQuotes(fieldname),
escapeQuotes(filepath.Base(filename)),
))
h.Set("Content-Type", "application/octet-stream")
if ct := mime.TypeByExtension(filepath.Ext(filename)); ct != "" {
h.Set("Content-Type", ct)
}
part, err := writer.CreatePart(h)
if err != nil {
panic(err)
}
// Copy the content of the file we have opened not reading the whole
// file into memory.
_, err = io.Copy(part, file)
if err != nil {
panic(err)
}
}
func writeField(w multipart.Writer, fieldName string, fieldVal string) error {
if err := w.WriteField(fieldName, fieldVal); err != nil {
message := "Can not write field " + fieldName + " into the request. Reason: " + err.Error()
logging.Logger().Warn(message)
return errors.New(message)
}
return nil
}
func createBlobletPartWriter(i int, path string, size int64, hash string, writer *multipart.Writer) (io.Writer, error) {
h := make(textproto.MIMEHeader)
h.Set("Content-Disposition", fmt.Sprintf(`form-data; name="bloblet-%d"; path="%s"; filename="%s"; hash="%s"`, i, path, bloblet.BlobletFileName, hash))
h.Set("Content-Type", "application/zip")
h.Set("Content-Length", fmt.Sprintf("%d", size))
h.Set("Content-Transfer-Encoding", "binary")
return writer.CreatePart(h)
}
func (m *Message) writeMultipartEnd(b *bytes.Buffer, writer *multipart.Writer) error {
multipart := `
--%s--
`
_, err := b.WriteString(fmt.Sprintf(multipart, writer.Boundary()))
return err
}
func createZipPartWriter(zipStats os.FileInfo, writer *multipart.Writer) (io.Writer, error) {
h := make(textproto.MIMEHeader)
h.Set("Content-Disposition", `form-data; name="application"; filename="application.zip"`)
h.Set("Content-Type", "application/zip")
h.Set("Content-Length", fmt.Sprintf("%d", zipStats.Size()))
h.Set("Content-Transfer-Encoding", "binary")
return writer.CreatePart(h)
}
func addFileReader(w *multipart.Writer, f *File) error {
part, err := w.CreateFormFile(f.ParamName, f.Name)
if err != nil {
return err
}
_, err = io.Copy(part, f.Reader)
return err
}
// Add a file to a multipart writer.
func addFormFileFromData(writer *multipart.Writer, name, path string, data []byte) error {
part, err := writer.CreateFormFile(name, filepath.Base(path))
if err != nil {
return err
}
_, err = part.Write(data)
return err
}
func writeFields(mpw *multipart.Writer, fields map[string]string) error {
for k, v := range fields {
err := mpw.WriteField(k, v)
if err != nil {
return err
}
}
return nil
}
func WriteFormData(bw *multipart.Writer, FormData map[string]string) error {
for key, value := range FormData {
formFieldWriter, err := bw.CreateFormField(key)
if err != nil {
return err
}
formFieldWriter.Write([]byte(value))
}
return nil
}
func (r Client) PostWithMultiPartData(req_url string, headers map[string][]string, params map[string][]string, body io.Reader, filename string) (resp *http.Response, err error) {
var buffer *bytes.Buffer = new(bytes.Buffer)
var writer *multipart.Writer = multipart.NewWriter(buffer)
for k, v := range params {
for _, field := range v {
err1 := writer.WriteField(k, field)
if err1 != nil {
err = err1
return
}
}
}
w, err := writer.CreateFormFile("file", filename)
if err != nil {
return
}
_, err = io.Copy(w, body)
if err != nil {
return
}
err = writer.Close()
if err != nil {
return
}
if headers == nil {
headers = make(map[string][]string)
}
headers["Content-Type"] = []string{writer.FormDataContentType()}
return r.Post(req_url, headers, buffer, int64(buffer.Len()))
}
func SendMediaRequest(client *twittergo.Client, reqUrl string, params map[string]string, media []byte) (mediaResp twittergo.MediaResponse, err error) {
var (
req *http.Request
resp *twittergo.APIResponse
body io.ReadWriter = bytes.NewBufferString("")
mp *multipart.Writer
writer io.Writer
contentType string
)
mp = multipart.NewWriter(body)
for key, value := range params {
mp.WriteField(key, value)
}
if media != nil {
if writer, err = mp.CreateFormField("media"); err != nil {
return
}
writer.Write(media)
}
contentType = fmt.Sprintf("multipart/form-data;boundary=%v", mp.Boundary())
mp.Close()
if req, err = http.NewRequest("POST", reqUrl, body); err != nil {
return
}
req.Header.Set("Content-Type", contentType)
if resp, err = client.SendRequest(req); err != nil {
return
}
err = resp.Parse(&mediaResp)
return
}
func createJpegFormFile(w *multipart.Writer, fieldname, filename string) (io.Writer, error) {
h := make(textproto.MIMEHeader)
h.Set("Content-Disposition",
fmt.Sprintf(`form-data; name="%s"; filename="%s"`,
escapeQuotes(fieldname), escapeQuotes(filename)))
// Major change from the stock function is to declare this with
// type == image/jpeg, otherwise Shutterfly's API will choke on
// the request:
h.Set("Content-Type", "image/jpeg")
return w.CreatePart(h)
}
// writeMultiPartFiles writes the given files as parts of a multipart message
// using the given writer.
func writeMultiPartFiles(writer *multipart.Writer, files map[string][]byte) error {
for fileName, fileContent := range files {
fw, err := writer.CreateFormFile(fileName, fileName)
if err != nil {
return err
}
io.Copy(fw, bytes.NewBuffer(fileContent))
}
return nil
}
/*
* extra.CheckCrc:
* 0: 不进行crc32校验
* 1: 以writeMultipart自动生成crc32的值，进行校验
* 2: 以extra.Crc32的值，进行校验
* other: 和2一样， 以 extra.Crc32的值，进行校验
*/
func writeMultipart(writer *multipart.Writer, uptoken, key string, hasKey bool, extra *PutExtra) (err error) {
if extra == nil {
extra = &PutExtra{}
}
//token
if err = writer.WriteField("token", uptoken); err != nil {
return
}
//key
if hasKey {
if err = writer.WriteField("key", key); err != nil {
return
}
}
// extra.Params
if extra.Params != nil {
for k, v := range extra.Params {
err = writer.WriteField(k, v)
if err != nil {
return
}
}
}
//extra.CheckCrc
if extra.CheckCrc != 0 {
err = writer.WriteField("crc32", strconv.FormatInt(int64(extra.Crc32), 10))
if err != nil {
return
}
}
//file
head := make(textproto.MIMEHeader)
// default the filename is same as key , but ""
var fileName = key
if fileName == "" {
fileName = "filename"
}
head.Set("Content-Disposition",
fmt.Sprintf(`form-data; name="file"; filename="%s"`, escapeQuotes(fileName)))
if extra.MimeType != "" {
head.Set("Content-Type", extra.MimeType)
}
_, err = writer.CreatePart(head)
return err
}
// CreateFormFile creates a form file
func CreateFormFile(w *multipart.Writer, fieldname, filename, contentType string) (io.Writer, error) {
h := make(textproto.MIMEHeader)
h.Set("Content-Type", contentType)
h.Set("Content-Disposition",
fmt.Sprintf(`form-data; name="%s"; filename="%s"`,
escapeQuotes(fieldname), escapeQuotes(filename)))
if contentType == "" {
contentType = "application/octet-stream"
}
return w.CreatePart(h)
}
func (m *Message) writeContentTypeWithBoundary(b *bytes.Buffer, writer *multipart.Writer, contentType string) error {
contentTypeFormat := `
--%s
Content-Type: %s; charset=UTF-8;
Content-Transfer-Encoding: 8bit
`
_, err := b.WriteString(fmt.Sprintf(contentTypeFormat, writer.Boundary(), contentType))
return err
}
// addField adds a field to the multipart writer
func addField(w *multipart.Writer, k, v string) error {
fw, err := w.CreateFormField(k)
if err != nil {
return err
}
_, err = fw.Write([]byte(v))
if err != nil {
return err
}
return nil
}
func (n *GitLabClient) createArtifactsForm(mpw *multipart.Writer, reader io.Reader, baseName string) error {
wr, err := mpw.CreateFormFile("file", baseName)
if err != nil {
return err
}
_, err = io.Copy(wr, reader)
if err != nil {
return err
}
return nil
}
func addField(w *multipart.Writer, fieldName string, value []byte) error {
fw, err := w.CreateFormField(fieldName)
if err != nil {
return err
}
_, err = fw.Write(value)
return err
}
func multipartMIME(
writer *multipart.Writer,
msg string,
attachments []*Attachment,
) error {
// write message
mh := make(textproto.MIMEHeader)
mh.Add("Content-Type", "text/plain")
mh.Add("Content-Transfer-Encoding", "base64")
msgWriter, err := writer.CreatePart(mh)
if err != nil {
return log.Error(err)
}
_, err = io.WriteString(msgWriter, base64.Encode([]byte(msg)))
if err != nil {
return log.Error(err)
}
// write attachments
for _, attachment := range attachments {
mh = make(textproto.MIMEHeader)
base := filepath.Base(attachment.Filename)
if attachment.ContentType != "" {
mh.Add("Content-Type", attachment.ContentType)
} else {
ct := mime.TypeByExtension(filepath.Ext(base))
if ct != "" {
mh.Add("Content-Type", ct)
} else {
mh.Add("Content-Type", "application/octet-stream")
}
}
mh.Add("Content-Transfer-Encoding", "base64")
mh.Add("Content-Disposition", "attachment; filename="+base)
if attachment.Inline {
mh.Add("Content-Disposition", "inline")
}
attachmentWriter, err := writer.CreatePart(mh)
if err != nil {
return log.Error(err)
}
encoder := base64.NewEncoder(attachmentWriter)
if _, err := io.Copy(encoder, attachment.Reader); err != nil {
return log.Error(err)
}
if err := encoder.Close(); err != nil {
return log.Error(err)
}
}
return nil
}
func writeFileField(w *multipart.Writer, fieldsubid string, filePath string) error {
ff, err := w.CreateFormField(fieldsubid)
if err != nil {
return err
}
file, err := os.Open(filePath)
if err != nil {
return err
}
if _, err := io.Copy(ff, file); err != nil {
return err
}
return nil
}
// writeMultiPartParams writes the given parameters as parts of a multipart
// message using the given writer.
func writeMultiPartParams(writer *multipart.Writer, parameters url.Values) error {
for key, values := range parameters {
for _, value := range values {
fw, err := writer.CreateFormField(key)
if err != nil {
return err
}
buffer := bytes.NewBufferString(value)
io.Copy(fw, buffer)
}
}
return nil
}
func appendPart(w *multipart.Writer, headers func(h textproto.MIMEHeader), body string) {
if body == "" {
return
}
h := textproto.MIMEHeader{}
h.Set("Content-Transfer-Encoding", "quoted-printable")
headers(h)
partW, err := w.CreatePart(h)
log.Panice(err, "create MIME part")
quoW := quotedprintable.NewWriter(partW)
defer quoW.Close()
io.WriteString(quoW, body)
}
