rsurl 0.0.2

//! C ABI for rsurl.
//!
//! A deliberately minimal, libcurl-shaped "easy" API. Function names use a
//! `rsurl_` prefix (not `curl_`) so this can be linked alongside libcurl
//! without symbol clashes, while still being familiar to anyone who has
//! used libcurl before.
//!
//! Lifecycle:
//!
//! ```c
//! RSURL *h = rsurl_easy_init();
//! rsurl_easy_setopt(h, RSURLOPT_URL, "http://example.com");
//! rsurl_easy_perform(h);
//! const uint8_t *body; size_t len;
//! rsurl_easy_response_body(h, &body, &len);
//! rsurl_easy_cleanup(h);
//! ```
//!
//! All pointer parameters except `handle` may be NULL where stated. Returned
//! pointers from `rsurl_easy_response_*` borrow from the handle and become
//! invalid on the next `rsurl_easy_perform` or `rsurl_easy_cleanup`.

#![allow(non_camel_case_types)]

use std::ffi::{c_char, c_int, c_long, CStr};
use std::panic::{self, AssertUnwindSafe};
use std::ptr;

use crate::http::{Request, Response};

/// Unwind barrier for the C ABI: a Rust panic crossing an `extern "C"`
/// boundary is undefined behavior, so every exported function runs its body
/// through `catch_unwind` and converts a caught panic into `default`.
///
/// `AssertUnwindSafe` is sound here because the closures only touch a single
/// handle behind a raw pointer (no shared `&mut` state observed after a
/// panic) and any panic aborts the operation before returning a value to C;
/// the handle is left in a valid—if possibly partially-updated—state, which
/// is the same guarantee callers already get from an error return.
fn ffi_guard<T>(default: T, f: impl FnOnce() -> T) -> T {
    panic::catch_unwind(AssertUnwindSafe(f)).unwrap_or(default)
}

/// Opaque handle. Never dereferenced from C.
pub enum RSURL {}

/// Option codes accepted by `rsurl_easy_setopt`.
#[repr(C)]
pub enum RsurlOpt {
    /// const char* — the target URL.
    Url = 1,
    /// const char* — override HTTP method (default GET, or POST if body set).
    CustomRequest = 2,
    /// const char* — single header line ("Name: value"). Repeat to add multiple.
    Header = 3,
    /// const char* — request body (UTF-8 string, NUL-terminated).
    PostFieldsString = 4,
    /// long — connect timeout in seconds. 0 disables.
    ConnectTimeout = 5,
    /// long — read timeout in seconds. 0 disables.
    Timeout = 6,
    /// const char* — User-Agent value.
    UserAgent = 7,
}

/// Status codes returned by the API.
#[repr(C)]
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum RsurlCode {
    Ok = 0,
    InvalidHandle = 1,
    UnknownOption = 2,
    InvalidArg = 3,
    NoResponse = 4,
    Network = 5,
    BadResponse = 6,
    Unsupported = 7,
}

struct Handle {
    url: Option<String>,
    method: Option<String>,
    user_agent: Option<String>,
    headers: Vec<(String, String)>,
    body: Option<Vec<u8>>,
    connect_timeout_secs: Option<u64>,
    timeout_secs: Option<u64>,
    last_response: Option<Response>,
    /// Stable storage so C callers can read header values as NUL-terminated
    /// strings without us having to allocate per-call.
    header_buf: Vec<Vec<u8>>,
}

impl Handle {
    fn new() -> Self {
        Handle {
            url: None,
            method: None,
            user_agent: None,
            headers: Vec::new(),
            body: None,
            connect_timeout_secs: None,
            timeout_secs: None,
            last_response: None,
            header_buf: Vec::new(),
        }
    }
}

fn handle_mut<'a>(h: *mut RSURL) -> Option<&'a mut Handle> {
    if h.is_null() {
        return None;
    }
    // SAFETY: handles are always created from Box::into_raw of a Handle.
    Some(unsafe { &mut *(h as *mut Handle) })
}

fn handle_ref<'a>(h: *const RSURL) -> Option<&'a Handle> {
    if h.is_null() {
        return None;
    }
    // SAFETY: handles are always created from Box::into_raw of a Handle.
    Some(unsafe { &*(h as *const Handle) })
}

/// Allocate a new easy handle. Returns NULL on allocation failure (practically
/// never on this platform). Free with `rsurl_easy_cleanup`.
#[no_mangle]
pub extern "C" fn rsurl_easy_init() -> *mut RSURL {
    ffi_guard(ptr::null_mut(), || {
        let boxed = Box::new(Handle::new());
        Box::into_raw(boxed) as *mut RSURL
    })
}

