791 lines
19 KiB
Go
791 lines
19 KiB
Go
|
// 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 textproto
|
||
|
|
|
||
|
|
import (
|
||
|
|
"bufio"
|
||
|
|
"bytes"
|
||
|
|
"fmt"
|
||
|
|
"io"
|
||
|
|
"strconv"
|
||
|
|
"strings"
|
||
|
|
"sync"
|
||
|
|
)
|
||
|
|
|
||
|
|
// A Reader implements convenience methods for reading requests
|
||
|
|
// or responses from a text protocol network connection.
|
||
|
|
type Reader struct {
|
||
|
|
R *bufio.Reader
|
||
|
|
dot *dotReader
|
||
|
|
buf []byte // a re-usable buffer for readContinuedLineSlice
|
||
|
|
}
|
||
|
|
|
||
|
|
// NewReader returns a new Reader reading from r.
|
||
|
|
//
|
||
|
|
// To avoid denial of service attacks, the provided bufio.Reader
|
||
|
|
// should be reading from an io.LimitReader or similar Reader to bound
|
||
|
|
// the size of responses.
|
||
|
|
func NewReader(r *bufio.Reader) *Reader {
|
||
|
|
commonHeaderOnce.Do(initCommonHeader)
|
||
|
|
return &Reader{R: r}
|
||
|
|
}
|
||
|
|
|
||
|
|
// ReadLine reads a single line from r,
|
||
|
|
// eliding the final \n or \r\n from the returned string.
|
||
|
|
func (r *Reader) ReadLine() (string, error) {
|
||
|
|
line, err := r.readLineSlice()
|
||
|
|
return string(line), err
|
||
|
|
}
|
||
|
|
|
||
|
|
// ReadLineBytes is like ReadLine but returns a []byte instead of a string.
|
||
|
|
func (r *Reader) ReadLineBytes() ([]byte, error) {
|
||
|
|
line, err := r.readLineSlice()
|
||
|
|
if line != nil {
|
||
|
|
buf := make([]byte, len(line))
|
||
|
|
copy(buf, line)
|
||
|
|
line = buf
|
||
|
|
}
|
||
|
|
return line, err
|
||
|
|
}
|
||
|
|
|
||
|
|
func (r *Reader) readLineSlice() ([]byte, error) {
|
||
|
|
r.closeDot()
|
||
|
|
var line []byte
|
||
|
|
for {
|
||
|
|
l, more, err := r.R.ReadLine()
|
||
|
|
if err != nil {
|
||
|
|
return nil, err
|
||
|
|
}
|
||
|
|
// Avoid the copy if the first call produced a full line.
|
||
|
|
if line == nil && !more {
|
||
|
|
return l, nil
|
||
|
|
}
|
||
|
|
line = append(line, l...)
|
||
|
|
if !more {
|
||
|
|
break
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return line, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
// ReadContinuedLine reads a possibly continued line from r,
|
||
|
|
// eliding the final trailing ASCII white space.
|
||
|
|
// Lines after the first are considered continuations if they
|
||
|
|
// begin with a space or tab character. In the returned data,
|
||
|
|
// continuation lines are separated from the previous line
|
||
|
|
// only by a single space: the newline and leading white space
|
||
|
|
// are removed.
|
||
|
|
//
|
||
|
|
// For example, consider this input:
|
||
|
|
//
|
||
|
|
// Line 1
|
||
|
|
// continued...
|
||
|
|
// Line 2
|
||
|
|
//
|
||
|
|
// The first call to ReadContinuedLine will return "Line 1 continued..."
|
||
|
|
// and the second will return "Line 2".
|
||
|
|
//
|
||
|
|
// Empty lines are never continued.
|
||
|
|
//
|
||
|
|
func (r *Reader) ReadContinuedLine() (string, error) {
|
||
|
|
line, err := r.readContinuedLineSlice(noValidation)
|
||
|
|
return string(line), err
|
||
|
|
}
|
||
|
|
|
||
|
|
// trim returns s with leading and trailing spaces and tabs removed.
|
||
|
|
// It does not assume Unicode or UTF-8.
|
||
|
|
func trim(s []byte) []byte {
|
||
|
|
i := 0
|
||
|
|
for i < len(s) && (s[i] == ' ' || s[i] == '\t') {
|
||
|
|
i++
|
||
|
|
}
|
||
|
|
n := len(s)
|
||
|
|
for n > i && (s[n-1] == ' ' || s[n-1] == '\t') {
|
||
|
|
n--
|
||
|
|
}
|
||
|
|
return s[i:n]
|
||
|
|
}
|
||
|
|
|
||
|
|
// ReadContinuedLineBytes is like ReadContinuedLine but
|
||
|
|
// returns a []byte instead of a string.
|
||
|
|
func (r *Reader) ReadContinuedLineBytes() ([]byte, error) {
|
||
|
|
line, err := r.readContinuedLineSlice(noValidation)
|
||
|
|
if line != nil {
|
||
|
|
buf := make([]byte, len(line))
|
||
|
|
copy(buf, line)
|
||
|
|
line = buf
|
||
|
|
}
|
||
|
|
return line, err
|
||
|
|
}
|
||
|
|
|
||
|
|
// readContinuedLineSlice reads continued lines from the reader buffer,
|
||
|
|
// returning a byte slice with all lines. The validateFirstLine function
|
||
|
|
// is run on the first read line, and if it returns an error then this
|
||
|
|
// error is returned from readContinuedLineSlice.
|
||
|
|
func (r *Reader) readContinuedLineSlice(validateFirstLine func([]byte) error) ([]byte, error) {
|
||
|
|
if validateFirstLine == nil {
|
||
|
|
return nil, fmt.Errorf("missing validateFirstLine func")
|
||
|
|
}
|
||
|
|
|
||
|
|
// Read the first line.
|
||
|
|
line, err := r.readLineSlice()
|
||
|
|
if err != nil {
|
||
|
|
return nil, err
|
||
|
|
}
|
||
|
|
if len(line) == 0 { // blank line - no continuation
|
||
|
|
return line, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
if err := validateFirstLine(line); err != nil {
|
||
|
|
return nil, err
|
||
|
|
}
|
||
|
|
|
||
|
|
// Optimistically assume that we have started to buffer the next line
|
||
|
|
// and it starts with an ASCII letter (the next header key), or a blank
|
||
|
|
// line, so we can avoid copying that buffered data around in memory
|
||
|
|
// and skipping over non-existent whitespace.
|
||
|
|
if r.R.Buffered() > 1 {
|
||
|
|
peek, _ := r.R.Peek(2)
|
||
|
|
if len(peek) > 0 && (isASCIILetter(peek[0]) || peek[0] == '\n') ||
|
||
|
|
len(peek) == 2 && peek[0] == '\r' && peek[1] == '\n' {
|
||
|
|
return trim(line), nil
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// ReadByte or the next readLineSlice will flush the read buffer;
|
||
|
|
// copy the slice into buf.
|
||
|
|
r.buf = append(r.buf[:0], trim(line)...)
|
||
|
|
|
||
|
|
// Read continuation lines.
|
||
|
|
for r.skipSpace() > 0 {
|
||
|
|
line, err := r.readLineSlice()
|
||
|
|
if err != nil {
|
||
|
|
break
|
||
|
|
}
|
||
|
|
r.buf = append(r.buf, ' ')
|
||
|
|
r.buf = append(r.buf, trim(line)...)
|
||
|
|
}
|
||
|
|
return r.buf, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
// skipSpace skips R over all spaces and returns the number of bytes skipped.
|
||
|
|
func (r *Reader) skipSpace() int {
|
||
|
|
n := 0
|
||
|
|
for {
|
||
|
|
c, err := r.R.ReadByte()
|
||
|
|
if err != nil {
|
||
|
|
// Bufio will keep err until next read.
|
||
|
|
break
|
||
|
|
}
|
||
|
|
if c != ' ' && c != '\t' {
|
||
|
|
r.R.UnreadByte()
|
||
|
|
break
|
||
|
|
}
|
||
|
|
n++
|
||
|
|
}
|
||
|
|
return n
|
||
|
|
}
|
||
|
|
|
||
|
|
func (r *Reader) readCodeLine(expectCode int) (code int, continued bool, message string, err error) {
|
||
|
|
line, err := r.ReadLine()
|
||
|
|
if err != nil {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
return parseCodeLine(line, expectCode)
|
||
|
|
}
|
||
|
|
|
||
|
|
func parseCodeLine(line string, expectCode int) (code int, continued bool, message string, err error) {
|
||
|
|
if len(line) < 4 || line[3] != ' ' && line[3] != '-' {
|
||
|
|
err = ProtocolError("short response: " + line)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
continued = line[3] == '-'
|
||
|
|
code, err = strconv.Atoi(line[0:3])
|
||
|
|
if err != nil || code < 100 {
|
||
|
|
err = ProtocolError("invalid response code: " + line)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
message = line[4:]
|
||
|
|
if 1 <= expectCode && expectCode < 10 && code/100 != expectCode ||
|
||
|
|
10 <= expectCode && expectCode < 100 && code/10 != expectCode ||
|
||
|
|
100 <= expectCode && expectCode < 1000 && code != expectCode {
|
||
|
|
err = &Error{code, message}
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// ReadCodeLine reads a response code line of the form
|
||
|
|
// code message
|
||
|
|
// where code is a three-digit status code and the message
|
||
|
|
// extends to the rest of the line. An example of such a line is:
|
||
|
|
// 220 plan9.bell-labs.com ESMTP
|
||
|
|
//
|
||
|
|
// If the prefix of the status does not match the digits in expectCode,
|
||
|
|
// ReadCodeLine returns with err set to &Error{code, message}.
|
||
|
|
// For example, if expectCode is 31, an error will be returned if
|
||
|
|
// the status is not in the range [310,319].
|
||
|
|
//
|
||
|
|
// If the response is multi-line, ReadCodeLine returns an error.
|
||
|
|
//
|
||
|
|
// An expectCode <= 0 disables the check of the status code.
|
||
|
|
//
|
||
|
|
func (r *Reader) ReadCodeLine(expectCode int) (code int, message string, err error) {
|
||
|
|
code, continued, message, err := r.readCodeLine(expectCode)
|
||
|
|
if err == nil && continued {
|
||
|
|
err = ProtocolError("unexpected multi-line response: " + message)
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// ReadResponse reads a multi-line response of the form:
|
||
|
|
//
|
||
|
|
// code-message line 1
|
||
|
|
// code-message line 2
|
||
|
|
// ...
|
||
|
|
// code message line n
|
||
|
|
//
|
||
|
|
// where code is a three-digit status code. The first line starts with the
|
||
|
|
// code and a hyphen. The response is terminated by a line that starts
|
||
|
|
// with the same code followed by a space. Each line in message is
|
||
|
|
// separated by a newline (\n).
|
||
|
|
//
|
||
|
|
// See page 36 of RFC 959 (https://www.ietf.org/rfc/rfc959.txt) for
|
||
|
|
// details of another form of response accepted:
|
||
|
|
//
|
||
|
|
// code-message line 1
|
||
|
|
// message line 2
|
||
|
|
// ...
|
||
|
|
// code message line n
|
||
|
|
//
|
||
|
|
// If the prefix of the status does not match the digits in expectCode,
|
||
|
|
// ReadResponse returns with err set to &Error{code, message}.
|
||
|
|
// For example, if expectCode is 31, an error will be returned if
|
||
|
|
// the status is not in the range [310,319].
|
||
|
|
//
|
||
|
|
// An expectCode <= 0 disables the check of the status code.
|
||
|
|
//
|
||
|
|
func (r *Reader) ReadResponse(expectCode int) (code int, message string, err error) {
|
||
|
|
code, continued, message, err := r.readCodeLine(expectCode)
|
||
|
|
multi := continued
|
||
|
|
for continued {
|
||
|
|
line, err := r.ReadLine()
|
||
|
|
if err != nil {
|
||
|
|
return 0, "", err
|
||
|
|
}
|
||
|
|
|
||
|
|
var code2 int
|
||
|
|
var moreMessage string
|
||
|
|
code2, continued, moreMessage, err = parseCodeLine(line, 0)
|
||
|
|
if err != nil || code2 != code {
|
||
|
|
message += "\n" + strings.TrimRight(line, "\r\n")
|
||
|
|
continued = true
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
message += "\n" + moreMessage
|
||
|
|
}
|
||
|
|
if err != nil && multi && message != "" {
|
||
|
|
// replace one line error message with all lines (full message)
|
||
|
|
err = &Error{code, message}
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// DotReader returns a new Reader that satisfies Reads using the
|
||
|
|
// decoded text of a dot-encoded block read from r.
|
||
|
|
// The returned Reader is only valid until the next call
|
||
|
|
// to a method on r.
|
||
|
|
//
|
||
|
|
// Dot encoding is a common framing used for data blocks
|
||
|
|
// in text protocols such as SMTP. The data consists of a sequence
|
||
|
|
// of lines, each of which ends in "\r\n". The sequence itself
|
||
|
|
// ends at a line containing just a dot: ".\r\n". Lines beginning
|
||
|
|
// with a dot are escaped with an additional dot to avoid
|
||
|
|
// looking like the end of the sequence.
|
||
|
|
//
|
||
|
|
// The decoded form returned by the Reader's Read method
|
||
|
|
// rewrites the "\r\n" line endings into the simpler "\n",
|
||
|
|
// removes leading dot escapes if present, and stops with error io.EOF
|
||
|
|
// after consuming (and discarding) the end-of-sequence line.
|
||
|
|
func (r *Reader) DotReader() io.Reader {
|
||
|
|
r.closeDot()
|
||
|
|
r.dot = &dotReader{r: r}
|
||
|
|
return r.dot
|
||
|
|
}
|
||
|
|
|
||
|
|
type dotReader struct {
|
||
|
|
r *Reader
|
||
|
|
state int
|
||
|
|
}
|
||
|
|
|
||
|
|
// Read satisfies reads by decoding dot-encoded data read from d.r.
|
||
|
|
func (d *dotReader) Read(b []byte) (n int, err error) {
|
||
|
|
// Run data through a simple state machine to
|
||
|
|
// elide leading dots, rewrite trailing \r\n into \n,
|
||
|
|
// and detect ending .\r\n line.
|
||
|
|
const (
|
||
|
|
stateBeginLine = iota // beginning of line; initial state; must be zero
|
||
|
|
stateDot // read . at beginning of line
|
||
|
|
stateDotCR // read .\r at beginning of line
|
||
|
|
stateCR // read \r (possibly at end of line)
|
||
|
|
stateData // reading data in middle of line
|
||
|
|
stateEOF // reached .\r\n end marker line
|
||
|
|
)
|
||
|
|
br := d.r.R
|
||
|
|
for n < len(b) && d.state != stateEOF {
|
||
|
|
var c byte
|
||
|
|
c, err = br.ReadByte()
|
||
|
|
if err != nil {
|
||
|
|
if err == io.EOF {
|
||
|
|
err = io.ErrUnexpectedEOF
|
||
|
|
}
|
||
|
|
break
|
||
|
|
}
|
||
|
|
switch d.state {
|
||
|
|
case stateBeginLine:
|
||
|
|
if c == '.' {
|
||
|
|
d.state = stateDot
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
if c == '\r' {
|
||
|
|
d.state = stateCR
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
d.state = stateData
|
||
|
|
|
||
|
|
case stateDot:
|
||
|
|
if c == '\r' {
|
||
|
|
d.state = stateDotCR
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
if c == '\n' {
|
||
|
|
d.state = stateEOF
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
d.state = stateData
|
||
|
|
|
||
|
|
case stateDotCR:
|
||
|
|
if c == '\n' {
|
||
|
|
d.state = stateEOF
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
// Not part of .\r\n.
|
||
|
|
// Consume leading dot and emit saved \r.
|
||
|
|
br.UnreadByte()
|
||
|
|
c = '\r'
|
||
|
|
d.state = stateData
|
||
|
|
|
||
|
|
case stateCR:
|
||
|
|
if c == '\n' {
|
||
|
|
d.state = stateBeginLine
|
||
|
|
break
|
||
|
|
}
|
||
|
|
// Not part of \r\n. Emit saved \r
|
||
|
|
br.UnreadByte()
|
||
|
|
c = '\r'
|
||
|
|
d.state = stateData
|
||
|
|
|
||
|
|
case stateData:
|
||
|
|
if c == '\r' {
|
||
|
|
d.state = stateCR
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
if c == '\n' {
|
||
|
|
d.state = stateBeginLine
|
||
|
|
}
|
||
|
|
}
|
||
|
|
b[n] = c
|
||
|
|
n++
|
||
|
|
}
|
||
|
|
if err == nil && d.state == stateEOF {
|
||
|
|
err = io.EOF
|
||
|
|
}
|
||
|
|
if err != nil && d.r.dot == d {
|
||
|
|
d.r.dot = nil
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// closeDot drains the current DotReader if any,
|
||
|
|
// making sure that it reads until the ending dot line.
|
||
|
|
func (r *Reader) closeDot() {
|
||
|
|
if r.dot == nil {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
buf := make([]byte, 128)
|
||
|
|
for r.dot != nil {
|
||
|
|
// When Read reaches EOF or an error,
|
||
|
|
// it will set r.dot == nil.
|
||
|
|
r.dot.Read(buf)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// ReadDotBytes reads a dot-encoding and returns the decoded data.
|
||
|
|
//
|
||
|
|
// See the documentation for the DotReader method for details about dot-encoding.
|
||
|
|
func (r *Reader) ReadDotBytes() ([]byte, error) {
|
||
|
|
return io.ReadAll(r.DotReader())
|
||
|
|
}
|
||
|
|
|
||
|
|
// ReadDotLines reads a dot-encoding and returns a slice
|
||
|
|
// containing the decoded lines, with the final \r\n or \n elided from each.
|
||
|
|
//
|
||
|
|
// See the documentation for the DotReader method for details about dot-encoding.
|
||
|
|
func (r *Reader) ReadDotLines() ([]string, error) {
|
||
|
|
// We could use ReadDotBytes and then Split it,
|
||
|
|
// but reading a line at a time avoids needing a
|
||
|
|
// large contiguous block of memory and is simpler.
|
||
|
|
var v []string
|
||
|
|
var err error
|
||
|
|
for {
|
||
|
|
var line string
|
||
|
|
line, err = r.ReadLine()
|
||
|
|
if err != nil {
|
||
|
|
if err == io.EOF {
|
||
|
|
err = io.ErrUnexpectedEOF
|
||
|
|
}
|
||
|
|
break
|
||
|
|
}
|
||
|
|
|
||
|
|
// Dot by itself marks end; otherwise cut one dot.
|
||
|
|
if len(line) > 0 && line[0] == '.' {
|
||
|
|
if len(line) == 1 {
|
||
|
|
break
|
||
|
|
}
|
||
|
|
line = line[1:]
|
||
|
|
}
|
||
|
|
v = append(v, line)
|
||
|
|
}
|
||
|
|
return v, err
|
||
|
|
}
|
||
|
|
|
||
|
|
var colon = []byte(":")
|
||
|
|
|
||
|
|
// ReadMIMEHeader reads a MIME-style header from r.
|
||
|
|
// The header is a sequence of possibly continued Key: Value lines
|
||
|
|
// ending in a blank line.
|
||
|
|
// The returned map m maps CanonicalMIMEHeaderKey(key) to a
|
||
|
|
// sequence of values in the same order encountered in the input.
|
||
|
|
//
|
||
|
|
// For example, consider this input:
|
||
|
|
//
|
||
|
|
// My-Key: Value 1
|
||
|
|
// Long-Key: Even
|
||
|
|
// Longer Value
|
||
|
|
// My-Key: Value 2
|
||
|
|
//
|
||
|
|
// Given that input, ReadMIMEHeader returns the map:
|
||
|
|
//
|
||
|
|
// map[string][]string{
|
||
|
|
// "My-Key": {"Value 1", "Value 2"},
|
||
|
|
// "Long-Key": {"Even Longer Value"},
|
||
|
|
// }
|
||
|
|
//
|
||
|
|
func (r *Reader) ReadMIMEHeader() (MIMEHeader, error) {
|
||
|
|
// Avoid lots of small slice allocations later by allocating one
|
||
|
|
// large one ahead of time which we'll cut up into smaller
|
||
|
|
// slices. If this isn't big enough later, we allocate small ones.
|
||
|
|
var strs []string
|
||
|
|
hint := r.upcomingHeaderNewlines()
|
||
|
|
if hint > 0 {
|
||
|
|
strs = make([]string, hint)
|
||
|
|
}
|
||
|
|
|
||
|
|
m := make(MIMEHeader, hint)
|
||
|
|
|
||
|
|
// The first line cannot start with a leading space.
|
||
|
|
if buf, err := r.R.Peek(1); err == nil && (buf[0] == ' ' || buf[0] == '\t') {
|
||
|
|
line, err := r.readLineSlice()
|
||
|
|
if err != nil {
|
||
|
|
return m, err
|
||
|
|
}
|
||
|
|
return m, ProtocolError("malformed MIME header initial line: " + string(line))
|
||
|
|
}
|
||
|
|
|
||
|
|
for {
|
||
|
|
kv, err := r.readContinuedLineSlice(mustHaveFieldNameColon)
|
||
|
|
if len(kv) == 0 {
|
||
|
|
return m, err
|
||
|
|
}
|
||
|
|
|
||
|
|
// Key ends at first colon.
|
||
|
|
k, v, ok := bytes.Cut(kv, colon)
|
||
|
|
if !ok {
|
||
|
|
return m, ProtocolError("malformed MIME header line: " + string(kv))
|
||
|
|
}
|
||
|
|
key := canonicalMIMEHeaderKey(k)
|
||
|
|
|
||
|
|
// As per RFC 7230 field-name is a token, tokens consist of one or more chars.
|
||
|
|
// We could return a ProtocolError here, but better to be liberal in what we
|
||
|
|
// accept, so if we get an empty key, skip it.
|
||
|
|
if key == "" {
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
|
||
|
|
// Skip initial spaces in value.
|
||
|
|
value := strings.TrimLeft(string(v), " \t")
|
||
|
|
|
||
|
|
vv := m[key]
|
||
|
|
if vv == nil && len(strs) > 0 {
|
||
|
|
// More than likely this will be a single-element key.
|
||
|
|
// Most headers aren't multi-valued.
|
||
|
|
// Set the capacity on strs[0] to 1, so any future append
|
||
|
|
// won't extend the slice into the other strings.
|
||
|
|
vv, strs = strs[:1:1], strs[1:]
|
||
|
|
vv[0] = value
|
||
|
|
m[key] = vv
|
||
|
|
} else {
|
||
|
|
m[key] = append(vv, value)
|
||
|
|
}
|
||
|
|
|
||
|
|
if err != nil {
|
||
|
|
return m, err
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// noValidation is a no-op validation func for readContinuedLineSlice
|
||
|
|
// that permits any lines.
|
||
|
|
func noValidation(_ []byte) error { return nil }
|
||
|
|
|
||
|
|
// mustHaveFieldNameColon ensures that, per RFC 7230, the
|
||
|
|
// field-name is on a single line, so the first line must
|
||
|
|
// contain a colon.
|
||
|
|
func mustHaveFieldNameColon(line []byte) error {
|
||
|
|
if bytes.IndexByte(line, ':') < 0 {
|
||
|
|
return ProtocolError(fmt.Sprintf("malformed MIME header: missing colon: %q", line))
|
||
|
|
}
|
||
|
|
return nil
|
||
|
|
}
|
||
|
|
|
||
|
|
var nl = []byte("\n")
|
||
|
|
|
||
|
|
// upcomingHeaderNewlines returns an approximation of the number of newlines
|
||
|
|
// that will be in this header. If it gets confused, it returns 0.
|
||
|
|
func (r *Reader) upcomingHeaderNewlines() (n int) {
|
||
|
|
// Try to determine the 'hint' size.
|
||
|
|
r.R.Peek(1) // force a buffer load if empty
|
||
|
|
s := r.R.Buffered()
|
||
|
|
if s == 0 {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
peek, _ := r.R.Peek(s)
|
||
|
|
return bytes.Count(peek, nl)
|
||
|
|
}
|
||
|
|
|
||
|
|
// CanonicalMIMEHeaderKey returns the canonical format of the
|
||
|
|
// MIME header key s. The canonicalization converts the first
|
||
|
|
// letter and any letter following a hyphen to upper case;
|
||
|
|
// the rest are converted to lowercase. For example, the
|
||
|
|
// canonical key for "accept-encoding" is "Accept-Encoding".
|
||
|
|
// MIME header keys are assumed to be ASCII only.
|
||
|
|
// If s contains a space or invalid header field bytes, it is
|
||
|
|
// returned without modifications.
|
||
|
|
func CanonicalMIMEHeaderKey(s string) string {
|
||
|
|
commonHeaderOnce.Do(initCommonHeader)
|
||
|
|
|
||
|
|
// Quick check for canonical encoding.
|
||
|
|
upper := true
|
||
|
|
for i := 0; i < len(s); i++ {
|
||
|
|
c := s[i]
|
||
|
|
if !validHeaderFieldByte(c) {
|
||
|
|
return s
|
||
|
|
}
|
||
|
|
if upper && 'a' <= c && c <= 'z' {
|
||
|
|
return canonicalMIMEHeaderKey([]byte(s))
|
||
|
|
}
|
||
|
|
if !upper && 'A' <= c && c <= 'Z' {
|
||
|
|
return canonicalMIMEHeaderKey([]byte(s))
|
||
|
|
}
|
||
|
|
upper = c == '-'
|
||
|
|
}
|
||
|
|
return s
|
||
|
|
}
|
||
|
|
|
||
|
|
const toLower = 'a' - 'A'
|
||
|
|
|
||
|
|
// validHeaderFieldByte reports whether b is a valid byte in a header
|
||
|
|
// field name. RFC 7230 says:
|
||
|
|
// header-field = field-name ":" OWS field-value OWS
|
||
|
|
// field-name = token
|
||
|
|
// tchar = "!" / "#" / "$" / "%" / "&" / "'" / "*" / "+" / "-" / "." /
|
||
|
|
// "^" / "_" / "`" / "|" / "~" / DIGIT / ALPHA
|
||
|
|
// token = 1*tchar
|
||
|
|
func validHeaderFieldByte(b byte) bool {
|
||
|
|
return int(b) < len(isTokenTable) && isTokenTable[b]
|
||
|
|
}
|
||
|
|
|
||
|
|
// canonicalMIMEHeaderKey is like CanonicalMIMEHeaderKey but is
|
||
|
|
// allowed to mutate the provided byte slice before returning the
|
||
|
|
// string.
|
||
|
|
//
|
||
|
|
// For invalid inputs (if a contains spaces or non-token bytes), a
|
||
|
|
// is unchanged and a string copy is returned.
|
||
|
|
func canonicalMIMEHeaderKey(a []byte) string {
|
||
|
|
// See if a looks like a header key. If not, return it unchanged.
|
||
|
|
for _, c := range a {
|
||
|
|
if validHeaderFieldByte(c) {
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
// Don't canonicalize.
|
||
|
|
return string(a)
|
||
|
|
}
|
||
|
|
|
||
|
|
upper := true
|
||
|
|
for i, c := range a {
|
||
|
|
// Canonicalize: first letter upper case
|
||
|
|
// and upper case after each dash.
|
||
|
|
// (Host, User-Agent, If-Modified-Since).
|
||
|
|
// MIME headers are ASCII only, so no Unicode issues.
|
||
|
|
if upper && 'a' <= c && c <= 'z' {
|
||
|
|
c -= toLower
|
||
|
|
} else if !upper && 'A' <= c && c <= 'Z' {
|
||
|
|
c += toLower
|
||
|
|
}
|
||
|
|
a[i] = c
|
||
|
|
upper = c == '-' // for next time
|
||
|
|
}
|
||
|
|
// The compiler recognizes m[string(byteSlice)] as a special
|
||
|
|
// case, so a copy of a's bytes into a new string does not
|
||
|
|
// happen in this map lookup:
|
||
|
|
if v := commonHeader[string(a)]; v != "" {
|
||
|
|
return v
|
||
|
|
}
|
||
|
|
return string(a)
|
||
|
|
}
|
||
|
|
|
||
|
|
// commonHeader interns common header strings.
|
||
|
|
var commonHeader map[string]string
|
||
|
|
|
||
|
|
var commonHeaderOnce sync.Once
|
||
|
|
|
||
|
|
func initCommonHeader() {
|
||
|
|
commonHeader = make(map[string]string)
|
||
|
|
for _, v := range []string{
|
||
|
|
"Accept",
|
||
|
|
"Accept-Charset",
|
||
|
|
"Accept-Encoding",
|
||
|
|
"Accept-Language",
|
||
|
|
"Accept-Ranges",
|
||
|
|
"Cache-Control",
|
||
|
|
"Cc",
|
||
|
|
"Connection",
|
||
|
|
"Content-Id",
|
||
|
|
"Content-Language",
|
||
|
|
"Content-Length",
|
||
|
|
"Content-Transfer-Encoding",
|
||
|
|
"Content-Type",
|
||
|
|
"Cookie",
|
||
|
|
"Date",
|
||
|
|
"Dkim-Signature",
|
||
|
|
"Etag",
|
||
|
|
"Expires",
|
||
|
|
"From",
|
||
|
|
"Host",
|
||
|
|
"If-Modified-Since",
|
||
|
|
"If-None-Match",
|
||
|
|
"In-Reply-To",
|
||
|
|
"Last-Modified",
|
||
|
|
"Location",
|
||
|
|
"Message-Id",
|
||
|
|
"Mime-Version",
|
||
|
|
"Pragma",
|
||
|
|
"Received",
|
||
|
|
"Return-Path",
|
||
|
|
"Server",
|
||
|
|
"Set-Cookie",
|
||
|
|
"Subject",
|
||
|
|
"To",
|
||
|
|
"User-Agent",
|
||
|
|
"Via",
|
||
|
|
"X-Forwarded-For",
|
||
|
|
"X-Imforwards",
|
||
|
|
"X-Powered-By",
|
||
|
|
} {
|
||
|
|
commonHeader[v] = v
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// isTokenTable is a copy of net/http/lex.go's isTokenTable.
|
||
|
|
// See https://httpwg.github.io/specs/rfc7230.html#rule.token.separators
|
||
|
|
var isTokenTable = [127]bool{
|
||
|
|
'!': true,
|
||
|
|
'#': true,
|
||
|
|
'$': true,
|
||
|
|
'%': true,
|
||
|
|
'&': true,
|
||
|
|
'\'': true,
|
||
|
|
'*': true,
|
||
|
|
'+': true,
|
||
|
|
'-': true,
|
||
|
|
'.': true,
|
||
|
|
'0': true,
|
||
|
|
'1': true,
|
||
|
|
'2': true,
|
||
|
|
'3': true,
|
||
|
|
'4': true,
|
||
|
|
'5': true,
|
||
|
|
'6': true,
|
||
|
|
'7': true,
|
||
|
|
'8': true,
|
||
|
|
'9': true,
|
||
|
|
'A': true,
|
||
|
|
'B': true,
|
||
|
|
'C': true,
|
||
|
|
'D': true,
|
||
|
|
'E': true,
|
||
|
|
'F': true,
|
||
|
|
'G': true,
|
||
|
|
'H': true,
|
||
|
|
'I': true,
|
||
|
|
'J': true,
|
||
|
|
'K': true,
|
||
|
|
'L': true,
|
||
|
|
'M': true,
|
||
|
|
'N': true,
|
||
|
|
'O': true,
|
||
|
|
'P': true,
|
||
|
|
'Q': true,
|
||
|
|
'R': true,
|
||
|
|
'S': true,
|
||
|
|
'T': true,
|
||
|
|
'U': true,
|
||
|
|
'W': true,
|
||
|
|
'V': true,
|
||
|
|
'X': true,
|
||
|
|
'Y': true,
|
||
|
|
'Z': true,
|
||
|
|
'^': true,
|
||
|
|
'_': true,
|
||
|
|
'`': true,
|
||
|
|
'a': true,
|
||
|
|
'b': true,
|
||
|
|
'c': true,
|
||
|
|
'd': true,
|
||
|
|
'e': true,
|
||
|
|
'f': true,
|
||
|
|
'g': true,
|
||
|
|
'h': true,
|
||
|
|
'i': true,
|
||
|
|
'j': true,
|
||
|
|
'k': true,
|
||
|
|
'l': true,
|
||
|
|
'm': true,
|
||
|
|
'n': true,
|
||
|
|
'o': true,
|
||
|
|
'p': true,
|
||
|
|
'q': true,
|
||
|
|
'r': true,
|
||
|
|
's': true,
|
||
|
|
't': true,
|
||
|
|
'u': true,
|
||
|
|
'v': true,
|
||
|
|
'w': true,
|
||
|
|
'x': true,
|
||
|
|
'y': true,
|
||
|
|
'z': true,
|
||
|
|
'|': true,
|
||
|
|
'~': true,
|
||
|
|
}
|