use url::Url;
use crate::error::{Aria2Error, RecoverableError};
use crate::http::digest_auth::DigestAuthChallenge;
use crate::http::request_response::HttpMethod;
use crate::http::stream_filter::{AutoFilterSelector, NullSinkFilter, process_filters};
use super::types::{
AuthScheme, HttpAuthChallenge, HttpRedirectInfo, RedirectType, SkipResponseResult,
};
pub use aria2_protocol::http::response::HttpResponse;
use aria2_protocol::http::response::is_redirect_status;
pub struct HttpSkipResponseHandler {
max_redirects: u32,
http_auth_challenge_enabled: bool,
max_file_not_found: u32,
retry_wait_secs: u64,
}
impl HttpSkipResponseHandler {
pub fn new(max_redirects: u32) -> Self {
Self {
max_redirects,
http_auth_challenge_enabled: false,
max_file_not_found: 0,
retry_wait_secs: 0,
}
}
pub fn with_http_auth_challenge(mut self, enabled: bool) -> Self {
self.http_auth_challenge_enabled = enabled;
self
}
pub fn with_max_file_not_found(mut self, count: u32) -> Self {
self.max_file_not_found = count;
self
}
pub fn with_retry_wait(mut self, secs: u64) -> Self {
self.retry_wait_secs = secs;
self
}
pub fn handle(
&self,
response: &HttpResponse,
request_method: HttpMethod,
current_url: &Url,
redirect_count: u32,
) -> Result<SkipResponseResult, Aria2Error> {
self.consume_body(response)?;
self.process_response(response, request_method, current_url, redirect_count)
}
fn consume_body(&self, response: &HttpResponse) -> Result<(), Aria2Error> {
let content_encoding = response.header("Content-Encoding").map(|s| s.as_str());
let transfer_encoding = response.header("Transfer-Encoding").map(|s| s.as_str());
let mut filters = AutoFilterSelector::select_filters(content_encoding, transfer_encoding)?;
if response.body.is_empty() {
tracing::trace!("Empty response body, nothing to consume");
return Ok(());
}
filters.push(Box::new(NullSinkFilter::new()));
let _ = process_filters(&mut filters, &response.body)?;
tracing::debug!(
"Consumed {} bytes of response body (discarded)",
response.body.len()
);
Ok(())
}
fn process_response(
&self,
response: &HttpResponse,
request_method: HttpMethod,
current_url: &Url,
redirect_count: u32,
) -> Result<SkipResponseResult, Aria2Error> {
let status = response.status_code;
if is_redirect_status(status) {
return self.handle_redirect(response, request_method, current_url, redirect_count);
}
if status >= 400 {
return Ok(self.handle_error_status(response, status));
}
tracing::debug!("Response status {} consumed, no special action", status);
Ok(SkipResponseResult::Consumed)
}
fn handle_redirect(
&self,
response: &HttpResponse,
request_method: HttpMethod,
current_url: &Url,
redirect_count: u32,
) -> Result<SkipResponseResult, Aria2Error> {
if redirect_count >= self.max_redirects {
return Err(Aria2Error::Recoverable(
RecoverableError::HttpTooManyRedirects {
count: redirect_count,
},
));
}
let location = response.location();
let location = match location {
Some(loc) => loc,
None => {
if response.status_code == 300 {
tracing::warn!("300 Multiple Choices without Location header");
return Ok(SkipResponseResult::FatalError {
status_code: 300,
message: "Multiple choices without Location header".to_string(),
});
}
return Err(Aria2Error::Parse(
"Redirect response missing Location header".to_string(),
));
}
};
let target_url = current_url.join(location).map_err(|e| {
Aria2Error::Parse(format!(
"Failed to resolve redirect URL '{}': {}",
location, e
))
})?;
let redirect_type = match response.status_code {
300 | 301 => RedirectType::Permanent,
303 => RedirectType::SeeOther,
307 | 308 => RedirectType::PreserveMethod,
_ => RedirectType::Temporary, };
let change_method = redirect_type.should_change_method(request_method);
let new_count = redirect_count + 1;
tracing::info!(
"HTTP redirect: {} -> {} (type={:?}, change_method={}, count={}/{})",
current_url,
target_url,
redirect_type,
change_method,
new_count,
self.max_redirects
);
Ok(SkipResponseResult::Redirect(HttpRedirectInfo {
target_url,
change_method,
redirect_type,
redirect_count: new_count,
}))
}
fn handle_error_status(&self, response: &HttpResponse, status: u16) -> SkipResponseResult {
match status {
401 => self.handle_auth_challenge(response, false),
407 => self.handle_auth_challenge(response, true),
404 => {
if self.max_file_not_found == 0 {
SkipResponseResult::FatalError {
status_code: status,
message: "Resource not found".to_string(),
}
} else {
SkipResponseResult::RetryableError {
status_code: status,
message: "Resource not found".to_string(),
}
}
}
413 => {
if response.header("Retry-After").is_some() {
tracing::info!("413 Request Entity Too Large with Retry-After, will retry");
SkipResponseResult::RetryableError {
status_code: status,
message: "Request entity too large, retrying after backoff".to_string(),
}
} else {
SkipResponseResult::FatalError {
status_code: status,
message: "Request entity too large".to_string(),
}
}
}
502 | 503 => {
if self.retry_wait_secs > 0 {
SkipResponseResult::RetryableError {
status_code: status,
message: format!("Server returned error: {}", status),
}
} else {
SkipResponseResult::FatalError {
status_code: status,
message: format!("Server returned error: {}", status),
}
}
}
504 => {
SkipResponseResult::RetryableError {
status_code: status,
message: format!("Gateway timeout: {}", status),
}
}
_ => SkipResponseResult::FatalError {
status_code: status,
message: format!("HTTP error: {}", status),
},
}
}
fn handle_auth_challenge(&self, response: &HttpResponse, is_proxy: bool) -> SkipResponseResult {
let header_name = if is_proxy {
"Proxy-Authenticate"
} else {
"WWW-Authenticate"
};
let auth_header = response.header(header_name);
match auth_header {
Some(value) => {
let scheme = AuthScheme::from_header(value);
match scheme {
Some(AuthScheme::Digest) => {
let digest = DigestAuthChallenge::parse(value).ok();
let realm = digest.as_ref().map(|d| d.realm.clone()).unwrap_or_default();
SkipResponseResult::AuthChallenge(HttpAuthChallenge {
scheme: AuthScheme::Digest,
realm,
is_proxy,
digest_challenge: digest,
})
}
Some(scheme) => {
let realm = Self::extract_realm(value);
SkipResponseResult::AuthChallenge(HttpAuthChallenge {
scheme,
realm,
is_proxy,
digest_challenge: None,
})
}
None => {
tracing::warn!("Unknown auth scheme in {} header: {}", header_name, value);
SkipResponseResult::FatalError {
status_code: if is_proxy { 407 } else { 401 },
message: "Authentication failed: unknown scheme".to_string(),
}
}
}
}
None => {
if self.http_auth_challenge_enabled && !is_proxy {
SkipResponseResult::AuthChallenge(HttpAuthChallenge {
scheme: AuthScheme::Basic,
realm: String::new(),
is_proxy: false,
digest_challenge: None,
})
} else {
SkipResponseResult::FatalError {
status_code: if is_proxy { 407 } else { 401 },
message: "Authentication failed".to_string(),
}
}
}
}
}
pub(crate) fn extract_realm(header_value: &str) -> String {
let lower = header_value.to_lowercase();
if let Some(idx) = lower.find("realm=") {
let rest = &header_value[idx + 6..];
let rest = rest.trim();
if let Some(stripped) = rest.strip_prefix('"') {
if let Some(end) = stripped.find('"') {
return stripped[..end].to_string();
}
} else {
let end = rest
.find(|c: char| c.is_whitespace() || c == ',')
.unwrap_or(rest.len());
return rest[..end].to_string();
}
}
String::new()
}
}