pub(crate) fn decode_aria2_base64(input: &str) -> Vec<u8> {
use base64::Engine;
let filtered: Vec<u8> = input
.bytes()
.filter(|byte| {
matches!(
byte,
b'A'..=b'Z'
| b'a'..=b'z'
| b'0'..=b'9'
| b'+'
| b'/'
| b'='
)
})
.collect();
if filtered.is_empty() {
return Vec::new();
}
let input = if let Some(eq_pos) = filtered.iter().position(|byte| *byte == b'=') {
let group_start = eq_pos / 4 * 4;
let group_end = group_start + 4;
if group_end > filtered.len()
|| filtered[eq_pos..group_end].iter().any(|byte| *byte != b'=')
{
return Vec::new();
}
&filtered[..group_end]
} else if filtered.len() % 4 == 1 {
&filtered[..filtered.len() - 1]
} else {
&filtered
};
base64::engine::general_purpose::STANDARD
.decode(input)
.unwrap_or_default()
}
pub(crate) fn percent_decode(input: &str) -> String {
let bytes = input.as_bytes();
let mut output = Vec::with_capacity(bytes.len());
let mut index = 0;
while index < bytes.len() {
if bytes[index] == b'%'
&& index + 2 < bytes.len()
&& let (Some(high), Some(low)) =
(hex_digit(bytes[index + 1]), hex_digit(bytes[index + 2]))
{
output.push((high << 4) | low);
index += 3;
continue;
}
output.push(bytes[index]);
index += 1;
}
String::from_utf8_lossy(&output).into_owned()
}
fn hex_digit(value: u8) -> Option<u8> {
match value {
b'0'..=b'9' => Some(value - b'0'),
b'a'..=b'f' => Some(value - b'a' + 10),
b'A'..=b'F' => Some(value - b'A' + 10),
_ => None,
}
}
pub fn normalize_rpc_options(
options: &std::collections::HashMap<String, serde_json::Value>,
) -> std::collections::HashMap<String, serde_json::Value> {
options
.iter()
.filter_map(|(key, value)| {
option_value_to_string(value)
.map(|value| (key.clone(), serde_json::Value::String(value)))
})
.collect()
}
fn option_value_to_string(value: &serde_json::Value) -> Option<String> {
match value {
serde_json::Value::String(value) => Some(value.clone()),
serde_json::Value::Number(value) => Some(value.to_string()),
serde_json::Value::Bool(value) => Some(value.to_string()),
serde_json::Value::Array(values) => values
.iter()
.map(option_value_to_string)
.collect::<Option<Vec<_>>>()
.map(|values| values.join("\n")),
serde_json::Value::Null | serde_json::Value::Object(_) => None,
}
}
pub use crate::types::generate_session_id;
pub fn build_version_info() -> serde_json::Value {
crate::types::VersionInfo::from_env().to_json_value()
}
const NATIVE_NUMERIC_FIELDS: &[&str] = &["creationDate"];
pub fn to_aria2_wire_format(value: serde_json::Value) -> serde_json::Value {
match value {
serde_json::Value::Object(map) => {
let mut new_map = serde_json::Map::with_capacity(map.len());
for (k, v) in map {
if NATIVE_NUMERIC_FIELDS.contains(&k.as_str()) {
new_map.insert(k, v);
} else {
new_map.insert(k, to_aria2_wire_format(v));
}
}
serde_json::Value::Object(new_map)
}
serde_json::Value::Array(arr) => {
let new_arr: Vec<serde_json::Value> =
arr.into_iter().map(to_aria2_wire_format).collect();
serde_json::Value::Array(new_arr)
}
serde_json::Value::Number(n) => serde_json::Value::String(n.to_string()),
serde_json::Value::Bool(b) => serde_json::Value::String(if b {
"true".to_string()
} else {
"false".to_string()
}),
serde_json::Value::String(_) | serde_json::Value::Null => value,
}
}
pub fn split_auth_token(params: &serde_json::Value) -> (Option<String>, Option<serde_json::Value>) {
match params {
serde_json::Value::Array(arr) => {
let token = arr
.first()
.and_then(|v| v.as_str())
.and_then(|s| s.strip_prefix("token:"))
.map(str::to_string);
match token {
Some(t) => {
let mut rest = arr.clone();
rest.remove(0);
(Some(t), Some(serde_json::Value::Array(rest)))
}
None => (None, None),
}
}
other => (
other
.get("token")
.and_then(|v| v.as_str())
.map(str::to_string),
None,
),
}
}
pub(crate) fn split_auth_token_owned(
params: serde_json::Value,
) -> (Option<String>, serde_json::Value) {
match params {
serde_json::Value::Array(mut arr) => {
let token = arr
.first()
.and_then(|value| value.as_str())
.and_then(|value| value.strip_prefix("token:"))
.map(str::to_owned);
if token.is_some() {
arr.remove(0);
}
(token, serde_json::Value::Array(arr))
}
params => {
let token = params
.get("token")
.and_then(|value| value.as_str())
.map(str::to_owned);
(token, params)
}
}
}
pub fn format_session_summary(
active_count: usize,
waiting_count: usize,
stopped_count: usize,
) -> String {
format!(
"Session Summary: {} active, {} waiting, {} stopped",
active_count, waiting_count, stopped_count
)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_build_version_info_structure() {
let info = build_version_info();
assert_eq!(info, crate::types::VersionInfo::from_env().to_json_value());
assert!(info.get("version").is_some());
assert!(info.get("enabledFeatures").is_some());
assert!(info.get("session").is_none());
}
#[test]
fn test_format_session_summary() {
let summary = format_session_summary(5, 3, 2);
assert!(summary.contains("5 active"));
assert!(summary.contains("3 waiting"));
assert!(summary.contains("2 stopped"));
}
#[test]
fn test_to_aria2_wire_format_numbers() {
let input = serde_json::json!({"a": 123, "b": 456});
let output = to_aria2_wire_format(input);
assert_eq!(output["a"].as_str(), Some("123"));
assert_eq!(output["b"].as_str(), Some("456"));
}
#[test]
fn test_to_aria2_wire_format_bools() {
let input = serde_json::json!({"x": true, "y": false});
let output = to_aria2_wire_format(input);
assert_eq!(output["x"].as_str(), Some("true"));
assert_eq!(output["y"].as_str(), Some("false"));
}
#[test]
fn test_to_aria2_wire_format_native_numeric() {
let input = serde_json::json!({"creationDate": 1700000000, "other": 42});
let output = to_aria2_wire_format(input);
assert!(
output["creationDate"].is_number(),
"creationDate should remain a number"
);
assert_eq!(output["other"].as_str(), Some("42"));
}
#[test]
fn test_to_aria2_wire_format_bitfield() {
let input = serde_json::json!({"bitfield": "ff00ff00"});
let output = to_aria2_wire_format(input);
assert_eq!(output["bitfield"].as_str(), Some("ff00ff00"));
}
#[test]
fn test_to_aria2_wire_format_piece_fields() {
let input = serde_json::json!({"pieceLength": 262144, "numPieces": 128});
let output = to_aria2_wire_format(input);
assert_eq!(output["pieceLength"].as_str(), Some("262144"));
assert_eq!(output["numPieces"].as_str(), Some("128"));
}
#[test]
fn test_to_aria2_wire_format_followed_by() {
let input = serde_json::json!({"followedBy": ["gid-abc", "gid-def"]});
let output = to_aria2_wire_format(input);
assert_eq!(output["followedBy"][0].as_str(), Some("gid-abc"));
assert_eq!(output["followedBy"][1].as_str(), Some("gid-def"));
}
#[test]
fn test_to_aria2_wire_format_complete_status() {
let input = serde_json::json!({
"gid": "abc123",
"totalLength": 1048576,
"completedLength": 524288,
"downloadSpeed": 1024000,
"uploadSpeed": 512000,
"uploadLength": 0,
"connections": 4,
"pieceLength": 16384,
"numPieces": 64,
"numSeeders": 2,
"verifiedLength": 0,
"verifyIntegrityPending": "false",
"seeder": "false",
"infoHash": "abcdef0123456789",
"belongsTo": "parent-gid",
"followedBy": ["child1", "child2"],
"bitfield": "ffff0000",
"dir": "/downloads",
"files": [{"index": 1, "path": "/downloads/file.iso", "length": 1048576, "completedLength": 524288, "selected": "true", "uris": [{"uri": "http://example.com/file.iso", "status": "used"}]}]
});
let output = to_aria2_wire_format(input);
assert_eq!(output["totalLength"].as_str(), Some("1048576"));
assert_eq!(output["completedLength"].as_str(), Some("524288"));
assert_eq!(output["downloadSpeed"].as_str(), Some("1024000"));
assert_eq!(output["uploadSpeed"].as_str(), Some("512000"));
assert_eq!(output["pieceLength"].as_str(), Some("16384"));
assert_eq!(output["numPieces"].as_str(), Some("64"));
assert_eq!(output["numSeeders"].as_str(), Some("2"));
assert_eq!(output["gid"].as_str(), Some("abc123"));
assert_eq!(output["bitfield"].as_str(), Some("ffff0000"));
assert_eq!(output["infoHash"].as_str(), Some("abcdef0123456789"));
assert_eq!(output["belongsTo"].as_str(), Some("parent-gid"));
assert_eq!(output["verifyIntegrityPending"].as_str(), Some("false"));
assert_eq!(output["seeder"].as_str(), Some("false"));
assert_eq!(output["followedBy"][0].as_str(), Some("child1"));
assert_eq!(output["followedBy"][1].as_str(), Some("child2"));
let file = &output["files"][0];
assert_eq!(file["path"].as_str(), Some("/downloads/file.iso"));
let uri = &file["uris"][0];
assert_eq!(uri["uri"].as_str(), Some("http://example.com/file.iso"));
assert_eq!(uri["status"].as_str(), Some("used"));
}
}