use std::io;
use std::mem::MaybeUninit;
use std::net::SocketAddr;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex, MutexGuard};
use std::time::Instant;
use rustorb_giop::{FragmentAssembler, Message, MessageHeader, Version};
use tokio::sync::Notify;
use crate::sock::ReadHalf;
use crate::tls::Tls;
use crate::trace;
pub(crate) struct PeerAddr(pub(crate) Option<SocketAddr>);
impl std::fmt::Display for PeerAddr {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self.0 {
Some(addr) => addr.fmt(f),
None => f.write_str("an unknown peer"),
}
}
}
const READ_AHEAD: usize = 16 * 1024;
#[derive(Debug)]
pub(crate) enum ReadError {
Closed(io::Error),
BadHeader(String),
TooLarge(usize, Version),
Truncated(io::Error),
Malformed(Version, String),
}
type ReadFn<'a> = dyn FnMut(&mut [MaybeUninit<u8>]) -> io::Result<usize> + 'a;
#[derive(Debug)]
struct MessageReader {
buf: Vec<u8>,
start: usize,
large: Option<(MessageHeader, Vec<u8>)>,
max_message_size: usize,
}
impl MessageReader {
fn new(max_message_size: usize) -> MessageReader {
MessageReader {
buf: Vec::with_capacity(READ_AHEAD),
start: 0,
large: None,
max_message_size,
}
}
fn starts_large(&self) -> bool {
let buffered = &self.buf[self.start..];
self.large.is_some()
|| buffered.len() >= MessageHeader::SIZE
&& MessageHeader::parse(&buffered[..MessageHeader::SIZE])
.is_ok_and(|h| h.total_len() > READ_AHEAD)
}
fn has_buffered(&self) -> bool {
self.start < self.buf.len() || self.large.is_some()
}
fn next(
&mut self,
read: &mut ReadFn<'_>,
defer_large: bool,
) -> Result<Option<(MessageHeader, Vec<u8>)>, ReadError> {
loop {
if let Some((header, msg)) = &mut self.large {
let total = header.total_len();
while msg.len() < total {
let left = total - msg.len();
match read(&mut msg.spare_capacity_mut()[..left]) {
Ok(0) => {
return Err(ReadError::Truncated(io::ErrorKind::UnexpectedEof.into()));
}
Ok(n) => {
unsafe { msg.set_len(msg.len() + n) };
}
Err(e) if e.kind() == io::ErrorKind::Interrupted => {}
Err(e) if e.kind() == io::ErrorKind::WouldBlock => return Ok(None),
Err(e) => return Err(ReadError::Truncated(e)),
}
}
return Ok(self.large.take());
}
let buffered = &self.buf[self.start..];
if buffered.len() >= MessageHeader::SIZE {
let header = MessageHeader::parse(&buffered[..MessageHeader::SIZE])
.map_err(|e| ReadError::BadHeader(e.to_string()))?;
let total = header.total_len();
if total > self.max_message_size {
return Err(ReadError::TooLarge(total, header.version));
}
if buffered.len() >= total {
let msg = buffered[..total].to_vec();
self.start += total;
return Ok(Some((header, msg)));
}
if total > READ_AHEAD {
if defer_large {
return Ok(None);
}
let mut msg = Vec::with_capacity(total);
msg.extend_from_slice(buffered);
self.start = self.buf.len();
self.large = Some((header, msg));
continue;
}
}
match self.fill(read) {
Ok(true) => {}
Ok(false) => return Ok(None),
Err(e) => return Err(e),
}
}
}
fn fill(&mut self, read: &mut ReadFn<'_>) -> Result<bool, ReadError> {
if self.start == self.buf.len() {
self.buf.clear();
self.start = 0;
} else if self.buf.len() == self.buf.capacity() {
self.buf.drain(..self.start);
self.start = 0;
}
let at_boundary = self.start == self.buf.len();
loop {
match read(self.buf.spare_capacity_mut()) {
Ok(0) => {
let eof = io::Error::from(io::ErrorKind::UnexpectedEof);
return Err(if at_boundary {
ReadError::Closed(eof)
} else {
ReadError::Truncated(eof)
});
}
Ok(n) => {
unsafe { self.buf.set_len(self.buf.len() + n) };
return Ok(true);
}
Err(e) if e.kind() == io::ErrorKind::Interrupted => {}
Err(e) if e.kind() == io::ErrorKind::WouldBlock => return Ok(false),
Err(e) if at_boundary => return Err(ReadError::Closed(e)),
Err(e) => return Err(ReadError::Truncated(e)),
}
}
}
fn drain(&mut self, read: &mut ReadFn<'_>) -> bool {
if self.large.is_none() {
while self.buf.len() < self.buf.capacity() || self.start > 0 {
match self.fill(read) {
Ok(true) => {}
Ok(false) => break,
Err(_) => return true,
}
}
}
self.has_buffered()
}
}
#[derive(Debug)]
pub(crate) struct ReadSide {
reader: MessageReader,
pub(crate) assembler: FragmentAssembler,
held: Option<Result<(Version, Message), ReadError>>,
peer: Option<SocketAddr>,
}
impl ReadSide {
fn next(
&mut self,
read: &mut ReadFn<'_>,
defer_large: bool,
) -> Result<Option<(Version, Message)>, ReadError> {
if let Some(held) = self.held.take() {
return held.map(Some);
}
loop {
let Some((header, msg)) = self.reader.next(read, defer_large)? else {
return Ok(None);
};
trace::trace!(
"received {} from {}",
trace::MessageSummary(&msg, msg.len()),
PeerAddr(self.peer)
);
let version = header.version;
let malformed = |e: rustorb_giop::Error| ReadError::Malformed(version, e.to_string());
let Some(whole) = self.assembler.push_owned(msg).map_err(malformed)? else {
continue;
};
let (_, message) = whole.into_decoded().map_err(malformed)?;
return Ok(Some((version, message)));
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Holder {
Task { active: bool },
Thread,
Busy,
}
#[derive(Debug)]
pub(crate) enum Here {
Message(Version, Message),
TimedOut,
HandedBack,
}
#[derive(Debug)]
pub(crate) struct Inbound {
stream: ReadHalf,
tls: Option<Arc<Tls>>,
holder: Mutex<Holder>,
side: Mutex<ReadSide>,
back: Notify,
handed_back: AtomicBool,
peer: Option<SocketAddr>,
}
impl Inbound {
pub(crate) fn new(stream: ReadHalf, tls: Option<Arc<Tls>>, max_message_size: usize) -> Inbound {
let peer = stream.peer_addr();
Inbound {
stream,
tls,
holder: Mutex::new(Holder::Task { active: true }),
side: Mutex::new(ReadSide {
reader: MessageReader::new(max_message_size),
assembler: FragmentAssembler::new(max_message_size),
held: None,
peer,
}),
back: Notify::new(),
handed_back: AtomicBool::new(false),
peer,
}
}
fn read(&self, raw: &mut ReadFn<'_>, buf: &mut [MaybeUninit<u8>]) -> io::Result<usize> {
match &self.tls {
Some(tls) => tls.read(buf, raw),
None => raw(buf),
}
}
pub(crate) fn side(&self) -> MutexGuard<'_, ReadSide> {
self.side.lock().unwrap()
}
pub(crate) fn peer(&self) -> PeerAddr {
PeerAddr(self.peer)
}
pub(crate) fn mid_message(&self) -> bool {
match self.side.try_lock() {
Ok(side) => {
side.reader.has_buffered() || side.assembler.has_pending() || side.held.is_some()
}
Err(_) => true,
}
}
pub(crate) fn shutdown(&self) {
self.stream.shutdown_read();
}
pub(crate) async fn next(&self) -> Result<(Version, Message), ReadError> {
loop {
if self.task_may_read() {
let stream = &self.stream;
let direct = self.handed_back.swap(false, Ordering::AcqRel);
let mut raw = |buf: &mut [MaybeUninit<u8>]| {
if direct {
stream.recv(buf)
} else {
stream.try_recv(buf)
}
};
let mut read = |buf: &mut [MaybeUninit<u8>]| self.read(&mut raw, buf);
if let Some(msg) = self.side().next(&mut read, false)? {
return Ok(msg);
}
}
self.task_wait().await;
}
}
fn task_may_read(&self) -> bool {
let mut holder = self.holder.lock().unwrap();
match *holder {
Holder::Task { .. } => {
*holder = Holder::Task { active: true };
true
}
Holder::Busy => {
let stream = &self.stream;
let mut side = self.side.lock().unwrap();
let mut raw = |buf: &mut [MaybeUninit<u8>]| stream.try_recv(buf);
let more = side.reader.drain(&mut |buf| self.read(&mut raw, buf));
if more {
*holder = Holder::Task { active: true };
true
} else {
false
}
}
Holder::Thread => {
self.stream.clear_readable();
false
}
}
}
async fn task_wait(&self) {
{
let mut holder = self.holder.lock().unwrap();
if let Holder::Task { .. } = *holder {
*holder = Holder::Task { active: false };
}
}
let mut back = std::pin::pin!(self.back.notified());
let mut readable = std::pin::pin!(self.stream.readable());
std::future::poll_fn(|cx| {
if back.as_mut().poll(cx).is_ready() || readable.as_mut().poll(cx).is_ready() {
std::task::Poll::Ready(())
} else {
std::task::Poll::Pending
}
})
.await;
}
pub(crate) fn claim(&self) -> bool {
if !cfg!(unix) {
return false;
}
let mut holder = self.holder.lock().unwrap();
match *holder {
Holder::Task { active: false } | Holder::Busy => {
*holder = Holder::Thread;
true
}
_ => false,
}
}
pub(crate) fn read_here(&self, until: Option<Instant>) -> Here {
let mut side = self.side();
let stream = &self.stream;
let mut raw = |buf: &mut [MaybeUninit<u8>]| stream.recv(buf);
let mut read = |buf: &mut [MaybeUninit<u8>]| self.read(&mut raw, buf);
loop {
match side.next(&mut read, true) {
Ok(Some((version, msg))) => return Here::Message(version, msg),
Ok(None) if side.reader.starts_large() => {
drop(side);
self.release();
return Here::HandedBack;
}
Ok(None) => {}
Err(e) => {
side.held = Some(Err(e));
drop(side);
self.release();
return Here::HandedBack;
}
}
if !wait_readable(stream, until) {
drop(side);
self.release();
return Here::TimedOut;
}
}
}
pub(crate) fn give_back(&self, version: Version, msg: Message) {
self.side().held = Some(Ok((version, msg)));
self.release();
}
pub(crate) fn busy(&self) -> bool {
let mut holder = self.holder.lock().unwrap();
let stream = &self.stream;
let mut side = self.side.lock().unwrap();
let mut raw = |buf: &mut [MaybeUninit<u8>]| stream.recv(buf);
let more = side.reader.drain(&mut |buf| self.read(&mut raw, buf));
if more || side.held.is_some() {
*holder = Holder::Task { active: false };
drop(side);
drop(holder);
self.hand_back();
false
} else {
*holder = Holder::Busy;
true
}
}
fn hand_back(&self) {
self.handed_back.store(true, Ordering::Release);
self.back.notify_one();
}
pub(crate) fn unbusy(&self) {
let mut holder = self.holder.lock().unwrap();
if *holder == Holder::Busy {
*holder = Holder::Task { active: false };
}
}
pub(crate) fn release(&self) {
let mut holder = self.holder.lock().unwrap();
match *holder {
Holder::Thread => {
let stream = &self.stream;
let mut side = self.side.lock().unwrap();
let mut raw = |buf: &mut [MaybeUninit<u8>]| stream.recv(buf);
let more = side.reader.drain(&mut |buf| self.read(&mut raw, buf));
*holder = Holder::Task { active: false };
if more || side.held.is_some() {
drop(side);
drop(holder);
self.hand_back();
}
}
Holder::Busy => *holder = Holder::Task { active: false },
Holder::Task { .. } => {}
}
}
}
#[cfg(unix)]
fn wait_readable(stream: &ReadHalf, until: Option<Instant>) -> bool {
loop {
let timeout = match until {
None => -1,
Some(at) => {
let left = at.saturating_duration_since(Instant::now());
if left.is_zero() {
return false;
}
i32::try_from(left.as_micros().div_ceil(1000)).unwrap_or(i32::MAX)
}
};
let mut fd = libc::pollfd {
fd: stream.raw_fd(),
events: libc::POLLIN,
revents: 0,
};
let n = unsafe { libc::poll(&mut fd, 1, timeout) };
if n > 0 {
return true;
}
if n < 0 && io::Error::last_os_error().kind() != io::ErrorKind::Interrupted {
return true;
}
}
}
#[cfg(not(unix))]
fn wait_readable(_: &ReadHalf, _: Option<Instant>) -> bool {
false
}