// Copyright 2010 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 mime import ( "bytes" "errors" "fmt" "sort" "strings" "unicode" ) // FormatMediaType serializes mediatype t and the parameters // param as a media type conforming to RFC 2045 and RFC 2616. // The type and parameter names are written in lower-case. // When any of the arguments result in a standard violation then // FormatMediaType returns the empty string. func FormatMediaType(t string, param map[string]string) string { var b bytes.Buffer if slash := strings.Index(t, "/"); slash == -1 { if !isToken(t) { return "" } b.WriteString(strings.ToLower(t)) } else { major, sub := t[:slash], t[slash+1:] if !isToken(major) || !isToken(sub) { return "" } b.WriteString(strings.ToLower(major)) b.WriteByte('/') b.WriteString(strings.ToLower(sub)) } attrs := make([]string, 0, len(param)) for a := range param { attrs = append(attrs, a) } sort.Strings(attrs) for _, attribute := range attrs { value := param[attribute] b.WriteByte(';') b.WriteByte(' ') if !isToken(attribute) { return "" } b.WriteString(strings.ToLower(attribute)) b.WriteByte('=') if isToken(value) { b.WriteString(value) continue } b.WriteByte('"') offset := 0 for index, character := range value { if character == '"' || character == '\\' { b.WriteString(value[offset:index]) offset = index b.WriteByte('\\') } if character&0x80 != 0 { return "" } } b.WriteString(value[offset:]) b.WriteByte('"') } return b.String() } func checkMediaTypeDisposition(s string) error { typ, rest := consumeToken(s) if typ == "" { return errors.New("mime: no media type") } if rest == "" { return nil } if !strings.HasPrefix(rest, "/") { return errors.New("mime: expected slash after first token") } subtype, rest := consumeToken(rest[1:]) if subtype == "" { return errors.New("mime: expected token after slash") } if rest != "" { return errors.New("mime: unexpected content after media subtype") } return nil } // ParseMediaType parses a media type value and any optional // parameters, per RFC 1521. Media types are the values in // Content-Type and Content-Disposition headers (RFC 2183). // On success, ParseMediaType returns the media type converted // to lowercase and trimmed of white space and a non-nil map. // The returned map, params, maps from the lowercase // attribute to the attribute value with its case preserved. func ParseMediaType(v string) (mediatype string, params map[string]string, err error) { i := strings.Index(v, ";") if i == -1 { i = len(v) } mediatype = strings.TrimSpace(strings.ToLower(v[0:i])) err = checkMediaTypeDisposition(mediatype) if err != nil { return "", nil, err } params = make(map[string]string) // Map of base parameter name -> parameter name -> value // for parameters containing a '*' character. // Lazily initialized. var continuation map[string]map[string]string v = v[i:] for len(v) > 0 { v = strings.TrimLeftFunc(v, unicode.IsSpace) if len(v) == 0 { break } key, value, rest := consumeMediaParam(v) if key == "" { if strings.TrimSpace(rest) == ";" { // Ignore trailing semicolons. // Not an error. return } // Parse error. return "", nil, errors.New("mime: invalid media parameter") } pmap := params if idx := strings.Index(key, "*"); idx != -1 { baseName := key[:idx] if continuation == nil { continuation = make(map[string]map[string]string) } var ok bool if pmap, ok = continuation[baseName]; !ok { continuation[baseName] = make(map[string]string) pmap = continuation[baseName] } } if _, exists := pmap[key]; exists { // Duplicate parameter name is bogus. return "", nil, errors.New("mime: duplicate parameter name") } pmap[key] = value v = rest } // Stitch together any continuations or things with stars // (i.e. RFC 2231 things with stars: "foo*0" or "foo*") var buf bytes.Buffer for key, pieceMap := range continuation { singlePartKey := key + "*" if v, ok := pieceMap[singlePartKey]; ok { decv := decode2231Enc(v) params[key] = decv continue } buf.Reset() valid := false for n := 0; ; n++ { simplePart := fmt.Sprintf("%s*%d", key, n) if v, ok := pieceMap[simplePart]; ok { valid = true buf.WriteString(v) continue } encodedPart := simplePart + "*" if v, ok := pieceMap[encodedPart]; ok { valid = true if n == 0 { buf.WriteString(decode2231Enc(v)) } else { decv, _ := percentHexUnescape(v) buf.WriteString(decv) } } else { break } } if valid { params[key] = buf.String() } } return } func decode2231Enc(v string) string { sv := strings.SplitN(v, "'", 3) if len(sv) != 3 { return "" } // TODO: ignoring lang in sv[1] for now. If anybody needs it we'll // need to decide how to expose it in the API. But I'm not sure // anybody uses it in practice. charset := strings.ToLower(sv[0]) if charset != "us-ascii" && charset != "utf-8" { // TODO: unsupported encoding return "" } encv, _ := percentHexUnescape(sv[2]) return encv } func isNotTokenChar(r rune) bool { return !isTokenChar(r) } // consumeToken consumes a token from the beginning of provided // string, per RFC 2045 section 5.1 (referenced from 2183), and return // the token consumed and the rest of the string. Returns ("", v) on // failure to consume at least one character. func consumeToken(v string) (token, rest string) { notPos := strings.IndexFunc(v, isNotTokenChar) if notPos == -1 { return v, "" } if notPos == 0 { return "", v } return v[0:notPos], v[notPos:] } // consumeValue consumes a "value" per RFC 2045, where a value is // either a 'token' or a 'quoted-string'. On success, consumeValue // returns the value consumed (and de-quoted/escaped, if a // quoted-string) and the rest of the string. On failure, returns // ("", v). func consumeValue(v string) (value, rest string) { if v == "" { return } if v[0] != '"' { return consumeToken(v) } // parse a quoted-string buffer := new(bytes.Buffer) for i := 1; i < len(v); i++ { r := v[i] if r == '"' { return buffer.String(), v[i+1:] } // When MSIE sends a full file path (in "intranet mode"), it does not // escape backslashes: "C:\dev\go\foo.txt", not "C:\\dev\\go\\foo.txt". // // No known MIME generators emit unnecessary backslash escapes // for simple token characters like numbers and letters. // // If we see an unnecessary backslash escape, assume it is from MSIE // and intended as a literal backslash. This makes Go servers deal better // with MSIE without affecting the way they handle conforming MIME // generators. if r == '\\' && i+1 < len(v) && !isTokenChar(rune(v[i+1])) { buffer.WriteByte(v[i+1]) i++ continue } if r == '\r' || r == '\n' { return "", v } buffer.WriteByte(v[i]) } // Did not find end quote. return "", v } func consumeMediaParam(v string) (param, value, rest string) { rest = strings.TrimLeftFunc(v, unicode.IsSpace) if !strings.HasPrefix(rest, ";") { return "", "", v } rest = rest[1:] // consume semicolon rest = strings.TrimLeftFunc(rest, unicode.IsSpace) param, rest = consumeToken(rest) param = strings.ToLower(param) if param == "" { return "", "", v } rest = strings.TrimLeftFunc(rest, unicode.IsSpace) if !strings.HasPrefix(rest, "=") { return "", "", v } rest = rest[1:] // consume equals sign rest = strings.TrimLeftFunc(rest, unicode.IsSpace) value, rest2 := consumeValue(rest) if value == "" && rest2 == rest { return "", "", v } rest = rest2 return param, value, rest } func percentHexUnescape(s string) (string, error) { // Count %, check that they're well-formed. percents := 0 for i := 0; i < len(s); { if s[i] != '%' { i++ continue } percents++ if i+2 >= len(s) || !ishex(s[i+1]) || !ishex(s[i+2]) { s = s[i:] if len(s) > 3 { s = s[0:3] } return "", fmt.Errorf("mime: bogus characters after %%: %q", s) } i += 3 } if percents == 0 { return s, nil } t := make([]byte, len(s)-2*percents) j := 0 for i := 0; i < len(s); { switch s[i] { case '%': t[j] = unhex(s[i+1])<<4 | unhex(s[i+2]) j++ i += 3 default: t[j] = s[i] j++ i++ } } return string(t), nil } func ishex(c byte) bool { switch { case '0' <= c && c <= '9': return true case 'a' <= c && c <= 'f': return true case 'A' <= c && c <= 'F': return true } return false } func unhex(c byte) byte { switch { case '0' <= c && c <= '9': return c - '0' case 'a' <= c && c <= 'f': return c - 'a' + 10 case 'A' <= c && c <= 'F': return c - 'A' + 10 } return 0 }