WebDAV

Locks default to in-process per factory; dead properties default to xattrs (optional Cargo feature) or sidecar files next to their resources. Both can instead be moved out of the content tree — see WebDavConfig::lock_root / sidecar_root below — so several handlers can share one lock table and one property store for the same content, including a read-only content tree.

Standards

Architecture

HTTP endpoint (H1 / H2 / H3)
        │
        ▼
WebDavFactory → WebDavHandler (ServerHandler)
        │
        ├── StorageExecutor  (FS read/write off reactor)
        ├── WebDavLockManager (in-memory, or file-backed under lock_root)
        └── DeadPropertyStore (xattr | sidecar [next to resource | under sidecar_root] | none)

Auth is not implemented in this crate. Put HTTP Basic/Digest/Bearer (Auth / hopf-http auth factories) or ACL (Access control) around the listener.

Methods and Allow matrix

Method summary

Constants: MAX_WEBDAV_REQUEST_BODY = 1 MiB (PROPFIND/PROPPATCH/LOCK bodies); MAX_WEBDAV_PUT_BODY = 16 MiB (matches default HttpLimits::max_request_body — raise both for larger PUTs); DEFAULT_MAX_TREE_ENTRIES = 10 000.

Depth, headers, and locks

Supported request headers (as applicable): Depth (0 / 1 / infinity), Destination, Overwrite, If, Lock-Token, Timeout.

Depth: infinity (the PROPFIND default when Depth is omitted) is allowed, but PROPFIND and recursive COPY stop with 507 once WebDavConfig::max_tree_entries resources have been visited. Depth 0/1 are unchanged. MOVE still uses atomic rename (no tree walk).

Locks (WebDavLockManager):

Locks are per WebDavFactory process by default — not shared across hosts. Setting WebDavConfig::lock_root (issue #415) switches WebDavLockManager to file-backed records under that directory instead, keyed by each resource's path relative to root_path: every handler pointed at the same lock_root then shares the same lock table, which is what a second handler process serving the same content tree needs (its in-memory table would otherwise start empty and grant a conflicting lock). Every lock operation then does blocking file I/O, so lock_root needs a filesystem where a create-new open is atomic and one handler's write is visible to the others before they finish their own conflict check — a local disk or a true ReadWriteOnce volume, not NFS's attribute-cached semantics.

Live and dead properties

Live properties (examples): creationdate, displayname, getcontentlength, getcontenttype, getetag, getlastmodified, lockdiscovery, resourcetype, supportedlock, …

Dead properties — DeadPropMode:

Configuration

WebDavConfig (Default)

Cargo features

Wiring

use std::sync::Arc;
use hopf_core::{Runtime, RuntimeConfig, StorageConfig, TcpListenerConfig};
use hopf_http::{CleartextHttpEndpoint, HttpLimits};
use hopf_webdav::{WebDavConfig, WebDavFactory, DeadPropMode};

let rt = Arc::new(Runtime::start(RuntimeConfig {
    storage: StorageConfig::default(),
    ..RuntimeConfig::default()
})?);

let cfg = WebDavConfig {
    root_path: "/var/webdav".into(),
    allow_write: true,
    webdav_enabled: true,
    welcome_file: "index.html".into(),
    dead_property_storage: DeadPropMode::Auto,
};

let factory = Arc::new(WebDavFactory::new(cfg, Arc::clone(rt.storage()))?);
let limits = HttpLimits::default();
let endpoint_factory = {
    let f = Arc::clone(&factory);
    Arc::new(move || {
        Box::new(CleartextHttpEndpoint::new(
            Arc::clone(&f) as Arc<dyn hopf_http::ServerHandlerFactory>,
            limits,
        )) as Box<dyn hopf_core::ProtocolHandler>
    })
};

rt.add_tcp_listener(TcpListenerConfig::new(
    "127.0.0.1:8080".parse()?,
    endpoint_factory,
))?;

For HTTPS, use the same stack as HTTP TLS + ALPN: acceptor_from_pem with &[b"h2", b"http/1.1"], AlpnHttpEndpoint as the handler factory, TcpListenerConfig::with_tls(acceptor). See HTTP server and TLS → Wiring.

WebDavFactory::new creates the root directory if needed, builds the Allow header from flags, installs a default MIME map, and shares one lock manager + dead-prop store across handlers from that factory.

Parser / multistatus APIs

Useful lower-level types (also for tests / custom handlers):

Examples

See Cookbook: WebDAV.

# Cleartext WebDAV+write (example forces webdav_enabled; write default true in example)
WEBDAV_ROOT=/tmp/dav WEBDAV_WRITE=1 \
  cargo run -p webdav -- 127.0.0.1:8080 /tmp/dav

Note: the example defaults WEBDAV_WRITE to true, while WebDavConfig defaults allow_write to false.

Limitations

• Locks are in-memory per factory by default (not clustered); set WebDavConfig::lock_root to share file-backed lock records across handlers pointed at the same content, but only on a filesystem with atomic create-new and immediately-visible writes (a local disk, not NFS).
• No in-crate auth or ACL — compose with HTTP auth / PeerAcl.
• Feature xattr required for real xattrs; Auto falls back to sidecar.
• Not a standalone service crate; always behind HTTP.
• No Gumdrop-style separate WebDAV RBAC surface in this crate.

GitHub