use std::sync::Arc;
use super::auth::AuthConfig;
use super::config::ServerConfig;
use super::cors::CorsConfig;
use super::tls::{TlsConfig, TlsError};
use super::ws_session::handle_ws_socket;
use crate::engine::{RpcEngine, dispatch_wire_entries};
pub struct RpcServer {
config: ServerConfig,
tls_acceptor: Option<tokio_rustls::TlsAcceptor>,
engine: Arc<RpcEngine>,
}
impl RpcServer {
pub fn new(config: ServerConfig) -> Result<Self, TlsError> {
let tls_acceptor = if let Some(ref tls_config) = config.tls {
let server_config = tls_config.load_server_config()?;
Some(tokio_rustls::TlsAcceptor::from(server_config))
} else {
None
};
let engine = if let Some(token) = config.auth.token.as_deref() {
Arc::new(
RpcEngine::new().with_auth_middleware(super::auth::RpcAuthMiddleware::new(token)),
)
} else {
Arc::new(RpcEngine::new())
};
Ok(Self {
config,
tls_acceptor,
engine,
})
}
pub fn new_with_engine(config: ServerConfig, engine: Arc<RpcEngine>) -> Result<Self, TlsError> {
let tls_acceptor = if let Some(ref tls_config) = config.tls {
let server_config = tls_config.load_server_config()?;
Some(tokio_rustls::TlsAcceptor::from(server_config))
} else {
None
};
Ok(Self {
config,
tls_acceptor,
engine,
})
}
pub fn new_http(host: impl Into<String>, port: u16) -> Self {
Self {
config: ServerConfig::default().with_host(host).with_port(port),
tls_acceptor: None,
engine: Arc::new(RpcEngine::new()),
}
}
pub fn new_https(
host: impl Into<String>,
port: u16,
cert_path: impl Into<String>,
key_path: impl Into<String>,
) -> Result<Self, TlsError> {
let tls_config = TlsConfig::new(cert_path, key_path);
let server_config = tls_config.load_server_config()?;
let tls_acceptor = tokio_rustls::TlsAcceptor::from(server_config);
Ok(Self {
config: ServerConfig::default()
.with_host(host)
.with_port(port)
.with_tls(tls_config),
tls_acceptor: Some(tls_acceptor),
engine: Arc::new(RpcEngine::new()),
})
}
pub fn addr(&self) -> String {
self.config.addr()
}
pub fn port(&self) -> u16 {
self.config.port
}
pub fn is_secure(&self) -> bool {
self.tls_acceptor.is_some()
}
pub fn scheme(&self) -> &'static str {
self.config.scheme()
}
pub fn rpc_url(&self) -> String {
format!(
"{}://{}{}",
self.scheme(),
self.addr(),
crate::constants::RPC_ENDPOINT_PATH
)
}
pub async fn bind_listener(
&self,
) -> Result<tokio::net::TcpListener, Box<dyn std::error::Error + Send + Sync>> {
use std::net::SocketAddr;
let addr: SocketAddr = self.addr().parse()?;
let listener = tokio::net::TcpListener::bind(addr).await?;
tracing::info!("RPC server listening on {}://{}", self.scheme(), addr);
Ok(listener)
}
pub fn config(&self) -> &ServerConfig {
&self.config
}
pub fn tls_acceptor(&self) -> Option<&tokio_rustls::TlsAcceptor> {
self.tls_acceptor.as_ref()
}
pub async fn serve(&self) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
let listener = self.bind_listener().await?;
self.serve_on_listener(listener).await
}
pub async fn serve_on_listener(
&self,
listener: tokio::net::TcpListener,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
use axum::{
Router, middleware,
routing::{get, post},
};
let state = RpcState {
engine: self.engine.clone(),
max_request_size: self.config.max_request_size,
auth: self.config.auth.clone(),
};
let cors_layer = build_cors_layer(&self.config.cors);
let app = Router::new()
.route("/jsonrpc", post(handle_jsonrpc))
.route("/jsonrpc", get(handle_jsonrpc_or_ws)) .route("/rpc", post(handle_xmlrpc))
.layer(axum::extract::DefaultBodyLimit::max(
self.config.max_request_size,
))
.layer(middleware::from_fn_with_state(
state.clone(),
http_auth_middleware,
))
.layer(cors_layer)
.with_state(state);
if let Some(ref tls_acceptor) = self.tls_acceptor {
tracing::info!("TLS enabled, serving HTTPS");
self.serve_tls(listener, tls_acceptor.clone(), app).await?;
} else {
self.serve_http(listener, app).await?;
}
Ok(())
}
async fn serve_http(
&self,
listener: tokio::net::TcpListener,
app: axum::Router,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
use axum::extract::Request;
use hyper_util::rt::{TokioExecutor, TokioIo};
use std::net::SocketAddr;
use tower_service::Service;
loop {
let (connection, remote_addr) = listener.accept().await?;
let mut make_service = app
.clone()
.into_make_service_with_connect_info::<SocketAddr>();
tokio::spawn(async move {
let router = make_service.call(remote_addr).await.unwrap();
let io = TokioIo::new(connection);
let hyper_service =
hyper::service::service_fn(move |request: Request<hyper::body::Incoming>| {
let mut router = router.clone();
async move {
let response = router.call(request).await.unwrap();
if response.extensions().get::<DropHttpConnection>().is_some() {
return Err(std::io::Error::new(
std::io::ErrorKind::ConnectionAborted,
"oversized aria2 RPC request",
));
}
Ok::<_, std::io::Error>(response)
}
});
if let Err(error) =
hyper_util::server::conn::auto::Builder::new(TokioExecutor::new())
.serve_connection_with_upgrades(io, hyper_service)
.await
{
tracing::debug!(%remote_addr, %error, "HTTP connection ended");
}
});
}
}
async fn serve_tls(
&self,
listener: tokio::net::TcpListener,
tls_acceptor: tokio_rustls::TlsAcceptor,
app: axum::Router,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
use axum::extract::Request;
use hyper_util::rt::{TokioExecutor, TokioIo};
use std::net::SocketAddr;
use tower_service::Service;
loop {
let (cnx, remote_addr) = listener.accept().await?;
let tls_acceptor = tls_acceptor.clone();
let mut make_service = app
.clone()
.into_make_service_with_connect_info::<SocketAddr>();
tokio::spawn(async move {
let Ok(tls_stream) = tls_acceptor.accept(cnx).await else {
tracing::error!("TLS handshake failed for connection from {}", remote_addr);
return;
};
let router = make_service.call(remote_addr).await.unwrap();
let io = TokioIo::new(tls_stream);
let hyper_service =
hyper::service::service_fn(move |request: Request<hyper::body::Incoming>| {
let mut router = router.clone();
async move {
let response = router.call(request).await.unwrap();
if response.extensions().get::<DropHttpConnection>().is_some() {
return Err(std::io::Error::new(
std::io::ErrorKind::ConnectionAborted,
"oversized aria2 RPC request",
));
}
Ok::<_, std::io::Error>(response)
}
});
let result = hyper_util::server::conn::auto::Builder::new(TokioExecutor::new())
.serve_connection_with_upgrades(io, hyper_service)
.await;
if let Err(err) = result {
tracing::warn!("HTTPS connection error from {}: {}", remote_addr, err);
}
});
}
}
}
#[derive(Clone)]
pub struct RpcState {
pub(crate) engine: Arc<RpcEngine>,
pub(crate) auth: AuthConfig,
pub(crate) max_request_size: usize,
}
#[derive(Clone, Debug)]
struct DropHttpConnection;
fn build_cors_layer(config: &CorsConfig) -> tower_http::cors::CorsLayer {
use axum::http::{HeaderName, HeaderValue, Method};
use std::time::Duration;
use tower_http::cors::{AllowHeaders, AllowMethods, AllowOrigin, Any, CorsLayer};
if config.allowed_origins().is_empty() {
return CorsLayer::new();
}
let methods = if config.allow_methods.trim() == "*" {
AllowMethods::any()
} else {
AllowMethods::list(
config
.allow_methods
.split(',')
.filter_map(|method| method.trim().parse::<Method>().ok()),
)
};
let headers = if config.allow_headers.trim() == "*" {
AllowHeaders::any()
} else {
AllowHeaders::list(
config
.allow_headers
.split(',')
.filter_map(|header| header.trim().parse::<HeaderName>().ok()),
)
};
let max_age = crate::constants::CORS_MAX_AGE;
let origin = if config.is_wildcard() {
if config.allow_credentials {
AllowOrigin::mirror_request()
} else {
Any.into()
}
} else {
AllowOrigin::list(
config
.allowed_origins()
.iter()
.filter_map(|origin| HeaderValue::from_str(origin).ok()),
)
};
CorsLayer::new()
.allow_origin(origin)
.allow_methods(methods)
.allow_headers(headers)
.allow_credentials(config.allow_credentials)
.max_age(Duration::from_secs(max_age))
}
async fn http_auth_middleware(
axum::extract::State(state): axum::extract::State<RpcState>,
request: axum::extract::Request,
next: axum::middleware::Next,
) -> axum::response::Response {
use axum::http::{Method, StatusCode, header};
use axum::response::IntoResponse;
let authorized = request.method() == Method::OPTIONS
|| !state.auth.has_basic()
|| state.auth.verify_authorization(
request
.headers()
.get(header::AUTHORIZATION)
.and_then(|value| value.to_str().ok()),
);
if authorized {
if request_content_length_exceeds_limit(&request, state.max_request_size) {
let mut response = axum::response::Response::new(axum::body::Body::empty());
response.extensions_mut().insert(DropHttpConnection);
return response;
}
next.run(request).await
} else {
(
StatusCode::UNAUTHORIZED,
[(header::WWW_AUTHENTICATE, "Basic realm=\"aria2\"")],
"Unauthorized",
)
.into_response()
}
}
fn request_content_length_exceeds_limit(
request: &axum::extract::Request,
max_request_size: usize,
) -> bool {
use axum::http::header;
let is_websocket_upgrade = request
.headers()
.get(header::UPGRADE)
.and_then(|value| value.to_str().ok())
.is_some_and(|value| value.eq_ignore_ascii_case("websocket"))
&& request
.headers()
.get(header::CONNECTION)
.and_then(|value| value.to_str().ok())
.is_some_and(|value| {
value
.split(',')
.any(|token| token.trim().eq_ignore_ascii_case("upgrade"))
});
if is_websocket_upgrade {
return false;
}
request
.headers()
.get(header::CONTENT_LENGTH)
.and_then(|value| value.to_str().ok())
.and_then(|value| value.parse::<u64>().ok())
.is_some_and(|content_length| content_length > max_request_size as u64)
}
struct JsonGetRequest {
body: Vec<u8>,
callback: Option<String>,
}
fn parse_json_get_query(query: &str) -> JsonGetRequest {
let query = query.strip_prefix('?').unwrap_or(query);
let mut method = None;
let mut id = None;
let mut params = None;
let mut callback = None;
for item in query.split('&') {
if let Some(value) = item.strip_prefix("method=") {
method = Some(value);
} else if let Some(value) = item.strip_prefix("id=") {
id = Some(value);
} else if let Some(value) = item.strip_prefix("params=") {
params = Some(value);
} else if let Some(value) = item.strip_prefix("jsoncallback=") {
callback = Some(value);
}
}
let has_params = params.is_some_and(|encoded| !encoded.is_empty());
let decoded_params = params.map(|encoded| {
let decoded = crate::rpc_helpers::percent_decode(encoded);
crate::rpc_helpers::decode_aria2_base64(&decoded)
});
let body = match (method, id) {
(None, None) => decoded_params.unwrap_or_default(),
(method, id) => {
let mut body = Vec::new();
body.extend_from_slice(b"{");
if let Some(method) = method {
body.extend_from_slice(b"\"method\":\"");
body.extend_from_slice(method.as_bytes());
body.extend_from_slice(b"\"");
}
if let Some(id) = id {
body.extend_from_slice(b",\"id\":\"");
body.extend_from_slice(id.as_bytes());
body.extend_from_slice(b"\"");
}
if has_params {
let params = decoded_params
.as_deref()
.expect("non-empty params must have a decoded value");
body.extend_from_slice(b",\"params\":");
body.extend_from_slice(params);
}
body.extend_from_slice(b"}");
body
}
};
JsonGetRequest {
body,
callback: callback.map(str::to_owned),
}
}
struct JsonRpcHttpResponse {
status: axum::http::StatusCode,
body: Vec<u8>,
close_connection: bool,
}
fn http_status_for_jsonrpc_error(code: i32) -> axum::http::StatusCode {
use axum::http::StatusCode;
match code {
1 | -32600 => StatusCode::BAD_REQUEST,
-32601 => StatusCode::NOT_FOUND,
_ => StatusCode::INTERNAL_SERVER_ERROR,
}
}
fn serialize_jsonrpc_response(response: crate::json_rpc::JsonRpcResponse) -> JsonRpcHttpResponse {
let status = response
.error
.as_ref()
.map(|error| http_status_for_jsonrpc_error(error.code))
.unwrap_or(axum::http::StatusCode::OK);
let body = response.to_bytes().unwrap_or_else(|error| {
format!(
"{{\"jsonrpc\":\"2.0\",\"id\":null,\"error\":{{\"code\":-32603,\"message\":{}}}}}",
serde_json::Value::String(error.to_string())
)
.into_bytes()
});
JsonRpcHttpResponse {
status,
body,
close_connection: response.error.is_some(),
}
}
async fn dispatch_jsonrpc_body(engine: &RpcEngine, body: &[u8]) -> JsonRpcHttpResponse {
use crate::json_rpc::{JsonRpcBatchResponse, JsonRpcWireEntry, parse_aria2_wire_document};
match parse_aria2_wire_document(body) {
Ok(document) if !document.is_batch => {
let entry = document
.entries
.into_iter()
.next()
.expect("single JSON-RPC document must contain one entry");
let response = match entry {
JsonRpcWireEntry::Request(request) => engine.handle_request_owned(request).await,
JsonRpcWireEntry::Error(response) => response,
};
serialize_jsonrpc_response(response)
}
Ok(document) => {
let body = JsonRpcBatchResponse(dispatch_wire_entries(engine, document.entries).await)
.to_bytes()
.unwrap_or_else(|error| {
format!(
"{{\"jsonrpc\":\"2.0\",\"id\":null,\"error\":{{\"code\":-32603,\"message\":{}}}}}",
serde_json::Value::String(error.to_string())
)
.into_bytes()
});
JsonRpcHttpResponse {
status: axum::http::StatusCode::OK,
body,
close_connection: false,
}
}
Err(error) => serialize_jsonrpc_response(error.into_response(None)),
}
}
fn into_jsonrpc_http_response(
response: JsonRpcHttpResponse,
content_type: &'static str,
) -> axum::response::Response {
use axum::http::{HeaderValue, header};
use axum::response::IntoResponse;
let close_connection = response.close_connection;
let mut http_response = (
response.status,
[(header::CONTENT_TYPE, content_type)],
response.body,
)
.into_response();
if close_connection {
http_response
.headers_mut()
.insert(header::CONNECTION, HeaderValue::from_static("close"));
}
http_response
}
fn wrap_jsonp(body: Vec<u8>, callback: Option<&str>) -> Vec<u8> {
match callback {
Some(callback) => {
let mut wrapped = Vec::with_capacity(callback.len() + body.len() + 2);
wrapped.extend_from_slice(callback.as_bytes());
wrapped.push(b'(');
wrapped.extend_from_slice(&body);
wrapped.push(b')');
wrapped
}
None => body,
}
}
impl std::fmt::Debug for RpcServer {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("RpcServer")
.field("addr", &self.addr())
.field("secure", &self.is_secure())
.field("config", &self.config)
.finish()
}
}
async fn handle_jsonrpc(
axum::extract::State(state): axum::extract::State<RpcState>,
body: axum::body::Bytes,
) -> impl axum::response::IntoResponse {
let response = dispatch_jsonrpc_body(&state.engine, &body).await;
into_jsonrpc_http_response(response, "application/json-rpc")
}
async fn handle_xmlrpc(
axum::extract::State(state): axum::extract::State<RpcState>,
body: axum::body::Bytes,
) -> impl axum::response::IntoResponse {
use crate::json_rpc::JsonRpcRequest;
use crate::xml_rpc::{XmlRpcResponse, XmlRpcValue, parse_request};
use axum::http::{StatusCode, header};
let (status, content_type, response_body) = match parse_request(&body) {
Ok(request) => {
let params = request
.params
.iter()
.map(XmlRpcValue::to_json_value)
.collect::<Result<Vec<_>, _>>();
match params {
Ok(params) => {
let json_request =
JsonRpcRequest::new(request.method_name, serde_json::Value::Array(params))
.with_id(serde_json::Value::String("xmlrpc".into()));
let json_response = state.engine.handle_request(&json_request).await;
let response = match json_response.result {
Some(result) => XmlRpcValue::from_json_value(result)
.map(XmlRpcResponse::single)
.unwrap_or_else(|error| {
XmlRpcResponse::fault(1, &error.to_string())
}),
None => {
let message = json_response
.error
.map(|error| error.message)
.unwrap_or_else(|| "Missing RPC response".into());
XmlRpcResponse::fault(1, &message)
}
};
(StatusCode::OK, Some("text/xml"), response.to_xml())
}
Err(_) => (StatusCode::BAD_REQUEST, None, String::new()),
}
}
Err(_) => (StatusCode::BAD_REQUEST, None, String::new()),
};
let mut response = axum::response::Response::new(axum::body::Body::from(response_body));
*response.status_mut() = status;
if let Some(content_type) = content_type {
response.headers_mut().insert(
header::CONTENT_TYPE,
axum::http::HeaderValue::from_static(content_type),
);
}
response
}
async fn handle_jsonrpc_or_ws(
axum::extract::State(state): axum::extract::State<RpcState>,
ws: Option<axum::extract::ws::WebSocketUpgrade>,
query: axum::extract::RawQuery,
) -> impl axum::response::IntoResponse {
match ws {
Some(upgrade) => {
let max_request_size = state.max_request_size;
upgrade.on_upgrade(move |socket| {
handle_ws_socket(socket, state.engine.clone(), max_request_size)
})
}
None => {
let parsed = parse_json_get_query(query.0.as_deref().unwrap_or_default());
let response = dispatch_jsonrpc_body(&state.engine, &parsed.body).await;
let content_type = if parsed.callback.is_some() {
"text/javascript"
} else {
"application/json-rpc"
};
let body = wrap_jsonp(response.body, parsed.callback.as_deref());
into_jsonrpc_http_response(JsonRpcHttpResponse { body, ..response }, content_type)
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_json_get_query_matches_aria2_wire_grammar() {
use base64::Engine;
let encoded = base64::engine::general_purpose::STANDARD.encode("[]");
let parsed = parse_json_get_query(&format!(
"method=aria2.getVersion&id=foo%20bar¶ms={encoded}&jsoncallback=cb%2Ename"
));
assert_eq!(
parsed.body,
br#"{"method":"aria2.getVersion","id":"foo%20bar","params":[]}"#
);
assert_eq!(parsed.callback.as_deref(), Some("cb%2Ename"));
}
#[test]
fn test_json_get_query_keeps_original_malformed_cases_for_json_parser() {
let no_query = parse_json_get_query("");
assert!(no_query.body.is_empty());
let id_only = parse_json_get_query("id=only-id");
assert_eq!(id_only.body, br#"{,"id":"only-id"}"#);
let invalid_base64 = parse_json_get_query("method=aria2.getVersion¶ms=not-base64");
assert!(!invalid_base64.body.is_empty());
}
#[test]
fn test_json_get_query_omits_empty_params_like_aria2() {
let parsed = parse_json_get_query("method=aria2.getVersion&id=empty¶ms=");
assert_eq!(
parsed.body,
br#"{"method":"aria2.getVersion","id":"empty"}"#
);
}
#[test]
fn test_json_get_callback_is_not_normalized() {
let parsed = parse_json_get_query("jsoncallback=bad;alert(1)//");
assert_eq!(parsed.callback.as_deref(), Some("bad;alert(1)//"));
}
#[test]
fn test_rpc_server_new_http() {
let server = RpcServer::new_http("127.0.0.1", 6800);
assert_eq!(server.addr(), "127.0.0.1:6800");
assert_eq!(server.port(), 6800);
assert!(!server.is_secure());
assert_eq!(server.scheme(), "http");
assert_eq!(server.rpc_url(), "http://127.0.0.1:6800/jsonrpc");
}
#[test]
fn test_rpc_server_from_config() {
let config = ServerConfig::default().with_host("0.0.0.0").with_port(8080);
let server = RpcServer::new(config).expect("Failed to create server");
assert_eq!(server.addr(), "0.0.0.0:8080");
assert!(!server.is_secure());
}
#[test]
fn test_rpc_server_debug_format() {
let server = RpcServer::new_http("localhost", 6800);
let debug_str = format!("{:?}", server);
assert!(debug_str.contains("RpcServer"));
assert!(debug_str.contains("localhost:6800"));
assert!(debug_str.contains("secure: false"));
}
#[test]
fn test_rpc_server_config_accessor() {
let config = ServerConfig::default()
.with_host("192.168.1.1")
.with_port(9999);
let server = RpcServer::new(config).expect("Failed to create server");
let cfg = server.config();
assert_eq!(cfg.host, "192.168.1.1");
assert_eq!(cfg.port, 9999);
}
#[test]
fn test_rpc_server_tls_acceptor_none_for_http() {
let server = RpcServer::new_http("127.0.0.1", 6800);
assert!(server.tls_acceptor().is_none());
}
}