mod error;
mod format;
#[cfg(test)]
mod tests;
pub use error::SyncError;
pub use format::*;
use alloc::vec::Vec;
use crate::base::channel::Channel;
use crate::base::decimal::format_u32;
use crate::base::protocol::features::Feature;
use crate::base::recv_buf::RecvBuf;
use crate::base::session::Session;
use crate::error::Error;
use format::{u32_at, SyncId, DENT_V1_SIZE, DENT_V2_SIZE, STAT_V1_SIZE};
const FLAG_FEATURES: [(SyncFlags, Feature); 4] = [
(SyncFlags::BROTLI, Feature::SendrecvV2Brotli),
(SyncFlags::LZ4, Feature::SendrecvV2Lz4),
(SyncFlags::ZSTD, Feature::SendrecvV2Zstd),
(SyncFlags::DRY_RUN, Feature::SendrecvV2DryRunSend),
];
const COMPRESSION: [SyncFlags; 3] = [SyncFlags::BROTLI, SyncFlags::LZ4, SyncFlags::ZSTD];
fn check_path(path: &str) -> Result<(), SyncError> {
if path.contains('\0') {
return Err(SyncError::InvalidPath);
}
Ok(())
}
pub struct SyncSession<'a, 'b, S> {
channel: Channel<'a, S>,
rx: RecvBuf<'b>,
}
impl<'a, 'b, S: Session> SyncSession<'a, 'b, S> {
pub fn new(channel: Channel<'a, S>, buf: &'b mut [u8]) -> Self {
assert!(
buf.len() >= HEADER_SIZE,
"SyncSession buffer must be at least {} bytes",
HEADER_SIZE,
);
Self {
channel,
rx: RecvBuf::new(buf),
}
}
fn require_sendrecv_v2(&self, flags: SyncFlags) -> Result<(), Error<S::IoError>> {
if COMPRESSION.iter().filter(|&&c| flags.contains(c)).count() > 1 {
return Err(SyncError::InvalidFlags(flags).into());
}
self.channel.session.require_feature(Feature::SendrecvV2)?;
for (flag, feature) in FLAG_FEATURES {
if flags.contains(flag) {
self.channel.session.require_feature(feature)?;
}
}
Ok(())
}
fn peek_id(&self) -> [u8; 4] {
self.rx.peek(4).try_into().expect("peeked four bytes")
}
fn peek_u32(&self, offset: usize) -> u32 {
u32_at(self.rx.peek(offset + 4), offset)
}
async fn write_header(&mut self, id: SyncId, arg: u32) -> Result<(), Error<S::IoError>> {
let mut hdr = [0u8; HEADER_SIZE];
hdr[..4].copy_from_slice(&id.as_bytes());
hdr[4..8].copy_from_slice(&arg.to_le_bytes());
self.channel.write(&hdr).await
}
async fn write_request(
&mut self,
id: SyncId,
parts: &[&[u8]],
) -> Result<(), Error<S::IoError>> {
let arg_len: usize = parts.iter().map(|p| p.len()).sum();
self.write_message(id, arg_len as u32, parts).await
}
async fn write_message(
&mut self,
id: SyncId,
arg: u32,
parts: &[&[u8]],
) -> Result<(), Error<S::IoError>> {
let total = HEADER_SIZE + parts.iter().map(|p| p.len()).sum::<usize>();
self.rx.compact();
let window = self.rx.window();
if total <= window.len() {
window[..4].copy_from_slice(&id.as_bytes());
window[4..8].copy_from_slice(&arg.to_le_bytes());
let mut off = HEADER_SIZE;
for p in parts {
window[off..off + p.len()].copy_from_slice(p);
off += p.len();
}
self.channel.write(&window[..total]).await
} else {
self.write_header(id, arg).await?;
for p in parts {
if !p.is_empty() {
self.channel.write(p).await?;
}
}
Ok(())
}
}
async fn read_next_id(&mut self, allowed: &[SyncId]) -> Result<SyncId, Error<S::IoError>> {
self.rx
.fill_at_least(&mut self.channel, HEADER_SIZE)
.await?;
let raw = self.peek_id();
match SyncId::from_bytes(raw) {
Some(SyncId::Fail) => {
let msg = self.read_fail_body().await?;
Err(SyncError::Failed(msg).into())
}
Some(id) if allowed.contains(&id) => Ok(id),
_ => Err(SyncError::UnexpectedId(raw).into()),
}
}
async fn pushed(
&mut self,
sent: Result<(), Error<S::IoError>>,
) -> Result<(), Error<S::IoError>> {
match sent {
Err(Error::ChannelClosed) => match self.read_next_id(&[]).await {
Err(failed @ Error::Sync(SyncError::Failed(_))) => Err(failed),
_ => Err(Error::ChannelClosed),
},
sent => sent,
}
}
async fn read_fail_body(&mut self) -> Result<Vec<u8>, Error<S::IoError>> {
let msg_len = self.peek_u32(4) as usize;
self.rx.advance(HEADER_SIZE);
let kept = msg_len.min(self.rx.capacity());
if kept > 0 {
self.rx.fill_at_least(&mut self.channel, kept).await?;
}
let msg = self.rx.take(kept).to_vec();
let mut left = msg_len - kept;
while left > 0 {
let chunk = left.min(self.rx.capacity());
self.rx.fill_at_least(&mut self.channel, chunk).await?;
self.rx.advance(chunk);
left -= chunk;
}
Ok(msg)
}
pub async fn stat(&mut self, path: &str) -> Result<StatV1, Error<S::IoError>> {
check_path(path)?;
self.rx.compact();
self.write_request(SyncId::Stat, &[path.as_bytes()]).await?;
self.read_next_id(&[SyncId::Stat]).await?;
self.rx
.fill_at_least(&mut self.channel, STAT_V1_SIZE)
.await?;
let mode = FileMode(self.peek_u32(4));
let size = self.peek_u32(8);
let mtime = self.peek_u32(12);
self.rx.advance(STAT_V1_SIZE);
Ok(StatV1 { mode, size, mtime })
}
pub async fn stat_v2(&mut self, path: &str) -> Result<StatV2, Error<S::IoError>> {
check_path(path)?;
self.channel.session.require_feature(Feature::StatV2)?;
self.rx.compact();
self.write_request(SyncId::Sta2, &[path.as_bytes()]).await?;
self.read_next_id(&[SyncId::Sta2]).await?;
self.rx
.fill_at_least(&mut self.channel, STAT_V2_SIZE)
.await?;
let body = &self.rx.peek(STAT_V2_SIZE)[4..];
let stat = parse_stat_v2_body(body.try_into().expect("checked STAT_V2_SIZE bytes"));
self.rx.advance(STAT_V2_SIZE);
if stat.error != 0 {
return Err(SyncError::RemoteErrno(stat.error).into());
}
Ok(stat)
}
pub async fn list(&mut self, path: &str) -> Result<Vec<DirEntry>, Error<S::IoError>> {
check_path(path)?;
self.rx.compact();
self.write_request(SyncId::List, &[path.as_bytes()]).await?;
let mut entries = Vec::new();
loop {
if self.read_next_id(&[SyncId::Dent, SyncId::Done]).await? == SyncId::Done {
self.rx
.fill_at_least(&mut self.channel, DENT_V1_SIZE)
.await?;
self.rx.advance(DENT_V1_SIZE);
return Ok(entries);
}
self.rx
.fill_at_least(&mut self.channel, DENT_V1_SIZE)
.await?;
let mode = FileMode(self.peek_u32(4));
let size = self.peek_u32(8);
let mtime = self.peek_u32(12);
let namelen = self.peek_u32(16) as usize;
self.rx.advance(DENT_V1_SIZE);
self.rx.fill_at_least(&mut self.channel, namelen).await?;
let name = self.rx.take(namelen).to_vec();
entries.push(DirEntry {
name,
mode,
size,
mtime,
});
}
}
pub async fn list_v2(&mut self, path: &str) -> Result<Vec<DirEntryV2>, Error<S::IoError>> {
check_path(path)?;
self.channel.session.require_feature(Feature::LsV2)?;
self.rx.compact();
self.write_request(SyncId::Lis2, &[path.as_bytes()]).await?;
let mut entries = Vec::new();
loop {
if self.read_next_id(&[SyncId::Dnt2, SyncId::Done]).await? == SyncId::Done {
self.rx
.fill_at_least(&mut self.channel, DENT_V2_SIZE)
.await?;
self.rx.advance(DENT_V2_SIZE);
return Ok(entries);
}
self.rx
.fill_at_least(&mut self.channel, DENT_V2_SIZE)
.await?;
let body = &self.rx.peek(STAT_V2_SIZE)[4..];
let stat = parse_stat_v2_body(body.try_into().expect("checked STAT_V2_SIZE bytes"));
let namelen = self.peek_u32(72) as usize;
self.rx.advance(DENT_V2_SIZE);
self.rx.fill_at_least(&mut self.channel, namelen).await?;
let name = self.rx.take(namelen).to_vec();
entries.push(DirEntryV2 { name, stat });
}
}
pub async fn recv_start(&mut self, path: &str) -> Result<(), Error<S::IoError>> {
check_path(path)?;
self.rx.compact();
self.write_request(SyncId::Recv, &[path.as_bytes()]).await
}
pub async fn recv_v2_start(
&mut self,
path: &str,
flags: SyncFlags,
) -> Result<(), Error<S::IoError>> {
check_path(path)?;
if flags.contains(SyncFlags::DRY_RUN) {
return Err(SyncError::InvalidFlags(flags).into());
}
self.require_sendrecv_v2(flags)?;
let path_bytes = path.as_bytes();
self.write_message(
SyncId::Rcv2,
path_bytes.len() as u32,
&[
path_bytes,
&SyncId::Rcv2.as_bytes(),
&flags.bits().to_le_bytes(),
],
)
.await
}
pub async fn recv_next(&mut self) -> Result<Option<&[u8]>, Error<S::IoError>> {
self.rx.compact();
if self.read_next_id(&[SyncId::Data, SyncId::Done]).await? == SyncId::Done {
self.rx.advance(HEADER_SIZE);
return Ok(None);
}
let data_len = self.peek_u32(4) as usize;
let chunk_len = HEADER_SIZE
.checked_add(data_len)
.ok_or(Error::ReceiveBufferFull)?;
self.rx.fill_at_least(&mut self.channel, chunk_len).await?;
self.rx.advance(HEADER_SIZE);
Ok(Some(self.rx.take(data_len)))
}
pub async fn recv(&mut self, path: &str) -> Result<Vec<u8>, Error<S::IoError>> {
self.recv_start(path).await?;
let mut data = Vec::new();
while let Some(chunk) = self.recv_next().await? {
data.extend_from_slice(chunk);
}
Ok(data)
}
pub async fn recv_v2(
&mut self,
path: &str,
flags: SyncFlags,
) -> Result<Vec<u8>, Error<S::IoError>> {
self.recv_v2_start(path, flags).await?;
let mut data = Vec::new();
while let Some(chunk) = self.recv_next().await? {
data.extend_from_slice(chunk);
}
Ok(data)
}
pub async fn send_start(
&mut self,
path: &str,
mode: FileMode,
) -> Result<(), Error<S::IoError>> {
check_path(path)?;
let mut mode_dec = [0u8; 10];
let mode_str = format_u32(mode.0, &mut mode_dec);
let sent = self
.write_request(SyncId::Send, &[path.as_bytes(), b",", mode_str])
.await;
self.pushed(sent).await
}
pub async fn send_v2_start(
&mut self,
path: &str,
mode: FileMode,
flags: SyncFlags,
) -> Result<(), Error<S::IoError>> {
check_path(path)?;
self.require_sendrecv_v2(flags)?;
let path_bytes = path.as_bytes();
let sent = self
.write_message(
SyncId::Snd2,
path_bytes.len() as u32,
&[
path_bytes,
&SyncId::Snd2.as_bytes(),
&mode.0.to_le_bytes(),
&flags.bits().to_le_bytes(),
],
)
.await;
self.pushed(sent).await
}
pub async fn send_data(&mut self, data: &[u8]) -> Result<(), Error<S::IoError>> {
for chunk in data.chunks(SYNC_DATA_MAX) {
let sent = self.write_request(SyncId::Data, &[chunk]).await;
self.pushed(sent).await?;
}
Ok(())
}
pub async fn send_done(&mut self, mtime: u32) -> Result<(), Error<S::IoError>> {
let sent = self.write_header(SyncId::Done, mtime).await;
self.pushed(sent).await?;
self.rx.compact();
self.read_next_id(&[SyncId::Okay]).await?;
self.rx.advance(HEADER_SIZE);
Ok(())
}
pub async fn send(
&mut self,
path: &str,
mode: FileMode,
mtime: u32,
data: &[u8],
) -> Result<(), Error<S::IoError>> {
self.send_start(path, mode).await?;
self.send_data(data).await?;
self.send_done(mtime).await
}
pub async fn send_v2(
&mut self,
path: &str,
mode: FileMode,
mtime: u32,
flags: SyncFlags,
data: &[u8],
) -> Result<(), Error<S::IoError>> {
self.send_v2_start(path, mode, flags).await?;
self.send_data(data).await?;
self.send_done(mtime).await
}
pub async fn quit(mut self) -> Result<(), Error<S::IoError>> {
let sent = match self.write_header(SyncId::Quit, 0).await {
Err(Error::ChannelClosed) => Ok(()),
sent => sent,
};
let closed = self.channel.close().await;
sent.and(closed)
}
}
pub async fn open<'a, 'b, S: Session>(
session: &'a mut S,
buf: &'b mut [u8],
) -> Result<SyncSession<'a, 'b, S>, Error<S::IoError>> {
let channel = session.open(b"sync:\0").await?;
Ok(SyncSession::new(channel, buf))
}