Bound reads to their limit, treat 416 as end of file, and refuse to remove a non-empty directory
This commit is contained in:
+156
-1
@@ -72,6 +72,58 @@ pub fn outcome(status: u16) -> Result<(), ErrorCode> {
|
||||
}
|
||||
}
|
||||
|
||||
/// What a ranged GET's status means to a reader: whether a body follows. A
|
||||
/// range that starts at the end of the file draws 416 from Apache and most
|
||||
/// other servers, which for a reader is simply end of file, not a failure.
|
||||
pub fn range_outcome(status: u16) -> Result<bool, ErrorCode> {
|
||||
match status {
|
||||
416 => Ok(false),
|
||||
_ => outcome(status).map(|()| true),
|
||||
}
|
||||
}
|
||||
|
||||
/// A response body served in pieces no larger than the caller asked for. The
|
||||
/// host may hand over more than one pull wanted, so the surplus waits here for
|
||||
/// the next pull rather than being dropped or passed through oversize.
|
||||
#[derive(Default)]
|
||||
pub struct Body {
|
||||
spare: Vec<u8>,
|
||||
ended: bool,
|
||||
}
|
||||
|
||||
impl Body {
|
||||
/// A body that was never sent: every pull reports end of file.
|
||||
pub fn empty() -> Self {
|
||||
Self {
|
||||
spare: Vec::new(),
|
||||
ended: true,
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns at most `limit` bytes, drawing on `next` until the limit is met
|
||||
/// or the body ends. `next` is asked for the shortfall and may answer with
|
||||
/// more or less than that.
|
||||
pub fn pull(
|
||||
&mut self,
|
||||
limit: usize,
|
||||
mut next: impl FnMut(u32) -> Result<Vec<u8>, ErrorCode>,
|
||||
) -> Result<Vec<u8>, ErrorCode> {
|
||||
let mut data = std::mem::take(&mut self.spare);
|
||||
while data.len() < limit && !self.ended {
|
||||
let chunk = next((limit - data.len()) as u32)?;
|
||||
if chunk.is_empty() {
|
||||
self.ended = true;
|
||||
} else {
|
||||
data.extend_from_slice(&chunk);
|
||||
}
|
||||
}
|
||||
if data.len() > limit {
|
||||
self.spare = data.split_off(limit);
|
||||
}
|
||||
Ok(data)
|
||||
}
|
||||
}
|
||||
|
||||
/// One entry from a multistatus reply.
|
||||
pub struct Found {
|
||||
pub href: String,
|
||||
@@ -186,11 +238,46 @@ pub fn name_of(href: &str) -> String {
|
||||
String::from_utf8_lossy(&decoded).into_owned()
|
||||
}
|
||||
|
||||
/// The direct children in a Depth 1 reply. The first response describes the
|
||||
/// resource asked about, so it must be a collection before the rest can be
|
||||
/// called its children.
|
||||
pub fn children(found: &[Found]) -> Result<&[Found], ErrorCode> {
|
||||
match found.split_first() {
|
||||
None => Err(ErrorCode::NotFound),
|
||||
Some((first, rest)) if first.collection => Ok(rest),
|
||||
Some(_) => Err(ErrorCode::InvalidInput),
|
||||
}
|
||||
}
|
||||
|
||||
/// Whether a Depth 1 reply describes something `remove` may delete: a file,
|
||||
/// or a collection with no children. DELETE on a collection is recursive in
|
||||
/// WebDAV, so this check is the only thing keeping a whole tree.
|
||||
pub fn removable(found: &[Found]) -> Result<(), ErrorCode> {
|
||||
match children(found) {
|
||||
Ok([]) => Ok(()),
|
||||
Ok(_) => Err(ErrorCode::Conflict),
|
||||
Err(ErrorCode::InvalidInput) => Ok(()),
|
||||
Err(error) => Err(error),
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::{basic, multistatus, name_of, outcome, url};
|
||||
use super::{
|
||||
Body, Found, basic, children, multistatus, name_of, outcome, range_outcome,
|
||||
removable, url,
|
||||
};
|
||||
use crate::sdk::ErrorCode;
|
||||
|
||||
fn found(collection: bool) -> Found {
|
||||
Found {
|
||||
href: String::new(),
|
||||
collection,
|
||||
length: 0,
|
||||
etag: None,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn paths_join_onto_the_root_without_growing_a_boundary() {
|
||||
assert_eq!(
|
||||
@@ -230,6 +317,74 @@ mod tests {
|
||||
assert!(matches!(outcome(500), Err(ErrorCode::Unavailable)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_range_past_the_end_is_end_of_file_not_a_failure() {
|
||||
assert_eq!(range_outcome(206), Ok(true));
|
||||
assert_eq!(range_outcome(200), Ok(true));
|
||||
assert_eq!(range_outcome(416), Ok(false));
|
||||
assert_eq!(range_outcome(404), Err(ErrorCode::NotFound));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_body_never_hands_over_more_than_the_limit() -> Result<(), ErrorCode> {
|
||||
// The host answers every pull with a whole 10-byte piece, whatever the
|
||||
// shortfall asked for.
|
||||
let mut asked = Vec::new();
|
||||
let mut source = |wanted: u32| {
|
||||
asked.push(wanted);
|
||||
Ok(if asked.len() > 2 {
|
||||
Vec::new()
|
||||
} else {
|
||||
vec![asked.len() as u8; 10]
|
||||
})
|
||||
};
|
||||
let mut body = Body::default();
|
||||
assert_eq!(body.pull(4, &mut source)?, vec![1, 1, 1, 1]);
|
||||
// The surplus of the first piece is served before anything new is read.
|
||||
assert_eq!(body.pull(8, &mut source)?, vec![1, 1, 1, 1, 1, 1, 2, 2]);
|
||||
assert_eq!(body.pull(100, &mut source)?, vec![2; 8]);
|
||||
assert_eq!(body.pull(100, &mut source)?, Vec::<u8>::new());
|
||||
// Only the shortfall is asked for, and nothing after the body ended.
|
||||
assert_eq!(asked, vec![4, 2, 92]);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_body_keeps_reading_until_the_limit_is_met() -> Result<(), ErrorCode> {
|
||||
// A host that answers in pieces smaller than the limit is drained until
|
||||
// the limit is met, so a short piece is never mistaken for end of file.
|
||||
let mut body = Body::default();
|
||||
let mut left = 7;
|
||||
let mut source = |_wanted: u32| {
|
||||
let piece = left.min(3);
|
||||
left -= piece;
|
||||
Ok(vec![9; piece])
|
||||
};
|
||||
assert_eq!(body.pull(5, &mut source)?, vec![9; 5]);
|
||||
assert_eq!(body.pull(5, &mut source)?, vec![9; 2]);
|
||||
assert_eq!(Body::empty().pull(5, &mut source)?, Vec::<u8>::new());
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn only_an_empty_directory_or_a_file_may_be_removed() {
|
||||
assert_eq!(removable(&[found(false)]), Ok(()));
|
||||
assert_eq!(removable(&[found(true)]), Ok(()));
|
||||
assert_eq!(
|
||||
removable(&[found(true), found(false)]),
|
||||
Err(ErrorCode::Conflict)
|
||||
);
|
||||
assert_eq!(removable(&[]), Err(ErrorCode::NotFound));
|
||||
assert_eq!(
|
||||
children(&[found(false)]).err(),
|
||||
Some(ErrorCode::InvalidInput)
|
||||
);
|
||||
assert_eq!(
|
||||
children(&[found(true), found(false), found(true)]).map(<[Found]>::len),
|
||||
Ok(2)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_multistatus_reply_yields_the_collection_then_its_children()
|
||||
-> Result<(), ErrorCode> {
|
||||
|
||||
Reference in New Issue
Block a user