cogo_http/header/common/
range.rs

1use std::fmt::{self, Display};
2use std::str::FromStr;
3
4use crate::header::{Header, HeaderFormat};
5use crate::header::parsing::{from_one_raw_str, from_comma_delimited};
6
7/// `Range` header, defined in [RFC7233](https://tools.ietf.org/html/rfc7233#section-3.1)
8///
9/// The "Range" header field on a GET request modifies the method
10/// semantics to request transfer of only one or more subranges of the
11/// selected representation data, rather than the entire selected
12/// representation data.
13///
14/// # ABNF
15/// ```plain
16/// Range =	byte-ranges-specifier / other-ranges-specifier
17/// other-ranges-specifier = other-range-unit "=" other-range-set
18/// other-range-set = 1*VCHAR
19///
20/// bytes-unit = "bytes"
21///
22/// byte-ranges-specifier = bytes-unit "=" byte-range-set
23/// byte-range-set = 1#(byte-range-spec / suffix-byte-range-spec)
24/// byte-range-spec = first-byte-pos "-" [last-byte-pos]
25/// first-byte-pos = 1*DIGIT
26/// last-byte-pos = 1*DIGIT
27/// ```
28///
29/// # Example values
30/// * `bytes=1000-`
31/// * `bytes=-2000`
32/// * `bytes=0-1,30-40`
33/// * `bytes=0-10,20-90,-100`
34/// * `custom_unit=0-123`
35/// * `custom_unit=xxx-yyy`
36///
37/// # Examples
38/// ```
39/// use cogo_http::header::{Headers, Range, ByteRangeSpec};
40///
41/// let mut headers = Headers::new();
42/// headers.set(Range::Bytes(
43///     vec![ByteRangeSpec::FromTo(1, 100), ByteRangeSpec::AllFrom(200)]
44/// ));
45///
46/// headers.clear();
47/// headers.set(Range::Unregistered("letters".to_owned(), "a-f".to_owned()));
48/// ```
49/// ```
50/// use cogo_http::header::{Headers, Range};
51///
52/// let mut headers = Headers::new();
53/// headers.set(Range::bytes(1, 100));
54///
55/// headers.clear();
56/// headers.set(Range::bytes_multi(vec![(1, 100), (200, 300)]));
57/// ```
58#[derive(PartialEq, Clone, Debug)]
59pub enum Range {
60    /// Byte range
61    Bytes(Vec<ByteRangeSpec>),
62    /// Custom range, with unit not registered at IANA
63    /// (`other-range-unit`: String , `other-range-set`: String)
64    Unregistered(String, String)
65}
66
67/// Each `Range::Bytes` header can contain one or more `ByteRangeSpecs`.
68/// Each `ByteRangeSpec` defines a range of bytes to fetch
69#[derive(PartialEq, Clone, Debug)]
70pub enum ByteRangeSpec {
71    /// Get all bytes between x and y ("x-y")
72    FromTo(u64, u64),
73    /// Get all bytes starting from x ("x-")
74    AllFrom(u64),
75    /// Get last x bytes ("-x")
76    Last(u64)
77}
78
79impl Range {
80    /// Get the most common byte range header ("bytes=from-to")
81    pub fn bytes(from: u64, to: u64) -> Range {
82        Range::Bytes(vec![ByteRangeSpec::FromTo(from, to)])
83    }
84
85    /// Get byte range header with multiple subranges
86    /// ("bytes=from1-to1,from2-to2,fromX-toX")
87    pub fn bytes_multi(ranges: Vec<(u64, u64)>) -> Range {
88        Range::Bytes(ranges.iter().map(|r| ByteRangeSpec::FromTo(r.0, r.1)).collect())
89    }
90}
91
92
93impl fmt::Display for ByteRangeSpec {
94    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
95        match *self {
96            ByteRangeSpec::FromTo(from, to) => write!(f, "{}-{}", from, to),
97            ByteRangeSpec::Last(pos) => write!(f, "-{}", pos),
98            ByteRangeSpec::AllFrom(pos) => write!(f, "{}-", pos),
99        }
100    }
101}
102
103
104impl fmt::Display for Range {
105    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
106        match *self {
107            Range::Bytes(ref ranges) => {
108                r#try!(write!(f, "bytes="));
109
110                for (i, range) in ranges.iter().enumerate() {
111                    if i != 0 {
112                        r#try!(f.write_str(","));
113                    }
114                    r#try!(Display::fmt(range, f));
115                }
116                Ok(())
117            },
118            Range::Unregistered(ref unit, ref range_str) => {
119                write!(f, "{}={}", unit, range_str)
120            },
121        }
122    }
123}
124
125impl FromStr for Range {
126    type Err = crate::Error;
127
128    fn from_str(s: &str) -> crate::Result<Range> {
129        let mut iter = s.splitn(2, "=");
130
131        match (iter.next(), iter.next()) {
132            (Some("bytes"), Some(ranges)) => {
133                match from_comma_delimited(&[ranges]) {
134                    Ok(ranges) => {
135                        if ranges.is_empty() {
136                            return Err(crate::Error::Header);
137                        }
138                        Ok(Range::Bytes(ranges))
139                    },
140                    Err(_) => Err(crate::Error::Header)
141                }
142            }
143            (Some(unit), Some(range_str)) if unit != "" && range_str != "" => {
144                Ok(Range::Unregistered(unit.to_owned(), range_str.to_owned()))
145
146            },
147            _ => Err(crate::Error::Header)
148        }
149    }
150}
151
152impl FromStr for ByteRangeSpec {
153    type Err = crate::Error;
154
155    fn from_str(s: &str) -> crate::Result<ByteRangeSpec> {
156        let mut parts = s.splitn(2, "-");
157
158        match (parts.next(), parts.next()) {
159            (Some(""), Some(end)) => {
160                end.parse().or(Err(crate::Error::Header)).map(ByteRangeSpec::Last)
161            },
162            (Some(start), Some("")) => {
163                start.parse().or(Err(crate::Error::Header)).map(ByteRangeSpec::AllFrom)
164            },
165            (Some(start), Some(end)) => {
166                match (start.parse(), end.parse()) {
167                    (Ok(start), Ok(end)) if start <= end => Ok(ByteRangeSpec::FromTo(start, end)),
168                    _ => Err(crate::Error::Header)
169                }
170            },
171            _ => Err(crate::Error::Header)
172        }
173    }
174}
175
176impl Header for Range {
177
178    fn header_name() -> &'static str {
179        "Range"
180    }
181
182    fn parse_header(raw: &[Vec<u8>]) -> crate::Result<Range> {
183        from_one_raw_str(raw)
184    }
185}
186
187impl HeaderFormat for Range {
188
189    fn fmt_header(&self, f: &mut fmt::Formatter) -> fmt::Result {
190        Display::fmt(self, f)
191    }
192
193}
194
195#[test]
196fn test_parse_bytes_range_valid() {
197    let r: Range = Header::parse_header(&[b"bytes=1-100".to_vec()]).unwrap();
198    let r2: Range = Header::parse_header(&[b"bytes=1-100,-".to_vec()]).unwrap();
199    let r3 =  Range::bytes(1, 100);
200    assert_eq!(r, r2);
201    assert_eq!(r2, r3);
202
203    let r: Range = Header::parse_header(&[b"bytes=1-100,200-".to_vec()]).unwrap();
204    let r2: Range = Header::parse_header(&[b"bytes= 1-100 , 101-xxx,  200- ".to_vec()]).unwrap();
205    let r3 =  Range::Bytes(
206        vec![ByteRangeSpec::FromTo(1, 100), ByteRangeSpec::AllFrom(200)]
207    );
208    assert_eq!(r, r2);
209    assert_eq!(r2, r3);
210
211    let r: Range = Header::parse_header(&[b"bytes=1-100,-100".to_vec()]).unwrap();
212    let r2: Range = Header::parse_header(&[b"bytes=1-100, ,,-100".to_vec()]).unwrap();
213    let r3 =  Range::Bytes(
214        vec![ByteRangeSpec::FromTo(1, 100), ByteRangeSpec::Last(100)]
215    );
216    assert_eq!(r, r2);
217    assert_eq!(r2, r3);
218
219    let r: Range = Header::parse_header(&[b"custom=1-100,-100".to_vec()]).unwrap();
220    let r2 =  Range::Unregistered("custom".to_owned(), "1-100,-100".to_owned());
221    assert_eq!(r, r2);
222
223}
224
225#[test]
226fn test_parse_unregistered_range_valid() {
227    let r: Range = Header::parse_header(&[b"custom=1-100,-100".to_vec()]).unwrap();
228    let r2 =  Range::Unregistered("custom".to_owned(), "1-100,-100".to_owned());
229    assert_eq!(r, r2);
230
231    let r: Range = Header::parse_header(&[b"custom=abcd".to_vec()]).unwrap();
232    let r2 =  Range::Unregistered("custom".to_owned(), "abcd".to_owned());
233    assert_eq!(r, r2);
234
235    let r: Range = Header::parse_header(&[b"custom=xxx-yyy".to_vec()]).unwrap();
236    let r2 =  Range::Unregistered("custom".to_owned(), "xxx-yyy".to_owned());
237    assert_eq!(r, r2);
238}
239
240#[test]
241fn test_parse_invalid() {
242    let r: crate::Result<Range> = Header::parse_header(&[b"bytes=1-a,-".to_vec()]);
243    assert_eq!(r.ok(), None);
244
245    let r: crate::Result<Range> = Header::parse_header(&[b"bytes=1-2-3".to_vec()]);
246    assert_eq!(r.ok(), None);
247
248    let r: crate::Result<Range> = Header::parse_header(&[b"abc".to_vec()]);
249    assert_eq!(r.ok(), None);
250
251    let r: crate::Result<Range> = Header::parse_header(&[b"bytes=1-100=".to_vec()]);
252    assert_eq!(r.ok(), None);
253
254    let r: crate::Result<Range> = Header::parse_header(&[b"bytes=".to_vec()]);
255    assert_eq!(r.ok(), None);
256
257    let r: crate::Result<Range> = Header::parse_header(&[b"custom=".to_vec()]);
258    assert_eq!(r.ok(), None);
259
260    let r: crate::Result<Range> = Header::parse_header(&[b"=1-100".to_vec()]);
261    assert_eq!(r.ok(), None);
262}
263
264#[test]
265fn test_fmt() {
266    use crate::header::Headers;
267
268    let mut headers = Headers::new();
269
270    headers.set(
271        Range::Bytes(
272            vec![ByteRangeSpec::FromTo(0, 1000), ByteRangeSpec::AllFrom(2000)]
273    ));
274    assert_eq!(&headers.to_string(), "Range: bytes=0-1000,2000-\r\n");
275
276    headers.clear();
277    headers.set(Range::Bytes(vec![]));
278
279    assert_eq!(&headers.to_string(), "Range: bytes=\r\n");
280
281    headers.clear();
282    headers.set(Range::Unregistered("custom".to_owned(), "1-xxx".to_owned()));
283
284    assert_eq!(&headers.to_string(), "Range: custom=1-xxx\r\n");
285}
286
287bench_header!(bytes_multi, Range, { vec![b"bytes=1-1001,2001-3001,10001-".to_vec()]});
288bench_header!(custom_unit, Range, { vec![b"other=0-100000".to_vec()]});
cogo_http/header/common/range.rs

cogo_http/header/common/
range.rs
