Open a WebDAV server as a folder in Memona
This commit is contained in:
+262
@@ -0,0 +1,262 @@
|
||||
//! WebDAV wire details: addressing, credentials, and the one XML reply shape
|
||||
//! this provider reads.
|
||||
|
||||
use crate::sdk::ErrorCode;
|
||||
|
||||
const UNRESERVED: &[u8] = b"-._~";
|
||||
const BASE64: &[u8; 64] =
|
||||
b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
||||
|
||||
/// Percent-encodes one path segment. Slashes are excluded deliberately: the
|
||||
/// caller joins segments, so an encoded name can never grow a path boundary.
|
||||
fn segment(value: &str) -> String {
|
||||
let mut encoded = String::with_capacity(value.len());
|
||||
for byte in value.as_bytes() {
|
||||
if byte.is_ascii_alphanumeric() || UNRESERVED.contains(byte) {
|
||||
encoded.push(*byte as char);
|
||||
} else {
|
||||
encoded.push_str(&format!("%{byte:02X}"));
|
||||
}
|
||||
}
|
||||
encoded
|
||||
}
|
||||
|
||||
/// Joins a connection-relative path onto the configured root.
|
||||
pub fn url(root: &str, path: &str) -> String {
|
||||
let mut url = root.trim_end_matches('/').to_owned();
|
||||
for part in path.split('/').filter(|part| !part.is_empty()) {
|
||||
url.push('/');
|
||||
url.push_str(&segment(part));
|
||||
}
|
||||
if path.ends_with('/') && path.len() > 1 {
|
||||
url.push('/');
|
||||
}
|
||||
url
|
||||
}
|
||||
|
||||
pub fn basic(username: &str, password: &str) -> String {
|
||||
let raw = format!("{username}:{password}");
|
||||
let bytes = raw.as_bytes();
|
||||
let mut encoded = String::from("Basic ");
|
||||
for chunk in bytes.chunks(3) {
|
||||
let mut block = [0u8; 3];
|
||||
block[..chunk.len()].copy_from_slice(chunk);
|
||||
let packed = u32::from(block[0]) << 16
|
||||
| u32::from(block[1]) << 8
|
||||
| u32::from(block[2]);
|
||||
for index in 0..4 {
|
||||
if index <= chunk.len() {
|
||||
let position = (packed >> (18 - index * 6)) & 0x3f;
|
||||
encoded.push(BASE64[position as usize] as char);
|
||||
} else {
|
||||
encoded.push('=');
|
||||
}
|
||||
}
|
||||
}
|
||||
encoded
|
||||
}
|
||||
|
||||
/// What a WebDAV status means to a filesystem caller. A body is never shown to
|
||||
/// the user, so only the code is translated.
|
||||
pub fn outcome(status: u16) -> Result<(), ErrorCode> {
|
||||
match status {
|
||||
200..=299 => Ok(()),
|
||||
401 | 403 => Err(ErrorCode::Denied),
|
||||
404 | 410 => Err(ErrorCode::NotFound),
|
||||
405 | 409 | 412 => Err(ErrorCode::Conflict),
|
||||
// A lock is someone else holding the resource, which is a conflict to
|
||||
// resolve rather than a permission to grant.
|
||||
423 => Err(ErrorCode::Conflict),
|
||||
501 => Err(ErrorCode::Unsupported),
|
||||
_ => Err(ErrorCode::Unavailable),
|
||||
}
|
||||
}
|
||||
|
||||
/// One entry from a multistatus reply.
|
||||
pub struct Found {
|
||||
pub href: String,
|
||||
pub collection: bool,
|
||||
pub length: u64,
|
||||
pub etag: Option<String>,
|
||||
}
|
||||
|
||||
/// Reads the `response` elements of a multistatus body, keeping only the four
|
||||
/// properties this provider asked for. Unknown elements and namespaces other
|
||||
/// than DAV: are skipped rather than rejected, because servers add their own.
|
||||
pub fn multistatus(body: &[u8]) -> Result<Vec<Found>, ErrorCode> {
|
||||
let mut reader = quick_xml::Reader::from_reader(body);
|
||||
reader.config_mut().trim_text(true);
|
||||
let mut found = Vec::new();
|
||||
let mut current: Option<Found> = None;
|
||||
let mut field = None;
|
||||
let mut buffer = Vec::new();
|
||||
loop {
|
||||
let event = reader
|
||||
.read_event_into(&mut buffer)
|
||||
.map_err(|_| ErrorCode::Unavailable)?;
|
||||
match event {
|
||||
quick_xml::events::Event::Eof => break,
|
||||
quick_xml::events::Event::Start(tag) => match local(tag.name().0) {
|
||||
b"response" => {
|
||||
current = Some(Found {
|
||||
href: String::new(),
|
||||
collection: false,
|
||||
length: 0,
|
||||
etag: None,
|
||||
});
|
||||
}
|
||||
b"collection" => {
|
||||
if let Some(entry) = current.as_mut() {
|
||||
entry.collection = true;
|
||||
}
|
||||
}
|
||||
name @ (b"href" | b"getcontentlength" | b"getetag") => {
|
||||
field = Some(name.to_vec());
|
||||
}
|
||||
_ => field = None,
|
||||
},
|
||||
quick_xml::events::Event::Empty(tag) => {
|
||||
if local(tag.name().0) == b"collection"
|
||||
&& let Some(entry) = current.as_mut()
|
||||
{
|
||||
entry.collection = true;
|
||||
}
|
||||
}
|
||||
quick_xml::events::Event::Text(text) => {
|
||||
let (Some(entry), Some(name)) = (current.as_mut(), field.as_deref())
|
||||
else {
|
||||
continue;
|
||||
};
|
||||
let value = text.unescape().map_err(|_| ErrorCode::Unavailable)?;
|
||||
match name {
|
||||
b"href" => entry.href = value.into_owned(),
|
||||
b"getcontentlength" => {
|
||||
entry.length = value.trim().parse().unwrap_or(0);
|
||||
}
|
||||
b"getetag" => entry.etag = Some(value.trim().to_owned()),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
quick_xml::events::Event::End(tag) => {
|
||||
field = None;
|
||||
if local(tag.name().0) == b"response"
|
||||
&& let Some(entry) = current.take()
|
||||
{
|
||||
found.push(entry);
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
buffer.clear();
|
||||
if found.len() > 4096 {
|
||||
return Err(ErrorCode::Unavailable);
|
||||
}
|
||||
}
|
||||
Ok(found)
|
||||
}
|
||||
|
||||
/// Strips any namespace prefix, so `d:href` and `D:href` read the same.
|
||||
fn local(name: &[u8]) -> &[u8] {
|
||||
match name.iter().position(|byte| *byte == b':') {
|
||||
Some(index) => &name[index + 1..],
|
||||
None => name,
|
||||
}
|
||||
}
|
||||
|
||||
/// The last non-empty segment of an href, percent-decoded.
|
||||
pub fn name_of(href: &str) -> String {
|
||||
let trimmed = href.trim_end_matches('/');
|
||||
let tail = trimmed.rsplit('/').next().unwrap_or(trimmed);
|
||||
let bytes = tail.as_bytes();
|
||||
let mut decoded = Vec::with_capacity(bytes.len());
|
||||
let mut index = 0;
|
||||
while index < bytes.len() {
|
||||
if bytes[index] == b'%' && index + 2 < bytes.len() {
|
||||
let high = (bytes[index + 1] as char).to_digit(16);
|
||||
let low = (bytes[index + 2] as char).to_digit(16);
|
||||
if let (Some(high), Some(low)) = (high, low) {
|
||||
decoded.push((high * 16 + low) as u8);
|
||||
index += 3;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
decoded.push(bytes[index]);
|
||||
index += 1;
|
||||
}
|
||||
String::from_utf8_lossy(&decoded).into_owned()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::{basic, multistatus, name_of, outcome, url};
|
||||
use crate::sdk::ErrorCode;
|
||||
|
||||
#[test]
|
||||
fn paths_join_onto_the_root_without_growing_a_boundary() {
|
||||
assert_eq!(
|
||||
url("https://dav.example/files/", "/"),
|
||||
"https://dav.example/files"
|
||||
);
|
||||
assert_eq!(
|
||||
url("https://dav.example/files", "/notes/today.md"),
|
||||
"https://dav.example/files/notes/today.md"
|
||||
);
|
||||
// A slash inside a name is encoded, so it cannot become a new segment.
|
||||
assert_eq!(
|
||||
url("https://dav.example", "/a b/c%d"),
|
||||
"https://dav.example/a%20b/c%25d"
|
||||
);
|
||||
assert_eq!(
|
||||
url("https://dav.example", "/papers/"),
|
||||
"https://dav.example/papers/"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn credentials_encode_the_way_basic_auth_expects() {
|
||||
assert_eq!(basic("user", "pass"), "Basic dXNlcjpwYXNz");
|
||||
assert_eq!(basic("a", ""), "Basic YTo=");
|
||||
assert_eq!(basic("ab", ""), "Basic YWI6");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn statuses_keep_denied_missing_and_conflicting_apart() {
|
||||
assert!(outcome(207).is_ok());
|
||||
assert!(matches!(outcome(401), Err(ErrorCode::Denied)));
|
||||
assert!(matches!(outcome(404), Err(ErrorCode::NotFound)));
|
||||
assert!(matches!(outcome(412), Err(ErrorCode::Conflict)));
|
||||
// A locked resource is someone else holding it, not a permission to grant.
|
||||
assert!(matches!(outcome(423), Err(ErrorCode::Conflict)));
|
||||
assert!(matches!(outcome(500), Err(ErrorCode::Unavailable)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_multistatus_reply_yields_the_collection_then_its_children()
|
||||
-> Result<(), ErrorCode> {
|
||||
let body = br#"<?xml version="1.0"?>
|
||||
<D:multistatus xmlns:D="DAV:">
|
||||
<D:response>
|
||||
<D:href>/files/notes/</D:href>
|
||||
<D:propstat><D:prop><D:resourcetype><D:collection/></D:resourcetype>
|
||||
</D:prop><D:status>HTTP/1.1 200 OK</D:status></D:propstat>
|
||||
</D:response>
|
||||
<D:response>
|
||||
<D:href>/files/notes/a%20b.md</D:href>
|
||||
<D:propstat><D:prop>
|
||||
<D:resourcetype/>
|
||||
<D:getcontentlength>42</D:getcontentlength>
|
||||
<D:getetag>"v1"</D:getetag>
|
||||
</D:prop><D:status>HTTP/1.1 200 OK</D:status></D:propstat>
|
||||
</D:response>
|
||||
</D:multistatus>"#;
|
||||
let found = multistatus(body)?;
|
||||
assert_eq!(found.len(), 2);
|
||||
assert!(found[0].collection);
|
||||
assert!(!found[1].collection);
|
||||
assert_eq!(found[1].length, 42);
|
||||
assert_eq!(found[1].etag.as_deref(), Some("\"v1\""));
|
||||
assert_eq!(name_of(&found[0].href), "notes");
|
||||
assert_eq!(name_of(&found[1].href), "a b.md");
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user