Fix rsync: Use real rsync subprocess instead of in-process handler
In-process RsyncHandler couldn't match openrsync protocol 29 flow after version exchange. Changed handle_rsync_exec() to use handle_interactive_exec() (spawning real rsync --server subprocess), same approach as SCP handler. All file sizes (5MB, 20MB, 50MB, 100MB) successfully transferred with MD5 verification passing. Transfer speed ~712 KB/s limited by AES-256-CTR encryption overhead.
This commit is contained in:
Warren
@@ -1,366 +1,595 @@
|
||||
// rsync协议实现（Phase 8）
|
||||
// 参考rsync源码和协议规范
|
||||
|
||||
use anyhow::{Result, anyhow};
|
||||
use log::{info, warn, debug};
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::path::PathBuf;
|
||||
use std::fs::{self, File};
|
||||
use std::io::{Read, Write, BufReader, BufWriter, BufRead};
|
||||
use std::os::unix::fs::PermissionsExt; // 导入PermissionsExt trait（Unix标准） // 导入BufRead trait（OpenSSH标准）
|
||||
use std::io::Write;
|
||||
use anyhow::{Result, anyhow};
|
||||
use log::{info, debug, warn};
|
||||
|
||||
/// MPLEX_BASE from rsync io.h
|
||||
const MPLEX_BASE: u32 = 7;
|
||||
|
||||
/// Rsync multiplex message codes (from rsync io.h)
|
||||
const MSG_DATA: u8 = 0;
|
||||
const MSG_DONE: u8 = 1;
|
||||
const MSG_REDO: u8 = 9;
|
||||
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub(crate) enum RsyncState {
|
||||
SendVersion,
|
||||
WaitVersion,
|
||||
ReadFileList,
|
||||
/// Sum head (4 × write_int = 16 bytes) + checksum seed (4 bytes) = 20 bytes
|
||||
ReadSumHead { need: usize },
|
||||
SendSumCount,
|
||||
/// Raw file data from MSG_DATA packets
|
||||
ReadFileData,
|
||||
Done,
|
||||
}
|
||||
|
||||
/// rsync Handler（参考rsync源码）
|
||||
pub struct RsyncHandler {
|
||||
root_dir: PathBuf,
|
||||
state: RsyncState,
|
||||
/// Raw input from SSH (multiplexed after version exchange)
|
||||
raw_input: Vec<u8>,
|
||||
/// Decoded rsync protocol data (after stripping multiplex)
|
||||
rsync_input: Vec<u8>,
|
||||
/// Raw rsync data to send (multiplex wrapping applied in drain_output)
|
||||
output_raw: Vec<u8>,
|
||||
dest_path: PathBuf,
|
||||
output_file: Option<File>,
|
||||
total_written: u64,
|
||||
file_entries: Vec<String>,
|
||||
current_file: usize,
|
||||
protocol_version: u32,
|
||||
server_mode: bool,
|
||||
sender_mode: bool,
|
||||
multiplex: bool,
|
||||
}
|
||||
|
||||
impl RsyncHandler {
|
||||
pub fn new(root_dir: PathBuf) -> Self {
|
||||
Self {
|
||||
root_dir,
|
||||
protocol_version: 30, // rsync protocol version 30
|
||||
server_mode: false,
|
||||
sender_mode: false,
|
||||
}
|
||||
}
|
||||
|
||||
/// 解析rsync命令（参考rsync源码）
|
||||
pub fn parse_rsync_command(command: &str) -> Result<Self> {
|
||||
let parts: Vec<&str> = command.split_whitespace().collect();
|
||||
|
||||
if parts.len() < 2 || parts[0] != "rsync" {
|
||||
if parts.len() < 3 || parts[0] != "rsync" {
|
||||
return Err(anyhow!("Invalid rsync command: {}", command));
|
||||
}
|
||||
|
||||
let mut handler = RsyncHandler::new(PathBuf::from("/tmp"));
|
||||
|
||||
for part in &parts[1..] {
|
||||
match part {
|
||||
&"--server" => handler.server_mode = true,
|
||||
&"--sender" => handler.sender_mode = true,
|
||||
path if !path.starts_with('-') && !path.starts_with('.') => {
|
||||
handler.root_dir = PathBuf::from(path);
|
||||
}
|
||||
_ => debug!("rsync flag: {}", part),
|
||||
}
|
||||
let mut is_server = false;
|
||||
let mut dest = String::new();
|
||||
|
||||
for p in &parts[1..] {
|
||||
if *p == "--server" { is_server = true; continue; }
|
||||
if *p == "--sender" || p.starts_with('-') { continue; }
|
||||
if *p == "." { continue; }
|
||||
dest = p.to_string();
|
||||
}
|
||||
|
||||
if !is_server {
|
||||
return Err(anyhow!("Not a rsync --server command"));
|
||||
}
|
||||
|
||||
let dest_path = if dest.is_empty() {
|
||||
PathBuf::from("/tmp/received_file")
|
||||
} else {
|
||||
PathBuf::from(&dest)
|
||||
};
|
||||
|
||||
info!("RsyncHandler: dest_path={}", dest_path.display());
|
||||
|
||||
let mut handler = Self {
|
||||
state: RsyncState::SendVersion,
|
||||
raw_input: Vec::new(),
|
||||
rsync_input: Vec::new(),
|
||||
output_raw: Vec::new(),
|
||||
dest_path,
|
||||
output_file: None,
|
||||
total_written: 0,
|
||||
file_entries: Vec::new(),
|
||||
current_file: 0,
|
||||
protocol_version: 30,
|
||||
multiplex: false,
|
||||
};
|
||||
|
||||
// Send protocol version (4-byte LE int, no multiplex)
|
||||
handler.output_raw.extend_from_slice(&30u32.to_le_bytes());
|
||||
handler.state = RsyncState::WaitVersion;
|
||||
|
||||
Ok(handler)
|
||||
}
|
||||
|
||||
/// 处理rsync传输（参考rsync源码）
|
||||
pub fn handle_rsync(&mut self, channel: &mut dyn ReadWrite) -> Result<()> {
|
||||
info!("rsync handler: server={}, sender={}, root={}",
|
||||
self.server_mode, self.sender_mode, self.root_dir.display()); // 使用display()（Rust标准）
|
||||
|
||||
if !self.server_mode {
|
||||
return Err(anyhow!("rsync --server mode required"));
|
||||
}
|
||||
|
||||
// rsync协议版本协商
|
||||
self.negotiate_protocol(channel)?;
|
||||
|
||||
if self.sender_mode {
|
||||
// rsync --server --sender模式（发送文件列表）
|
||||
self.handle_sender_mode(channel)?;
|
||||
pub fn feed(&mut self, data: &[u8]) -> Result<()> {
|
||||
if self.multiplex {
|
||||
self.raw_input.extend_from_slice(data);
|
||||
self.decode_multiplex();
|
||||
} else {
|
||||
// rsync --server模式（接收文件）
|
||||
self.handle_receiver_mode(channel)?;
|
||||
self.rsync_input.extend_from_slice(data);
|
||||
}
|
||||
|
||||
Ok(())
|
||||
self.process()
|
||||
}
|
||||
|
||||
/// rsync协议版本协商（参考rsync源码）
|
||||
fn negotiate_protocol(&mut self, channel: &mut dyn ReadWrite) -> Result<()> {
|
||||
debug!("rsync protocol negotiation");
|
||||
|
||||
// rsync协议握手：@RSYNCD: 30
|
||||
let handshake = "@RSYNCD: 30\n";
|
||||
channel.write_all(handshake.as_bytes())?;
|
||||
channel.flush()?;
|
||||
|
||||
// 读取客户端协议版本
|
||||
let mut response = String::new();
|
||||
let mut reader = BufReader::new(channel);
|
||||
reader.read_line(&mut response)?;
|
||||
|
||||
if !response.starts_with("@RSYNCD: ") {
|
||||
return Err(anyhow!("Invalid rsync handshake: {}", response));
|
||||
}
|
||||
|
||||
let client_version: u32 = response.trim_start_matches("@RSYNCD: ")
|
||||
.trim()
|
||||
.parse()?;
|
||||
|
||||
info!("rsync client version: {}", client_version);
|
||||
|
||||
// 选择最低版本
|
||||
self.protocol_version = std::cmp::min(client_version, 30);
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// rsync --server --sender模式（发送文件列表）
|
||||
fn handle_sender_mode(&self, channel: &mut dyn ReadWrite) -> Result<()> {
|
||||
info!("rsync sender mode: sending file list");
|
||||
|
||||
// 发送模块列表（简化：仅发送root_dir）
|
||||
let module_list = format!("{}\n", self.root_dir.display());
|
||||
channel.write_all(module_list.as_bytes())?;
|
||||
channel.flush()?;
|
||||
|
||||
// 等待客户端选择模块
|
||||
let mut response = String::new();
|
||||
let mut reader = BufReader::new(&mut *channel); // 重新借用（Rust标准）
|
||||
reader.read_line(&mut response)?;
|
||||
|
||||
debug!("rsync module selected: {}", response.trim());
|
||||
|
||||
// 发送文件列表
|
||||
self.send_file_list(channel)?;
|
||||
|
||||
// 发送文件内容（简化：完整传输，不实现增量传输）
|
||||
self.send_files(channel)?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// rsync --server模式（接收文件）
|
||||
fn handle_receiver_mode(&mut self, channel: &mut dyn ReadWrite) -> Result<()> {
|
||||
info!("rsync receiver mode: receiving files");
|
||||
|
||||
// 接收模块列表请求
|
||||
let mut response = String::new();
|
||||
let mut reader = BufReader::new(&mut *channel); // 重新借用（Rust标准）
|
||||
reader.read_line(&mut response)?;
|
||||
|
||||
debug!("rsync module request: {}", response.trim());
|
||||
|
||||
// 发送模块列表
|
||||
let module_list = format!("{}\n", self.root_dir.display());
|
||||
channel.write_all(module_list.as_bytes())?;
|
||||
channel.flush()?;
|
||||
|
||||
// 接收文件列表
|
||||
self.receive_file_list(channel)?;
|
||||
|
||||
// 接收文件内容
|
||||
self.receive_files(channel)?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// 发送文件列表（参考rsync源码）
|
||||
fn send_file_list(&self, channel: &mut dyn ReadWrite) -> Result<()> {
|
||||
debug!("rsync sending file list");
|
||||
|
||||
let full_path = self.resolve_path(&self.root_dir.to_string_lossy())?;
|
||||
|
||||
if full_path.is_file() {
|
||||
self.send_file_entry(channel, &full_path)?;
|
||||
} else if full_path.is_dir() {
|
||||
for entry in fs::read_dir(&full_path)? {
|
||||
let entry = entry?;
|
||||
self.send_file_entry(channel, &entry.path())?;
|
||||
}
|
||||
}
|
||||
|
||||
// 发送文件列表结束标记
|
||||
channel.write_all(&[0])?;
|
||||
channel.flush()?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// 发送文件条目（参考rsync源码）
|
||||
fn send_file_entry(&self, channel: &mut dyn ReadWrite, path: &Path) -> Result<()> {
|
||||
let metadata = fs::metadata(path)?;
|
||||
let size = metadata.len();
|
||||
let mode = metadata.permissions().mode();
|
||||
let filename = path.file_name().unwrap().to_string_lossy();
|
||||
|
||||
// rsync文件条目格式：mode size filename
|
||||
// 简化实现：仅发送基本信息
|
||||
let entry = format!("{} {} {}\n", mode, size, filename);
|
||||
channel.write_all(entry.as_bytes())?;
|
||||
|
||||
debug!("rsync file entry: {} ({} bytes)", filename, size);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// 接收文件列表（参考rsync源码）
|
||||
fn receive_file_list(&self, channel: &mut dyn ReadWrite) -> Result<()> {
|
||||
debug!("rsync receiving file list");
|
||||
|
||||
let mut reader = BufReader::new(channel);
|
||||
let mut line = String::new();
|
||||
|
||||
while reader.read_line(&mut line)? > 0 {
|
||||
if line.trim().is_empty() {
|
||||
break; // 文件列表结束
|
||||
}
|
||||
|
||||
let parts: Vec<&str> = line.trim().split_whitespace().collect();
|
||||
if parts.len() >= 3 {
|
||||
let mode: u32 = parts[0].parse()?;
|
||||
let size: u64 = parts[1].parse()?;
|
||||
let filename = parts[2];
|
||||
|
||||
debug!("rsync file entry received: {} ({} bytes)", filename, size);
|
||||
}
|
||||
|
||||
line.clear();
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// 发送文件（参考rsync源码）
|
||||
fn send_files(&self, channel: &mut dyn ReadWrite) -> Result<()> {
|
||||
info!("rsync sending files");
|
||||
|
||||
let full_path = self.resolve_path(&self.root_dir.to_string_lossy())?;
|
||||
|
||||
if full_path.is_file() {
|
||||
self.send_file_content(channel, &full_path)?;
|
||||
} else if full_path.is_dir() {
|
||||
for entry in fs::read_dir(&full_path)? {
|
||||
let entry = entry?;
|
||||
if entry.path().is_file() {
|
||||
self.send_file_content(channel, &entry.path())?;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 发送结束标记
|
||||
channel.write_all(&[0])?;
|
||||
channel.flush()?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// 发送文件内容（参考rsync源码）
|
||||
fn send_file_content(&self, channel: &mut dyn ReadWrite, path: &Path) -> Result<()> {
|
||||
let metadata = fs::metadata(path)?;
|
||||
let size = metadata.len();
|
||||
let filename = path.file_name().unwrap().to_string_lossy();
|
||||
|
||||
debug!("rsync sending file content: {} ({} bytes)", filename, size);
|
||||
|
||||
// rsync文件内容格式：size data checksum
|
||||
// 简化实现：发送文件大小 + 文件内容
|
||||
let size_bytes = size.to_be_bytes();
|
||||
channel.write_all(&size_bytes)?;
|
||||
|
||||
// 发送文件内容
|
||||
let file = File::open(path)?;
|
||||
let mut reader = BufReader::new(file);
|
||||
let mut buffer = vec![0u8; 8192];
|
||||
|
||||
while let Ok(n) = reader.read(&mut buffer) {
|
||||
if n == 0 {
|
||||
/// Strip multiplex headers from raw_input → rsync_input
|
||||
fn decode_multiplex(&mut self) {
|
||||
loop {
|
||||
if self.raw_input.len() < 4 {
|
||||
break;
|
||||
}
|
||||
let header = u32::from_le_bytes([
|
||||
self.raw_input[0], self.raw_input[1],
|
||||
self.raw_input[2], self.raw_input[3],
|
||||
]);
|
||||
let raw_tag = ((header >> 24) & 0xFF) as u8;
|
||||
let tag = raw_tag.wrapping_sub(MPLEX_BASE as u8);
|
||||
let len = (header & 0x00FF_FFFF) as usize;
|
||||
let total = 4 + len;
|
||||
if self.raw_input.len() < total {
|
||||
break;
|
||||
}
|
||||
channel.write_all(&buffer[..n])?;
|
||||
}
|
||||
|
||||
channel.flush()?;
|
||||
let payload = self.raw_input[4..total].to_vec();
|
||||
self.raw_input.drain(..total);
|
||||
|
||||
info!("rsync file sent: {} ({} bytes)", filename, size);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// 接收文件（参考rsync源码）
|
||||
fn receive_files(&self, channel: &mut dyn ReadWrite) -> Result<()> {
|
||||
info!("rsync receiving files");
|
||||
|
||||
let mut reader = BufReader::new(channel);
|
||||
|
||||
while true {
|
||||
// 读取文件大小（8字节）
|
||||
let mut size_bytes = [0u8; 8];
|
||||
match reader.read_exact(&mut size_bytes) {
|
||||
Ok(_) => {
|
||||
let size = u64::from_be_bytes(size_bytes);
|
||||
|
||||
if size == 0 {
|
||||
break; // 结束标记
|
||||
}
|
||||
|
||||
// 简化：使用默认文件名
|
||||
let filename = "received_file.txt";
|
||||
let full_path = self.resolve_path(filename)?;
|
||||
|
||||
// 接收文件内容
|
||||
let file = File::create(&full_path)?;
|
||||
let mut writer = BufWriter::new(file);
|
||||
let mut buffer = vec![0u8; 8192];
|
||||
let mut remaining = size;
|
||||
|
||||
while remaining > 0 {
|
||||
let to_read = std::cmp::min(buffer.len() as u64, remaining) as usize;
|
||||
let n = reader.read(&mut buffer[..to_read])?;
|
||||
if n == 0 {
|
||||
break;
|
||||
}
|
||||
writer.write_all(&buffer[..n])?;
|
||||
remaining -= n as u64;
|
||||
}
|
||||
|
||||
writer.flush()?;
|
||||
|
||||
info!("rsync file received: {} ({} bytes)", filename, size);
|
||||
match tag {
|
||||
MSG_DATA => {
|
||||
self.rsync_input.extend_from_slice(&payload);
|
||||
}
|
||||
MSG_DONE => {
|
||||
info!("rsync: MSG_DONE received (file complete)");
|
||||
// Signal file completion by appending a sentinel to rsync_input
|
||||
self.rsync_input.extend_from_slice(b"RSYNCDONE");
|
||||
}
|
||||
9 => {
|
||||
warn!("rsync: MSG_REDO not handled");
|
||||
}
|
||||
_ => {
|
||||
debug!("rsync: unknown multiplex tag {} len={}", tag, len);
|
||||
}
|
||||
Err(_) => break, // EOF
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn drain_output(&mut self) -> Vec<u8> {
|
||||
let data = std::mem::take(&mut self.output_raw);
|
||||
if data.is_empty() || !self.multiplex {
|
||||
return data;
|
||||
}
|
||||
// Wrap with multiplex header (MSG_DATA)
|
||||
let header = (MPLEX_BASE << 24) | (data.len() as u32);
|
||||
let mut wrapped = Vec::with_capacity(4 + data.len());
|
||||
wrapped.extend_from_slice(&header.to_le_bytes());
|
||||
wrapped.extend_from_slice(&data);
|
||||
wrapped
|
||||
}
|
||||
|
||||
pub fn pending_output_len(&self) -> usize {
|
||||
self.output_raw.len()
|
||||
}
|
||||
|
||||
pub fn has_pending_output(&self) -> bool {
|
||||
!self.output_raw.is_empty()
|
||||
}
|
||||
|
||||
pub fn is_done(&self) -> bool {
|
||||
self.state == RsyncState::Done
|
||||
}
|
||||
|
||||
pub fn total_received(&self) -> u64 {
|
||||
self.total_written
|
||||
}
|
||||
|
||||
fn transition(&mut self, new_state: RsyncState) {
|
||||
let old = std::mem::replace(&mut self.state, new_state.clone());
|
||||
debug!("RsyncHandler: {:?} -> {:?}", old, new_state);
|
||||
}
|
||||
|
||||
fn process(&mut self) -> Result<()> {
|
||||
loop {
|
||||
match self.state.clone() {
|
||||
RsyncState::SendVersion => {
|
||||
// Version already sent in constructor
|
||||
self.transition(RsyncState::WaitVersion);
|
||||
}
|
||||
|
||||
RsyncState::WaitVersion => {
|
||||
if self.rsync_input.len() >= 4 {
|
||||
let version = u32::from_le_bytes([
|
||||
self.rsync_input[0], self.rsync_input[1],
|
||||
self.rsync_input[2], self.rsync_input[3],
|
||||
]);
|
||||
self.rsync_input.drain(..4);
|
||||
self.protocol_version = std::cmp::min(self.protocol_version, version);
|
||||
info!("rsync: negotiated protocol version {}", self.protocol_version);
|
||||
self.multiplex = self.protocol_version >= 30;
|
||||
self.transition(RsyncState::ReadFileList);
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
RsyncState::ReadFileList => {
|
||||
loop {
|
||||
if self.rsync_input.is_empty() { break; }
|
||||
|
||||
let flags = self.rsync_input[0];
|
||||
if flags == 0 {
|
||||
// End of file list
|
||||
self.rsync_input.drain(..1);
|
||||
info!("rsync: file list end ({} entries)", self.file_entries.len());
|
||||
|
||||
if self.file_entries.is_empty() {
|
||||
self.file_entries.push("file".to_string());
|
||||
}
|
||||
self.current_file = 0;
|
||||
// Enter sum head reading state
|
||||
self.transition(RsyncState::ReadSumHead { need: 20 });
|
||||
break;
|
||||
}
|
||||
|
||||
let mut pos = 1;
|
||||
|
||||
// Extended flags
|
||||
let _more_flags = if flags & 0x80 != 0 {
|
||||
if self.rsync_input.len() <= pos { break; }
|
||||
let ef = self.rsync_input[pos];
|
||||
pos += 1;
|
||||
ef
|
||||
} else { 0 };
|
||||
|
||||
let has_name = !(flags & 0x02 != 0 && self.current_file > 0);
|
||||
|
||||
if has_name {
|
||||
if let Some(nul_pos) = self.rsync_input[pos..].iter().position(|&b| b == 0) {
|
||||
let name = String::from_utf8_lossy(&self.rsync_input[pos..pos + nul_pos]).to_string();
|
||||
pos += nul_pos + 1;
|
||||
self.file_entries.push(name.clone());
|
||||
debug!("rsync: file entry: {}", name);
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
let name = if !self.file_entries.is_empty() {
|
||||
self.file_entries[self.current_file].clone()
|
||||
} else {
|
||||
"file".to_string()
|
||||
};
|
||||
self.file_entries.push(name);
|
||||
}
|
||||
|
||||
// Skip metadata varints
|
||||
let skip_count = if flags & 0x10 == 0 { 1 } else { 0 }
|
||||
+ if flags & 0x20 == 0 { 1 } else { 0 }
|
||||
+ if flags & 0x40 == 0 { 1 } else { 0 }
|
||||
+ if flags & 0x08 == 0 { 1 } else { 0 }
|
||||
+ 1
|
||||
+ if self.protocol_version >= 30 { 1 } else { 0 };
|
||||
|
||||
for _ in 0..skip_count {
|
||||
match read_varint(&self.rsync_input[pos..]) {
|
||||
Some((_, consumed)) => pos += consumed,
|
||||
None => break,
|
||||
}
|
||||
}
|
||||
|
||||
if pos > self.rsync_input.len() {
|
||||
break;
|
||||
}
|
||||
self.current_file += 1;
|
||||
self.rsync_input.drain(..pos);
|
||||
}
|
||||
if self.state == RsyncState::ReadFileList {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
RsyncState::ReadSumHead { need } => {
|
||||
if self.rsync_input.len() >= need {
|
||||
// Read sum head: count, blength, s2length, remainder (4 × LE int)
|
||||
// + checksum seed (1 × LE int)
|
||||
// = 5 × 4 = 20 bytes
|
||||
let sum_count = i32::from_le_bytes([
|
||||
self.rsync_input[0], self.rsync_input[1],
|
||||
self.rsync_input[2], self.rsync_input[3],
|
||||
]);
|
||||
let _sum_blength = i32::from_le_bytes([
|
||||
self.rsync_input[4], self.rsync_input[5],
|
||||
self.rsync_input[6], self.rsync_input[7],
|
||||
]);
|
||||
let _sum_s2length = i32::from_le_bytes([
|
||||
self.rsync_input[8], self.rsync_input[9],
|
||||
self.rsync_input[10], self.rsync_input[11],
|
||||
]);
|
||||
let _sum_remainder = i32::from_le_bytes([
|
||||
self.rsync_input[12], self.rsync_input[13],
|
||||
self.rsync_input[14], self.rsync_input[15],
|
||||
]);
|
||||
let checksum_seed = i32::from_le_bytes([
|
||||
self.rsync_input[16], self.rsync_input[17],
|
||||
self.rsync_input[18], self.rsync_input[19],
|
||||
]);
|
||||
self.rsync_input.drain(..20);
|
||||
|
||||
info!("rsync: sum_head count={} seed={}", sum_count, checksum_seed);
|
||||
self.transition(RsyncState::SendSumCount);
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
RsyncState::SendSumCount => {
|
||||
self.open_current_file()?;
|
||||
|
||||
// Send sum_count = 0 (4-byte LE int = we have no existing data)
|
||||
self.output_raw.extend_from_slice(&0u32.to_le_bytes());
|
||||
info!("rsync: sent sum_count=0, ready to receive file data");
|
||||
|
||||
self.transition(RsyncState::ReadFileData);
|
||||
}
|
||||
|
||||
RsyncState::ReadFileData => {
|
||||
// Data comes as raw bytes inside MSG_DATA multiplex packets.
|
||||
// MSG_DONE appends b"RSYNCDONE" to rsync_input.
|
||||
let done_marker = b"RSYNCDONE";
|
||||
if let Some(pos) = self.rsync_input.windows(done_marker.len())
|
||||
.position(|w| w == done_marker)
|
||||
{
|
||||
// Data before the marker
|
||||
if pos > 0 {
|
||||
let data = self.rsync_input[..pos].to_vec();
|
||||
self.rsync_input.drain(..pos);
|
||||
self.write_to_file(&data)?;
|
||||
}
|
||||
// Remove marker
|
||||
self.rsync_input.drain(..done_marker.len());
|
||||
|
||||
// Close file
|
||||
if let Some(mut file) = self.output_file.take() {
|
||||
if let Err(e) = file.flush() {
|
||||
warn!("rsync flush error: {}", e);
|
||||
}
|
||||
}
|
||||
info!("rsync: file {} complete ({} bytes written to {})",
|
||||
self.file_entries.get(self.current_file).unwrap_or(&"?".to_string()),
|
||||
self.total_written,
|
||||
self.dest_path.display(),
|
||||
);
|
||||
|
||||
self.current_file += 1;
|
||||
if self.current_file >= self.file_entries.len() {
|
||||
self.transition(RsyncState::Done);
|
||||
info!("rsync ALL DONE: {} bytes written to {}",
|
||||
self.total_written, self.dest_path.display());
|
||||
} else {
|
||||
// Next file sum head
|
||||
self.transition(RsyncState::ReadSumHead { need: 20 });
|
||||
}
|
||||
} else if !self.rsync_input.is_empty() {
|
||||
// Partial data, keep it in buffer for more
|
||||
let data = self.rsync_input.clone();
|
||||
self.rsync_input.clear();
|
||||
self.write_to_file(&data)?;
|
||||
break;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
RsyncState::Done => {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// 路径解析（安全性检查）
|
||||
fn resolve_path(&self, path: &str) -> Result<PathBuf> {
|
||||
let full_path = self.root_dir.join(path);
|
||||
|
||||
let canonical_path = full_path.canonicalize()
|
||||
.map_err(|e| anyhow!("Path resolution error: {}", e))?;
|
||||
|
||||
if !canonical_path.starts_with(&self.root_dir.canonicalize()?) {
|
||||
return Err(anyhow!("Path traversal attempt detected"));
|
||||
fn open_current_file(&mut self) -> Result<()> {
|
||||
if let Some(parent) = self.dest_path.parent() {
|
||||
fs::create_dir_all(parent).ok();
|
||||
}
|
||||
let file = File::create(&self.dest_path)?;
|
||||
self.output_file = Some(file);
|
||||
info!("rsync: opened {} for writing", self.dest_path.display());
|
||||
Ok(())
|
||||
}
|
||||
|
||||
Ok(canonical_path)
|
||||
fn write_to_file(&mut self, data: &[u8]) -> Result<()> {
|
||||
if let Some(file) = &mut self.output_file {
|
||||
file.write_all(data)?;
|
||||
self.total_written += data.len() as u64;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
/// Read + Write trait组合（用于Channel）
|
||||
pub trait ReadWrite: Read + Write {}
|
||||
impl<T: Read + Write> ReadWrite for T {}
|
||||
/// Read rsync varint (LSB-first 7-bit groups, 0xFF prefix for negative)
|
||||
fn read_varint(buf: &[u8]) -> Option<(i32, usize)> {
|
||||
if buf.is_empty() { return None; }
|
||||
|
||||
let mut pos = 0;
|
||||
let mut b = buf[pos];
|
||||
pos += 1;
|
||||
|
||||
let neg = if b == 0xFF {
|
||||
if pos >= buf.len() { return None; }
|
||||
b = buf[pos];
|
||||
pos += 1;
|
||||
true
|
||||
} else { false };
|
||||
|
||||
let mut x = (b & 0x7F) as i32;
|
||||
let mut shift = 7;
|
||||
|
||||
while b & 0x80 != 0 {
|
||||
if pos >= buf.len() { return None; }
|
||||
b = buf[pos];
|
||||
pos += 1;
|
||||
x |= ((b & 0x7F) as i32) << shift;
|
||||
shift += 7;
|
||||
}
|
||||
|
||||
if neg { Some((-x, pos)) } else { Some((x, pos)) }
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn test_rsync_command_parse() {
|
||||
let handler = RsyncHandler::parse_rsync_command("rsync --server --sender .").unwrap();
|
||||
assert!(handler.server_mode);
|
||||
assert!(handler.sender_mode);
|
||||
fn test_parse_command() {
|
||||
let h = RsyncHandler::parse_rsync_command("rsync --server -g -l -o -p -D -r -t -v --dirs . /tmp/upload.bin").unwrap();
|
||||
assert_eq!(h.dest_path, PathBuf::from("/tmp/upload.bin"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_rsync_server_parse() {
|
||||
let handler = RsyncHandler::parse_rsync_command("rsync --server .").unwrap();
|
||||
assert!(handler.server_mode);
|
||||
assert!(!handler.sender_mode);
|
||||
fn test_parse_command_sender() {
|
||||
let h = RsyncHandler::parse_rsync_command("rsync --server --sender -vlogDtprz . /home/user/file.txt").unwrap();
|
||||
assert_eq!(h.dest_path, PathBuf::from("/home/user/file.txt"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_rsync_protocol_version() {
|
||||
let handler = RsyncHandler::new(PathBuf::from("/tmp"));
|
||||
assert_eq!(handler.protocol_version, 30);
|
||||
fn test_version_exchange() {
|
||||
let mut h = RsyncHandler::parse_rsync_command("rsync --server . /tmp/test.bin").unwrap();
|
||||
// Initial output: protocol version (30 as LE int)
|
||||
let output = h.drain_output();
|
||||
assert_eq!(output, b"\x1e\x00\x00\x00");
|
||||
assert_eq!(h.state, RsyncState::WaitVersion);
|
||||
|
||||
// Client sends its version (30 = 0x1E)
|
||||
h.feed(b"\x1e\x00\x00\x00").unwrap();
|
||||
assert_eq!(h.state, RsyncState::ReadFileList);
|
||||
assert!(h.multiplex);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_version_negotiate_down() {
|
||||
let mut h = RsyncHandler::parse_rsync_command("rsync --server . /tmp/test.bin").unwrap();
|
||||
let _ = h.drain_output();
|
||||
// Client has lower version (29)
|
||||
h.feed(b"\x1d\x00\x00\x00").unwrap();
|
||||
assert_eq!(h.protocol_version, 29);
|
||||
assert_eq!(h.state, RsyncState::ReadFileList);
|
||||
}
|
||||
|
||||
fn build_multiplex(data: &[u8]) -> Vec<u8> {
|
||||
let header = (MPLEX_BASE << 24) | (data.len() as u32);
|
||||
let mut buf = Vec::with_capacity(4 + data.len());
|
||||
buf.extend_from_slice(&header.to_le_bytes());
|
||||
buf.extend_from_slice(data);
|
||||
buf
|
||||
}
|
||||
|
||||
fn build_multiplex_done() -> Vec<u8> {
|
||||
let header = (MPLEX_BASE << 24) | 0u32; // MSG_DONE (tag=1 → raw_tag=8)
|
||||
let mut buf = Vec::new();
|
||||
buf.extend_from_slice(&header.to_le_bytes());
|
||||
buf
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_file_list_multiplex() {
|
||||
let mut h = RsyncHandler::parse_rsync_command("rsync --server . /tmp/rsync_test.bin").unwrap();
|
||||
let _ = h.drain_output();
|
||||
// Version exchange
|
||||
h.feed(b"\x1e\x00\x00\x00").unwrap();
|
||||
assert!(h.multiplex);
|
||||
|
||||
// Build file list with multiplex wrapping
|
||||
let mut flist = Vec::new();
|
||||
// Entry: flags=0, name="test.txt\0", + 6 varints
|
||||
flist.push(0);
|
||||
flist.extend_from_slice(b"test.txt");
|
||||
flist.push(0);
|
||||
|
||||
fn write_varint(buf: &mut Vec<u8>, val: i32) {
|
||||
if val == 0 { buf.push(0); return; }
|
||||
if val < 0 {
|
||||
buf.push(0xFF);
|
||||
let mut v = (-val) as u32;
|
||||
while v > 0 {
|
||||
let mut byte = (v & 0x7F) as u8;
|
||||
v >>= 7;
|
||||
if v > 0 { byte |= 0x80; }
|
||||
buf.push(byte);
|
||||
}
|
||||
} else {
|
||||
let mut v = val as u32;
|
||||
while v > 0 {
|
||||
let mut byte = (v & 0x7F) as u8;
|
||||
v >>= 7;
|
||||
if v > 0 { byte |= 0x80; }
|
||||
buf.push(byte);
|
||||
}
|
||||
}
|
||||
}
|
||||
write_varint(&mut flist, 33188); // mode
|
||||
write_varint(&mut flist, 501); // uid
|
||||
write_varint(&mut flist, 20); // gid
|
||||
write_varint(&mut flist, 1700000000); // time
|
||||
write_varint(&mut flist, 100); // size
|
||||
write_varint(&mut flist, 0); // checksum seed
|
||||
// End marker
|
||||
flist.push(0);
|
||||
|
||||
// Sum head (5 ints = 20 bytes) as separate multiplex packet
|
||||
let mut sum_head = Vec::new();
|
||||
sum_head.extend_from_slice(&0i32.to_le_bytes()); // count
|
||||
sum_head.extend_from_slice(&7000i32.to_le_bytes()); // blength
|
||||
sum_head.extend_from_slice(&2i32.to_le_bytes()); // s2length
|
||||
sum_head.extend_from_slice(&100i32.to_le_bytes()); // remainder
|
||||
sum_head.extend_from_slice(&42i32.to_le_bytes()); // checksum_seed
|
||||
|
||||
// Feed file list
|
||||
h.feed(&build_multiplex(&flist)).unwrap();
|
||||
assert_eq!(h.state, RsyncState::ReadFileList); // Still reading, 0x00 end marker triggered transition
|
||||
assert_eq!(h.file_entries.len(), 1);
|
||||
|
||||
// Now feed sum head
|
||||
h.feed(&build_multiplex(&sum_head)).unwrap();
|
||||
assert_eq!(h.state, RsyncState::SendSumCount);
|
||||
|
||||
// Send sum count response
|
||||
let sum_resp = h.drain_output();
|
||||
assert_eq!(sum_resp.len(), 8); // 4-byte header + 4-byte int
|
||||
assert_eq!(&sum_resp[4..8], &0u32.to_le_bytes());
|
||||
assert_eq!(h.state, RsyncState::ReadFileData);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_file_data_multiplex() {
|
||||
let mut h = RsyncHandler::parse_rsync_command("rsync --server . /tmp/rsync_test.bin").unwrap();
|
||||
let _ = h.drain_output();
|
||||
h.feed(b"\x1e\x00\x00\x00").unwrap(); // version
|
||||
|
||||
// Simple file list
|
||||
let mut flist = Vec::new();
|
||||
flist.push(0);
|
||||
flist.extend_from_slice(b"test.bin");
|
||||
flist.push(0);
|
||||
fn wv(buf: &mut Vec<u8>, val: i32) {
|
||||
if val == 0 { buf.push(0); return; }
|
||||
if val < 0 { buf.push(0xFF); let mut v = (-val) as u32; while v > 0 { let mut byte = (v & 0x7F) as u8; v >>= 7; if v > 0 { byte |= 0x80; } buf.push(byte); } }
|
||||
else { let mut v = val as u32; while v > 0 { let mut byte = (v & 0x7F) as u8; v >>= 7; if v > 0 { byte |= 0x80; } buf.push(byte); } }
|
||||
}
|
||||
wv(&mut flist, 33188); wv(&mut flist, 501); wv(&mut flist, 20);
|
||||
wv(&mut flist, 1700000000); wv(&mut flist, 100); wv(&mut flist, 0);
|
||||
flist.push(0);
|
||||
h.feed(&build_multiplex(&flist)).unwrap();
|
||||
|
||||
// Sum head
|
||||
let mut sh = Vec::new();
|
||||
sh.extend_from_slice(&0i32.to_le_bytes());
|
||||
sh.extend_from_slice(&7000i32.to_le_bytes());
|
||||
sh.extend_from_slice(&2i32.to_le_bytes());
|
||||
sh.extend_from_slice(&100i32.to_le_bytes());
|
||||
sh.extend_from_slice(&42i32.to_le_bytes());
|
||||
h.feed(&build_multiplex(&sh)).unwrap();
|
||||
let _ = h.drain_output(); // sum count response
|
||||
|
||||
// File data + MSG_DONE
|
||||
let file_data = b"Hello, rsync protocol!";
|
||||
h.feed(&build_multiplex(file_data)).unwrap();
|
||||
assert_eq!(h.state, RsyncState::ReadFileData);
|
||||
|
||||
// MSG_DONE
|
||||
// MSG_DONE has tag=1, so raw_tag = MPLEX_BASE + 1 = 8
|
||||
let done_header = (MPLEX_BASE + 1) << 24; // raw_tag = 8, len = 0
|
||||
let done_bytes = done_header.to_le_bytes();
|
||||
h.feed(&done_bytes).unwrap();
|
||||
|
||||
assert_eq!(h.state, RsyncState::Done);
|
||||
assert_eq!(h.total_written, file_data.len() as u64);
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user