107 lines
2.7 KiB
Go
107 lines
2.7 KiB
Go
package main
|
|
|
|
import (
|
|
"errors"
|
|
"net/textproto"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
// errNoOverlap is returned by serveContent's parseRange if first-byte-pos of
|
|
// all of the byte-range-spec values is greater than the content size.
|
|
var errInvalidRange = errors.New("invalid range")
|
|
|
|
// httpRange specifies the byte range to be sent to the client.
|
|
type httpRange struct {
|
|
start, length int64
|
|
}
|
|
|
|
// parseRange parses a Range header string as per RFC 7233.
|
|
// errNoOverlap is returned if none of the ranges overlap.
|
|
func parseRange(s string, size int64) ([]httpRange, error) {
|
|
if s == "" {
|
|
return nil, nil // header not present
|
|
}
|
|
const b = "bytes="
|
|
if !strings.HasPrefix(s, b) {
|
|
return nil, errInvalidRange
|
|
}
|
|
var ranges []httpRange
|
|
noOverlap := false
|
|
for _, ra := range strings.Split(s[len(b):], ",") {
|
|
ra = textproto.TrimString(ra)
|
|
if ra == "" {
|
|
continue
|
|
}
|
|
start, end, ok := Cut(ra, "-")
|
|
if !ok {
|
|
return nil, errInvalidRange
|
|
}
|
|
start, end = textproto.TrimString(start), textproto.TrimString(end)
|
|
var r httpRange
|
|
if start == "" {
|
|
// If no start is specified, end specifies the
|
|
// range start relative to the end of the file,
|
|
// and we are dealing with <suffix-length>
|
|
// which has to be a non-negative integer as per
|
|
// RFC 7233 Section 2.1 "Byte-Ranges".
|
|
if end == "" || end[0] == '-' {
|
|
return nil, errInvalidRange
|
|
}
|
|
i, err := strconv.ParseInt(end, 10, 64)
|
|
if i < 0 || err != nil {
|
|
return nil, errInvalidRange
|
|
}
|
|
if i > size {
|
|
i = size
|
|
}
|
|
r.start = size - i
|
|
r.length = size - r.start
|
|
} else {
|
|
i, err := strconv.ParseInt(start, 10, 64)
|
|
if err != nil || i < 0 {
|
|
return nil, errInvalidRange
|
|
}
|
|
if i >= size {
|
|
// If the range begins after the size of the content,
|
|
// then it does not overlap.
|
|
noOverlap = true
|
|
continue
|
|
}
|
|
r.start = i
|
|
if end == "" {
|
|
// If no end is specified, range extends to end of the file.
|
|
r.length = size - r.start
|
|
} else {
|
|
i, err := strconv.ParseInt(end, 10, 64)
|
|
if err != nil || r.start > i {
|
|
return nil, errInvalidRange
|
|
}
|
|
if i >= size {
|
|
i = size - 1
|
|
}
|
|
r.length = i - r.start + 1
|
|
}
|
|
}
|
|
ranges = append(ranges, r)
|
|
}
|
|
if noOverlap && len(ranges) == 0 {
|
|
// The specified ranges did not overlap with the content.
|
|
return nil, errInvalidRange
|
|
}
|
|
return ranges, nil
|
|
}
|
|
|
|
// Cut slices s around the first instance of sep,
|
|
// returning the text before and after sep.
|
|
// The found result reports whether sep appears in s.
|
|
// If sep does not appear in s, cut returns s, nil, false.
|
|
//
|
|
// Cut returns slices of the original slice s, not copies.
|
|
func Cut(s, sep string) (before, after string, found bool) {
|
|
if i := strings.Index(s, sep); i >= 0 {
|
|
return s[:i], s[i+len(sep):], true
|
|
}
|
|
return s, "", false
|
|
}
|