use std::collections::HashMap;
use std::ffi::{CStr, c_char, c_void};
use std::panic::{AssertUnwindSafe, catch_unwind};
use std::ptr;
use std::slice;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use std::time::Duration;
use tokio::runtime::Runtime;
use tokio::sync::oneshot;
use tokio::task::JoinHandle;
use crate::config::{ConfigManager, OptionValue};
use crate::engine::download_engine::DownloadEngine;
use crate::engine::engine_command::{EngineCommand, EngineCommandSender};
#[cfg(feature = "metalink")]
use crate::engine::metalink::to_request_group::MetalinkToRequestGroup;
use crate::error::Result;
use crate::rate_limiter::RateLimiterConfig;
use crate::request::request_group::{
DownloadOptions, DownloadStatus, GroupId, HaltReason, RequestGroup,
};
use crate::request::request_group_man::{PositionMode, RequestGroupMan};
use crate::util::rwlock_ext::RwLockRecover;
#[repr(C)]
pub struct Aria2RustKeyValue {
pub name: *const c_char,
pub value: *const c_char,
}
#[repr(u32)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Aria2RustDownloadStatus {
Active = 0,
Waiting = 1,
Paused = 2,
Complete = 3,
Error = 4,
Removed = 5,
}
pub const ARIA2_RUST_POSITION_SET: u32 = 0;
pub const ARIA2_RUST_POSITION_CUR: u32 = 1;
pub const ARIA2_RUST_POSITION_END: u32 = 2;
#[repr(C)]
#[derive(Debug, Clone, Copy, Default)]
pub struct Aria2RustDownloadInfo {
pub status: u32,
pub total_length: u64,
pub completed_length: u64,
pub upload_length: u64,
pub download_speed: u64,
pub upload_speed: u64,
pub error_code: u32,
}
#[repr(C)]
#[derive(Debug, Clone, Copy, Default)]
pub struct Aria2RustFileInfo {
pub length: u64,
pub completed_length: u64,
pub selected: u8,
}
#[repr(C)]
#[derive(Debug, Clone, Copy, Default)]
pub struct Aria2RustGlobalStat {
pub download_speed: u64,
pub upload_speed: u64,
pub num_active: u64,
pub num_waiting: u64,
pub num_stopped: u64,
}
pub struct Aria2RustSession {
runtime: Runtime,
config: ConfigManager,
request_man: Arc<RequestGroupMan>,
command_tx: EngineCommandSender,
shutdown_tx: Option<oneshot::Sender<()>>,
engine_task: Option<JoinHandle<Result<()>>>,
keep_running: bool,
last_error: String,
}
static LIBRARY_INITIALIZED: AtomicBool = AtomicBool::new(false);
const INVALID_ARGUMENT: i32 = -1;
const INTERNAL_ERROR: i32 = -2;
const BUFFER_TOO_SMALL: i32 = -3;
const TIMEOUT: i32 = -4;
fn ffi_result<T>(fallback: T, f: impl FnOnce() -> T) -> T {
catch_unwind(AssertUnwindSafe(f)).unwrap_or(fallback)
}
unsafe fn read_c_string(ptr: *const c_char) -> std::result::Result<String, String> {
if ptr.is_null() {
return Err("null C string".to_string());
}
unsafe { CStr::from_ptr(ptr) }
.to_str()
.map(str::to_string)
.map_err(|_| "option contains invalid UTF-8".to_string())
}
unsafe fn read_key_values(
options: *const Aria2RustKeyValue,
count: usize,
) -> std::result::Result<Vec<(String, String)>, String> {
if count == 0 {
return Ok(Vec::new());
}
if options.is_null() {
return Err("options pointer is null".to_string());
}
let entries = unsafe { slice::from_raw_parts(options, count) };
entries
.iter()
.map(|entry| {
let name = unsafe { read_c_string(entry.name) }?;
let value = unsafe { read_c_string(entry.value) }?;
Ok((name, value))
})
.collect()
}
fn status_code(status: &DownloadStatus) -> u32 {
match status {
DownloadStatus::Active => Aria2RustDownloadStatus::Active as u32,
DownloadStatus::Waiting => Aria2RustDownloadStatus::Waiting as u32,
DownloadStatus::Paused => Aria2RustDownloadStatus::Paused as u32,
DownloadStatus::Complete => Aria2RustDownloadStatus::Complete as u32,
DownloadStatus::Error(_) => Aria2RustDownloadStatus::Error as u32,
DownloadStatus::Removed => Aria2RustDownloadStatus::Removed as u32,
}
}
fn result_info(result: &crate::request::request_group::DownloadResult) -> Aria2RustDownloadInfo {
Aria2RustDownloadInfo {
status: status_code(&result.status),
total_length: result.total_length,
completed_length: result.completed_length,
upload_length: result.upload_length,
download_speed: result.download_speed,
upload_speed: result.upload_speed,
error_code: result.code.as_code(),
}
}
fn download_info_from_manager(
manager: &RequestGroupMan,
gid: u64,
) -> Option<Aria2RustDownloadInfo> {
if let Some(group) = manager.find_group(GroupId::new(gid)) {
let group = group.recover();
return Some(Aria2RustDownloadInfo {
status: status_code(&group.status()),
total_length: group.total_length(),
completed_length: group.completed_length(),
upload_length: group.upload_length(),
download_speed: group.download_speed(),
upload_speed: group.upload_speed(),
error_code: group.create_download_result().code.as_code(),
});
}
manager
.find_stopped_result(&GroupId::new(gid).to_hex_string())
.as_ref()
.map(result_info)
}
impl Aria2RustSession {
fn new(raw_options: Vec<(String, String)>) -> std::result::Result<Self, String> {
let runtime = Runtime::new().map_err(|error| format!("runtime init failed: {error}"))?;
let (config, keep_running) = runtime.block_on(async {
let mut config = ConfigManager::new();
let mut keep_running = false;
for (name, value) in raw_options {
if name == "keep-running" {
keep_running = parse_bool(&value)?;
continue;
}
if !config.registry().contains(&name) {
continue;
}
config
.set_global_option(&name, OptionValue::Str(value))
.await
.map_err(|error| format!("invalid option {name}: {error}"))?;
}
Ok::<_, String>((config, keep_running))
})?;
let request_man = Arc::new(RequestGroupMan::new());
let mut engine = DownloadEngine::new();
#[cfg(feature = "bittorrent")]
{
let sources = runtime.block_on(config.get_global_option("bt-tracker-source"));
let sources = match sources {
Some(OptionValue::List(values)) => values,
Some(OptionValue::Str(value)) => value
.split([',', '\n'])
.map(str::trim)
.filter(|value| !value.is_empty())
.map(str::to_string)
.collect(),
_ => Vec::new(),
};
let update_interval = runtime
.block_on(config.get_global_i64("bt-tracker-update-interval"))
.filter(|seconds| *seconds > 0)
.map(|seconds| Duration::from_secs(seconds as u64))
.unwrap_or(
aria2_protocol::bittorrent::tracker::public_list::DEFAULT_TRACKER_UPDATE_INTERVAL,
);
let enabled = runtime
.block_on(config.get_global_bool("enable-public-trackers"))
.unwrap_or(true);
engine.set_public_tracker_config(
aria2_protocol::bittorrent::tracker::public_list::TrackerCatalogConfig {
enabled,
sources,
update_interval,
},
);
}
engine.set_request_group_man(Arc::clone(&request_man));
engine.set_keep_alive(true);
let max_concurrent = runtime.block_on(config.get_global_i64("max-concurrent-downloads"));
if let Some(max) = max_concurrent.filter(|value| *value >= 0) {
request_man.set_max_concurrent(max as u32);
}
let download_limit = runtime
.block_on(config.get_global_i64("max-overall-download-limit"))
.and_then(non_zero_limit);
let upload_limit = runtime
.block_on(config.get_global_i64("max-overall-upload-limit"))
.and_then(non_zero_limit);
if download_limit.is_some() || upload_limit.is_some() {
engine.set_global_rate_limiter(RateLimiterConfig::new(download_limit, upload_limit));
request_man.set_global_speed_limit(download_limit, upload_limit);
}
let command_tx = engine.engine_command_sender();
let shutdown_tx = engine.take_shutdown_sender();
let engine_task = runtime.spawn(engine.run());
Ok(Self {
runtime,
config,
request_man,
command_tx,
shutdown_tx,
engine_task: Some(engine_task),
keep_running,
last_error: String::new(),
})
}
fn fail<T>(&mut self, message: impl Into<String>, fallback: T) -> T {
self.last_error = message.into();
fallback
}
fn merged_options(
&mut self,
overrides: Vec<(String, String)>,
) -> std::result::Result<DownloadOptions, String> {
let values = self.runtime.block_on(self.config.get_all_global_options());
let mut strings = values
.into_iter()
.filter_map(|(name, value)| {
if value.is_none() {
None
} else {
Some((name, value.to_string()))
}
})
.collect::<HashMap<_, _>>();
for (name, value) in overrides {
if name == "keep-running" {
continue;
}
let Some(definition) = self.config.registry().get(&name) else {
continue;
};
let parsed = definition
.parse_value(&value)
.map_err(|error| format!("invalid option {name}: {error}"))?;
strings.insert(name, parsed.to_string());
}
Ok(DownloadOptions::from_option_strings(&strings))
}
fn add_uri(
&mut self,
uris: Vec<String>,
overrides: Vec<(String, String)>,
) -> std::result::Result<u64, String> {
if uris.is_empty() || uris.iter().any(String::is_empty) {
return Err("at least one non-empty URI is required".to_string());
}
let options = self.merged_options(overrides)?;
let gid = {
let man = &self.request_man;
let gid = man.next_available_gid();
let group = Arc::new(std::sync::RwLock::new(RequestGroup::new(
gid,
uris,
options.clone(),
)));
if options.pause {
group
.recover_mut()
.pause()
.map_err(|error| error.to_string())?;
}
man.add_group_arc(Arc::clone(&group));
if let Err(error) = self.command_tx.send(EngineCommand::AddDownload { group }) {
let _ = man.remove_group_by_id(gid);
return Err(error.to_string());
}
Ok::<_, String>(gid.value())
}?;
Ok(gid)
}
#[cfg(feature = "bittorrent")]
fn add_torrent(
&mut self,
data: Vec<u8>,
web_seed_uris: Vec<String>,
overrides: Vec<(String, String)>,
) -> std::result::Result<u64, String> {
if data.is_empty() {
return Err("torrent data must not be empty".to_string());
}
let options = self.merged_options(overrides)?;
let gid = self.request_man.next_available_gid();
let mut uris = Vec::with_capacity(1);
uris.push(format!("bt://{}", gid.to_hex_string()));
let group = Arc::new(std::sync::RwLock::new(RequestGroup::new(
gid,
uris,
options.clone(),
)));
if options.pause {
group
.recover_mut()
.pause()
.map_err(|error| error.to_string())?;
}
crate::engine::bittorrent::download::command::prepare_group_metadata(
Arc::clone(&group),
&data,
&options,
options.dir.as_deref(),
&web_seed_uris,
)
.map_err(|error| error.to_string())?;
group.recover().set_bt_metadata_data(data);
self.request_man.add_group_arc(Arc::clone(&group));
if let Err(error) = self.command_tx.send(EngineCommand::AddDownload { group }) {
let _ = self.request_man.remove_group_by_id(gid);
return Err(error.to_string());
}
Ok(gid.value())
}
#[cfg(not(feature = "bittorrent"))]
fn add_torrent(
&mut self,
data: Vec<u8>,
web_seed_uris: Vec<String>,
overrides: Vec<(String, String)>,
) -> std::result::Result<u64, String> {
let _ = (data, web_seed_uris, overrides);
Err("BitTorrent is not enabled".to_string())
}
#[cfg(feature = "metalink")]
fn add_metalink(
&mut self,
data: Vec<u8>,
overrides: Vec<(String, String)>,
gid_capacity: Option<usize>,
) -> std::result::Result<Vec<u64>, String> {
if data.is_empty() {
return Err("metalink data must not be empty".to_string());
}
let options = self.merged_options(overrides)?;
let converter = MetalinkToRequestGroup::new();
let mut gids = std::iter::from_fn(|| Some(self.request_man.next_available_gid()));
let expansion = converter
.create_groups_from_bytes(&data, &options, &mut gids)
.map_err(|error| error.to_string())?;
let resource_groups = expansion.resource_groups;
#[cfg(feature = "bittorrent")]
let graphs = expansion.torrent_graphs;
#[cfg(feature = "bittorrent")]
let required_gids = resource_groups.len() + graphs.len().saturating_mul(2);
#[cfg(not(feature = "bittorrent"))]
let required_gids = resource_groups.len();
if gid_capacity.is_some_and(|capacity| capacity < required_gids) {
return Err(format!(
"output buffer too small; required {required_gids} GIDs"
));
}
let mut response_gids = Vec::new();
for group in resource_groups {
let gid = group.recover().gid();
self.request_man.add_group_arc(Arc::clone(&group));
if let Err(error) = self.command_tx.send(EngineCommand::AddDownload { group }) {
let _ = self.request_man.remove_group_by_id(gid);
return Err(error.to_string());
}
response_gids.push(gid.value());
}
#[cfg(feature = "bittorrent")]
{
for graph in graphs {
let metadata_gid = graph.metadata.recover().gid();
let payload_gid = graph.payload.recover().gid();
let metadata_group = Arc::clone(&graph.metadata);
let payload_group = Arc::clone(&graph.payload);
self.request_man
.add_metalink_graph(graph)
.map_err(|error| error.to_string())?;
self.command_tx
.send(EngineCommand::AddDownload {
group: metadata_group,
})
.map_err(|error| error.to_string())?;
self.command_tx
.send(EngineCommand::AddDownload {
group: payload_group,
})
.map_err(|error| error.to_string())?;
response_gids.extend([metadata_gid.value(), payload_gid.value()]);
}
}
Ok(response_gids)
}
#[cfg(not(feature = "metalink"))]
fn add_metalink(
&mut self,
data: Vec<u8>,
overrides: Vec<(String, String)>,
gid_capacity: Option<usize>,
) -> std::result::Result<Vec<u64>, String> {
let _ = (data, overrides, gid_capacity);
Err("Metalink is not enabled".to_string())
}
fn run(&mut self, mode: u32) -> i32 {
let keep_running = self.keep_running;
let request_man = Arc::clone(&self.request_man);
self.runtime.block_on(async {
if mode == 1 {
if !keep_running && request_man.download_finished() {
return 0;
}
tokio::task::yield_now().await;
return if keep_running || !request_man.download_finished() {
1
} else {
0
};
}
let notifier = request_man.download_finished_notifier();
loop {
let notified = notifier.notified();
tokio::pin!(notified);
notified.as_mut().enable();
if request_man.download_finished() {
return 0;
}
notified.await;
}
})
}
fn wait_download(
&self,
gid: u64,
timeout_ms: u64,
) -> std::result::Result<Aria2RustDownloadInfo, i32> {
let request_man = Arc::clone(&self.request_man);
let wait = async move {
let signal = request_man.activity_signal();
let mut observed = signal.generation();
loop {
let Some(info) = download_info_from_manager(&request_man, gid) else {
return Err(INVALID_ARGUMENT);
};
if matches!(
info.status,
status if status == Aria2RustDownloadStatus::Complete as u32
|| status == Aria2RustDownloadStatus::Error as u32
|| status == Aria2RustDownloadStatus::Removed as u32
) {
return Ok(info);
}
signal.wait_for_change(&mut observed).await;
}
};
if timeout_ms == 0 {
self.runtime.block_on(wait)
} else {
self.runtime.block_on(async {
tokio::time::timeout(Duration::from_millis(timeout_ms), wait)
.await
.unwrap_or(Err(TIMEOUT))
})
}
}
fn finalize(&mut self) -> i32 {
let _ = self.command_tx.send(EngineCommand::ForceHaltAll {
reason: HaltReason::ShutdownSignal,
});
if let Some(shutdown_tx) = self.shutdown_tx.take() {
let _ = shutdown_tx.send(());
}
if let Some(engine_task) = self.engine_task.take() {
let _ = self.runtime.block_on(engine_task);
}
0
}
fn change_global_options(&mut self, options: Vec<(String, String)>) -> i32 {
let mut download_limit_changed = false;
let mut upload_limit_changed = false;
let mut max_concurrent = None;
#[cfg(feature = "bittorrent")]
let mut public_tracker_sources = None;
#[cfg(feature = "bittorrent")]
let mut public_tracker_update_interval = None;
#[cfg(feature = "bittorrent")]
let mut public_trackers_enabled = None;
for (name, value) in options {
if name == "keep-running" {
match parse_bool(&value) {
Ok(value) => self.keep_running = value,
Err(error) => return self.fail(error, INVALID_ARGUMENT),
}
continue;
}
if !self.config.registry().contains(&name) {
continue;
}
let parsed = match self
.config
.registry()
.get(&name)
.and_then(|def| def.parse_value(&value).ok())
{
Some(value) => value,
None => return self.fail(format!("invalid option {name}"), INVALID_ARGUMENT),
};
if self
.runtime
.block_on(
self.config
.set_global_option(&name, OptionValue::Str(value.clone())),
)
.is_err()
{
return self.fail(format!("invalid option {name}"), INVALID_ARGUMENT);
}
match name.as_str() {
"max-concurrent-downloads" => max_concurrent = parsed.as_i64(),
"max-overall-download-limit" => download_limit_changed = true,
"max-overall-upload-limit" => upload_limit_changed = true,
#[cfg(feature = "bittorrent")]
"bt-tracker-source" => public_tracker_sources = Some(value),
#[cfg(feature = "bittorrent")]
"bt-tracker-update-interval" => public_tracker_update_interval = parsed.as_i64(),
#[cfg(feature = "bittorrent")]
"enable-public-trackers" => public_trackers_enabled = parsed.as_bool(),
_ => {}
}
}
if let Some(max) = max_concurrent.filter(|value| *value >= 0) {
let _ = self
.command_tx
.send(EngineCommand::SetMaxConcurrent { max: max as u32 });
}
if download_limit_changed || upload_limit_changed {
let download_limit = self
.runtime
.block_on(self.config.get_global_i64("max-overall-download-limit"))
.and_then(non_zero_limit);
let upload_limit = self
.runtime
.block_on(self.config.get_global_i64("max-overall-upload-limit"))
.and_then(non_zero_limit);
let _ = self.command_tx.send(EngineCommand::SetGlobalRateLimit {
download_limit,
upload_limit,
});
}
#[cfg(feature = "bittorrent")]
{
if let Some(sources) = public_tracker_sources {
let _ = self
.command_tx
.send(EngineCommand::SetPublicTrackerSources { sources });
}
if let Some(seconds) = public_tracker_update_interval.filter(|seconds| *seconds > 0) {
let _ = self
.command_tx
.send(EngineCommand::SetPublicTrackerUpdateInterval {
seconds: seconds as u64,
});
}
if let Some(enabled) = public_trackers_enabled {
let _ = self
.command_tx
.send(EngineCommand::SetPublicTrackersEnabled { enabled });
}
}
0
}
fn change_options(&mut self, gid: u64, options: Vec<(String, String)>) -> i32 {
let changes = options
.into_iter()
.map(|(name, value)| (name, serde_json::Value::String(value)))
.collect();
let result = {
let manager = &self.request_man;
manager.change_group_options(&GroupId::new(gid).to_hex_string(), changes)
};
match result {
Ok(()) => 0,
Err(error) => self.fail(error, INVALID_ARGUMENT),
}
}
fn pause_all(&mut self, force: bool) -> i32 {
if force {
self.request_man.force_pause_all();
} else {
self.request_man.pause_all();
}
let command = if force {
EngineCommand::ForcePauseAll
} else {
EngineCommand::PauseAll
};
self.command_tx
.send(command)
.map(|_| 0)
.unwrap_or_else(|error| self.fail(error.to_string(), INTERNAL_ERROR))
}
fn unpause_all(&mut self) -> i32 {
self.request_man.unpause_all();
self.command_tx
.send(EngineCommand::UnpauseAll)
.map(|_| 0)
.unwrap_or_else(|error| self.fail(error.to_string(), INTERNAL_ERROR))
}
fn change_position(
&mut self,
gid: u64,
position: i32,
mode: u32,
) -> std::result::Result<usize, String> {
let mode = match mode {
0 => PositionMode::SetFromStart,
1 => PositionMode::MoveFromStart,
2 => PositionMode::SetFromEnd,
_ => return Err("invalid queue position mode".to_string()),
};
self.request_man
.change_position(GroupId::new(gid), position, mode)
.map_err(|error| error.to_string())
}
fn get_info(&self, gid: u64) -> Option<Aria2RustDownloadInfo> {
download_info_from_manager(&self.request_man, gid)
}
fn file_entries(&self, gid: u64) -> Option<Vec<crate::request::request_group::FileEntry>> {
if let Some(group) = self.request_man.find_group(GroupId::new(gid)) {
return Some(group.recover().create_download_result().files);
}
self.request_man
.find_stopped_result(&GroupId::new(gid).to_hex_string())
.map(|result| result.files)
}
fn global_stat(&mut self) -> Aria2RustGlobalStat {
let manager = &self.request_man;
let mut stat = Aria2RustGlobalStat {
num_stopped: manager.stopped_results_len() as u64,
..Default::default()
};
for group in manager.list_groups() {
let group = group.recover();
match group.status() {
DownloadStatus::Active => {
stat.num_active += 1;
stat.download_speed =
stat.download_speed.saturating_add(group.download_speed());
stat.upload_speed = stat.upload_speed.saturating_add(group.upload_speed());
}
DownloadStatus::Waiting | DownloadStatus::Paused => stat.num_waiting += 1,
DownloadStatus::Complete | DownloadStatus::Error(_) | DownloadStatus::Removed => {}
}
}
stat
}
}
fn parse_bool(value: &str) -> std::result::Result<bool, String> {
match value.to_ascii_lowercase().as_str() {
"true" | "yes" | "1" | "on" => Ok(true),
"false" | "no" | "0" | "off" => Ok(false),
_ => Err(format!("invalid boolean '{value}'")),
}
}
fn non_zero_limit(value: i64) -> Option<u64> {
(value > 0).then_some(value as u64)
}
fn write_c_string(value: &str, output: *mut c_char, capacity: usize) -> usize {
let required = value.len().saturating_add(1);
if output.is_null() || capacity < required {
return required;
}
unsafe {
ptr::copy_nonoverlapping(value.as_ptr().cast::<c_char>(), output, value.len());
*output.add(value.len()) = 0;
}
required
}
#[unsafe(no_mangle)]
pub extern "C" fn aria2_rust_library_init() -> i32 {
ffi_result(INTERNAL_ERROR, || {
LIBRARY_INITIALIZED.store(true, Ordering::Release);
0
})
}
#[unsafe(no_mangle)]
pub extern "C" fn aria2_rust_library_deinit() -> i32 {
ffi_result(INTERNAL_ERROR, || {
LIBRARY_INITIALIZED.store(false, Ordering::Release);
0
})
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn aria2_rust_session_new(
options: *const Aria2RustKeyValue,
option_count: usize,
_user_data: *mut c_void,
) -> *mut Aria2RustSession {
ffi_result(ptr::null_mut(), || {
if !LIBRARY_INITIALIZED.load(Ordering::Acquire) {
return ptr::null_mut();
}
let options = match unsafe { read_key_values(options, option_count) } {
Ok(options) => options,
Err(_) => return ptr::null_mut(),
};
match Aria2RustSession::new(options) {
Ok(session) => Box::into_raw(Box::new(session)),
Err(_) => ptr::null_mut(),
}
})
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn aria2_rust_session_final(session: *mut Aria2RustSession) -> i32 {
ffi_result(INTERNAL_ERROR, || {
if session.is_null() {
return 0;
}
let mut session = unsafe { Box::from_raw(session) };
session.finalize()
})
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn aria2_rust_add_uri(
session: *mut Aria2RustSession,
uris: *const *const c_char,
uri_count: usize,
options: *const Aria2RustKeyValue,
option_count: usize,
gid_out: *mut u64,
) -> i32 {
ffi_result(INTERNAL_ERROR, || {
if session.is_null() || (uri_count > 0 && uris.is_null()) || gid_out.is_null() {
return INVALID_ARGUMENT;
}
let uri_ptrs = unsafe { slice::from_raw_parts(uris, uri_count) };
let uris = match uri_ptrs
.iter()
.map(|uri| unsafe { read_c_string(*uri) })
.collect::<std::result::Result<Vec<_>, _>>()
{
Ok(uris) => uris,
Err(_) => return INVALID_ARGUMENT,
};
let options = match unsafe { read_key_values(options, option_count) } {
Ok(options) => options,
Err(_) => return INVALID_ARGUMENT,
};
let session = unsafe { &mut *session };
match session.add_uri(uris, options) {
Ok(gid) => {
unsafe { *gid_out = gid };
0
}
Err(error) => session.fail(error, INVALID_ARGUMENT),
}
})
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn aria2_rust_add_torrent(
session: *mut Aria2RustSession,
torrent_data: *const u8,
torrent_length: usize,
web_seed_uris: *const *const c_char,
web_seed_uri_count: usize,
options: *const Aria2RustKeyValue,
option_count: usize,
gid_out: *mut u64,
) -> i32 {
ffi_result(INTERNAL_ERROR, || {
if session.is_null()
|| torrent_data.is_null()
|| torrent_length == 0
|| (web_seed_uri_count > 0 && web_seed_uris.is_null())
|| gid_out.is_null()
{
return INVALID_ARGUMENT;
}
let data = unsafe { slice::from_raw_parts(torrent_data, torrent_length) }.to_vec();
let web_seed_uris = if web_seed_uri_count == 0 {
Vec::new()
} else {
let uri_ptrs = unsafe { slice::from_raw_parts(web_seed_uris, web_seed_uri_count) };
match uri_ptrs
.iter()
.map(|uri| unsafe { read_c_string(*uri) })
.collect::<std::result::Result<Vec<_>, _>>()
{
Ok(uris) => uris,
Err(_) => return INVALID_ARGUMENT,
}
};
let options = match unsafe { read_key_values(options, option_count) } {
Ok(options) => options,
Err(_) => return INVALID_ARGUMENT,
};
let session = unsafe { &mut *session };
match session.add_torrent(data, web_seed_uris, options) {
Ok(gid) => {
unsafe { *gid_out = gid };
0
}
Err(error) => session.fail(error, INVALID_ARGUMENT),
}
})
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn aria2_rust_add_metalink(
session: *mut Aria2RustSession,
metalink_data: *const u8,
data_length: usize,
options: *const Aria2RustKeyValue,
option_count: usize,
gids_out: *mut u64,
gid_capacity: usize,
gid_count_out: *mut usize,
) -> i32 {
ffi_result(INTERNAL_ERROR, || {
if session.is_null()
|| metalink_data.is_null()
|| data_length == 0
|| gid_count_out.is_null()
|| (gid_capacity > 0 && gids_out.is_null())
{
return INVALID_ARGUMENT;
}
let data = unsafe { slice::from_raw_parts(metalink_data, data_length) }.to_vec();
let options = match unsafe { read_key_values(options, option_count) } {
Ok(options) => options,
Err(_) => return INVALID_ARGUMENT,
};
let session = unsafe { &mut *session };
let gids = match session.add_metalink(data, options, Some(gid_capacity)) {
Ok(gids) => gids,
Err(error) if error.starts_with("output buffer too small;") => {
return session.fail(error, BUFFER_TOO_SMALL);
}
Err(error) => return session.fail(error, INVALID_ARGUMENT),
};
unsafe { *gid_count_out = gids.len() };
if !gids_out.is_null() {
let destination = unsafe { slice::from_raw_parts_mut(gids_out, gid_capacity) };
for (slot, gid) in destination.iter_mut().zip(gids.iter().copied()) {
*slot = gid;
}
}
0
})
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn aria2_rust_run(session: *mut Aria2RustSession, mode: u32) -> i32 {
ffi_result(INTERNAL_ERROR, || {
if session.is_null() || mode > 1 {
return INVALID_ARGUMENT;
}
unsafe { (&mut *session).run(mode) }
})
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn aria2_rust_wait_download(
session: *mut Aria2RustSession,
gid: u64,
timeout_ms: u64,
output: *mut Aria2RustDownloadInfo,
) -> i32 {
ffi_result(INTERNAL_ERROR, || {
if session.is_null() || output.is_null() {
return INVALID_ARGUMENT;
}
let session = unsafe { &mut *session };
match session.wait_download(gid, timeout_ms) {
Ok(info) => {
unsafe { *output = info };
0
}
Err(TIMEOUT) => session.fail("download wait timed out", TIMEOUT),
Err(INVALID_ARGUMENT) => session.fail(format!("GID {gid} not found"), INVALID_ARGUMENT),
Err(error) => session.fail(format!("download wait failed: {error}"), INTERNAL_ERROR),
}
})
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn aria2_rust_remove(
session: *mut Aria2RustSession,
gid: u64,
force: u8,
) -> i32 {
ffi_result(INTERNAL_ERROR, || {
if session.is_null() {
return INVALID_ARGUMENT;
}
let session = unsafe { &mut *session };
let removal_result = {
let manager = &session.request_man;
if force != 0 {
manager.force_remove_group(GroupId::new(gid))
} else {
manager.remove_group(GroupId::new(gid))
}
};
if let Err(error) = removal_result {
return session.fail(error.to_string(), INVALID_ARGUMENT);
}
let command = if force != 0 {
EngineCommand::ForceRemoveDownload {
gid: GroupId::new(gid),
}
} else {
EngineCommand::RemoveDownload {
gid: GroupId::new(gid),
}
};
session
.command_tx
.send(command)
.map(|_| 0)
.unwrap_or_else(|error| session.fail(error.to_string(), INTERNAL_ERROR))
})
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn aria2_rust_pause(
session: *mut Aria2RustSession,
gid: u64,
force: u8,
) -> i32 {
ffi_result(INTERNAL_ERROR, || {
if session.is_null() {
return INVALID_ARGUMENT;
}
let session = unsafe { &mut *session };
let result = session
.request_man
.find_group(GroupId::new(gid))
.ok_or_else(|| format!("GID {gid} not found"));
let Some(group) = result.ok() else {
return session.fail(format!("GID {gid} not found"), INVALID_ARGUMENT);
};
let command = if force != 0 {
EngineCommand::ForcePause {
gid: GroupId::new(gid),
}
} else {
EngineCommand::Pause {
gid: GroupId::new(gid),
}
};
let pause_result = {
let mut group = group.recover_mut();
if force != 0 {
group.force_pause()
} else {
group.pause()
}
};
if let Err(error) = pause_result {
return session.fail(error.to_string(), INVALID_ARGUMENT);
}
session
.command_tx
.send(command)
.map(|_| 0)
.unwrap_or_else(|error| session.fail(error.to_string(), INTERNAL_ERROR))
})
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn aria2_rust_unpause(session: *mut Aria2RustSession, gid: u64) -> i32 {
ffi_result(INTERNAL_ERROR, || {
if session.is_null() {
return INVALID_ARGUMENT;
}
let session = unsafe { &mut *session };
let result = session.request_man.unpause_group(GroupId::new(gid));
if let Err(error) = result {
return session.fail(error.to_string(), INVALID_ARGUMENT);
}
session
.command_tx
.send(EngineCommand::Unpause {
gid: GroupId::new(gid),
})
.map(|_| 0)
.unwrap_or_else(|error| session.fail(error.to_string(), INTERNAL_ERROR))
})
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn aria2_rust_pause_all(session: *mut Aria2RustSession, force: u8) -> i32 {
ffi_result(INTERNAL_ERROR, || {
if session.is_null() {
return INVALID_ARGUMENT;
}
unsafe { (&mut *session).pause_all(force != 0) }
})
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn aria2_rust_unpause_all(session: *mut Aria2RustSession) -> i32 {
ffi_result(INTERNAL_ERROR, || {
if session.is_null() {
return INVALID_ARGUMENT;
}
unsafe { (&mut *session).unpause_all() }
})
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn aria2_rust_change_position(
session: *mut Aria2RustSession,
gid: u64,
position: i32,
mode: u32,
position_out: *mut usize,
) -> i32 {
ffi_result(INTERNAL_ERROR, || {
if session.is_null() || position_out.is_null() {
return INVALID_ARGUMENT;
}
let session = unsafe { &mut *session };
match session.change_position(gid, position, mode) {
Ok(new_position) => {
unsafe { *position_out = new_position };
0
}
Err(error) => session.fail(error, INVALID_ARGUMENT),
}
})
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn aria2_rust_change_option(
session: *mut Aria2RustSession,
gid: u64,
options: *const Aria2RustKeyValue,
option_count: usize,
) -> i32 {
ffi_result(INTERNAL_ERROR, || {
if session.is_null() {
return INVALID_ARGUMENT;
}
let options = match unsafe { read_key_values(options, option_count) } {
Ok(options) => options,
Err(_) => return INVALID_ARGUMENT,
};
unsafe { (&mut *session).change_options(gid, options) }
})
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn aria2_rust_change_global_option(
session: *mut Aria2RustSession,
options: *const Aria2RustKeyValue,
option_count: usize,
) -> i32 {
ffi_result(INTERNAL_ERROR, || {
if session.is_null() {
return INVALID_ARGUMENT;
}
let options = match unsafe { read_key_values(options, option_count) } {
Ok(options) => options,
Err(_) => return INVALID_ARGUMENT,
};
unsafe { (&mut *session).change_global_options(options) }
})
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn aria2_rust_get_download_info(
session: *mut Aria2RustSession,
gid: u64,
output: *mut Aria2RustDownloadInfo,
) -> i32 {
ffi_result(INTERNAL_ERROR, || {
if session.is_null() || output.is_null() {
return INVALID_ARGUMENT;
}
let session = unsafe { &mut *session };
match session.get_info(gid) {
Some(info) => {
unsafe { *output = info };
0
}
None => session.fail(format!("GID {gid} not found"), INVALID_ARGUMENT),
}
})
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn aria2_rust_get_file_count(
session: *mut Aria2RustSession,
gid: u64,
) -> usize {
ffi_result(0, || {
if session.is_null() {
return 0;
}
unsafe { (&*session).file_entries(gid).map_or(0, |files| files.len()) }
})
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn aria2_rust_get_file_info(
session: *mut Aria2RustSession,
gid: u64,
file_index: usize,
output: *mut Aria2RustFileInfo,
) -> i32 {
ffi_result(INTERNAL_ERROR, || {
if session.is_null() || output.is_null() || file_index == 0 {
return INVALID_ARGUMENT;
}
let entry = unsafe { (&*session).file_entries(gid) }
.and_then(|files| files.into_iter().nth(file_index - 1));
match entry {
Some(entry) => {
unsafe {
*output = Aria2RustFileInfo {
length: entry.length,
completed_length: entry.completed_length,
selected: u8::from(entry.selected),
};
}
0
}
None => unsafe { (&mut *session).fail("file entry not found", INVALID_ARGUMENT) },
}
})
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn aria2_rust_get_file_path(
session: *mut Aria2RustSession,
gid: u64,
file_index: usize,
output: *mut c_char,
capacity: usize,
) -> usize {
ffi_result(0, || {
if session.is_null() || file_index == 0 {
return 0;
}
let Some(path) = (unsafe { (&*session).file_entries(gid) })
.and_then(|files| files.into_iter().nth(file_index - 1))
.map(|entry| entry.path)
else {
return 0;
};
write_c_string(&path, output, capacity)
})
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn aria2_rust_get_global_stat(
session: *mut Aria2RustSession,
output: *mut Aria2RustGlobalStat,
) -> i32 {
ffi_result(INTERNAL_ERROR, || {
if session.is_null() || output.is_null() {
return INVALID_ARGUMENT;
}
let stat = unsafe { (&mut *session).global_stat() };
unsafe { *output = stat };
0
})
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn aria2_rust_get_active_downloads(
session: *mut Aria2RustSession,
output: *mut u64,
capacity: usize,
) -> usize {
ffi_result(0, || {
if session.is_null() || (capacity > 0 && output.is_null()) {
return 0;
}
let gids = unsafe { (&*session).request_man.get_active_groups() };
let values = gids
.iter()
.map(|group| group.recover().gid().value())
.collect::<Vec<_>>();
if !output.is_null() {
let destination = unsafe { slice::from_raw_parts_mut(output, capacity) };
for (slot, gid) in destination.iter_mut().zip(values.iter().copied()) {
*slot = gid;
}
}
values.len()
})
}
#[unsafe(no_mangle)]
pub extern "C" fn aria2_rust_gid_to_hex(gid: u64, output: *mut c_char, capacity: usize) -> usize {
ffi_result(0, || {
write_c_string(&GroupId::new(gid).to_hex_string(), output, capacity)
})
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn aria2_rust_hex_to_gid(input: *const c_char) -> u64 {
ffi_result(0, || {
let Ok(input) = (unsafe { read_c_string(input) }) else {
return 0;
};
GroupId::from_hex_string(&input).map_or(0, |gid| gid.value())
})
}
#[unsafe(no_mangle)]
pub extern "C" fn aria2_rust_is_null_gid(gid: u64) -> u8 {
u8::from(gid == 0)
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn aria2_rust_last_error(
session: *mut Aria2RustSession,
output: *mut c_char,
capacity: usize,
) -> usize {
ffi_result(0, || {
if session.is_null() {
return 0;
}
let session = unsafe { &mut *session };
write_c_string(&session.last_error, output, capacity)
})
}
#[cfg(test)]
mod tests {
use super::*;
use std::ffi::CString;
use std::sync::Mutex;
static TEST_LOCK: Mutex<()> = Mutex::new(());
fn kv(name: &str, value: &str) -> (Aria2RustKeyValue, CString, CString) {
let name_c = CString::new(name).unwrap();
let value_c = CString::new(value).unwrap();
(
Aria2RustKeyValue {
name: name_c.as_ptr(),
value: value_c.as_ptr(),
},
name_c,
value_c,
)
}
#[test]
fn c_api_session_lifecycle_and_queue_controls() {
let _guard = TEST_LOCK
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner());
assert_eq!(aria2_rust_library_init(), 0);
let (pause_entry, pause_name, pause_value) = kv("pause", "true");
let session = unsafe { aria2_rust_session_new(&pause_entry, 1, ptr::null_mut()) };
let _keep_alive = [pause_name, pause_value];
assert!(!session.is_null());
let uri = CString::new("http://127.0.0.1:1/not-started").unwrap();
let uri_ptr = uri.as_ptr();
let mut gid = 0;
assert_eq!(
unsafe { aria2_rust_add_uri(session, &uri_ptr, 1, ptr::null(), 0, &mut gid,) },
0
);
assert_ne!(gid, 0);
let mut info = Aria2RustDownloadInfo::default();
let mut initial_info_result = -1;
for _ in 0..100 {
initial_info_result = unsafe { aria2_rust_get_download_info(session, gid, &mut info) };
if initial_info_result == 0 {
break;
}
std::thread::yield_now();
}
assert_eq!(initial_info_result, 0);
assert_eq!(info.status, Aria2RustDownloadStatus::Paused as u32);
let mut unpause_result = -1;
for _ in 0..100 {
unpause_result = unsafe { aria2_rust_unpause(session, gid) };
if unpause_result == 0 {
break;
}
std::thread::yield_now();
}
assert_eq!(unpause_result, 0);
let mut pause_result = -1;
for _ in 0..100 {
pause_result = unsafe { aria2_rust_pause(session, gid, 1) };
if pause_result == 0 {
break;
}
std::thread::yield_now();
}
assert_eq!(pause_result, 0);
let mut info_result = -1;
for _ in 0..100 {
info_result = unsafe { aria2_rust_get_download_info(session, gid, &mut info) };
if info_result == 0 && info.status == Aria2RustDownloadStatus::Paused as u32 {
break;
}
std::thread::yield_now();
}
assert_eq!(info_result, 0);
assert_eq!(info.status, Aria2RustDownloadStatus::Paused as u32);
let mut remove_result = -1;
for _ in 0..100 {
remove_result = unsafe { aria2_rust_remove(session, gid, 1) };
if remove_result == 0 {
break;
}
std::thread::yield_now();
}
assert_eq!(remove_result, 0);
let mut removed_info_result = -1;
for _ in 0..2000 {
removed_info_result = unsafe { aria2_rust_get_download_info(session, gid, &mut info) };
if removed_info_result == 0 && info.status == Aria2RustDownloadStatus::Removed as u32 {
break;
}
std::thread::sleep(Duration::from_millis(1));
}
assert_eq!(removed_info_result, 0);
assert_eq!(info.status, Aria2RustDownloadStatus::Removed as u32);
assert_eq!(unsafe { aria2_rust_session_final(session) }, 0);
assert_eq!(aria2_rust_library_deinit(), 0);
}
#[test]
fn c_api_wait_download_is_event_driven_and_timeout_safe() {
let _guard = TEST_LOCK
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner());
assert_eq!(aria2_rust_library_init(), 0);
let (pause_entry, pause_name, pause_value) = kv("pause", "true");
let session = unsafe { aria2_rust_session_new(&pause_entry, 1, ptr::null_mut()) };
let _keep_alive = [pause_name, pause_value];
assert!(!session.is_null());
let uri = CString::new("http://127.0.0.1:1/not-started").unwrap();
let uri_ptr = uri.as_ptr();
let mut gid = 0;
assert_eq!(
unsafe { aria2_rust_add_uri(session, &uri_ptr, 1, ptr::null(), 0, &mut gid) },
0
);
let mut info = Aria2RustDownloadInfo::default();
assert_eq!(
unsafe { aria2_rust_wait_download(session, gid, 1, &mut info) },
TIMEOUT
);
unsafe {
(&*session)
.request_man
.find_group(GroupId::new(gid))
.expect("download group")
.recover()
.mark_complete();
}
assert_eq!(
unsafe { aria2_rust_wait_download(session, gid, 1_000, &mut info) },
0
);
assert_eq!(info.status, Aria2RustDownloadStatus::Complete as u32);
assert_eq!(unsafe { aria2_rust_session_final(session) }, 0);
assert_eq!(aria2_rust_library_deinit(), 0);
}
#[cfg(feature = "bittorrent")]
#[test]
fn c_api_torrent_file_metadata_is_available_before_start() {
let _guard = TEST_LOCK
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner());
assert_eq!(aria2_rust_library_init(), 0);
let (pause_entry, pause_name, pause_value) = kv("pause", "true");
let session = unsafe { aria2_rust_session_new(&pause_entry, 1, ptr::null_mut()) };
let _keep_alive = [pause_name, pause_value];
assert!(!session.is_null());
let torrent =
b"d8:announce27:http://example.com/announce4:infod6:lengthi4e4:name8:file.bin12:piece lengthi4e6:pieces20:12345678901234567890eee";
let mut gid = 0;
assert_eq!(
unsafe {
aria2_rust_add_torrent(
session,
torrent.as_ptr(),
torrent.len(),
ptr::null(),
0,
ptr::null(),
0,
&mut gid,
)
},
0
);
assert_eq!(unsafe { aria2_rust_get_file_count(session, gid) }, 1);
let mut info = Aria2RustFileInfo::default();
assert_eq!(
unsafe { aria2_rust_get_file_info(session, gid, 1, &mut info) },
0
);
assert_eq!(info.length, 4);
assert_eq!(info.completed_length, 0);
assert_eq!(info.selected, 1);
let required = unsafe { aria2_rust_get_file_path(session, gid, 1, ptr::null_mut(), 0) };
assert!(required > 1);
let mut path = vec![0 as c_char; required];
assert_eq!(
unsafe { aria2_rust_get_file_path(session, gid, 1, path.as_mut_ptr(), path.len()) },
required
);
let path = unsafe { CStr::from_ptr(path.as_ptr()) }.to_str().unwrap();
assert!(path.ends_with("file.bin"));
assert_eq!(unsafe { aria2_rust_session_final(session) }, 0);
assert_eq!(aria2_rust_library_deinit(), 0);
}
#[cfg(feature = "metalink")]
#[test]
fn c_api_metalink_returns_all_created_gids() {
let _guard = TEST_LOCK
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner());
assert_eq!(aria2_rust_library_init(), 0);
let (pause_entry, pause_name, pause_value) = kv("pause", "true");
let session = unsafe { aria2_rust_session_new(&pause_entry, 1, ptr::null_mut()) };
let _keep_alive = [pause_name, pause_value];
assert!(!session.is_null());
let metalink = br#"<metalink xmlns="urn:ietf:params:xml:ns:metalink"><file name="file.bin"><size>4</size><url>http://127.0.0.1:1/file.bin</url></file></metalink>"#;
let mut gids = [0u64; 2];
let mut gid_count = 0usize;
assert_eq!(
unsafe {
aria2_rust_add_metalink(
session,
metalink.as_ptr(),
metalink.len(),
ptr::null(),
0,
gids.as_mut_ptr(),
gids.len(),
&mut gid_count,
)
},
0
);
assert_eq!(gid_count, 1);
assert_ne!(gids[0], 0);
assert_eq!(unsafe { aria2_rust_get_file_count(session, gids[0]) }, 1);
assert_eq!(unsafe { aria2_rust_session_final(session) }, 0);
assert_eq!(aria2_rust_library_deinit(), 0);
}
#[test]
fn c_api_batch_controls_and_queue_position_match_library_semantics() {
let _guard = TEST_LOCK
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner());
assert_eq!(aria2_rust_library_init(), 0);
let (pause_entry, pause_name, pause_value) = kv("pause", "true");
let session = unsafe { aria2_rust_session_new(&pause_entry, 1, ptr::null_mut()) };
let _keep_alive = [pause_name, pause_value];
assert!(!session.is_null());
let first = CString::new("http://127.0.0.1:1/first").unwrap();
let second = CString::new("http://127.0.0.1:1/second").unwrap();
let first_ptr = first.as_ptr();
let second_ptr = second.as_ptr();
let mut first_gid = 0;
let mut second_gid = 0;
assert_eq!(
unsafe { aria2_rust_add_uri(session, &first_ptr, 1, ptr::null(), 0, &mut first_gid) },
0
);
assert_eq!(
unsafe { aria2_rust_add_uri(session, &second_ptr, 1, ptr::null(), 0, &mut second_gid) },
0
);
assert_eq!(unsafe { aria2_rust_pause_all(session, 1) }, 0);
let mut info = Aria2RustDownloadInfo::default();
assert_eq!(
unsafe { aria2_rust_get_download_info(session, first_gid, &mut info) },
0
);
assert_eq!(info.status, Aria2RustDownloadStatus::Paused as u32);
let mut new_position = usize::MAX;
assert_eq!(
unsafe {
aria2_rust_change_position(
session,
second_gid,
0,
ARIA2_RUST_POSITION_SET,
&mut new_position,
)
},
0
);
assert_eq!(new_position, 0);
assert_eq!(unsafe { aria2_rust_unpause_all(session) }, 0);
let mut info_result = -1;
for _ in 0..100 {
info_result = unsafe { aria2_rust_get_download_info(session, first_gid, &mut info) };
if info_result == 0 && info.status != Aria2RustDownloadStatus::Paused as u32 {
break;
}
std::thread::yield_now();
}
assert_eq!(info_result, 0);
assert_ne!(
info.status,
Aria2RustDownloadStatus::Paused as u32,
"unpause_all should resume the download"
);
assert_eq!(unsafe { aria2_rust_session_final(session) }, 0);
assert_eq!(aria2_rust_library_deinit(), 0);
}
#[test]
fn c_api_uses_shared_option_conversion_and_ignores_unknown_options() {
let _guard = TEST_LOCK
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner());
assert_eq!(aria2_rust_library_init(), 0);
let (entry, name, value) = kv("split", "4");
let (unknown, unknown_name, unknown_value) = kv("not-an-aria2-option", "ignored");
let entries = [entry, unknown];
let _keep_alive = [name, value, unknown_name, unknown_value];
let session =
unsafe { aria2_rust_session_new(entries.as_ptr(), entries.len(), ptr::null_mut()) };
assert!(!session.is_null());
let uri = CString::new("http://127.0.0.1:1/option-test").unwrap();
let uri_ptr = uri.as_ptr();
let mut gid = 0;
assert_eq!(
unsafe { aria2_rust_add_uri(session, &uri_ptr, 1, ptr::null(), 0, &mut gid,) },
0
);
assert_ne!(gid, 0);
let mut hex = [0 as c_char; 17];
assert_eq!(aria2_rust_gid_to_hex(gid, hex.as_mut_ptr(), hex.len()), 17);
assert_eq!(unsafe { aria2_rust_hex_to_gid(hex.as_ptr()) }, gid);
unsafe { aria2_rust_session_final(session) };
aria2_rust_library_deinit();
}
#[test]
fn c_api_change_option_uses_reserved_group_semantics() {
let _guard = TEST_LOCK
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner());
assert_eq!(aria2_rust_library_init(), 0);
let (pause_entry, pause_name, pause_value) = kv("pause", "true");
let session = unsafe { aria2_rust_session_new(&pause_entry, 1, ptr::null_mut()) };
let _keep_alive = [pause_name, pause_value];
assert!(!session.is_null());
let (dir_entry, dir_name, dir_value) = kv("dir", "reserved-dir");
let _keep_alive_option = [dir_name, dir_value];
let uri = CString::new("http://127.0.0.1:1/c-api-change-option").unwrap();
let uri_ptr = uri.as_ptr();
let mut gid = 0;
assert_eq!(
unsafe { aria2_rust_add_uri(session, &uri_ptr, 1, ptr::null(), 0, &mut gid) },
0
);
assert_eq!(
unsafe { aria2_rust_change_option(session, gid, &dir_entry, 1,) },
0
);
{
let group = unsafe { (&*session).request_man.find_group(GroupId::new(gid)) }
.expect("C API option change should keep the group");
let group = group.read().unwrap();
assert_eq!(group.options().dir.as_deref(), Some("reserved-dir"));
assert_eq!(
group.runtime_options().get("dir"),
Some(&serde_json::json!("reserved-dir"))
);
assert!(group.pending_options().is_empty());
}
assert_eq!(unsafe { aria2_rust_session_final(session) }, 0);
assert_eq!(aria2_rust_library_deinit(), 0);
}
}