Skip to main content

graphrt_http/
files.rs

1//! [`FileResolver`] for files reachable by URL (`remote_url` transfer), using the
2//! egress-policy-enforcing [`HttpClient`], so file URLs supplied by users cannot
3//! reach private networks.
4
5use futures::future::BoxFuture;
6use graphrt_core::file::{FileBytes, FileError, FileResolver};
7use graphrt_core::value::{File, FileTransfer};
8
9use crate::client::HttpClient;
10
11/// Downloads `http(s)` file URLs with a size cap.
12#[derive(Clone, Debug)]
13pub struct HttpFileResolver {
14    client: HttpClient,
15}
16
17impl HttpFileResolver {
18    pub fn new(client: HttpClient) -> Self {
19        Self { client }
20    }
21}
22
23impl FileResolver for HttpFileResolver {
24    fn read<'a>(&'a self, file: &'a File, max_bytes: u64) -> BoxFuture<'a, Result<FileBytes, FileError>> {
25        Box::pin(async move {
26            let Some(raw) = file.url.as_deref().filter(|u| u.starts_with("http://") || u.starts_with("https://"))
27            else {
28                return Err(FileError::Unsupported(file.name.clone()));
29            };
30            if file.transfer != FileTransfer::RemoteUrl && file.transfer != FileTransfer::ToolFile {
31                return Err(FileError::Unsupported(file.name.clone()));
32            }
33            let name = file.name.clone();
34            let url = reqwest::Url::parse(raw)
35                .map_err(|e| FileError::Invalid { name: name.clone(), message: format!("invalid URL: {e}") })?;
36            self.client.check_url(&url).map_err(|e| FileError::Denied { name: name.clone(), reason: e.to_string() })?;
37            let mut response = self
38                .client
39                .client(true)
40                .get(url)
41                .send()
42                .await
43                .map_err(|e| FileError::Io { name: name.clone(), message: e.without_url().to_string() })?;
44            let status = response.status();
45            if status == reqwest::StatusCode::NOT_FOUND {
46                return Err(FileError::NotFound { name });
47            }
48            if !status.is_success() {
49                return Err(FileError::Io { name, message: format!("HTTP status {}", status.as_u16()) });
50            }
51            if response.content_length().is_some_and(|len| len > max_bytes) {
52                return Err(FileError::TooLarge { name, limit: max_bytes });
53            }
54            let mime = response
55                .headers()
56                .get(reqwest::header::CONTENT_TYPE)
57                .and_then(|v| v.to_str().ok())
58                .map(|v| v.split(';').next().unwrap_or(v).trim().to_owned())
59                .filter(|v| !v.is_empty())
60                .or_else(|| file.mime_type.clone());
61            let mut bytes = Vec::new();
62            loop {
63                match response.chunk().await {
64                    Ok(Some(chunk)) => {
65                        let total = u64::try_from(bytes.len().saturating_add(chunk.len())).unwrap_or(u64::MAX);
66                        if total > max_bytes {
67                            return Err(FileError::TooLarge { name, limit: max_bytes });
68                        }
69                        bytes.extend_from_slice(&chunk);
70                    }
71                    Ok(None) => break,
72                    Err(e) => return Err(FileError::Io { name, message: e.without_url().to_string() }),
73                }
74            }
75            Ok(FileBytes { bytes, mime_type: mime })
76        })
77    }
78}
79
80#[cfg(test)]
81mod tests {
82    use super::*;
83    use crate::policy::EgressPolicy;
84
85    #[tokio::test]
86    async fn rejects_private_addresses_and_non_http() {
87        let resolver = HttpFileResolver::new(HttpClient::new(EgressPolicy::default()).unwrap());
88        let private = File { name: "x".into(), url: Some("http://127.0.0.1/x".into()), ..File::default() };
89        assert!(matches!(resolver.read(&private, 10).await, Err(FileError::Denied { .. })));
90        let data = File { name: "y".into(), url: Some("data:,hi".into()), ..File::default() };
91        assert!(matches!(resolver.read(&data, 10).await, Err(FileError::Unsupported(_))));
92    }
93}