use std::collections::VecDeque;
use tokio::io::AsyncReadExt;
use tokio::net::TcpStream;
use tracing::{debug, trace};
use crate::error::{Aria2Error, Result};
use crate::http::auth::erase_confidential_info;
use crate::http::connection::write_buffer::HttpWriteBuffer;
use crate::http::header_processor::{HttpHeaderParseState, HttpHeaderProcessor, HttpResponseHead};
use crate::http::request_response::HttpMethod;
pub struct PendingRequest {
pub segment_id: Option<u64>,
pub method: HttpMethod,
pub uri: String,
pub header_processor: HttpHeaderProcessor,
}
impl std::fmt::Debug for PendingRequest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("PendingRequest")
.field("segment_id", &self.segment_id)
.field("method", &self.method)
.field("uri", &self.uri)
.field("header_processor", &"<HttpHeaderProcessor>")
.finish()
}
}
impl PendingRequest {
pub fn new(segment_id: Option<u64>, method: HttpMethod, uri: String) -> Self {
Self {
segment_id,
method,
uri,
header_processor: HttpHeaderProcessor::new(),
}
}
pub fn reset_header_processor(&mut self) {
self.header_processor = HttpHeaderProcessor::new();
}
}
#[derive(Debug)]
pub struct PipelineResponse {
pub head: HttpResponseHead,
pub method: HttpMethod,
pub uri: String,
pub segment_id: Option<u64>,
}
const READ_BUF_SIZE: usize = 8192;
pub struct HttpPipelineConnection {
stream: TcpStream,
outstanding: VecDeque<PendingRequest>,
write_buffer: HttpWriteBuffer,
}
impl HttpPipelineConnection {
pub fn new(stream: TcpStream) -> Self {
Self {
stream,
outstanding: VecDeque::new(),
write_buffer: HttpWriteBuffer::new(),
}
}
pub fn has_outstanding(&self) -> bool {
!self.outstanding.is_empty()
}
pub fn outstanding_count(&self) -> usize {
self.outstanding.len()
}
pub fn is_issued(&self, segment_id: u64) -> bool {
self.outstanding
.iter()
.any(|entry| entry.segment_id == Some(segment_id))
}
pub async fn send_request(
&mut self,
segment_id: Option<u64>,
raw_request: &[u8],
method: HttpMethod,
uri: String,
) -> Result<()> {
let request_str = String::from_utf8_lossy(raw_request);
let safe_log = erase_confidential_info(&request_str);
debug!(
"Sending HTTP request (segment={:?}, outstanding={}): {}",
segment_id,
self.outstanding.len(),
safe_log.trim()
);
self.write_buffer
.push_str(String::from_utf8_lossy(raw_request).into_owned());
self.write_buffer
.flush(&mut self.stream)
.await
.map_err(|e| Aria2Error::Network(format!("Failed to send HTTP request: {}", e)))?;
self.outstanding
.push_back(PendingRequest::new(segment_id, method, uri));
Ok(())
}
pub async fn send_proxy_request(&mut self, raw_request: &[u8]) -> Result<()> {
debug!("Sending proxy CONNECT request");
self.write_buffer
.push_str(String::from_utf8_lossy(raw_request).into_owned());
self.write_buffer
.flush(&mut self.stream)
.await
.map_err(|e| Aria2Error::Network(format!("Failed to send proxy request: {}", e)))?;
self.outstanding
.push_back(PendingRequest::new(None, HttpMethod::Get, String::new()));
Ok(())
}
pub async fn receive_response(&mut self) -> Result<Option<PipelineResponse>> {
if self.outstanding.is_empty() {
return Err(Aria2Error::Network(
"No outstanding HTTP request entry found".to_string(),
));
}
let mut buf = [0u8; READ_BUF_SIZE];
loop {
let n = self.stream.read(&mut buf).await.map_err(|e| {
if e.kind() == std::io::ErrorKind::UnexpectedEof {
Aria2Error::Network(
"Connection closed by server before response complete (EOF)".to_string(),
)
} else {
Aria2Error::Network(format!("Error reading HTTP response: {}", e))
}
})?;
if n == 0 {
return Err(Aria2Error::Network(
"Connection closed by server before response complete".to_string(),
));
}
trace!("Read {} bytes for response parsing", n);
let entry = self.outstanding.front_mut().ok_or_else(|| {
Aria2Error::Network("No outstanding HTTP request entry found".to_string())
})?;
let state = entry.header_processor.feed(&buf[..n]).clone();
match state {
HttpHeaderParseState::Complete => {
let entry = self.outstanding.front().unwrap();
let head = entry.header_processor.get_result()?;
let header_str = entry.header_processor.get_header_string();
let safe_log = erase_confidential_info(&header_str);
debug!("Received HTTP response: {}", safe_log.trim());
if (100..200).contains(&head.status_code) {
trace!(
"Received {} informational response, resetting processor",
head.status_code
);
self.outstanding
.front_mut()
.unwrap()
.reset_header_processor();
continue;
}
let entry = self.outstanding.pop_front().unwrap();
return Ok(Some(PipelineResponse {
head,
method: entry.method,
uri: entry.uri,
segment_id: entry.segment_id,
}));
}
HttpHeaderParseState::ParsingStatusLine | HttpHeaderParseState::ParsingHeaders => {
continue;
}
HttpHeaderParseState::Error(msg) => {
self.outstanding.pop_front();
return Err(Aria2Error::Parse(format!(
"Error parsing HTTP response header: {}",
msg
)));
}
}
}
}
pub fn send_buffer_is_empty(&self) -> bool {
self.write_buffer.is_empty()
}
pub async fn send_pending_data(&mut self) -> Result<()> {
self.write_buffer
.flush(&mut self.stream)
.await
.map_err(|e| Aria2Error::Network(format!("Failed to flush pending data: {}", e)))?;
Ok(())
}
pub fn stream_mut(&mut self) -> &mut TcpStream {
&mut self.stream
}
pub fn into_stream(self) -> TcpStream {
self.stream
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_pending_request_reset_processor() {
let mut pr = PendingRequest::new(Some(1), HttpMethod::Get, "/file".into());
let _ = pr.header_processor.feed(b"HTTP/1.1 100 Continue\r\n\r\n");
pr.reset_header_processor();
}
#[test]
fn test_pipeline_connection_initial_state() {
let outstanding: VecDeque<PendingRequest> = VecDeque::new();
assert!(outstanding.is_empty());
let outstanding = {
let mut q = VecDeque::new();
q.push_back(PendingRequest::new(Some(1), HttpMethod::Get, "/a".into()));
q.push_back(PendingRequest::new(Some(2), HttpMethod::Get, "/b".into()));
q
};
assert_eq!(outstanding.len(), 2);
assert!(outstanding.iter().any(|e| e.segment_id == Some(1)));
assert!(outstanding.iter().any(|e| e.segment_id == Some(2)));
assert!(!outstanding.iter().any(|e| e.segment_id == Some(3)));
}
#[test]
fn test_erase_confidential_in_pipeline() {
let raw = "GET / HTTP/1.1\r\nAuthorization: Basic dXNlcg==\r\nHost: example.com\r\n";
let safe = erase_confidential_info(raw);
assert!(safe.contains("Authorization: <snip>"));
assert!(safe.contains("Host: example.com"));
}
}