Source file src/pkg/mime/mediatype.go
1 // Copyright 2010 The Go Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style 3 // license that can be found in the LICENSE file. 4 5 package mime 6 7 import ( 8 "bytes" 9 "errors" 10 "fmt" 11 "strings" 12 "unicode" 13 ) 14 15 // FormatMediaType serializes mediatype t and the parameters 16 // param as a media type conforming to RFC 2045 and RFC 2616. 17 // The type and parameter names are written in lower-case. 18 // When any of the arguments result in a standard violation then 19 // FormatMediaType returns the empty string. 20 func FormatMediaType(t string, param map[string]string) string { 21 slash := strings.Index(t, "/") 22 if slash == -1 { 23 return "" 24 } 25 major, sub := t[:slash], t[slash+1:] 26 if !isToken(major) || !isToken(sub) { 27 return "" 28 } 29 var b bytes.Buffer 30 b.WriteString(strings.ToLower(major)) 31 b.WriteByte('/') 32 b.WriteString(strings.ToLower(sub)) 33 34 for attribute, value := range param { 35 b.WriteByte(';') 36 b.WriteByte(' ') 37 if !isToken(attribute) { 38 return "" 39 } 40 b.WriteString(strings.ToLower(attribute)) 41 b.WriteByte('=') 42 if isToken(value) { 43 b.WriteString(value) 44 continue 45 } 46 47 b.WriteByte('"') 48 offset := 0 49 for index, character := range value { 50 if character == '"' || character == '\r' { 51 b.WriteString(value[offset:index]) 52 offset = index 53 b.WriteByte('\\') 54 } 55 if character&0x80 != 0 { 56 return "" 57 } 58 } 59 b.WriteString(value[offset:]) 60 b.WriteByte('"') 61 } 62 return b.String() 63 } 64 65 func checkMediaTypeDisposition(s string) error { 66 typ, rest := consumeToken(s) 67 if typ == "" { 68 return errors.New("mime: no media type") 69 } 70 if rest == "" { 71 return nil 72 } 73 if !strings.HasPrefix(rest, "/") { 74 return errors.New("mime: expected slash after first token") 75 } 76 subtype, rest := consumeToken(rest[1:]) 77 if subtype == "" { 78 return errors.New("mime: expected token after slash") 79 } 80 if rest != "" { 81 return errors.New("mime: unexpected content after media subtype") 82 } 83 return nil 84 } 85 86 // ParseMediaType parses a media type value and any optional 87 // parameters, per RFC 1521. Media types are the values in 88 // Content-Type and Content-Disposition headers (RFC 2183). 89 // On success, ParseMediaType returns the media type converted 90 // to lowercase and trimmed of white space and a non-nil map. 91 // The returned map, params, maps from the lowercase 92 // attribute to the attribute value with its case preserved. 93 func ParseMediaType(v string) (mediatype string, params map[string]string, err error) { 94 i := strings.Index(v, ";") 95 if i == -1 { 96 i = len(v) 97 } 98 mediatype = strings.TrimSpace(strings.ToLower(v[0:i])) 99 100 err = checkMediaTypeDisposition(mediatype) 101 if err != nil { 102 return "", nil, err 103 } 104 105 params = make(map[string]string) 106 107 // Map of base parameter name -> parameter name -> value 108 // for parameters containing a '*' character. 109 // Lazily initialized. 110 var continuation map[string]map[string]string 111 112 v = v[i:] 113 for len(v) > 0 { 114 v = strings.TrimLeftFunc(v, unicode.IsSpace) 115 if len(v) == 0 { 116 break 117 } 118 key, value, rest := consumeMediaParam(v) 119 if key == "" { 120 if strings.TrimSpace(rest) == ";" { 121 // Ignore trailing semicolons. 122 // Not an error. 123 return 124 } 125 // Parse error. 126 return "", nil, errors.New("mime: invalid media parameter") 127 } 128 129 pmap := params 130 if idx := strings.Index(key, "*"); idx != -1 { 131 baseName := key[:idx] 132 if continuation == nil { 133 continuation = make(map[string]map[string]string) 134 } 135 var ok bool 136 if pmap, ok = continuation[baseName]; !ok { 137 continuation[baseName] = make(map[string]string) 138 pmap = continuation[baseName] 139 } 140 } 141 if _, exists := pmap[key]; exists { 142 // Duplicate parameter name is bogus. 143 return "", nil, errors.New("mime: duplicate parameter name") 144 } 145 pmap[key] = value 146 v = rest 147 } 148 149 // Stitch together any continuations or things with stars 150 // (i.e. RFC 2231 things with stars: "foo*0" or "foo*") 151 var buf bytes.Buffer 152 for key, pieceMap := range continuation { 153 singlePartKey := key + "*" 154 if v, ok := pieceMap[singlePartKey]; ok { 155 decv := decode2231Enc(v) 156 params[key] = decv 157 continue 158 } 159 160 buf.Reset() 161 valid := false 162 for n := 0; ; n++ { 163 simplePart := fmt.Sprintf("%s*%d", key, n) 164 if v, ok := pieceMap[simplePart]; ok { 165 valid = true 166 buf.WriteString(v) 167 continue 168 } 169 encodedPart := simplePart + "*" 170 if v, ok := pieceMap[encodedPart]; ok { 171 valid = true 172 if n == 0 { 173 buf.WriteString(decode2231Enc(v)) 174 } else { 175 decv, _ := percentHexUnescape(v) 176 buf.WriteString(decv) 177 } 178 } else { 179 break 180 } 181 } 182 if valid { 183 params[key] = buf.String() 184 } 185 } 186 187 return 188 } 189 190 func decode2231Enc(v string) string { 191 sv := strings.SplitN(v, "'", 3) 192 if len(sv) != 3 { 193 return "" 194 } 195 // TODO: ignoring lang in sv[1] for now. If anybody needs it we'll 196 // need to decide how to expose it in the API. But I'm not sure 197 // anybody uses it in practice. 198 charset := strings.ToLower(sv[0]) 199 if charset != "us-ascii" && charset != "utf-8" { 200 // TODO: unsupported encoding 201 return "" 202 } 203 encv, _ := percentHexUnescape(sv[2]) 204 return encv 205 } 206 207 func isNotTokenChar(r rune) bool { 208 return !isTokenChar(r) 209 } 210 211 // consumeToken consumes a token from the beginning of provided 212 // string, per RFC 2045 section 5.1 (referenced from 2183), and return 213 // the token consumed and the rest of the string. Returns ("", v) on 214 // failure to consume at least one character. 215 func consumeToken(v string) (token, rest string) { 216 notPos := strings.IndexFunc(v, isNotTokenChar) 217 if notPos == -1 { 218 return v, "" 219 } 220 if notPos == 0 { 221 return "", v 222 } 223 return v[0:notPos], v[notPos:] 224 } 225 226 // consumeValue consumes a "value" per RFC 2045, where a value is 227 // either a 'token' or a 'quoted-string'. On success, consumeValue 228 // returns the value consumed (and de-quoted/escaped, if a 229 // quoted-string) and the rest of the string. On failure, returns 230 // ("", v). 231 func consumeValue(v string) (value, rest string) { 232 if !strings.HasPrefix(v, `"`) && !strings.HasPrefix(v, `'`) { 233 return consumeToken(v) 234 } 235 236 leadQuote := rune(v[0]) 237 238 // parse a quoted-string 239 rest = v[1:] // consume the leading quote 240 buffer := new(bytes.Buffer) 241 var idx int 242 var r rune 243 var nextIsLiteral bool 244 for idx, r = range rest { 245 switch { 246 case nextIsLiteral: 247 buffer.WriteRune(r) 248 nextIsLiteral = false 249 case r == leadQuote: 250 return buffer.String(), rest[idx+1:] 251 case r == '\\': 252 nextIsLiteral = true 253 case r != '\r' && r != '\n': 254 buffer.WriteRune(r) 255 default: 256 return "", v 257 } 258 } 259 return "", v 260 } 261 262 func consumeMediaParam(v string) (param, value, rest string) { 263 rest = strings.TrimLeftFunc(v, unicode.IsSpace) 264 if !strings.HasPrefix(rest, ";") { 265 return "", "", v 266 } 267 268 rest = rest[1:] // consume semicolon 269 rest = strings.TrimLeftFunc(rest, unicode.IsSpace) 270 param, rest = consumeToken(rest) 271 param = strings.ToLower(param) 272 if param == "" { 273 return "", "", v 274 } 275 276 rest = strings.TrimLeftFunc(rest, unicode.IsSpace) 277 if !strings.HasPrefix(rest, "=") { 278 return "", "", v 279 } 280 rest = rest[1:] // consume equals sign 281 rest = strings.TrimLeftFunc(rest, unicode.IsSpace) 282 value, rest = consumeValue(rest) 283 if value == "" { 284 return "", "", v 285 } 286 return param, value, rest 287 } 288 289 func percentHexUnescape(s string) (string, error) { 290 // Count %, check that they're well-formed. 291 percents := 0 292 for i := 0; i < len(s); { 293 if s[i] != '%' { 294 i++ 295 continue 296 } 297 percents++ 298 if i+2 >= len(s) || !ishex(s[i+1]) || !ishex(s[i+2]) { 299 s = s[i:] 300 if len(s) > 3 { 301 s = s[0:3] 302 } 303 return "", fmt.Errorf("mime: bogus characters after %%: %q", s) 304 } 305 i += 3 306 } 307 if percents == 0 { 308 return s, nil 309 } 310 311 t := make([]byte, len(s)-2*percents) 312 j := 0 313 for i := 0; i < len(s); { 314 switch s[i] { 315 case '%': 316 t[j] = unhex(s[i+1])<<4 | unhex(s[i+2]) 317 j++ 318 i += 3 319 default: 320 t[j] = s[i] 321 j++ 322 i++ 323 } 324 } 325 return string(t), nil 326 } 327 328 func ishex(c byte) bool { 329 switch { 330 case '0' <= c && c <= '9': 331 return true 332 case 'a' <= c && c <= 'f': 333 return true 334 case 'A' <= c && c <= 'F': 335 return true 336 } 337 return false 338 } 339 340 func unhex(c byte) byte { 341 switch { 342 case '0' <= c && c <= '9': 343 return c - '0' 344 case 'a' <= c && c <= 'f': 345 return c - 'a' + 10 346 case 'A' <= c && c <= 'F': 347 return c - 'A' + 10 348 } 349 return 0 350 }