use std::ptr;
use std::sync::{Arc, Mutex};
use bytes::Bytes;
use futures_util::StreamExt;
use tokio::sync::{mpsc, watch};
use crate::handle::{ClientHandle, ErrorHandle, RequestHandle};
use crate::runtime::blocking_send;
struct StreamState {
rx: Mutex<Option<mpsc::Receiver<Result<Bytes, eggfetch_core::Error>>>>,
last_error: Mutex<Option<String>>,
cancel_tx: watch::Sender<bool>,
}
impl StreamState {
fn new(rx: mpsc::Receiver<Result<Bytes, eggfetch_core::Error>>) -> Self {
let (cancel_tx, _) = watch::channel(false);
Self {
rx: Mutex::new(Some(rx)),
last_error: Mutex::new(None),
cancel_tx,
}
}
fn subscribe(&self) -> watch::Receiver<bool> {
self.cancel_tx.subscribe()
}
}
pub struct StreamingResponseHandle {
status: u16,
url: String,
headers: Vec<(String, String)>,
state: Arc<StreamState>,
}
pub struct StreamChunk {
pub data: *mut u8,
pub len: usize,
}
#[no_mangle]
pub unsafe extern "C" fn eggfetch_client_send_streaming(
client: *const ClientHandle,
request: *mut RequestHandle,
err_out: *mut *mut ErrorHandle,
) -> *mut StreamingResponseHandle {
crate::ffi_guard!(
{
if !err_out.is_null() {
let err = eggfetch_core::Error::Connect("panic at FFI boundary".into());
*err_out = Box::into_raw(crate::handle::error_to_handle(&err));
}
ptr::null_mut()
},
{
if client.is_null() {
if !request.is_null() {
drop(Box::from_raw(request));
}
if !err_out.is_null() {
let err = eggfetch_core::Error::Connect("null client handle".into());
*err_out = Box::into_raw(crate::handle::error_to_handle(&err));
}
return ptr::null_mut();
}
let Some(request) = request.as_mut() else {
if !err_out.is_null() {
let err = eggfetch_core::Error::Connect("null request handle".into());
*err_out = Box::into_raw(crate::handle::error_to_handle(&err));
}
return ptr::null_mut();
};
let client_clone = (*client).0.clone();
let request_box = Box::from_raw(request);
let Some(rb) = request_box.0 else {
if !err_out.is_null() {
let err = eggfetch_core::Error::RequestBuild(
"request handle already consumed".into(),
);
*err_out = Box::into_raw(crate::handle::error_to_handle(&err));
}
return ptr::null_mut();
};
let (tx, rx) = mpsc::channel(16);
let state = Arc::new(StreamState::new(rx));
let mut cancel_watch = state.subscribe();
let result = blocking_send(async move {
let mut resp = Box::pin(rb.send()).await?;
let status = resp.status().as_u16();
let url = resp.url().to_string();
let headers: Vec<(String, String)> = resp
.headers()
.iter()
.map(|(k, v)| {
(
k.as_str().to_owned(),
String::from_utf8_lossy(v.as_bytes()).into_owned(),
)
})
.collect();
let stream = resp.bytes_stream()?;
tokio::spawn(async move {
let mut stream = stream;
while let Some(chunk) = stream.next().await {
if *cancel_watch.borrow_and_update() {
break;
}
match chunk {
Ok(data) => {
if tx.send(Ok(data)).await.is_err() {
break;
}
}
Err(e) => {
let _ = tx.send(Err(e)).await;
break;
}
}
}
drop(client_clone);
});
Ok::<_, eggfetch_core::Error>(StreamingResponseHandle {
status,
url,
headers,
state,
})
})
.and_then(std::convert::identity);
match result {
Ok(handle) => Box::into_raw(Box::new(handle)),
Err(ref e) => {
if !err_out.is_null() {
*err_out = Box::into_raw(crate::handle::error_to_handle(e));
}
ptr::null_mut()
}
}
}
)
}
#[no_mangle]
pub unsafe extern "C" fn eggfetch_response_stream_free(handle: *mut StreamingResponseHandle) {
crate::ffi_guard!((), {
if !handle.is_null() {
let h = Box::from_raw(handle);
h.state.cancel_tx.send_replace(true);
}
});
}
#[no_mangle]
pub unsafe extern "C" fn eggfetch_response_stream_status(
handle: *const StreamingResponseHandle,
) -> u16 {
crate::ffi_guard!(0, { handle.as_ref().map_or(0, |h| h.status) })
}
#[no_mangle]
pub unsafe extern "C" fn eggfetch_response_stream_url(
handle: *const StreamingResponseHandle,
) -> *mut std::os::raw::c_char {
crate::ffi_guard!(ptr::null_mut(), {
let Some(handle) = handle.as_ref() else {
return ptr::null_mut();
};
crate::handle::FfiString::from_string(handle.url.clone())
.map_or_else(ptr::null_mut, crate::handle::FfiString::into_raw)
})
}
#[no_mangle]
pub unsafe extern "C" fn eggfetch_response_stream_header_count(
handle: *const StreamingResponseHandle,
) -> usize {
crate::ffi_guard!(0, { handle.as_ref().map_or(0, |h| h.headers.len()) })
}
#[no_mangle]
pub unsafe extern "C" fn eggfetch_response_stream_header(
handle: *const StreamingResponseHandle,
index: usize,
name_out: *mut *mut std::os::raw::c_char,
value_out: *mut *mut std::os::raw::c_char,
) -> i32 {
crate::ffi_guard!(-1, {
let Some(handle) = handle.as_ref() else {
return -1;
};
if name_out.is_null() || value_out.is_null() {
return -1;
}
let Some((name, value)) = handle.headers.get(index) else {
return -1;
};
let Some(name_str) = crate::handle::FfiString::from_string(name.clone()) else {
return -1;
};
let Some(value_str) = crate::handle::FfiString::from_string(value.clone()) else {
return -1;
};
*name_out = name_str.into_raw();
*value_out = value_str.into_raw();
0
})
}
#[no_mangle]
#[allow(
clippy::too_many_lines,
reason = "FFI stream cancellation, ownership, and error state must stay in one transition"
)]
pub unsafe extern "C" fn eggfetch_response_stream_next(
handle: *mut StreamingResponseHandle,
) -> *mut StreamChunk {
crate::ffi_guard!(ptr::null_mut(), {
struct RecvOutcome {
chunk: Option<Result<Bytes, eggfetch_core::Error>>,
rx: Option<mpsc::Receiver<Result<Bytes, eggfetch_core::Error>>>,
}
let Some(handle) = handle.as_ref() else {
return ptr::null_mut();
};
let state = Arc::clone(&handle.state);
let mut rx = {
let Ok(mut guard) = state.rx.lock() else {
if let Ok(mut last) = state.last_error.lock() {
*last = Some("stream receiver mutex poisoned".to_owned());
}
return ptr::null_mut();
};
match guard.take() {
Some(rx) => rx,
None => return ptr::null_mut(),
}
};
let mut cancelled = state.subscribe();
let outcome: Option<RecvOutcome> = if *cancelled.borrow_and_update() {
None
} else {
Some(
match blocking_send(async move {
tokio::select! {
chunk = rx.recv() => RecvOutcome { chunk, rx: Some(rx) },
() = async { let _ = cancelled.changed().await; } => {
RecvOutcome { chunk: None, rx: None }
}
}
}) {
Ok(outcome) => outcome,
Err(error) => {
if let Ok(mut last) = state.last_error.lock() {
*last = Some(error.to_string());
}
return ptr::null_mut();
}
},
)
};
let (chunk, rx) = match outcome {
None
| Some(RecvOutcome {
chunk: None,
rx: None,
}) => {
if let Ok(mut last) = state.last_error.lock() {
*last = Some("stream cancelled".to_owned());
}
return ptr::null_mut();
}
Some(RecvOutcome { chunk, rx }) => (chunk, rx),
};
match chunk {
Some(Ok(data)) => {
let len = data.len();
let buf = if len > 0 {
let Ok(layout) = std::alloc::Layout::array::<u8>(len) else {
if let Some(rx) = rx {
if let Ok(mut guard) = state.rx.lock() {
*guard = Some(rx);
}
}
if let Ok(mut last) = state.last_error.lock() {
*last = Some("out of memory: chunk layout unusable".to_owned());
}
return ptr::null_mut();
};
let buf = std::alloc::alloc(layout);
if buf.is_null() {
if let Some(rx) = rx {
if let Ok(mut guard) = state.rx.lock() {
*guard = Some(rx);
}
}
if let Ok(mut last) = state.last_error.lock() {
*last = Some("out of memory allocating chunk buffer".to_owned());
}
return ptr::null_mut();
}
std::ptr::copy_nonoverlapping(data.as_ptr(), buf, len);
buf
} else {
ptr::null_mut()
};
if let Ok(mut last) = state.last_error.lock() {
last.take();
}
if let Some(rx) = rx {
match state.rx.lock() {
Ok(mut guard) => *guard = Some(rx),
Err(_) => {
if let Ok(mut last) = state.last_error.lock() {
*last = Some("stream receiver mutex poisoned".to_owned());
}
}
}
}
Box::into_raw(Box::new(StreamChunk { data: buf, len }))
}
Some(Err(e)) => {
if let Ok(mut last) = state.last_error.lock() {
*last = Some(e.to_string());
}
ptr::null_mut()
}
None => ptr::null_mut(),
}
})
}
#[no_mangle]
pub unsafe extern "C" fn eggfetch_response_stream_error(
handle: *const StreamingResponseHandle,
) -> *mut std::os::raw::c_char {
crate::ffi_guard!(ptr::null_mut(), {
let Some(handle) = handle.as_ref() else {
return ptr::null_mut();
};
let Ok(last) = handle.state.last_error.lock() else {
return ptr::null_mut();
};
match last.as_ref() {
Some(message) => crate::handle::FfiString::from_string(message.clone())
.map_or_else(ptr::null_mut, crate::handle::FfiString::into_raw),
None => ptr::null_mut(),
}
})
}
#[no_mangle]
pub unsafe extern "C" fn eggfetch_stream_chunk_free(chunk: *mut StreamChunk) {
crate::ffi_guard!((), {
if !chunk.is_null() {
let c = Box::from_raw(chunk);
if !c.data.is_null() && c.len > 0 {
if let Ok(layout) = std::alloc::Layout::array::<u8>(c.len) {
std::alloc::dealloc(c.data, layout);
}
}
}
});
}
#[no_mangle]
pub unsafe extern "C" fn eggfetch_response_stream_cancel(handle: *mut StreamingResponseHandle) {
crate::ffi_guard!((), {
let Some(handle) = handle.as_ref() else {
return;
};
handle.state.cancel_tx.send_replace(true);
});
}