/// Free an easy handle. NULL is a no-op.
#[no_mangle]
pub extern "C" fn rsurl_easy_cleanup(handle: *mut RSURL) {
    ffi_guard((), || {
        if handle.is_null() {
            return;
        }
        // SAFETY: handle came from rsurl_easy_init's Box::into_raw.
        unsafe {
            drop(Box::from_raw(handle as *mut Handle));
        }
    })
}

/// Reset all options on a handle but keep it allocated. Clears any previous
/// response data.
#[no_mangle]
pub extern "C" fn rsurl_easy_reset(handle: *mut RSURL) -> RsurlCode {
    ffi_guard(RsurlCode::Network, || {
        let Some(h) = handle_mut(handle) else {
            return RsurlCode::InvalidHandle;
        };
        *h = Handle::new();
        RsurlCode::Ok
    })
}

/// Set an option taking a NUL-terminated `const char*`.
///
/// Pass NULL to clear/unset that option. The string is copied into the handle.
///
/// # Safety
///
/// `handle` must be a pointer returned by [`rsurl_easy_init`] and not yet
/// freed by [`rsurl_easy_cleanup`]. `value`, if non-null, must point to a
/// valid NUL-terminated C string for the duration of this call.
#[no_mangle]
pub unsafe extern "C" fn rsurl_easy_setopt_str(
    handle: *mut RSURL,
    option: c_int,
    value: *const c_char,
) -> RsurlCode {
    ffi_guard(RsurlCode::Network, || {
        let Some(h) = handle_mut(handle) else {
            return RsurlCode::InvalidHandle;
        };
        let s = if value.is_null() {
            None
        } else {
            // SAFETY: caller asserts value is a valid NUL-terminated C string.
            match unsafe { CStr::from_ptr(value) }.to_str() {
                Ok(s) => Some(s.to_string()),
                Err(_) => return RsurlCode::InvalidArg,
            }
        };
        let Some(opt) = opt_from_int(option) else {
            return RsurlCode::UnknownOption;
        };
        match opt {
            RsurlOpt::Url => h.url = s,
            RsurlOpt::CustomRequest => h.method = s,
            RsurlOpt::UserAgent => h.user_agent = s,
            RsurlOpt::Header => match s {
                Some(line) => {
                    let Some((k, v)) = line.split_once(':') else {
                        return RsurlCode::InvalidArg;
                    };
                    h.headers.push((k.trim().to_string(), v.trim().to_string()));
                }
                None => h.headers.clear(),
            },
            RsurlOpt::PostFieldsString => h.body = s.map(|s| s.into_bytes()),
            RsurlOpt::ConnectTimeout | RsurlOpt::Timeout => return RsurlCode::InvalidArg,
        }
        RsurlCode::Ok
    })
}

/// Set an option taking a `long` (e.g. timeouts).
#[no_mangle]
pub extern "C" fn rsurl_easy_setopt_long(
    handle: *mut RSURL,
    option: c_int,
    value: c_long,
) -> RsurlCode {
    ffi_guard(RsurlCode::Network, || {
        let Some(h) = handle_mut(handle) else {
            return RsurlCode::InvalidHandle;
        };
        let Some(opt) = opt_from_int(option) else {
            return RsurlCode::UnknownOption;
        };
        let secs = if value <= 0 { None } else { Some(value as u64) };
        match opt {
            RsurlOpt::ConnectTimeout => h.connect_timeout_secs = secs,
            RsurlOpt::Timeout => h.timeout_secs = secs,
            _ => return RsurlCode::InvalidArg,
        }
        RsurlCode::Ok
    })
}

fn opt_from_int(v: c_int) -> Option<RsurlOpt> {
    Some(match v {
        1 => RsurlOpt::Url,
        2 => RsurlOpt::CustomRequest,
        3 => RsurlOpt::Header,
        4 => RsurlOpt::PostFieldsString,
        5 => RsurlOpt::ConnectTimeout,
        6 => RsurlOpt::Timeout,
        7 => RsurlOpt::UserAgent,
        _ => return None,
    })
}

