use std::sync::Arc;
use std::sync::atomic::{AtomicBool, AtomicU32, Ordering};
use std::time::Duration;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::sync::Mutex;
use tracing::{debug, info, warn};
use super::connection::SshConnection;
use super::packet::SftpPacket;
mod error;
#[cfg(test)]
mod tests;
pub use error::SftpSessionError;
pub const SFTP_VERSION_MIN: u32 = 3;
pub const SFTP_VERSION_MAX: u32 = 3;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SftpExtension {
pub name: String,
pub data: String,
}
struct SftpIo {
stream: russh::ChannelStream<russh::client::Msg>,
recv_buffer: Vec<u8>,
}
struct InFlightRequest {
session_poisoned: Arc<AtomicBool>,
completed: bool,
}
impl InFlightRequest {
fn new(session_poisoned: Arc<AtomicBool>) -> Self {
Self {
session_poisoned,
completed: false,
}
}
fn complete(mut self) {
self.completed = true;
}
}
impl Drop for InFlightRequest {
fn drop(&mut self) {
if !self.completed {
self.session_poisoned.store(true, Ordering::Release);
}
}
}
impl std::fmt::Display for SftpExtension {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{}={}", self.name, self.data)
}
}
pub struct SftpSession {
io: Arc<Mutex<SftpIo>>,
server_version: u32,
next_request_id: Arc<AtomicU32>,
extensions: Vec<SftpExtension>,
created_at: std::time::Instant,
operation_count: Arc<AtomicU32>,
session_poisoned: Arc<AtomicBool>,
read_timeout: Duration,
}
impl std::fmt::Debug for SftpSession {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("SftpSession")
.field("server_version", &self.server_version)
.field("extensions", &self.extensions)
.field("age_secs", &self.age().as_secs())
.finish()
}
}
impl Clone for SftpSession {
fn clone(&self) -> Self {
Self {
io: Arc::clone(&self.io),
server_version: self.server_version,
next_request_id: Arc::clone(&self.next_request_id),
extensions: self.extensions.clone(),
created_at: self.created_at,
operation_count: Arc::clone(&self.operation_count),
session_poisoned: Arc::clone(&self.session_poisoned),
read_timeout: self.read_timeout,
}
}
}
impl SftpSession {
pub async fn open(conn: &mut SshConnection) -> Result<Self, SftpSessionError> {
debug!("[SFTP] Initializing SFTP session (pure Rust)...");
let channel = conn.open_sftp_channel().await?;
let read_timeout = conn.options().read_timeout;
let mut io = SftpIo {
stream: channel.into_stream(),
recv_buffer: Vec::new(),
};
let init_pkt = SftpPacket::Init { version: 3 };
let encoded = init_pkt.encode().map_err(SftpSessionError::PacketEncode)?;
Self::write_packet(&mut io, &encoded, "SFTP INIT").await?;
debug!("[SFTP] Sent SFTP INIT (version=3), awaiting VERSION...");
let version_response = Self::recv_packet_from_io(&mut io, read_timeout).await?;
let (server_version, extensions) = match version_response {
SftpPacket::Version {
version,
extensions,
} => {
Self::validate_server_version(version)?;
(version, extensions)
}
other => {
return Err(SftpSessionError::UnexpectedPacket {
expected: "VERSION",
actual_type: other.packet_type(),
});
}
};
info!(
"[SFTP] Session established (server version=v{}, supports v{}-v{}, {} extensions)",
server_version,
SFTP_VERSION_MIN,
SFTP_VERSION_MAX,
extensions.len()
);
Ok(Self {
io: Arc::new(Mutex::new(io)),
server_version,
next_request_id: Arc::new(AtomicU32::new(1)), extensions: extensions
.into_iter()
.map(|(name, data)| SftpExtension { name, data })
.collect(),
created_at: std::time::Instant::now(),
operation_count: Arc::new(AtomicU32::new(0)),
session_poisoned: Arc::new(AtomicBool::new(false)),
read_timeout,
})
}
fn validate_server_version(version: u32) -> Result<(), SftpSessionError> {
if version < SFTP_VERSION_MIN {
Err(SftpSessionError::UnsupportedVersion {
server_version: version,
minimum: SFTP_VERSION_MIN,
})
} else if version > SFTP_VERSION_MAX {
Err(SftpSessionError::UnsupportedVersionAboveMaximum {
server_version: version,
maximum: SFTP_VERSION_MAX,
})
} else {
Ok(())
}
}
async fn write_packet(
io: &mut SftpIo,
encoded: &[u8],
operation: &'static str,
) -> Result<(), SftpSessionError> {
io.stream
.write_all(encoded)
.await
.map_err(|source| SftpSessionError::ChannelWrite { operation, source })?;
io.stream
.flush()
.await
.map_err(|source| SftpSessionError::ChannelFlush { operation, source })
}
async fn recv_packet_from_io(
io: &mut SftpIo,
timeout: Duration,
) -> Result<SftpPacket, SftpSessionError> {
Self::recv_packet_from_reader(&mut io.stream, &mut io.recv_buffer, timeout).await
}
async fn recv_packet_from_reader<R>(
reader: &mut R,
recv_buffer: &mut Vec<u8>,
timeout: Duration,
) -> Result<SftpPacket, SftpSessionError>
where
R: tokio::io::AsyncRead + Unpin,
{
let deadline = tokio::time::Instant::now() + timeout;
loop {
if !recv_buffer.is_empty() {
match SftpPacket::decode(recv_buffer.as_slice()) {
Ok((packet, consumed)) => {
recv_buffer.drain(..consumed);
return Ok(packet);
}
Err(error) if error.kind() == std::io::ErrorKind::UnexpectedEof => {}
Err(error) => return Err(SftpSessionError::PacketDecode(error)),
}
}
let mut chunk = [0_u8; 32 * 1024];
let count = tokio::time::timeout_at(deadline, reader.read(&mut chunk))
.await
.map_err(|_| SftpSessionError::Timeout(timeout))?
.map_err(SftpSessionError::ChannelRead)?;
if count == 0 {
return Err(SftpSessionError::ChannelClosed);
}
recv_buffer.extend_from_slice(&chunk[..count]);
}
}
pub(super) async fn request(
&self,
mut pkt: SftpPacket,
) -> Result<SftpPacket, SftpSessionError> {
let req_id = self.allocate_request_id();
Self::set_request_id_in_packet(&mut pkt, req_id);
let encoded = pkt.encode().map_err(SftpSessionError::PacketEncode)?;
let mut io = self.io.lock().await;
if self.session_poisoned.load(Ordering::Acquire) {
return Err(SftpSessionError::SessionPoisoned);
}
let request_guard = InFlightRequest::new(Arc::clone(&self.session_poisoned));
Self::write_packet(&mut io, &encoded, "SFTP request").await?;
let response = Self::recv_packet_from_io(&mut io, self.read_timeout).await?;
let actual_id = response.request_id();
if actual_id != Some(req_id) {
return Err(SftpSessionError::RequestIdMismatch {
expected: req_id,
actual: actual_id,
});
}
self.operation_count.fetch_add(1, Ordering::Relaxed);
request_guard.complete();
Ok(response)
}
fn set_request_id_in_packet(pkt: &mut SftpPacket, new_request_id: u32) {
match pkt {
SftpPacket::Open { request_id, .. } => *request_id = new_request_id,
SftpPacket::Close { request_id, .. } => *request_id = new_request_id,
SftpPacket::Read { request_id, .. } => *request_id = new_request_id,
SftpPacket::Write { request_id, .. } => *request_id = new_request_id,
SftpPacket::Stat { request_id, .. } => *request_id = new_request_id,
SftpPacket::Lstat { request_id, .. } => *request_id = new_request_id,
SftpPacket::Fstat { request_id, .. } => *request_id = new_request_id,
SftpPacket::Setstat { request_id, .. } => *request_id = new_request_id,
SftpPacket::Fsetstat { request_id, .. } => *request_id = new_request_id,
SftpPacket::Opendir { request_id, .. } => *request_id = new_request_id,
SftpPacket::Readdir { request_id, .. } => *request_id = new_request_id,
SftpPacket::Realpath { request_id, .. } => *request_id = new_request_id,
SftpPacket::Remove { request_id, .. } => *request_id = new_request_id,
SftpPacket::Mkdir { request_id, .. } => *request_id = new_request_id,
SftpPacket::Rmdir { request_id, .. } => *request_id = new_request_id,
SftpPacket::Rename { request_id, .. } => *request_id = new_request_id,
SftpPacket::Readlink { request_id, .. } => *request_id = new_request_id,
SftpPacket::Symlink { request_id, .. } => *request_id = new_request_id,
_ => {} }
}
pub fn server_version(&self) -> u32 {
self.server_version
}
pub fn age(&self) -> Duration {
self.created_at.elapsed()
}
pub fn operation_count(&self) -> u32 {
self.operation_count.load(Ordering::Relaxed)
}
pub fn read_timeout(&self) -> Duration {
self.read_timeout
}
fn allocate_request_id(&self) -> u32 {
let id = self.next_request_id.fetch_add(1, Ordering::Relaxed);
if id == 0 {
warn!("[SFTP] Request ID counter wrapped around");
self.next_request_id.store(1, Ordering::Relaxed);
1
} else {
id
}
}
pub fn has_extension(&self, name: &str) -> bool {
self.extensions.iter().any(|ext| ext.name == name)
}
pub fn get_extension(&self, name: &str) -> Option<&SftpExtension> {
self.extensions.iter().find(|ext| ext.name == name)
}
pub fn extensions(&self) -> &[SftpExtension] {
&self.extensions
}
pub fn diagnostics(&self) -> String {
format!(
"SftpSession{{version=v{}, age={}s, ops={}, extensions=[{}]}}",
self.server_version,
self.age().as_secs(),
self.operation_count(),
self.extensions
.iter()
.map(|e| e.name.as_str())
.collect::<Vec<_>>()
.join(", ")
)
}
}