#[cfg(test)]
mod tests;
pub(crate) mod art;
use std::cell::RefCell;
use std::fs::File;
use std::io::{ErrorKind, PipeReader, Read, Write};
use std::os::fd::AsFd;
use std::panic::{self, AssertUnwindSafe, Location};
use std::process::{Child, Command, ExitStatus};
use std::rc::{Rc, Weak};
use std::sync::Once;
use std::time::Duration;
use calloop::{Interest, RegistrationToken};
use crabshell_reactive::{Memo, ReadSignal, Signal, untrack};
use crabshell_ui::{Cx, IntoProp};
use rustix::process::{Pid, PidfdFlags, Signal as Kill, kill_process_group, pidfd_open};
use crate::lines::panic_message;
use crate::{Shared, spawn};
pub(crate) const MAX_BODY: u64 = 4 * 1024 * 1024;
pub(crate) const TIMEOUT: Duration = Duration::from_secs(30);
const MAX_STDERR: usize = 4096;
pub(crate) struct Service {
shared: Rc<Shared>,
live: RefCell<Vec<Weak<RefCell<Run>>>>,
}
impl Service {
pub(crate) fn new(shared: Rc<Shared>) -> Service {
let live = RefCell::default();
Service { shared, live }
}
}
pub(crate) fn stop_all(cx: &Cx) {
let Some(service) = cx.service::<Service>() else {
return;
};
let live: Vec<_> = service
.live
.take()
.iter()
.filter_map(Weak::upgrade)
.collect();
for run in live {
run.borrow_mut().stop();
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct HttpError {
pub kind: HttpErrorKind,
pub message: String,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum HttpErrorKind {
NoCurl,
Status(u16),
TooLarge,
TimedOut,
NotUtf8,
Network,
Refused,
}
impl HttpError {
fn new(kind: HttpErrorKind, message: impl Into<String>) -> HttpError {
let message = message.into();
HttpError { kind, message }
}
}
fn allowed(url: &str) -> bool {
let scheme = url.split_once("://").map(|(scheme, _)| scheme);
scheme.is_some_and(|scheme| {
scheme.eq_ignore_ascii_case("http") || scheme.eq_ignore_ascii_case("https")
})
}
pub(crate) enum Sink {
Memory(Vec<u8>),
File(File),
}
type Done = Box<dyn FnOnce(Result<Sink, HttpError>)>;
pub(crate) struct Fetch(Rc<RefCell<Run>>);
struct Run {
shared: Rc<Shared>,
child: Option<Child>,
out: Option<(PipeReader, RegistrationToken)>,
err: PipeReader,
exit: Option<RegistrationToken>,
sink: Option<Sink>,
got: u64,
cap: u64,
done: Option<Done>,
}
pub(crate) fn fetch(
service: &Rc<Service>,
url: &str,
cap: u64,
timeout: Duration,
sink: Sink,
done: impl FnOnce(Result<Sink, HttpError>) + 'static,
) -> Result<Fetch, HttpError> {
if !allowed(url) {
return Err(HttpError::new(
HttpErrorKind::Refused,
"only http: and https: URLs are fetched",
));
}
let shared = &service.shared;
let Some(event_loop) = shared.event_loop() else {
return Err(HttpError::new(
HttpErrorKind::Network,
"the shell is stopping",
));
};
let mut command = Command::new(&shared.config.curl);
command.args([
"-q",
"--silent",
"--show-error",
"--globoff",
"--fail",
"--location",
]);
command.args([
"--max-redirs",
"5",
"--proto",
"=http,https",
"--proto-redir",
"=http,https",
]);
let seconds = timeout.as_secs_f64().clamp(0.001, f64::from(u32::MAX));
command.arg("--max-time").arg(format!("{seconds:.3}"));
if i64::try_from(cap).is_ok() {
command.arg("--max-filesize").arg(cap.to_string());
}
command.args(["--write-out", "%{stderr}%{response_code}", "--url", url]);
let spawned = crate::process::spawn_piped(&mut command, false);
drop(command);
let (child, out, err, _) = spawned.map_err(|error| {
let kind = match error.kind() {
ErrorKind::NotFound | ErrorKind::PermissionDenied => HttpErrorKind::NoCurl,
_ => HttpErrorKind::Network,
};
HttpError::new(kind, format!("couldn't start curl: {error}"))
})?;
let pidfd = pidfd_open(Pid::from_child(&child), PidfdFlags::NONBLOCK);
let run = Rc::new(RefCell::new(Run {
shared: Rc::clone(shared),
child: Some(child),
out: None,
err,
exit: None,
sink: Some(sink),
got: 0,
cap,
done: Some(Box::new(done)),
}));
let fetch = Fetch(Rc::clone(&run));
let mut live = service.live.borrow_mut();
live.retain(|run| run.strong_count() > 0);
live.push(Rc::downgrade(&run));
drop(live);
let fd = out.as_fd().try_clone_to_owned();
let reader = Rc::clone(&run);
let token = fd
.ok()
.and_then(|fd| event_loop.insert_fd(fd, Interest::READ, Box::new(move || on_output(&reader))));
let ended = Rc::clone(&run);
let exit = pidfd
.ok()
.and_then(|fd| event_loop.insert_fd(fd, Interest::READ, Box::new(move || on_exit(&ended))));
let mut state = run.borrow_mut();
state.out = token.map(|token| (out, token));
state.exit = exit;
let followed = state.out.is_some() && state.exit.is_some();
drop(state);
if !followed {
return Err(HttpError::new(
HttpErrorKind::Network,
"couldn't follow curl",
));
}
Ok(fetch)
}
fn on_output(run: &Rc<RefCell<Run>>) {
let mut state = run.borrow_mut();
let error = match state.read_out() {
Chunk::More | Chunk::Wait => return,
Chunk::End => {
if let Some((_, token)) = state.out.take() {
state.remove(token);
}
return;
}
Chunk::Failed(error) => error,
};
drop(state);
finish(run, Err(error));
}
fn on_exit(run: &Rc<RefCell<Run>>) {
let mut state = run.borrow_mut();
let status = match state.child.as_mut().map(Child::try_wait) {
Some(Ok(Some(status))) => Some(status),
Some(Ok(None)) | None => return,
Some(Err(_)) => None,
};
state.child = None;
let mut failed = None;
while failed.is_none() {
match state.read_out() {
Chunk::More => {}
Chunk::Wait | Chunk::End => break,
Chunk::Failed(error) => failed = Some(error),
}
}
let mut stderr = Vec::new();
let _ = (&state.err)
.take(MAX_STDERR as u64)
.read_to_end(&mut stderr);
let sink = state.sink.take();
drop(state);
let result = match failed {
Some(error) => Err(error),
None => outcome(status, &String::from_utf8_lossy(&stderr)),
};
let result = result
.and_then(|()| sink.ok_or_else(|| HttpError::new(HttpErrorKind::Network, "the body was lost")));
finish(run, result);
}
enum Chunk {
More,
Wait,
End,
Failed(HttpError),
}
impl Run {
fn read_out(&mut self) -> Chunk {
let mut chunk = [0; 64 * 1024];
let Some((out, _)) = self.out.as_mut() else {
return Chunk::End;
};
let read = match out.read(&mut chunk) {
Ok(read) => read,
Err(error) if error.kind() == ErrorKind::Interrupted => return Chunk::More,
Err(error) if error.kind() == ErrorKind::WouldBlock => return Chunk::Wait,
Err(_) => 0,
};
if read == 0 {
return Chunk::End;
}
self.got += read as u64;
if self.got > self.cap {
let cap = self.cap;
let message = format!("the body is over {cap} bytes");
return Chunk::Failed(HttpError::new(HttpErrorKind::TooLarge, message));
}
match self.sink.as_mut() {
Some(Sink::Memory(body)) => body.extend_from_slice(&chunk[..read]),
Some(Sink::File(file)) => {
if let Err(error) = file.write_all(&chunk[..read]) {
let message = format!("couldn't write the download: {error}");
return Chunk::Failed(HttpError::new(HttpErrorKind::Network, message));
}
}
None => {}
}
Chunk::More
}
fn remove(&self, token: RegistrationToken) {
if let Some(event_loop) = self.shared.event_loop() {
event_loop.remove(token);
}
}
fn stop(&mut self) {
let tokens = [self.exit.take(), self.out.take().map(|(_, token)| token)];
for token in tokens.into_iter().flatten() {
self.remove(token);
}
if let Some(child) = self.child.take() {
let _ = kill_process_group(Pid::from_child(&child), Kill::TERM);
spawn::reap(&self.shared, child, String::from("curl"));
}
}
}
fn finish(run: &Rc<RefCell<Run>>, result: Result<Sink, HttpError>) {
let done = {
let mut state = run.borrow_mut();
state.stop();
state.done.take()
};
if let Some(done) = done {
done(result);
}
}
impl Drop for Fetch {
fn drop(&mut self) {
let done = {
let mut state = self.0.borrow_mut();
state.stop();
state.done.take()
};
drop(done);
}
}
fn outcome(status: Option<ExitStatus>, stderr: &str) -> Result<(), HttpError> {
let (said, code) = stderr.rsplit_once('\n').unwrap_or(("", stderr));
let said = said.trim();
let said = said
.strip_prefix("curl: (")
.and_then(|rest| rest.split_once(") "))
.map_or(said, |(_, message)| message);
let exit = status.and_then(|status| status.code());
let message = match exit {
_ if !said.is_empty() => said.to_owned(),
Some(exit) => format!("curl exited with {exit}"),
None => String::from("curl was stopped"),
};
let kind = match exit {
Some(0) => return Ok(()),
Some(22) => HttpErrorKind::Status(code.trim().parse().unwrap_or(0)),
Some(28) => HttpErrorKind::TimedOut,
Some(63) => HttpErrorKind::TooLarge,
Some(1) => HttpErrorKind::Refused,
_ => HttpErrorKind::Network,
};
Err(HttpError::new(kind, message))
}
#[derive(Clone, Copy)]
pub struct Http {
body: Signal<Option<String>>,
error: Signal<Option<HttpError>>,
loading: Signal<bool>,
refreshes: Signal<u64>,
inner: Signal<Keep>,
}
struct Keep(Rc<Inner>);
impl Drop for Keep {
fn drop(&mut self) {
let fetch = self.0.state.borrow_mut().fetch.take();
drop(fetch);
}
}
struct Inner {
service: Option<Rc<Service>>,
body: Signal<Option<String>>,
error: Signal<Option<HttpError>>,
loading: Signal<bool>,
state: RefCell<State>,
}
struct State {
fetch: Option<Fetch>,
stopped: bool,
max_size: u64,
timeout: Duration,
}
#[track_caller]
pub(crate) fn http_get(cx: &Cx, url: impl IntoProp<String>) -> Http {
let at = Location::caller();
let service = cx.service::<Service>();
if service.is_none() {
static LOGGED: Once = Once::new();
LOGGED.call_once(|| {
tracing::warn!("cx.http_get() needs the services the shell provides; nothing is fetched");
});
}
let inner = Rc::new(Inner {
service,
body: cx.signal(None),
error: cx.signal(None),
loading: cx.signal(false),
state: RefCell::new(State {
fetch: None,
stopped: false,
max_size: MAX_BODY,
timeout: TIMEOUT,
}),
});
let refreshes = cx.signal(0);
let url = chosen(cx, url, at, "cx.http_get");
let weak = Rc::downgrade(&inner);
cx.effect(move || {
refreshes.get();
let Some(inner) = weak.upgrade().filter(|inner| !inner.state.borrow().stopped) else {
return;
};
let url = url.get();
untrack(|| inner.start(url));
});
Http {
body: inner.body,
error: inner.error,
loading: inner.loading,
refreshes,
inner: cx.signal(Keep(inner)),
}
}
fn chosen(
cx: &Cx,
url: impl IntoProp<String>,
at: &'static Location<'static>,
name: &'static str,
) -> Memo<Option<String>> {
let url = url.into_prop().shared();
cx.memo(move || {
panic::catch_unwind(AssertUnwindSafe(|| url()))
.inspect_err(|payload| {
let message = panic_message(payload.as_ref());
tracing::error!("{name} (called at {at}) panicked choosing its URL: {message}");
})
.ok()
})
}
impl Http {
pub fn body(&self) -> ReadSignal<Option<String>> {
self.body.read_only()
}
pub fn error(&self) -> ReadSignal<Option<HttpError>> {
self.error.read_only()
}
pub fn loading(&self) -> ReadSignal<bool> {
self.loading.read_only()
}
pub fn refresh(&self) {
if let Some(inner) = self.inner() {
inner.state.borrow_mut().stopped = false;
}
self.refreshes.try_update(|count| *count += 1);
}
pub fn stopped(self) -> Http {
if let Some(inner) = self.inner() {
inner.state.borrow_mut().stopped = true;
inner.stop();
}
self
}
pub fn max_size(self, bytes: u64) -> Http {
if let Some(inner) = self.inner() {
inner.state.borrow_mut().max_size = bytes;
}
self
}
pub fn timeout(self, timeout: Duration) -> Http {
if let Some(inner) = self.inner() {
inner.state.borrow_mut().timeout = timeout;
}
self
}
fn inner(&self) -> Option<Rc<Inner>> {
untrack(|| self.inner.try_with(|keep| Rc::clone(&keep.0)))
}
}
impl Inner {
fn start(self: &Rc<Self>, url: Option<String>) {
let running = self.state.borrow_mut().fetch.take();
drop(running);
let (Some(url), Some(service)) = (url.filter(|url| !url.is_empty()), self.service.clone())
else {
set(self.loading, false);
return;
};
let (cap, timeout) = {
let state = self.state.borrow();
(state.max_size, state.timeout)
};
let weak = Rc::downgrade(self);
let done = move |result| {
if let Some(inner) = Weak::upgrade(&weak) {
inner.done(result);
}
};
match fetch(&service, &url, cap, timeout, Sink::Memory(Vec::new()), done) {
Ok(fetch) => {
self.state.borrow_mut().fetch = Some(fetch);
set(self.loading, true);
}
Err(error) => self.failed(error),
}
}
fn stop(&self) {
let fetch = self.state.borrow_mut().fetch.take();
drop(fetch);
set(self.loading, false);
}
fn done(&self, result: Result<Sink, HttpError>) {
let fetch = self.state.borrow_mut().fetch.take();
drop(fetch);
let text = result.and_then(|sink| match sink {
Sink::Memory(body) => String::from_utf8(body)
.map_err(|_| HttpError::new(HttpErrorKind::NotUtf8, "the body isn't UTF-8")),
Sink::File(_) => Err(HttpError::new(HttpErrorKind::Network, "no body")),
});
match text {
Ok(text) => {
set(self.body, Some(text));
set(self.error, None);
set(self.loading, false);
}
Err(error) => self.failed(error),
}
}
fn failed(&self, error: HttpError) {
if untrack(|| self.error.try_with(|old| old.as_ref() != Some(&error))) == Some(true) {
tracing::info!(error = error.message, "a request failed");
}
set(self.error, Some(error));
set(self.loading, false);
}
}
fn set<T: PartialEq + 'static>(signal: Signal<T>, value: T) {
if untrack(|| signal.try_with(|old| *old != value)) == Some(true) {
signal.try_set(value);
}
}