/// Execute the request configured on the handle. Replaces any previous
/// response stored on the handle.
#[no_mangle]
pub extern "C" fn rsurl_easy_perform(handle: *mut RSURL) -> RsurlCode {
    ffi_guard(RsurlCode::Network, || {
        let Some(h) = handle_mut(handle) else {
            return RsurlCode::InvalidHandle;
        };
        let Some(url) = h.url.as_deref() else {
            return RsurlCode::InvalidArg;
        };
        let method = h.method.clone().unwrap_or_else(|| {
            if h.body.is_some() {
                "POST".to_string()
            } else {
                "GET".to_string()
            }
        });

        let mut req = match Request::new(&method, url) {
            Ok(r) => r,
            Err(crate::Error::UnsupportedScheme(_)) => return RsurlCode::Unsupported,
            Err(_) => return RsurlCode::InvalidArg,
        };
        for (k, v) in &h.headers {
            req = req.header(k, v);
        }
        if let Some(ua) = &h.user_agent {
            req = req.header("User-Agent", ua);
        }
        if let Some(body) = h.body.clone() {
            req = req.body(body);
        }

        match req.send() {
            Ok(resp) => {
                h.header_buf = resp
                    .headers
                    .iter()
                    .map(|(k, v)| {
                        let mut s = format!("{k}: {v}").into_bytes();
                        s.push(0);
                        s
                    })
                    .collect();
                h.last_response = Some(resp);
                RsurlCode::Ok
            }
            Err(crate::Error::UnsupportedScheme(_)) => RsurlCode::Unsupported,
            Err(crate::Error::Io(_)) | Err(crate::Error::UnexpectedEof) => RsurlCode::Network,
            Err(crate::Error::BadResponse(_)) | Err(crate::Error::H2NotNegotiated) => {
                RsurlCode::BadResponse
            }
            Err(crate::Error::InvalidUrl(_)) => RsurlCode::InvalidArg,
        }
    })
}

/// Borrow a pointer to the response body and its length. Pointer remains
/// valid until the next perform/reset/cleanup. `out_ptr` is set to NULL and
/// `out_len` to 0 if no response is available.
///
/// The returned buffer is **raw response bytes plus a length**; it is **not**
/// NUL-terminated and may contain embedded NUL bytes. C callers must use the
/// `*out_len` value and must **not** pass `*out_ptr` to `strlen`, `printf`,
/// or any function that treats it as a NUL-terminated C string.
///
/// # Safety
///
/// `handle` must be a pointer returned by [`rsurl_easy_init`] and not yet
/// freed by [`rsurl_easy_cleanup`]. `out_ptr` and `out_len` must be non-null
/// and point to writable storage of the appropriate type.
#[no_mangle]
pub unsafe extern "C" fn rsurl_easy_response_body(
    handle: *const RSURL,
    out_ptr: *mut *const u8,
    out_len: *mut usize,
) -> RsurlCode {
    ffi_guard(RsurlCode::Network, || {
        let Some(h) = handle_ref(handle) else {
            return RsurlCode::InvalidHandle;
        };
        if out_ptr.is_null() || out_len.is_null() {
            return RsurlCode::InvalidArg;
        }
        match &h.last_response {
            Some(resp) => unsafe {
                *out_ptr = resp.body.as_ptr();
                *out_len = resp.body.len();
            },
            None => unsafe {
                *out_ptr = ptr::null();
                *out_len = 0;
            },
        }
        RsurlCode::Ok
    })
}

/// Return the response HTTP status code, or 0 if no response is available.
#[no_mangle]
pub extern "C" fn rsurl_easy_response_status(handle: *const RSURL) -> c_long {
    ffi_guard(0, || {
        handle_ref(handle)
            .and_then(|h| h.last_response.as_ref())
            .map(|r| r.status as c_long)
            .unwrap_or(0)
    })
}

/// Borrow a pointer to a NUL-terminated `"Name: value"` header line by index.
/// Returns NULL if `index` is out of range or no response is available.
#[no_mangle]
pub extern "C" fn rsurl_easy_response_header(handle: *const RSURL, index: usize) -> *const c_char {
    ffi_guard(ptr::null(), || {
        let Some(h) = handle_ref(handle) else {
            return ptr::null();
        };
        h.header_buf
            .get(index)
            .map(|b| b.as_ptr() as *const c_char)
            .unwrap_or(ptr::null())
    })
}

/// Return the number of response headers available.
#[no_mangle]
pub extern "C" fn rsurl_easy_response_header_count(handle: *const RSURL) -> usize {
    ffi_guard(0, || {
        handle_ref(handle).map(|h| h.header_buf.len()).unwrap_or(0)
    })
}

/// Return a static, NUL-terminated human-readable string for a status code.
#[no_mangle]
pub extern "C" fn rsurl_strerror(code: c_int) -> *const c_char {
    ffi_guard(ptr::null(), || {
        let s: &'static [u8] = match code {
            0 => b"ok\0",
            1 => b"invalid handle\0",
            2 => b"unknown option\0",
            3 => b"invalid argument\0",
            4 => b"no response available\0",
            5 => b"network error\0",
            6 => b"bad response\0",
            7 => b"unsupported scheme or feature\0",
            _ => b"unknown error\0",
        };
        s.as_ptr() as *const c_char
    })
}

/// Return the rsurl version as a NUL-terminated string.
#[no_mangle]
pub extern "C" fn rsurl_version() -> *const c_char {
    ffi_guard(ptr::null(), || {
        concat!("rsurl/", env!("CARGO_PKG_VERSION"), "\0").as_ptr() as *const c_char
    })
}