use crate::error::{NetconfClientError, NetconfClientResult};
use crate::framer::{Framer, NETCONF_1_0_TERMINATOR};
use async_trait::async_trait;
use core::fmt;
use log::{debug, trace};
use memchr::memmem;
use std::io;
use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
pub const DEFAULT_MAX_MESSAGE_SIZE: usize = 256 * 1024 * 1024;
const MAX_CHUNK_DIGITS: usize = 10;
const READ_CHUNK: usize = 8 * 1024;
pub struct AsyncFramer<T> {
read_buffer: Vec<u8>,
upgraded: bool,
max_message_size: usize,
channel: T,
}
impl<T> fmt::Debug for AsyncFramer<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("AsyncFramer")
.field("upgraded", &self.upgraded)
.field("max_message_size", &self.max_message_size)
.field("buffered", &self.read_buffer.len())
.finish_non_exhaustive()
}
}
impl<T: AsyncRead + AsyncWrite + Unpin> AsyncFramer<T> {
pub fn new(channel: T) -> Self {
AsyncFramer {
read_buffer: Vec::new(),
upgraded: false,
max_message_size: DEFAULT_MAX_MESSAGE_SIZE,
channel,
}
}
pub fn set_max_message_size(&mut self, limit: usize) {
self.max_message_size = limit;
}
pub(crate) fn push_incoming(&mut self, bytes: &[u8]) {
self.read_buffer.extend_from_slice(bytes);
}
pub fn channel_mut(&mut self) -> &mut T {
&mut self.channel
}
fn too_large(&self) -> NetconfClientError {
NetconfClientError::MessageTooLarge {
limit: self.max_message_size,
}
}
fn unexpected_eof(msg: &str) -> NetconfClientError {
io::Error::new(io::ErrorKind::UnexpectedEof, msg).into()
}
async fn read_exact_from_incoming(&mut self, dest: &mut [u8]) -> NetconfClientResult<()> {
let mut filled = 0;
while filled < dest.len() {
if self.read_buffer.is_empty() {
let mut buf = [0u8; READ_CHUNK];
let n = self.channel.read(&mut buf).await?;
if n == 0 {
return Err(Self::unexpected_eof(
"connection closed in NETCONF 1.1 chunk",
));
}
self.read_buffer.extend_from_slice(&buf[..n]);
}
let take = (dest.len() - filled).min(self.read_buffer.len());
dest[filled..filled + take].copy_from_slice(&self.read_buffer[..take]);
self.read_buffer.drain(..take);
filled += take;
}
Ok(())
}
async fn read_header(&mut self) -> NetconfClientResult<u32> {
let mut buffer = [0u8; 2];
self.read_exact_from_incoming(&mut buffer).await?;
if buffer[0] != b'\n' {
return Err(NetconfClientError::MalformedChunk {
expected: '\n',
actual: buffer[0].into(),
});
}
if buffer[1] != b'#' {
return Err(NetconfClientError::MalformedChunk {
expected: '#',
actual: buffer[1].into(),
});
}
let mut chunk_size: u32 = 0;
let mut digits = 0usize;
loop {
let mut buffer = [0u8; 1];
self.read_exact_from_incoming(&mut buffer).await?;
let last_read = buffer[0];
if last_read == b'#' && digits == 0 {
continue;
}
if last_read == b'\n' {
return Ok(chunk_size);
}
if !last_read.is_ascii_digit() {
return Err(NetconfClientError::MalformedChunk {
expected: '0',
actual: last_read.into(),
});
}
digits += 1;
if digits > MAX_CHUNK_DIGITS {
return Err(self.too_large());
}
chunk_size = chunk_size
.checked_mul(10)
.and_then(|size| size.checked_add(u32::from(last_read - b'0')))
.ok_or_else(|| self.too_large())?;
}
}
async fn read_chunked(&mut self) -> NetconfClientResult<String> {
let mut message = Vec::new();
loop {
let chunk_size = self.read_header().await? as usize;
if chunk_size == 0 {
break;
}
if chunk_size > self.max_message_size.saturating_sub(message.len()) {
return Err(self.too_large());
}
let start = message.len();
message.resize(start + chunk_size, 0);
self.read_exact_from_incoming(&mut message[start..]).await?;
}
Ok(String::from_utf8_lossy(&message).trim_end().to_string())
}
async fn read_end_of_message(&mut self) -> NetconfClientResult<String> {
let terminator = NETCONF_1_0_TERMINATOR.as_bytes();
let mut buffer = [0u8; READ_CHUNK];
let mut scanned = 0;
loop {
if let Some(offset) = memmem::find(&self.read_buffer[scanned..], terminator) {
let end = scanned + offset;
let response = String::from_utf8_lossy(&self.read_buffer[..end])
.trim_end()
.to_string();
self.read_buffer.drain(..end + terminator.len());
if !self.read_buffer.is_empty() {
debug!(
"1.0 leftover {} bytes after terminator",
self.read_buffer.len()
);
}
return Ok(response);
}
scanned = self.read_buffer.len().saturating_sub(terminator.len() - 1);
if self.read_buffer.len() > self.max_message_size {
return Err(self.too_large());
}
let bytes = self.channel.read(&mut buffer).await?;
if bytes == 0 {
return Err(io::Error::new(
io::ErrorKind::UnexpectedEof,
"connection closed before the NETCONF 1.0 message terminator",
)
.into());
}
self.read_buffer.extend_from_slice(&buffer[..bytes]);
}
}
}
#[async_trait]
impl<T: AsyncRead + AsyncWrite + Unpin + Send> Framer for AsyncFramer<T> {
async fn upgrade(&mut self) {
self.upgraded = true;
}
async fn read_async(&mut self) -> NetconfClientResult<String> {
let result = if self.upgraded {
self.read_chunked().await
} else {
self.read_end_of_message().await
};
if result.is_err() {
self.read_buffer.clear();
}
result
}
async fn write_async(&mut self, rpc: &str) -> NetconfClientResult<()> {
trace!("rpc:\n{}", rpc);
let bytes = rpc.as_bytes();
if self.upgraded {
let header = format!("\n#{}\n", bytes.len());
let mut frame = Vec::with_capacity(header.len() + bytes.len() + 4);
frame.extend_from_slice(header.as_bytes());
frame.extend_from_slice(bytes);
frame.extend_from_slice(b"\n##\n");
debug!(
"1.1 write {} payload bytes (frame {})",
bytes.len(),
frame.len()
);
self.channel.write_all(&frame).await?;
} else {
self.channel.write_all(bytes).await?;
self.channel
.write_all(NETCONF_1_0_TERMINATOR.as_bytes())
.await?;
}
self.channel.flush().await?;
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
use pretty_assertions::assert_eq;
use std::io::Cursor;
#[test]
fn debug_omits_channel() {
let framer = AsyncFramer::new(Cursor::new(Vec::<u8>::new()));
let dbg = format!("{framer:?}");
assert!(dbg.contains("upgraded: false"), "{dbg}");
assert!(dbg.contains("buffered: 0"), "{dbg}");
}
#[tokio::test]
async fn test_chunked_framer() {
let rpc_error = r#"
#38
<?xml version="1.0" encoding="UTF-8"?>
#1
#10
<rpc-reply
#50
message-id="8ddd59e5-96fc-4a55-a75f-a3fae2d9f712"
#48
xmlns="urn:ietf:params:xml:ns:netconf:base:1.0"
#1
>
#1
#14
<rpc-error
#1
>
#1
#41
<error-type>protocol</error-type>
#1
#42
<error-tag>bad-element</error-tag>
#1
#46
<error-severity>error</error-severity>
#1
#22
<error-message
#1
>
#1
#58
Element is not valid in the specified context.
#1
#24
</error-message>
#1
#19
<error-info
#1
>
#1
#45
<bad-element>startu</bad-element>
#1
#21
</error-info>
#1
#16
</rpc-error>
#1
#12
</rpc-reply>
##
"#
.to_string();
let channel = Cursor::new(rpc_error.into_bytes());
let mut framer = AsyncFramer::new(channel);
framer.upgrade().await;
let resp = framer.read_async().await.unwrap();
let expected = r#"
<?xml version="1.0" encoding="UTF-8"?>
<rpc-reply message-id="8ddd59e5-96fc-4a55-a75f-a3fae2d9f712" xmlns="urn:ietf:params:xml:ns:netconf:base:1.0">
<rpc-error>
<error-type>protocol</error-type>
<error-tag>bad-element</error-tag>
<error-severity>error</error-severity>
<error-message>
Element is not valid in the specified context.
</error-message>
<error-info>
<bad-element>startu</bad-element>
</error-info>
</rpc-error>
</rpc-reply>
"#;
assert_eq!(resp, expected.trim());
}
#[tokio::test]
async fn test_eof_framer() {
let rpc_error = r#"
<?xml version="1.0" encoding="UTF-8"?>
<rpc-reply message-id="8ddd59e5-96fc-4a55-a75f-a3fae2d9f712" xmlns="urn:ietf:params:xml:ns:netconf:base:1.0">
<rpc-error>
<error-type>protocol</error-type>
<error-tag>bad-element</error-tag>
<error-severity>error</error-severity>
<error-message>
Element is not valid in the specified context.
</error-message>
<error-info>
<bad-element>startu</bad-element>
</error-info>
</rpc-error>
</rpc-reply>
]]>]]>"#;
let channel = Cursor::new(rpc_error.trim().as_bytes().to_vec());
let mut framer = AsyncFramer::new(channel);
let resp = framer.read_async().await.unwrap();
let expected = r#"
<?xml version="1.0" encoding="UTF-8"?>
<rpc-reply message-id="8ddd59e5-96fc-4a55-a75f-a3fae2d9f712" xmlns="urn:ietf:params:xml:ns:netconf:base:1.0">
<rpc-error>
<error-type>protocol</error-type>
<error-tag>bad-element</error-tag>
<error-severity>error</error-severity>
<error-message>
Element is not valid in the specified context.
</error-message>
<error-info>
<bad-element>startu</bad-element>
</error-info>
</rpc-error>
</rpc-reply>
"#;
assert_eq!(resp, expected.trim());
}
#[tokio::test]
async fn eof_without_terminator_is_an_error() {
let channel = Cursor::new(b"<rpc-reply/>".to_vec());
let mut framer = AsyncFramer::new(channel);
let err = framer.read_async().await.unwrap_err();
assert!(
matches!(&err, NetconfClientError::Io(io) if io.kind() == io::ErrorKind::UnexpectedEof),
"expected UnexpectedEof, got {err:?}"
);
}
#[tokio::test]
async fn terminator_split_across_reads_is_found() {
let (client, mut server) = tokio::io::duplex(64);
let writer = tokio::spawn(async move {
server.write_all(b"<ok/>]]").await.unwrap();
server.write_all(b">]]>rest").await.unwrap();
});
let mut framer = AsyncFramer::new(client);
assert_eq!(framer.read_async().await.unwrap(), "<ok/>");
writer.await.unwrap();
}
#[tokio::test]
async fn chunk_header_digits_are_bounded() {
let channel = Cursor::new(b"\n#99999999999\nx".to_vec());
let mut framer = AsyncFramer::new(channel);
framer.upgrade().await;
assert!(matches!(
framer.read_async().await.unwrap_err(),
NetconfClientError::MessageTooLarge { .. }
));
}
#[tokio::test]
async fn chunk_larger_than_limit_is_rejected() {
let channel = Cursor::new(b"\n#4000000000\n".to_vec());
let mut framer = AsyncFramer::new(channel);
framer.upgrade().await;
assert!(matches!(
framer.read_async().await.unwrap_err(),
NetconfClientError::MessageTooLarge { .. }
));
}
#[tokio::test]
async fn garbage_in_chunk_header_is_rejected() {
let channel = Cursor::new(b"\n#12#34\nx".to_vec());
let mut framer = AsyncFramer::new(channel);
framer.upgrade().await;
assert!(matches!(
framer.read_async().await.unwrap_err(),
NetconfClientError::MalformedChunk { .. }
));
}
#[tokio::test]
async fn eof_framer_keeps_pipelined_bytes() {
let channel = Cursor::new(b"<one/>]]>]]><two/>]]>]]>".to_vec());
let mut framer = AsyncFramer::new(channel);
assert_eq!(framer.read_async().await.unwrap(), "<one/>");
assert_eq!(framer.read_async().await.unwrap(), "<two/>");
}
fn chunked(xml: &str) -> Vec<u8> {
let mut out = format!("\n#{}\n", xml.len()).into_bytes();
out.extend_from_slice(xml.as_bytes());
out.extend_from_slice(b"\n##\n");
out
}
#[tokio::test]
async fn chunked_read_uses_bytes_left_after_1_0_hello() {
let reply =
"<rpc-reply xmlns=\"urn:ietf:params:xml:ns:netconf:base:1.0\"><ok/></rpc-reply>";
let mut wire = b"<hello/>]]>]]>".to_vec();
wire.extend_from_slice(&chunked(reply));
let mut framer = AsyncFramer::new(Cursor::new(wire));
assert_eq!(framer.read_async().await.unwrap(), "<hello/>");
framer.upgrade().await;
assert_eq!(framer.read_async().await.unwrap(), reply);
}
}