use std::collections::hash_map::RandomState;
use std::collections::{HashMap, HashSet, VecDeque};
use std::hash::{BuildHasher, Hasher};
use std::io;
use std::net::SocketAddr;
use std::panic::{self, AssertUnwindSafe};
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::sync::{Arc, Condvar, Mutex, OnceLock, Weak, mpsc as std_mpsc};
use std::time::{Duration, Instant, SystemTime};
use rustorb_cdr::ByteOrder;
use rustorb_giop::{
AlternateIiopAddress, BiDirIiopServiceContext, Body, CodeSetComponent, CodeSetComponentInfo,
CodeSetContext, IiopProfile, Ior, ListenPoint, LocateReplyHeader, LocateRequestHeader,
LocateStatus, Message, MessageEncoder, OutMessage, RequestHeader, ServiceContext, SslSecTrans,
TaggedComponent, TargetAddress, Version, association_options, component_tag,
};
use tokio::io::AsyncWriteExt;
use tokio::net::tcp::OwnedWriteHalf;
use tokio::net::{TcpListener, TcpStream};
use tokio::runtime::Handle;
use tokio::sync::{Notify, OwnedSemaphorePermit, Semaphore};
use tokio::task::JoinHandle;
use crate::codeset::{CONVERSION_CHAR, NATIVE_CHAR, NATIVE_WCHAR};
use crate::connection::{Closed, Connection, summary};
use crate::idle::{self, Stamp};
use crate::orb::OrbInner;
use crate::pi::{self, Interceptors, ServerEnding, ServerException, ServerRequestInfo};
use crate::poa::{
BOOT_ID_LEN, CurrentGuard, Dispatch, Disposition, Etherealization, ManagerInner, ParsedKey,
PoaInner, PoaManager, SerialEntry, UpcallGuard, etherealize_all, is_main_thread,
no_such_object, parse_key,
};
use crate::pool::{Job, Pool};
use crate::servant::{OBJECT_ID, ServerReply, location_forward_reply, system_exception_reply};
use crate::stream::InStream;
use crate::tls::{self, Tls};
use crate::trace;
use crate::wire::{Here, Inbound, PeerAddr, ReadError};
use crate::{
Bidirectional, CodeSets, CompletionStatus, EndpointAddr, Lifespan, Orb, Poa, Servant,
ServantManagerError, SystemException, SystemExceptionKind, ThreadPolicy,
};
pub(crate) struct Server {
orb: Weak<OrbInner>,
boot_id: [u8; BOOT_ID_LEN],
published: Vec<(String, u16)>,
loopback_ports: Vec<u16>,
published_tls: Vec<(String, u16)>,
loopback_tls_ports: Vec<u16>,
client_auth_required: bool,
fixed_port: bool,
order: ByteOrder,
max_message_size: usize,
fragment_size: usize,
max_requests: usize,
follow_linger: Duration,
follow_limit: usize,
idle_timeout: Option<Duration>,
root: OnceLock<Arc<PoaInner>>,
simple_keys: Mutex<HashMap<Vec<u8>, Vec<u8>>>,
pool: Mutex<Option<Pool>>,
managers: Mutex<Vec<Weak<ManagerInner>>>,
connections: Mutex<HashMap<u64, Arc<ServerConn>>>,
next_connection: AtomicU64,
listeners: Mutex<Vec<JoinHandle<()>>>,
shutting_down: AtomicBool,
in_flight: Mutex<usize>,
in_flight_done: Condvar,
}
impl std::fmt::Debug for Server {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Server")
.field("published", &self.published)
.finish_non_exhaustive()
}
}
fn code_set_info() -> CodeSetComponentInfo {
CodeSetComponentInfo {
for_char_data: CodeSetComponent {
native_code_set: NATIVE_CHAR,
conversion_code_sets: CONVERSION_CHAR.to_vec(),
},
for_wchar_data: CodeSetComponent {
native_code_set: NATIVE_WCHAR,
conversion_code_sets: Vec::new(),
},
}
}
fn new_boot_id() -> [u8; BOOT_ID_LEN] {
let mut h = RandomState::new().build_hasher();
if let Ok(t) = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH) {
h.write_u128(t.as_nanos());
}
h.write_u32(std::process::id());
h.finish().to_be_bytes()
}
fn host_name() -> String {
let candidates = [
std::fs::read_to_string("/proc/sys/kernel/hostname").ok(),
std::env::var("HOSTNAME").ok(),
];
candidates
.into_iter()
.flatten()
.map(|h| h.trim().to_owned())
.find(|h| !h.is_empty())
.or_else(|| {
let out = std::process::Command::new("hostname").output().ok()?;
let name = String::from_utf8(out.stdout).ok()?.trim().to_owned();
(!name.is_empty()).then_some(name)
})
.unwrap_or_else(|| "localhost".into())
}
fn initialize() -> SystemException {
SystemException::new(SystemExceptionKind::INITIALIZE, 0, CompletionStatus::No)
}
impl Server {
pub(crate) fn start(
orb: &Orb,
root_components: Vec<TaggedComponent>,
) -> Result<Arc<Server>, SystemException> {
let options = &orb.inner.options;
let endpoints = if options.endpoints.is_empty() && options.tls_endpoints.is_empty() {
vec![EndpointAddr {
host: String::new(),
port: 0,
}]
} else {
options.endpoints.clone()
};
let tls_config = if options.tls_endpoints.is_empty() {
None
} else {
Some(tls::server_config(&options.tls).map_err(|_| initialize())?)
};
let mut listeners = Vec::new();
let mut published = Vec::new();
let mut loopback_ports = Vec::new();
let mut published_tls = Vec::new();
let mut loopback_tls_ports = Vec::new();
let plain = endpoints
.iter()
.map(|ep| (ep, false, options.endpoint_publish.as_ref()));
let secure = options
.tls_endpoints
.iter()
.map(|ep| (ep, true, options.tls_endpoint_publish.as_ref()));
let mut first = [true, true];
for (ep, is_tls, publish) in plain.chain(secure) {
let bind_host = if ep.host.is_empty() {
"0.0.0.0"
} else {
&ep.host
};
let listener =
std::net::TcpListener::bind((bind_host, ep.port)).map_err(|_| initialize())?;
listener.set_nonblocking(true).map_err(|_| initialize())?;
let socket = socket2::SockRef::from(&listener);
if let Some(size) = options.socket_send_buffer {
socket
.set_send_buffer_size(size)
.map_err(|_| initialize())?;
}
if let Some(size) = options.socket_receive_buffer {
socket
.set_recv_buffer_size(size)
.map_err(|_| initialize())?;
}
let port = listener.local_addr().map_err(|_| initialize())?.port();
let (published, loopback_ports) = if is_tls {
(&mut published_tls, &mut loopback_tls_ports)
} else {
(&mut published, &mut loopback_ports)
};
if ep.host.is_empty() || is_loopback(&ep.host) {
loopback_ports.push(port);
}
let publish = publish.filter(|_| std::mem::take(&mut first[usize::from(is_tls)]));
let host = match publish {
Some(p) if !p.host.is_empty() => p.host.clone(),
_ if !ep.host.is_empty() => ep.host.clone(),
_ => host_name(),
};
let port = match publish {
Some(p) if p.port != 0 => p.port,
_ => port,
};
trace::info!(
"listening on {}{}, published as {host}:{port}",
listener
.local_addr()
.map_or_else(|_| format!("{bind_host}:{}", ep.port), |a| a.to_string()),
if is_tls { " (TLS)" } else { "" }
);
listeners.push((listener, is_tls));
published.push((host, port));
}
let server = Arc::new(Server {
orb: Arc::downgrade(&orb.inner),
boot_id: new_boot_id(),
published,
loopback_ports,
published_tls,
loopback_tls_ports,
client_auth_required: options.tls.client_auth == crate::ClientAuth::Required,
fixed_port: endpoints
.iter()
.chain(&options.tls_endpoints)
.any(|ep| ep.port != 0),
order: options.byte_order,
max_message_size: options.max_message_size,
fragment_size: options.fragment_size,
max_requests: options.max_requests_per_connection.max(1),
follow_linger: options.follow_linger,
follow_limit: if options.follow_linger.is_zero() {
0
} else {
options.follow_limit
},
idle_timeout: options.server_idle_timeout,
root: OnceLock::new(),
simple_keys: Mutex::new(HashMap::new()),
pool: Mutex::new(Some(Pool::new(
options.min_server_threads,
options.max_server_threads,
options.server_thread_idle_timeout,
))),
managers: Mutex::new(Vec::new()),
connections: Mutex::new(HashMap::new()),
next_connection: AtomicU64::new(0),
listeners: Mutex::new(Vec::new()),
shutting_down: AtomicBool::new(false),
in_flight: Mutex::new(0),
in_flight_done: Condvar::new(),
});
let manager = PoaManager::new(&server);
let _ = server
.root
.set(PoaInner::new_root(manager, server.boot_id, root_components));
let handle = orb.inner.handle.clone();
let _entered = handle.enter();
let mut tasks = Vec::new();
let limit = (options.max_server_connections > 0)
.then(|| Arc::new(Semaphore::new(options.max_server_connections)));
for (listener, is_tls) in listeners {
let listener = TcpListener::from_std(listener).map_err(|_| initialize())?;
let tls = tls_config.clone().filter(|_| is_tls);
tasks.push(handle.spawn(accept_loop(
Arc::downgrade(&server),
listener,
tls,
limit.clone(),
)));
}
if let Some(timeout) = server.idle_timeout {
tasks.push(handle.spawn(close_idle(Arc::downgrade(&server), timeout)));
}
*server.listeners.lock().unwrap() = tasks;
Ok(server)
}
pub(crate) fn root(&self) -> &Arc<PoaInner> {
self.root
.get()
.expect("the RootPOA is created with the server")
}
pub(crate) fn set_simple_key(&self, simple: &[u8], target: Option<Vec<u8>>) {
let mut keys = self.simple_keys.lock().unwrap();
match target {
Some(target) => keys.insert(simple.to_vec(), target),
None => keys.remove(simple),
};
}
pub(crate) fn has_fixed_port(&self) -> bool {
self.fixed_port
}
pub(crate) fn published(&self) -> &[(String, u16)] {
&self.published
}
pub(crate) fn published_tls(&self) -> &[(String, u16)] {
&self.published_tls
}
pub(crate) fn register_manager(&self, manager: &Arc<ManagerInner>) {
let mut managers = self.managers.lock().unwrap();
managers.retain(|m| m.strong_count() > 0);
managers.push(Arc::downgrade(manager));
}
pub(crate) fn submit(&self, job: Job) {
if let Some(pool) = &*self.pool.lock().unwrap() {
pool.submit(job);
}
}
pub(crate) fn ior(
&self,
type_id: &str,
key: Vec<u8>,
extra: &[TaggedComponent],
) -> Result<Ior, SystemException> {
let marshal =
|_| SystemException::new(SystemExceptionKind::MARSHAL, 0, CompletionStatus::No);
let (host, port) = match self.published.first() {
Some((host, port)) => (host.clone(), *port),
None => (self.published_tls[0].0.clone(), 0),
};
let mut components = vec![code_set_info().to_component(self.order).map_err(marshal)?];
let mut tls = self.published_tls.iter();
let mut rest_tls = Vec::new();
if let Some((tls_host, tls_port)) = tls.next() {
if tls_host.eq_ignore_ascii_case(&host) {
components.push(self.ssl_component(*tls_port).map_err(marshal)?);
} else {
rest_tls.push((tls_host, *tls_port));
}
}
rest_tls.extend(tls.map(|(h, p)| (h, *p)));
for (host, port) in self.published.iter().skip(1) {
let alternate = AlternateIiopAddress {
host: host.clone(),
port: *port,
};
components.push(alternate.to_component(self.order).map_err(marshal)?);
}
components.extend_from_slice(extra);
let mut profiles = vec![
IiopProfile {
version: Version::V1_2,
host,
port,
object_key: key.clone(),
components,
}
.to_tagged_profile(self.order)
.map_err(marshal)?,
];
for (host, port) in rest_tls {
let mut components = vec![
code_set_info().to_component(self.order).map_err(marshal)?,
self.ssl_component(port).map_err(marshal)?,
];
components.extend_from_slice(extra);
let profile = IiopProfile {
version: Version::V1_2,
host: host.clone(),
port: 0,
object_key: key.clone(),
components,
};
profiles.push(profile.to_tagged_profile(self.order).map_err(marshal)?);
}
Ok(Ior {
type_id: type_id.to_owned(),
profiles,
})
}
fn ssl_component(&self, port: u16) -> rustorb_giop::Result<rustorb_giop::TaggedComponent> {
use association_options::*;
let mut requires = INTEGRITY | CONFIDENTIALITY | ESTABLISH_TRUST_IN_TARGET;
let mut supports = requires | ESTABLISH_TRUST_IN_CLIENT;
if !self.published.is_empty() {
supports |= NO_PROTECTION;
}
if self.client_auth_required {
requires |= ESTABLISH_TRUST_IN_CLIENT;
}
SslSecTrans {
target_supports: supports,
target_requires: requires,
port,
}
.to_component(self.order)
}
fn orb(&self) -> Option<Orb> {
self.orb.upgrade().map(|inner| Orb { inner })
}
fn is_shutting_down(&self) -> bool {
self.shutting_down.load(Ordering::Acquire)
}
fn find(&self, key: &[u8], orb: Option<&Orb>) -> Result<(Arc<PoaInner>, Vec<u8>), Lookup> {
let alias;
let key = match parse_key(key) {
ParsedKey::Simple(simple) => {
alias = self
.simple_keys
.lock()
.unwrap()
.get(simple)
.cloned()
.ok_or(Lookup::Missing)?;
&alias[..]
}
_ => key,
};
let ParsedKey::Poa { path, boot_id, id } = parse_key(key) else {
return Err(Lookup::Missing);
};
let mut poa = Arc::clone(self.root());
for name in path {
poa = match orb {
Some(orb) => poa
.find_or_activate_child(orb, name)
.ok_or(Lookup::Missing)?,
None => poa.child(name).map_err(|activator| {
if activator {
Lookup::NeedsActivator
} else {
Lookup::Missing
}
})?,
};
}
let lifespan_matches = match (poa.policies().lifespan, boot_id) {
(Lifespan::Persistent, None) => true,
(Lifespan::Transient, Some(boot_id)) => boot_id == self.boot_id,
_ => false,
};
if !lifespan_matches || poa.is_destroyed() {
return Err(Lookup::Missing);
}
Ok((poa, id.to_vec()))
}
fn ticket(self: &Arc<Self>, permit: Option<OwnedSemaphorePermit>) -> Ticket {
*self.in_flight.lock().unwrap() += 1;
Ticket {
server: Arc::clone(self),
_permit: permit,
}
}
async fn on_request(
self: &Arc<Self>,
conn: &Arc<ServerConn>,
version: Version,
header: RequestHeader,
body: Body,
) {
if self.is_shutting_down() {
return;
}
let Ok(permit) = Arc::clone(&conn.permits).acquire_owned().await else {
return;
};
if let Some((key, request)) = self.prepare(conn, version, header, body, permit) {
self.route(key, request);
}
}
pub(crate) fn on_request_detached(
self: &Arc<Self>,
conn: &Arc<ServerConn>,
version: Version,
header: RequestHeader,
body: Body,
) {
if self.is_shutting_down() {
return;
}
match Arc::clone(&conn.permits).try_acquire_owned() {
Ok(permit) => {
if let Some((key, request)) = self.prepare(conn, version, header, body, permit) {
self.route(key, request);
}
}
Err(_) => {
let server = Arc::clone(self);
let conn = Arc::clone(conn);
tokio::spawn(async move {
server.on_request(&conn, version, header, body).await;
});
}
}
}
pub(crate) fn on_locate_request(
self: &Arc<Self>,
conn: &Arc<ServerConn>,
version: Version,
header: &LocateRequestHeader,
) {
self.on_locate(conn, version, header);
}
pub(crate) fn serve_connection(
self: &Arc<Self>,
client: &Arc<Connection>,
inbound: Arc<Inbound>,
handle: Handle,
) -> (Arc<ServerConn>, Option<ServiceContext>) {
let listen_points: Vec<ListenPoint> = self
.published
.iter()
.chain(&self.published_tls)
.map(|(host, port)| ListenPoint {
host: host.clone(),
port: *port,
})
.collect();
let context = BiDirIiopServiceContext { listen_points }
.to_service_context(self.order)
.ok();
let conn = Arc::new(ServerConn {
inbound,
out: Out::Client(Arc::downgrade(client), handle),
code_sets: Mutex::new(None),
requests: Mutex::default(),
version: Mutex::new(Version::V1_2),
permits: Arc::new(Semaphore::new(self.max_requests)),
writer: Mutex::new(None),
max_message_size: self.max_message_size,
fragment_size: self.fragment_size,
last_used: Stamp::new(),
bidir: OnceLock::new(),
originated: true,
});
(conn, context)
}
fn take_bidir(&self, conn: &Arc<ServerConn>, ctx: &[ServiceContext]) {
let Some(found) = BiDirIiopServiceContext::find(ctx) else {
return;
};
let peer = conn.inbound.peer();
let Some(orb) = self.orb() else { return };
if !orb.accepts_bidir() {
trace::debug!(
"{peer} offered its connection for bidirectional GIOP: not accepted \
(-ORBacceptBiDirectionalGIOP 0)"
);
return;
}
let Out::Box(out) = &conn.out else { return };
let listen_points = match found {
Ok(ctx) => ctx.listen_points,
Err(e) => {
trace::info!("{peer} sent a BI_DIR_IIOP context that cannot be read: {e}");
return;
}
};
if listen_points.is_empty() {
return;
}
let tls = out.tls.is_some();
let pool = Arc::downgrade(&orb.inner.connections);
let client = conn.bidir.get_or_init(|| {
let first = &listen_points[0];
Connection::accepted(
(first.host.clone(), first.port, tls),
Arc::clone(&conn.inbound),
Arc::clone(out),
pool,
)
});
if !client.is_usable() {
return;
}
let mut conns = orb.inner.connections.lock().unwrap();
for lp in &listen_points {
let keys = [
(lp.host.clone(), lp.port, tls),
(lp.host.clone(), lp.port, false),
];
for key in keys.into_iter().take(if tls { 2 } else { 1 }) {
match conns.get(&key) {
Some(c) if Arc::ptr_eq(c, client) => {}
Some(c) if c.is_usable() => {
trace::info!(
"{peer} offered {}:{} for bidirectional GIOP: not taken, a \
connection to it is open already",
lp.host,
lp.port
);
}
_ => {
trace::info!(
"calls to {}:{}{} go over the connection from {peer} \
(bidirectional GIOP)",
lp.host,
lp.port,
if key.2 { " (TLS)" } else { "" }
);
conns.insert(key, Arc::clone(client));
}
}
}
}
}
fn prepare(
self: &Arc<Self>,
conn: &Arc<ServerConn>,
version: Version,
header: RequestHeader,
body: Body,
permit: OwnedSemaphorePermit,
) -> Option<(Vec<u8>, Incoming)> {
let code_sets = conn.code_sets_for(version, &header.service_context);
conn.saw_version(version);
if version >= Version::V1_2 && !conn.originated {
self.take_bidir(conn, &header.service_context);
}
trace::debug!(
"request {:?} (id {}{}) from {}, GIOP {}.{}",
header.operation,
header.request_id,
if header.response_expected() {
""
} else {
", oneway"
},
conn.inbound.peer(),
version.major,
version.minor
);
let ticket = self.ticket(Some(permit));
if self.is_shutting_down() {
return None;
}
if !conn.begin(header.request_id, header.response_expected()) {
trace::debug!(
"request {:?} (id {}) not processed: CloseConnection sent",
header.operation,
header.request_id
);
return None;
}
let reply = ReplyTo::new(
conn,
version,
self.order,
header.request_id,
header.response_expected(),
);
let Some(key) = into_target_key(header.target) else {
reply.system(&no_such_object());
return None;
};
let request = Incoming {
operation: header.operation,
body,
code_sets,
contexts: header.service_context,
reply,
callback: conn.originated,
_ticket: ticket,
};
Some((key, request))
}
fn route(self: &Arc<Self>, key: Vec<u8>, request: Incoming) {
match self.find(&key, None) {
Ok((poa, id)) => self.admit(&poa, id, request),
Err(Lookup::Missing) => self.refuse(request, no_such_object()),
Err(Lookup::NeedsActivator) => {
let server = Arc::clone(self);
self.submit(Box::new(move || {
let found = server
.orb()
.and_then(|orb| server.find(&key, Some(&orb)).ok());
match found {
Some((poa, id)) => server.admit(&poa, id, request),
None => server.refuse(request, no_such_object()),
}
}));
}
}
}
fn admit(self: &Arc<Self>, poa: &Arc<PoaInner>, id: Vec<u8>, request: Incoming) {
if request.callback && !takes_callbacks(poa) {
self.refuse(request, not_bidirectional());
return;
}
let server = Arc::clone(self);
let target = Arc::clone(poa);
let dispatch: Dispatch = Box::new(move |disposition| match disposition {
Disposition::Run => server.schedule_upcall(&target, id, request),
Disposition::Reject(e) => server.refuse(request, e),
});
poa.manager.inner.dispatch(dispatch);
}
fn schedule_upcall(self: &Arc<Self>, poa: &Arc<PoaInner>, id: Vec<u8>, request: Incoming) {
if !matches!(poa.policies().thread, ThreadPolicy::OrbCtrl) {
let job = self.upcall_job(poa, id, request);
self.schedule(poa, job);
return;
}
let server = Arc::clone(self);
let poa = Arc::clone(poa);
let conn = request.reply.conn();
self.submit(Box::new(move || {
server.upcall(&poa, &id, request);
if let Some(conn) = conn {
server.follow(&conn);
}
}));
}
fn follow(self: &Arc<Self>, conn: &Arc<ServerConn>) {
if conn.originated {
return;
}
for _ in 0..self.follow_limit {
if self.is_shutting_down() || self.pool_has_queued() {
break;
}
let Ok(permit) = Arc::clone(&conn.permits).try_acquire_owned() else {
break;
};
if !conn.inbound.claim() {
return;
}
let (version, message) = match conn
.inbound
.read_here(Some(Instant::now() + self.follow_linger))
{
Here::Message(version, message) => (version, message),
Here::TimedOut | Here::HandedBack => return,
};
conn.last_used.touch();
let keep = match message {
Message::Request { header, body } => {
let keep = conn.inbound.busy();
if let Some((key, request)) = self.prepare(conn, version, header, body, permit)
{
self.route_here(key, request);
}
keep
}
Message::LocateRequest(header) => {
let keep = conn.inbound.busy();
self.on_locate(conn, version, &header);
keep
}
Message::CancelRequest(header) => {
let keep = conn.inbound.busy();
conn.cancel_request(header.request_id);
keep
}
other => {
conn.inbound.give_back(version, other);
return;
}
};
if !keep {
return;
}
}
conn.inbound.unbusy();
}
fn route_here(self: &Arc<Self>, key: Vec<u8>, request: Incoming) {
let found = match self.find(&key, None) {
Err(Lookup::NeedsActivator) => match self.orb() {
Some(orb) => self.find(&key, Some(&orb)),
None => Err(Lookup::Missing),
},
found => found,
};
let Ok((poa, id)) = found else {
self.refuse(request, no_such_object());
return;
};
if request.callback && !takes_callbacks(&poa) {
self.refuse(request, not_bidirectional());
return;
}
if !matches!(poa.policies().thread, ThreadPolicy::OrbCtrl) {
self.admit(&poa, id, request);
return;
}
let here = Arc::new(Mutex::new(RunHere {
waiting: true,
request: None,
}));
let slot = Arc::clone(&here);
let server = Arc::clone(self);
let target = Arc::clone(&poa);
poa.manager
.inner
.dispatch(Box::new(move |disposition| match disposition {
Disposition::Run => {
let mut slot = slot.lock().unwrap();
if slot.waiting {
slot.request = Some((id, request));
} else {
drop(slot);
server.schedule_upcall(&target, id, request);
}
}
Disposition::Reject(e) => server.refuse(request, e),
}));
let run = {
let mut here = here.lock().unwrap();
here.waiting = false;
here.request.take()
};
if let Some((id, request)) = run {
self.upcall(&poa, &id, request);
}
}
fn pool_has_queued(&self) -> bool {
self.pool
.lock()
.unwrap()
.as_ref()
.is_some_and(Pool::has_queued)
}
fn upcall_job(self: &Arc<Self>, poa: &Arc<PoaInner>, id: Vec<u8>, request: Incoming) -> Job {
let server = Arc::clone(self);
let poa = Arc::clone(poa);
Box::new(move || server.upcall(&poa, &id, request))
}
fn schedule(self: &Arc<Self>, poa: &Arc<PoaInner>, job: Job) {
match poa.policies().thread {
ThreadPolicy::OrbCtrl => self.submit(job),
ThreadPolicy::SingleThread => poa.run_serially(self, job),
ThreadPolicy::MainThread => {
if let Some(orb) = self.orb.upgrade() {
orb.push_main(job);
}
}
}
}
fn refuse(self: &Arc<Self>, request: Incoming, e: SystemException) {
let pi = self
.orb()
.and_then(|orb| orb.interceptors())
.filter(|pi| pi.has_server());
let Some(pi) = pi else {
request.reply.system(&e);
return;
};
let server = Arc::clone(self);
self.submit(Box::new(move || {
let Some(orb) = server.orb() else { return };
let Incoming {
operation,
contexts,
reply,
_ticket,
..
} = request;
let info = ServerRequestInfo::new(
&pi,
pi::ServerRequest {
request_id: reply.request_id,
operation: &operation,
response_expected: reply.response,
orb: &orb,
target: None,
contexts: &contexts,
},
);
let end = match pi::receive_request_service_contexts(&pi, &info) {
Err(end) => end,
Ok(()) => pi::send_reply(
&pi,
&info,
ServerEnding::Exception(ServerException::System(e)),
),
};
send_ending(reply, end, None, &info);
}));
}
fn upcall(self: &Arc<Self>, poa: &Arc<PoaInner>, id: &[u8], request: Incoming) {
if request.reply.is_cancelled() {
return;
}
let Some(orb) = self.orb() else { return };
if let Some(pi) = orb.interceptors().filter(|pi| pi.has_server()) {
self.upcall_pi(&pi, orb, poa, id, request);
return;
}
let Incoming {
operation,
body,
code_sets,
reply,
_ticket,
..
} = request;
let adapter = Poa {
orb: orb.clone(),
inner: Arc::clone(poa),
};
let _poa_activity = poa.activity().enter();
let _manager_activity = poa.manager.inner.activity().enter();
let mut out = match ServerReply::new(reply.version, self.order, reply.request_id, code_sets)
{
Ok(out) => out,
Err(e) => {
reply.system(&e);
return;
}
};
let resolved = match poa.resolve(&adapter, self, id, &operation) {
Ok(resolved) => resolved,
Err(ServantManagerError::ForwardRequest(to)) => {
reply.forward(to.ior());
return;
}
Err(ServantManagerError::System(e)) => {
reply.system(&e);
return;
}
};
let mut input = InStream {
dec: body.decoder(),
code_sets,
orb: Some(&orb),
completed: CompletionStatus::No,
wchar_needs_code_set: true,
values: Vec::new(),
typed_values: Vec::new(),
custom_items: None,
body: Some(&body),
};
let result = {
let _upcall = UpcallGuard::enter();
let _current = CurrentGuard::enter(&adapter, id, &resolved.servant);
panic::catch_unwind(AssertUnwindSafe(|| {
invoke(&*resolved.servant, &operation, &mut input, &mut out)
}))
};
resolved.finish(&adapter, id, &operation);
match result {
Ok(Ok(())) => match out.finish() {
Ok(msg) => {
trace::debug!("request {operation:?} (id {}) done", reply.request_id);
reply.send(msg)
}
Err(e) => reply.system(&e),
},
Ok(Err(e)) => reply.system(&e),
Err(_) => {
trace::warning!("servant panicked in {operation:?}");
reply.system(&SystemException::new(
SystemExceptionKind::UNKNOWN,
0,
CompletionStatus::Maybe,
));
}
}
}
fn upcall_pi(
self: &Arc<Self>,
pi: &Interceptors,
orb: Orb,
poa: &Arc<PoaInner>,
id: &[u8],
request: Incoming,
) {
let Incoming {
operation,
body,
code_sets,
contexts,
reply,
_ticket,
..
} = request;
let adapter = Poa {
orb: orb.clone(),
inner: Arc::clone(poa),
};
let _poa_activity = poa.activity().enter();
let _manager_activity = poa.manager.inner.activity().enter();
let target = pi::ServerTarget {
poa: adapter.clone(),
id: id.to_vec(),
};
let info = ServerRequestInfo::new(
pi,
pi::ServerRequest {
request_id: reply.request_id,
operation: &operation,
response_expected: reply.response,
orb: &orb,
target: Some(&target),
contexts: &contexts,
},
);
if let Err(end) = pi::receive_request_service_contexts(pi, &info) {
send_ending(reply, end, None, &info);
return;
}
let resolved = match poa.resolve(&adapter, self, id, &operation) {
Ok(resolved) => resolved,
Err(e) => {
let ending = match e {
ServantManagerError::ForwardRequest(to) => ServerEnding::Forward(to),
ServantManagerError::System(e) => {
ServerEnding::Exception(ServerException::System(e))
}
};
let end = pi::send_reply(pi, &info, ending);
send_ending(reply, end, None, &info);
return;
}
};
info.set_servant(&resolved.servant);
let _slots = info.enter_thread_scope(pi);
if let Err(end) = pi::receive_request(pi, &info) {
resolved.finish(&adapter, id, &operation);
send_ending(reply, end, None, &info);
return;
}
let mut out = match ServerReply::with_contexts(
reply.version,
self.order,
reply.request_id,
code_sets,
info.reply_contexts(),
) {
Ok(out) => out,
Err(e) => {
resolved.finish(&adapter, id, &operation);
let end = pi::send_reply(
pi,
&info,
ServerEnding::Exception(ServerException::System(e)),
);
send_ending(reply, end, None, &info);
return;
}
};
let mut input = InStream {
dec: body.decoder(),
code_sets,
orb: Some(&orb),
completed: CompletionStatus::No,
wchar_needs_code_set: true,
values: Vec::new(),
typed_values: Vec::new(),
custom_items: None,
body: Some(&body),
};
let result = {
let dsi = pi::DsiGuard::enter();
let _upcall = UpcallGuard::enter();
let _current = CurrentGuard::enter(&adapter, id, &resolved.servant);
let result = panic::catch_unwind(AssertUnwindSafe(|| {
invoke(&*resolved.servant, &operation, &mut input, &mut out)
}));
info.set_dsi(dsi.take());
result
};
resolved.finish(&adapter, id, &operation);
let ending = match result {
Ok(Ok(())) => match out.exception_id() {
Some(id) => ServerEnding::Exception(ServerException::User(id.to_owned())),
None => ServerEnding::Reply,
},
Ok(Err(e)) => ServerEnding::Exception(ServerException::System(e)),
Err(_) => {
trace::warning!("servant panicked in {operation:?}");
ServerEnding::Exception(ServerException::System(SystemException::new(
SystemExceptionKind::UNKNOWN,
0,
CompletionStatus::Maybe,
)))
}
};
let end = pi::send_reply(pi, &info, ending);
trace::debug!("request {operation:?} (id {}) done", reply.request_id);
send_ending(reply, end, Some(out), &info);
}
fn on_locate(
self: &Arc<Self>,
conn: &Arc<ServerConn>,
version: Version,
header: &LocateRequestHeader,
) {
if self.is_shutting_down() {
return;
}
conn.saw_version(version);
trace::debug!(
"LocateRequest (id {}) from {}",
header.request_id,
conn.inbound.peer()
);
let order = self.order;
let request_id = header.request_id;
let conn = Arc::clone(conn);
let answer = move |here: bool| {
let status = if here {
LocateStatus::ObjectHere
} else {
LocateStatus::UnknownObject
};
let reply = LocateReplyHeader {
request_id,
locate_status: status,
};
if let Ok(msg) = MessageEncoder::locate_reply(version, order, &reply)
.and_then(MessageEncoder::finish)
{
conn.send(msg.into());
}
};
let Some(key) = target_key(&header.target) else {
answer(false);
return;
};
match self.find(&key, None) {
Ok((poa, id)) => answer(located(&poa, &id)),
Err(Lookup::Missing) => answer(false),
Err(Lookup::NeedsActivator) => {
let server = Arc::clone(self);
self.submit(Box::new(move || {
let found = server
.orb()
.and_then(|orb| server.find(&key, Some(&orb)).ok());
answer(found.is_some_and(|(poa, id)| located(&poa, &id)));
}));
}
}
}
pub(crate) fn is_local(&self, host: &str, port: u16, tls: bool) -> bool {
if self.is_shutting_down() {
return false;
}
let (published, loopback_ports) = if tls {
(&self.published_tls, &self.loopback_tls_ports)
} else {
(&self.published, &self.loopback_ports)
};
published
.iter()
.any(|(h, p)| *p == port && h.eq_ignore_ascii_case(host))
|| (is_loopback(host) && loopback_ports.contains(&port))
}
pub(crate) fn is_own_profile(&self, profile: &IiopProfile) -> bool {
self.is_local(&profile.host, profile.port, false)
|| profile
.components
.iter()
.filter(|c| c.tag == component_tag::SSL_SEC_TRANS)
.filter_map(|c| SslSecTrans::from_component(c).ok())
.any(|ssl| self.is_local(&profile.host, ssl.port, true))
}
pub(crate) fn call_local(
self: &Arc<Self>,
version: Version,
header: RequestHeader,
body: Body,
code_sets: CodeSets,
timeout: Option<Duration>,
) -> Result<Option<Vec<u8>>, SystemException> {
if self.is_shutting_down() {
return Err(transient());
}
let Some(orb) = self.orb() else {
return Err(transient());
};
let response = header.response_expected();
let (tx, rx) = std_mpsc::channel();
let reply = ReplyTo::local(tx, version, self.order, header.request_id, response);
let request = Incoming {
operation: header.operation,
body,
code_sets,
contexts: header.service_context,
reply,
callback: false,
_ticket: self.ticket(None),
};
let found = target_key(&header.target).and_then(|key| self.find(&key, Some(&orb)).ok());
match found {
None => self.refuse(request, no_such_object()),
Some((poa, id)) => {
let (dtx, drx) = std_mpsc::channel();
poa.manager.inner.dispatch(Box::new(move |disposition| {
let _ = dtx.send(disposition);
}));
match wait(&drx, timeout, CompletionStatus::No)? {
Disposition::Reject(e) => self.refuse(request, e),
Disposition::Run => self.run_local(&poa, id, request),
}
}
}
if !response {
return Ok(None);
}
wait(&rx, timeout, CompletionStatus::Maybe).map(Some)
}
fn run_local(self: &Arc<Self>, poa: &Arc<PoaInner>, id: Vec<u8>, request: Incoming) {
match poa.policies().thread {
ThreadPolicy::OrbCtrl => self.upcall(poa, &id, request),
ThreadPolicy::SingleThread => match poa.enter_serially(self) {
SerialEntry::Reentrant => self.upcall(poa, &id, request),
SerialEntry::Acquired(_serial) => self.upcall(poa, &id, request),
SerialEntry::Busy => {
let job = self.upcall_job(poa, id, request);
poa.run_serially(self, job);
}
},
ThreadPolicy::MainThread if is_main_thread() => self.upcall(poa, &id, request),
ThreadPolicy::MainThread => {
let job = self.upcall_job(poa, id, request);
self.schedule(poa, job);
}
}
}
pub(crate) fn locate_local(&self, target: &TargetAddress) -> Result<bool, SystemException> {
if self.is_shutting_down() {
return Err(transient());
}
let Some(orb) = self.orb() else {
return Err(transient());
};
Ok(target_key(target)
.and_then(|key| self.find(&key, Some(&orb)).ok())
.is_some_and(|(poa, id)| located(&poa, &id)))
}
pub(crate) fn etherealize(&self, work: Vec<Etherealization>, wait: bool) {
if work.is_empty() {
return;
}
let Some(orb) = self.orb() else { return };
let run = move || {
let mut waited: Vec<&Arc<PoaInner>> = Vec::new();
for e in &work {
if !waited.iter().any(|p| Arc::ptr_eq(p, e.poa())) {
e.poa().activity().wait_idle();
waited.push(e.poa());
}
}
etherealize_all(&orb, work);
};
if wait {
run();
} else {
self.submit(Box::new(run));
}
}
pub(crate) fn etherealize_later(&self, work: Etherealization) {
let Some(orb) = self.orb() else { return };
self.submit(Box::new(move || work.run(&orb, None)));
}
fn add_connection(&self, conn: &Arc<ServerConn>) -> u64 {
let id = self.next_connection.fetch_add(1, Ordering::Relaxed);
self.connections
.lock()
.unwrap()
.insert(id, Arc::clone(conn));
id
}
fn remove_connection(&self, id: u64) {
self.connections.lock().unwrap().remove(&id);
}
fn close_conn(&self, conn: &Arc<ServerConn>) {
if let Some(client) = conn.bidir.get() {
client.leave_pool();
}
let version = *conn.version.lock().unwrap();
if let Ok(msg) = MessageEncoder::close_connection(version, self.order) {
conn.close(msg);
}
let conn = Arc::downgrade(conn);
tokio::spawn(async move {
tokio::time::sleep(idle::CLOSE_LINGER).await;
if let Some(conn) = conn.upgrade() {
conn.inbound.shutdown();
}
});
}
fn close_idle_connections(&self, timeout: Duration) {
let idle: Vec<_> = self
.connections
.lock()
.unwrap()
.values()
.filter(|c| c.choose_idle(Some(timeout)))
.cloned()
.collect();
for conn in idle {
trace::info!(
"closing the connection from {}: idle for {timeout:?}",
conn.inbound.peer()
);
self.close_conn(&conn);
}
}
fn close_least_used(&self) -> bool {
let candidate = self
.connections
.lock()
.unwrap()
.values()
.filter(|c| c.may_close())
.max_by_key(|c| c.idle_for())
.cloned();
match candidate {
Some(conn) if conn.choose_idle(None) => {
trace::info!(
"closing the connection from {}: at -ORBmaxServerConnections",
conn.inbound.peer()
);
self.close_conn(&conn);
true
}
_ => false,
}
}
pub(crate) fn shutdown(&self, handle: &Handle) {
if self.shutting_down.swap(true, Ordering::AcqRel) {
return;
}
for task in self.listeners.lock().unwrap().drain(..) {
task.abort();
}
let managers: Vec<_> = self
.managers
.lock()
.unwrap()
.iter()
.filter_map(Weak::upgrade)
.collect();
for manager in managers {
manager.shut_down();
}
if let Some(orb) = self.orb.upgrade() {
orb.close_main();
}
let mut in_flight = self.in_flight.lock().unwrap();
while *in_flight > 0 {
in_flight = self.in_flight_done.wait(in_flight).unwrap();
}
drop(in_flight);
let work = self.root().destroy_tree(true);
if let Some(orb) = self.orb() {
etherealize_all(&orb, work);
}
let conns: Vec<_> = self
.connections
.lock()
.unwrap()
.drain()
.map(|(_, c)| c)
.collect();
let mut writers = Vec::new();
for conn in conns {
let version = *conn.version.lock().unwrap();
if let Ok(msg) = MessageEncoder::close_connection(version, self.order) {
conn.close(msg);
}
writers.extend(conn.writer.lock().unwrap().take());
}
handle.block_on(async move {
for writer in writers {
let _ = tokio::time::timeout(Duration::from_secs(5), writer).await;
}
});
}
pub(crate) fn stop_pool(&self) {
let pool = self.pool.lock().unwrap().take();
drop(pool);
}
}
const MAX_SLICES: usize = 64;
struct RunHere {
waiting: bool,
request: Option<(Vec<u8>, Incoming)>,
}
enum Lookup {
Missing,
NeedsActivator,
}
struct Incoming {
operation: String,
body: Body,
code_sets: CodeSets,
contexts: Vec<ServiceContext>,
reply: ReplyTo,
callback: bool,
_ticket: Ticket,
}
fn takes_callbacks(poa: &PoaInner) -> bool {
poa.policies().bidirectional == Bidirectional::Both
}
fn not_bidirectional() -> SystemException {
SystemException::new(SystemExceptionKind::NO_PERMISSION, 0, CompletionStatus::No)
}
fn located(poa: &PoaInner, id: &[u8]) -> bool {
!poa.manager.inner.is_inactive() && poa.has_object(id)
}
fn transient() -> SystemException {
SystemException::new(SystemExceptionKind::TRANSIENT, 0, CompletionStatus::No)
}
fn is_loopback(host: &str) -> bool {
let host = host.trim_start_matches('[').trim_end_matches(']');
host.eq_ignore_ascii_case("localhost")
|| host
.parse::<std::net::IpAddr>()
.is_ok_and(|a| a.is_loopback())
}
fn wait<T>(
rx: &std_mpsc::Receiver<T>,
timeout: Option<Duration>,
completed: CompletionStatus,
) -> Result<T, SystemException> {
match timeout {
Some(limit) => rx.recv_timeout(limit).map_err(|e| match e {
std_mpsc::RecvTimeoutError::Timeout => {
SystemException::new(SystemExceptionKind::TIMEOUT, 0, completed)
}
std_mpsc::RecvTimeoutError::Disconnected => transient(),
}),
None => rx.recv().map_err(|_| transient()),
}
}
fn send_ending(
reply: ReplyTo,
end: ServerEnding,
out: Option<ServerReply>,
info: &ServerRequestInfo<'_>,
) {
let contexts = info.reply_contexts();
match (end, out) {
(ServerEnding::Reply | ServerEnding::Exception(ServerException::User(_)), Some(out)) => {
match out.finish_with(contexts.clone()) {
Ok(msg) => reply.send(msg),
Err(e) => reply.system_with(&e, &contexts),
}
}
(ServerEnding::Exception(ServerException::System(e)), _) => {
reply.system_with(&e, &contexts)
}
(ServerEnding::Forward(to), _) => reply.forward_with(to.ior(), &contexts),
(ServerEnding::Reply | ServerEnding::Exception(ServerException::User(_)), None) => reply
.system_with(
&SystemException::new(SystemExceptionKind::INTERNAL, 0, CompletionStatus::Maybe),
&contexts,
),
}
}
fn invoke(
servant: &dyn Servant,
operation: &str,
input: &mut InStream<'_>,
reply: &mut ServerReply,
) -> Result<(), SystemException> {
match operation {
"_is_a" => {
let id = input.read_string()?;
let is_a = id == OBJECT_ID || servant.is_a(&id);
reply.output().write_bool(is_a);
Ok(())
}
"_non_existent" => {
reply.output().write_bool(false);
Ok(())
}
"_interface" => Err(SystemException::new(
SystemExceptionKind::INTF_REPOS,
0,
CompletionStatus::No,
)),
"_repository_id" => reply.output().write_string(servant.repository_id()),
_ => servant.dispatch(operation, input, reply),
}
}
fn into_target_key(target: TargetAddress) -> Option<Vec<u8>> {
match target {
TargetAddress::Key(key) => Some(key),
other => target_key(&other),
}
}
fn target_key(target: &TargetAddress) -> Option<Vec<u8>> {
match target {
TargetAddress::Key(key) => Some(key.clone()),
TargetAddress::Profile(profile) => profile.iiop().ok().map(|p| p.object_key),
TargetAddress::Reference {
selected_profile_index,
ior,
} => ior
.profiles
.get(usize::try_from(*selected_profile_index).ok()?)?
.iiop()
.ok()
.map(|p| p.object_key),
}
}
struct Ticket {
server: Arc<Server>,
_permit: Option<OwnedSemaphorePermit>,
}
impl Drop for Ticket {
fn drop(&mut self) {
let mut in_flight = self.server.in_flight.lock().unwrap();
*in_flight -= 1;
if *in_flight == 0 {
self.server.in_flight_done.notify_all();
}
}
}
pub(crate) struct Outbox {
state: Mutex<OutState>,
pub(crate) tls: Option<Arc<Tls>>,
ready: Notify,
peer: Option<SocketAddr>,
}
struct OutState {
stream: Option<OwnedWriteHalf>,
queue: VecDeque<(OutMessage, usize)>,
closing: bool,
failed: bool,
flush: bool,
}
impl Outbox {
fn new(stream: OwnedWriteHalf, tls: Option<Arc<Tls>>, peer: Option<SocketAddr>) -> Outbox {
Outbox {
tls,
peer,
state: Mutex::new(OutState {
stream: Some(stream),
queue: VecDeque::new(),
closing: false,
failed: false,
flush: false,
}),
ready: Notify::new(),
}
}
pub(crate) fn send(&self, msg: OutMessage) -> bool {
let mut state = self.state.lock().unwrap();
if state.closing || state.failed {
return false;
}
trace::trace!("sent {} to {}", summary(&msg), PeerAddr(self.peer));
if let Some(tls) = &self.tls {
if let (true, Some(stream)) = (state.queue.is_empty(), &state.stream) {
tls.encrypt(&msg, 0);
if let Ok(true) = tls.flush(|bytes| stream.try_write(bytes)) {
return true;
}
state.flush = true;
} else {
state.queue.push_back((msg, 0));
}
drop(state);
self.ready.notify_one();
return true;
}
let mut written = 0;
if let (true, Some(stream)) = (state.queue.is_empty(), &state.stream) {
while written < msg.len() {
let result = match msg.as_single() {
Some(bytes) => stream.try_write(&bytes[written..]),
None => stream.try_write_vectored(&msg.slices_from(written, MAX_SLICES)),
};
match result {
Ok(0) => break,
Ok(n) => written += n,
Err(e) if e.kind() == io::ErrorKind::Interrupted => {}
Err(_) => break,
}
}
if written == msg.len() {
return true;
}
}
state.queue.push_back((msg, written));
drop(state);
self.ready.notify_one();
true
}
fn close(&self, last: Vec<u8>) {
let mut state = self.state.lock().unwrap();
if state.closing || state.failed {
return;
}
if !last.is_empty() {
state.queue.push_back((last.into(), 0));
}
state.closing = true;
drop(state);
self.ready.notify_one();
}
}
enum Out {
Box(Arc<Outbox>),
Client(Weak<Connection>, Handle),
}
pub(crate) struct ServerConn {
inbound: Arc<Inbound>,
out: Out,
code_sets: Mutex<Option<CodeSets>>,
requests: Mutex<Requests>,
version: Mutex<Version>,
permits: Arc<Semaphore>,
writer: Mutex<Option<JoinHandle<()>>>,
max_message_size: usize,
fragment_size: usize,
last_used: Stamp,
bidir: OnceLock<Arc<Connection>>,
originated: bool,
}
impl Drop for ServerConn {
fn drop(&mut self) {
if let Out::Box(out) = &self.out {
out.close(Vec::new());
}
}
}
#[derive(Default)]
struct Requests {
pending: HashSet<u32>,
cancelled: HashSet<u32>,
closing: bool,
}
impl ServerConn {
fn send(&self, msg: OutMessage) {
match &self.out {
Out::Box(out) => {
out.send(msg);
}
Out::Client(client, handle) => {
let Some(client) = client.upgrade() else {
return;
};
handle.spawn(async move {
let _ = client.send(&msg, None).await;
});
}
}
}
fn close(&self, last: Vec<u8>) {
if let Out::Box(out) = &self.out {
out.close(last);
}
}
fn saw_version(&self, version: Version) {
*self.version.lock().unwrap() = version;
}
fn code_sets_for(&self, version: Version, contexts: &[ServiceContext]) -> CodeSets {
if version < Version::V1_1 {
return CodeSets::DEFAULT;
}
let mut fixed = self.code_sets.lock().unwrap();
if fixed.is_none() {
if let Some(Ok(cs)) = CodeSetContext::find(contexts) {
*fixed = Some(CodeSets {
char_data: cs.char_data,
wchar_data: (cs.wchar_data != 0).then_some(cs.wchar_data),
});
}
}
fixed.unwrap_or(CodeSets::DEFAULT)
}
fn begin(&self, request_id: u32, response: bool) -> bool {
let mut requests = self.requests.lock().unwrap();
if requests.closing && response {
return false;
}
requests.pending.insert(request_id);
true
}
fn may_close(&self) -> bool {
let requests = self.requests.lock().unwrap();
!requests.closing
&& requests.pending.is_empty()
&& !self.inbound.mid_message()
&& self.bidir.get().is_none_or(|c| c.awaits_nothing())
}
fn idle_for(&self) -> Duration {
let idle = self.last_used.idle_for();
match self.bidir.get() {
Some(client) => idle.min(client.idle_for()),
None => idle,
}
}
pub(crate) fn choose_idle(&self, timeout: Option<Duration>) -> bool {
let mut requests = self.requests.lock().unwrap();
if requests.closing
|| !requests.pending.is_empty()
|| timeout.is_some_and(|t| self.last_used.idle_for() < t)
|| self.inbound.mid_message()
{
return false;
}
if let Some(client) = self.bidir.get() {
if !client.choose_close(timeout) {
return false;
}
}
requests.closing = true;
true
}
pub(crate) fn cancel_request(&self, request_id: u32) {
self.inbound.side().assembler.cancel(request_id);
self.cancel(request_id);
}
fn cancel(&self, request_id: u32) {
let mut requests = self.requests.lock().unwrap();
if requests.pending.contains(&request_id) {
requests.cancelled.insert(request_id);
}
}
fn is_cancelled(&self, request_id: u32) -> bool {
self.requests
.lock()
.unwrap()
.cancelled
.contains(&request_id)
}
fn end(&self, request_id: u32) -> bool {
self.last_used.touch();
let mut requests = self.requests.lock().unwrap();
requests.pending.remove(&request_id);
requests.cancelled.remove(&request_id)
}
}
struct ReplyTo {
sink: Option<Sink>,
version: Version,
order: ByteOrder,
request_id: u32,
response: bool,
}
enum Sink {
Conn(Arc<ServerConn>),
Local(std_mpsc::Sender<Vec<u8>>),
}
impl ReplyTo {
fn new(
conn: &Arc<ServerConn>,
version: Version,
order: ByteOrder,
request_id: u32,
response: bool,
) -> ReplyTo {
ReplyTo {
sink: Some(Sink::Conn(Arc::clone(conn))),
version,
order,
request_id,
response,
}
}
fn local(
tx: std_mpsc::Sender<Vec<u8>>,
version: Version,
order: ByteOrder,
request_id: u32,
response: bool,
) -> ReplyTo {
ReplyTo {
sink: Some(Sink::Local(tx)),
version,
order,
request_id,
response,
}
}
fn conn(&self) -> Option<Arc<ServerConn>> {
match &self.sink {
Some(Sink::Conn(c)) => Some(Arc::clone(c)),
_ => None,
}
}
fn is_cancelled(&self) -> bool {
match &self.sink {
Some(Sink::Conn(c)) => c.is_cancelled(self.request_id),
_ => false,
}
}
fn send(mut self, msg: OutMessage) {
match self.sink.take() {
Some(Sink::Conn(conn)) => {
let cancelled = conn.end(self.request_id);
if !self.response || cancelled {
return;
}
if msg.len() <= conn.max_message_size {
if conn.fragment_size > 0 {
conn.send(msg.fragment(conn.fragment_size));
} else {
conn.send(msg);
}
return;
}
trace::warning!(
"reply to request id {} of {} bytes is over the largest GIOP message \
({} bytes, -ORBgiopMaxMsgSize): replying MARSHAL",
self.request_id,
msg.len(),
conn.max_message_size
);
let e =
SystemException::new(SystemExceptionKind::MARSHAL, 0, CompletionStatus::Yes);
if let Some(msg) =
system_exception_reply(self.version, self.order, self.request_id, &e, &[])
{
conn.send(msg.into());
}
}
Some(Sink::Local(tx)) if self.response => {
let _ = tx.send(msg.into_vec());
}
Some(Sink::Local(_)) | None => {}
}
}
fn forward(self, ior: &Ior) {
self.forward_with(ior, &[]);
}
fn forward_with(self, ior: &Ior, contexts: &[ServiceContext]) {
trace::debug!(
"request id {}: replying LOCATION_FORWARD to {}",
self.request_id,
crate::trace::IorSummary(ior)
);
if !self.response {
return;
}
match location_forward_reply(self.version, self.order, self.request_id, ior, contexts) {
Some(msg) => self.send(msg.into()),
None => drop(self),
}
}
fn system(self, e: &SystemException) {
self.system_with(e, &[]);
}
fn system_with(self, e: &SystemException, contexts: &[ServiceContext]) {
trace::debug!("request id {}: replying {e}", self.request_id);
if !self.response {
return;
}
match system_exception_reply(self.version, self.order, self.request_id, e, contexts) {
Some(msg) => self.send(msg.into()),
None => drop(self),
}
}
}
impl Drop for ReplyTo {
fn drop(&mut self) {
if let Some(Sink::Conn(conn)) = self.sink.take() {
conn.end(self.request_id);
}
}
}
const HANDSHAKE_TIME: Duration = Duration::from_secs(30);
async fn accept_loop(
server: Weak<Server>,
listener: TcpListener,
tls: Option<Arc<rustls::ServerConfig>>,
limit: Option<Arc<Semaphore>>,
) {
loop {
let permit = match &limit {
Some(limit) => Some(connection_permit(&server, limit).await),
None => None,
};
let Ok((stream, _)) = listener.accept().await else {
tokio::time::sleep(Duration::from_millis(100)).await;
continue;
};
let Some(server) = server.upgrade() else {
return;
};
if server.is_shutting_down() {
return;
}
tokio::spawn(serve(server, stream, tls.clone(), permit));
}
}
async fn connection_permit(server: &Weak<Server>, limit: &Arc<Semaphore>) -> OwnedSemaphorePermit {
loop {
if let Ok(permit) = Arc::clone(limit).try_acquire_owned() {
return permit;
}
if let Some(server) = server.upgrade() {
server.close_least_used();
}
let wait = Arc::clone(limit).acquire_owned();
if let Ok(Ok(permit)) = tokio::time::timeout(Duration::from_secs(1), wait).await {
return permit;
}
}
}
async fn close_idle(server: Weak<Server>, timeout: Duration) {
let period = idle::scan_period(timeout);
loop {
tokio::time::sleep(period).await;
let Some(server) = server.upgrade() else {
return;
};
if server.is_shutting_down() {
return;
}
server.close_idle_connections(timeout);
}
}
async fn serve(
server: Arc<Server>,
stream: TcpStream,
tls: Option<Arc<rustls::ServerConfig>>,
_permit: Option<OwnedSemaphorePermit>,
) {
let _ = stream.set_nodelay(true);
let peer = PeerAddr(stream.peer_addr().ok());
let session = match tls {
Some(config) => {
match tokio::time::timeout(HANDSHAKE_TIME, tls::accept(&stream, config)).await {
Ok(Ok(session)) => Some(session),
Ok(Err(e)) => {
trace::info!("TLS handshake with {peer} failed: {e}");
return;
}
Err(_) => {
trace::info!("TLS handshake with {peer} timed out");
return;
}
}
}
None => None,
};
trace::info!(
"accepted a connection from {peer}{}",
if session.is_some() { " with TLS" } else { "" }
);
let (reader, writer) = stream.into_split();
let out = Arc::new(Outbox::new(writer, session.clone(), peer.0));
let conn = Arc::new(ServerConn {
inbound: Arc::new(Inbound::new(reader, session, server.max_message_size)),
out: Out::Box(Arc::clone(&out)),
code_sets: Mutex::new(None),
requests: Mutex::default(),
version: Mutex::new(Version::V1_0),
permits: Arc::new(Semaphore::new(server.max_requests)),
writer: Mutex::new(None),
max_message_size: server.max_message_size,
fragment_size: server.fragment_size,
last_used: Stamp::new(),
bidir: OnceLock::new(),
originated: false,
});
*conn.writer.lock().unwrap() = Some(tokio::spawn(write_loop(out)));
let id = server.add_connection(&conn);
let ended = read_loop(&server, &conn).await;
server.remove_connection(id);
if let Some(client) = conn.bidir.get() {
client.fail(match ended {
Ok(Ended::CloseConnection) => Closed::Orderly,
Ok(Ended::Peer) => Closed::Failed("connection closed by the client".into()),
Err(_) => Closed::Failed("malformed message".into()),
});
client.leave_pool();
}
match ended {
Ok(Ended::Peer) => trace::info!("connection from {peer} closed by the client"),
Ok(Ended::CloseConnection) => {
trace::info!("connection from {peer} closed (CloseConnection or MessageError)");
conn.close(Vec::new());
}
Err(version) => {
trace::info!("malformed message from {peer}: sending MessageError and closing");
if let Ok(msg) = MessageEncoder::message_error(version, server.order) {
conn.close(msg);
}
}
}
}
async fn write_loop(out: Arc<Outbox>) {
enum Step {
Write(OwnedWriteHalf, VecDeque<(OutMessage, usize)>),
Wait,
Shutdown(Option<OwnedWriteHalf>),
End,
}
loop {
let step = {
let mut state = out.state.lock().unwrap();
if state.failed {
Step::End
} else if !state.queue.is_empty() || state.flush {
state.flush = false;
match state.stream.take() {
Some(stream) => Step::Write(stream, std::mem::take(&mut state.queue)),
None => Step::End,
}
} else if state.closing {
Step::Shutdown(state.stream.take())
} else {
Step::Wait
}
};
match step {
Step::Write(stream, batch) if out.tls.is_some() => {
let tls = out.tls.as_deref().unwrap();
for (msg, written) in &batch {
tls.encrypt(msg, *written);
}
if flush_tls(tls, &stream).await.is_err() {
let mut state = out.state.lock().unwrap();
state.failed = true;
state.queue.clear();
return;
}
out.state.lock().unwrap().stream = Some(stream);
}
Step::Write(mut stream, mut batch) => {
while !batch.is_empty() {
let result = {
let mut slices = Vec::new();
for (msg, written) in &batch {
if slices.len() == MAX_SLICES {
break;
}
slices.extend(msg.slices_from(*written, MAX_SLICES - slices.len()));
}
stream.write_vectored(&slices).await
};
match result {
Ok(n) if n > 0 => advance(&mut batch, n),
Err(e) if e.kind() == io::ErrorKind::Interrupted => {}
_ => {
let mut state = out.state.lock().unwrap();
state.failed = true;
state.queue.clear();
return;
}
}
}
out.state.lock().unwrap().stream = Some(stream);
}
Step::Wait => out.ready.notified().await,
Step::Shutdown(stream) => {
if let Some(mut stream) = stream {
if let Some(tls) = &out.tls {
tls.close_notify();
let _ = flush_tls(tls, &stream).await;
}
let _ = stream.shutdown().await;
}
return;
}
Step::End => return,
}
}
}
async fn flush_tls(tls: &Tls, stream: &OwnedWriteHalf) -> io::Result<()> {
while !tls.flush(|bytes| stream.try_write(bytes))? {
stream.writable().await?;
}
Ok(())
}
fn advance(batch: &mut VecDeque<(OutMessage, usize)>, mut n: usize) {
while n > 0 {
let Some((msg, written)) = batch.front_mut() else {
return;
};
let left = msg.len() - *written;
if n < left {
*written += n;
return;
}
n -= left;
batch.pop_front();
}
}
enum Ended {
Peer,
CloseConnection,
}
async fn read_loop(server: &Arc<Server>, conn: &Arc<ServerConn>) -> Result<Ended, Version> {
loop {
let (version, message) = match conn.inbound.next().await {
Ok(read) => read,
Err(ReadError::Closed(_) | ReadError::Truncated(_)) => return Ok(Ended::Peer),
Err(ReadError::BadHeader(_)) => return Err(Version::V1_0),
Err(ReadError::TooLarge(_, version) | ReadError::Malformed(version, _)) => {
return Err(version);
}
};
conn.last_used.touch();
match message {
Message::Request { header, body } if conn.bidir.get().is_some() => {
server.on_request_detached(conn, version, header, body);
}
Message::Request { header, body } => {
server.on_request(conn, version, header, body).await;
}
Message::LocateRequest(header) => server.on_locate(conn, version, &header),
Message::CancelRequest(header) => conn.cancel_request(header.request_id),
Message::CloseConnection | Message::MessageError => {
return Ok(Ended::CloseConnection);
}
Message::Reply { ref header, .. } if conn.bidir.get().is_some() => {
let id = header.request_id;
conn.bidir.get().unwrap().deliver(id, message);
}
Message::LocateReply { ref header, .. } if conn.bidir.get().is_some() => {
let id = header.request_id;
conn.bidir.get().unwrap().deliver(id, message);
}
Message::Reply { .. } | Message::LocateReply { .. } | Message::Fragment { .. } => {
return Err(version);
}
}
}
}