forked/h2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chore: cargo fmt, clippy

Browse Source
This commit is contained in:
Gurwinder Singh
2019-08-17 09:07:32 +05:30
committed by Sean McArthur
parent e72d6dc189
commit f46840f3fa
43 changed files with 785 additions and 870 deletions
Download Patch File Download Diff File Expand all files Collapse all files

126
src/frame/headers.rs
View File

@@ -2,8 +2,8 @@ use super::{util, StreamDependency, StreamId};
use crate::frame::{Error, Frame, Head, Kind};
use crate::hpack;
use http::{uri, HeaderMap, Method, StatusCode, Uri};
use http::header::{self, HeaderName, HeaderValue};
use http::{uri, HeaderMap, Method, StatusCode, Uri};
use bytes::{Bytes, BytesMut};
use string::String;
@@ -118,12 +118,12 @@ impl Headers {
/// Create a new HEADERS frame
pub fn new(stream_id: StreamId, pseudo: Pseudo, fields: HeaderMap) -> Self {
Headers {
stream_id: stream_id,
stream_id,
stream_dep: None,
header_block: HeaderBlock {
fields: fields,
fields,
is_over_size: false,
pseudo: pseudo,
pseudo,
},
flags: HeadersFlag::default(),
}
@@ -137,11 +137,11 @@ impl Headers {
stream_id,
stream_dep: None,
header_block: HeaderBlock {
fields: fields,
fields,
is_over_size: false,
pseudo: Pseudo::default(),
},
flags: flags,
flags,
}
}
@@ -156,7 +156,7 @@ impl Headers {
// Read the padding length
if flags.is_padded() {
if src.len() < 1 {
if src.is_empty() {
return Err(Error::MalformedMessage);
}
pad = src[0] as usize;
@@ -195,19 +195,24 @@ impl Headers {
let headers = Headers {
stream_id: head.stream_id(),
stream_dep: stream_dep,
stream_dep,
header_block: HeaderBlock {
fields: HeaderMap::new(),
is_over_size: false,
pseudo: Pseudo::default(),
},
flags: flags,
flags,
};
Ok((headers, src))
}
pub fn load_hpack(&mut self, src: &mut BytesMut, max_header_list_size: usize, decoder: &mut hpack::Decoder) -> Result<(), Error> {
pub fn load_hpack(
&mut self,
src: &mut BytesMut,
max_header_list_size: usize,
decoder: &mut hpack::Decoder,
) -> Result<(), Error> {
self.header_block.load(src, max_header_list_size, decoder)
}
@@ -263,9 +268,9 @@ impl Headers {
// Get the HEADERS frame head
let head = self.head();
self.header_block.into_encoding()
.encode(&head, encoder, dst, |_| {
})
self.header_block
.into_encoding()
.encode(&head, encoder, dst, |_| {})
}
fn head(&self) -> Head {
@@ -307,7 +312,7 @@ impl PushPromise {
// Read the padding length
if flags.is_padded() {
if src.len() < 1 {
if src.is_empty() {
return Err(Error::MalformedMessage);
}
@@ -336,19 +341,24 @@ impl PushPromise {
}
let frame = PushPromise {
flags: flags,
flags,
header_block: HeaderBlock {
fields: HeaderMap::new(),
is_over_size: false,
pseudo: Pseudo::default(),
},
promised_id: promised_id,
promised_id,
stream_id: head.stream_id(),
};
Ok((frame, src))
}
pub fn load_hpack(&mut self, src: &mut BytesMut, max_header_list_size: usize, decoder: &mut hpack::Decoder) -> Result<(), Error> {
pub fn load_hpack(
&mut self,
src: &mut BytesMut,
max_header_list_size: usize,
decoder: &mut hpack::Decoder,
) -> Result<(), Error> {
self.header_block.load(src, max_header_list_size, decoder)
}
@@ -381,7 +391,8 @@ impl PushPromise {
let head = self.head();
let promised_id = self.promised_id;
self.header_block.into_encoding()
self.header_block
.into_encoding()
.encode(&head, encoder, dst, |dst| {
dst.put_u32_be(promised_id.into());
})
@@ -456,9 +467,7 @@ impl Continuation {
// Get the CONTINUATION frame head
let head = self.head();
self.header_block
.encode(&head, encoder, dst, |_| {
})
self.header_block.encode(&head, encoder, dst, |_| {})
}
}
@@ -471,7 +480,7 @@ impl Pseudo {
let mut path = parts
.path_and_query
.map(|v| v.into())
.unwrap_or_else(|| Bytes::new());
.unwrap_or_else(Bytes::new);
if path.is_empty() && method != Method::OPTIONS {
path = Bytes::from_static(b"/");
@@ -527,13 +536,15 @@ fn to_string(src: Bytes) -> String<Bytes> {
// ===== impl EncodingHeaderBlock =====
impl EncodingHeaderBlock {
fn encode<F>(mut self,
head: &Head,
encoder: &mut hpack::Encoder,
dst: &mut BytesMut,
f: F)
-> Option<Continuation>
where F: FnOnce(&mut BytesMut),
fn encode<F>(
mut self,
head: &Head,
encoder: &mut hpack::Encoder,
dst: &mut BytesMut,
f: F,
) -> Option<Continuation>
where
F: FnOnce(&mut BytesMut),
{
let head_pos = dst.len();
@@ -610,12 +621,9 @@ impl Iterator for Iter {
self.pseudo = None;
self.fields.next().map(|(name, value)| {
Field {
name: name,
value: value,
}
})
self.fields
.next()
.map(|(name, value)| Field { name, value })
}
}
@@ -727,9 +735,13 @@ impl fmt::Debug for PushPromiseFlag {
// ===== HeaderBlock =====
impl HeaderBlock {
fn load(&mut self, src: &mut BytesMut, max_header_list_size: usize, decoder: &mut hpack::Decoder) -> Result<(), Error> {
fn load(
&mut self,
src: &mut BytesMut,
max_header_list_size: usize,
decoder: &mut hpack::Decoder,
) -> Result<(), Error> {
let mut reg = !self.fields.is_empty();
let mut malformed = false;
let mut headers_size = self.calculate_header_list_size();
@@ -744,7 +756,8 @@ impl HeaderBlock {
malformed = true;
} else {
let __val = $val;
headers_size += decoded_header_size(stringify!($ident).len() + 1, __val.as_str().len());
headers_size +=
decoded_header_size(stringify!($ident).len() + 1, __val.as_str().len());
if headers_size < max_header_list_size {
self.pseudo.$field = Some(__val);
} else if !self.is_over_size {
@@ -752,7 +765,7 @@ impl HeaderBlock {
self.is_over_size = true;
}
}
}}
}};
}
let mut cursor = Cursor::new(src);
@@ -765,10 +778,7 @@ impl HeaderBlock {
use crate::hpack::Header::*;
match header {
Field {
name,
value,
} => {
Field { name, value } => {
// Connection level header fields are not supported and must
// result in a protocol error.
@@ -794,7 +804,7 @@ impl HeaderBlock {
self.is_over_size = true;
}
}
},
}
Authority(v) => set_pseudo!(authority, v),
Method(v) => set_pseudo!(method, v),
Scheme(v) => set_pseudo!(scheme, v),
@@ -810,7 +820,7 @@ impl HeaderBlock {
if malformed {
log::trace!("malformed message");
return Err(Error::MalformedMessage.into());
return Err(Error::MalformedMessage);
}
Ok(())
@@ -835,36 +845,38 @@ impl HeaderBlock {
/// > overhead of 32 octets for each header field.
fn calculate_header_list_size(&self) -> usize {
macro_rules! pseudo_size {
($name:ident) => ({
($name:ident) => {{
self.pseudo
.$name
.as_ref()
.map(|m| decoded_header_size(stringify!($name).len() + 1, m.as_str().len()))
.unwrap_or(0)
});
}};
}
pseudo_size!(method) +
pseudo_size!(scheme) +
pseudo_size!(status) +
pseudo_size!(authority) +
pseudo_size!(path) +
self.fields.iter()
.map(|(name, value)| decoded_header_size(name.as_str().len(), value.len()))
.sum::<usize>()
pseudo_size!(method)
+ pseudo_size!(scheme)
+ pseudo_size!(status)
+ pseudo_size!(authority)
+ pseudo_size!(path)
+ self
.fields
.iter()
.map(|(name, value)| decoded_header_size(name.as_str().len(), value.len()))
.sum::<usize>()
}
/// Iterate over all pseudos and headers to see if any individual pair
/// would be too large to encode.
pub(crate) fn has_too_big_field(&self) -> bool {
macro_rules! pseudo_size {
($name:ident) => ({
($name:ident) => {{
self.pseudo
.$name
.as_ref()
.map(|m| decoded_header_size(stringify!($name).len() + 1, m.as_str().len()))
.unwrap_or(0)
});
}};
}
if pseudo_size!(method) > MAX_HEADER_LENGTH {