use std::ptr;
use eggfetch_core::Client;
use crate::handle::ClientBuilderHandle;
#[no_mangle]
pub unsafe extern "C" fn eggfetch_client_builder_new() -> *mut ClientBuilderHandle {
crate::ffi_guard!(ptr::null_mut(), {
Box::into_raw(Box::new(ClientBuilderHandle(Some(Client::builder()))))
})
}
#[no_mangle]
pub unsafe extern "C" fn eggfetch_client_builder_free(handle: *mut ClientBuilderHandle) {
crate::ffi_guard!((), {
if !handle.is_null() {
drop(Box::from_raw(handle));
}
});
}
#[no_mangle]
pub unsafe extern "C" fn eggfetch_client_builder_build(
raw: *mut ClientBuilderHandle,
) -> *mut crate::handle::ClientHandle {
crate::ffi_guard!(ptr::null_mut(), {
let Some(handle) = raw.as_mut() else {
return ptr::null_mut();
};
let Some(builder) = handle.0.take() else {
return ptr::null_mut();
};
let client = builder.build();
Box::into_raw(Box::new(crate::handle::ClientHandle(client)))
})
}
#[no_mangle]
pub unsafe extern "C" fn eggfetch_client_builder_timeout(
handle: *mut ClientBuilderHandle,
secs: u64,
) -> i32 {
crate::ffi_guard!(-1, {
let Some(handle) = handle.as_mut() else {
return -1;
};
let timeout = eggfetch_core::Timeout::builder()
.total(std::time::Duration::from_secs(secs))
.build();
update_builder(handle, |builder| builder.merge_timeout(timeout))
})
}
#[no_mangle]
pub unsafe extern "C" fn eggfetch_client_builder_connect_timeout(
handle: *mut ClientBuilderHandle,
secs: u64,
) -> i32 {
crate::ffi_guard!(-1, {
let Some(handle) = handle.as_mut() else {
return -1;
};
let timeout = eggfetch_core::Timeout::builder()
.connect(std::time::Duration::from_secs(secs))
.build();
update_builder(handle, |builder| builder.merge_timeout(timeout))
})
}
#[no_mangle]
pub unsafe extern "C" fn eggfetch_client_builder_read_timeout(
handle: *mut ClientBuilderHandle,
secs: u64,
) -> i32 {
crate::ffi_guard!(-1, {
let Some(handle) = handle.as_mut() else {
return -1;
};
let timeout = eggfetch_core::Timeout::builder()
.read(std::time::Duration::from_secs(secs))
.build();
update_builder(handle, |builder| builder.merge_timeout(timeout))
})
}
#[no_mangle]
pub unsafe extern "C" fn eggfetch_client_builder_write_timeout(
handle: *mut ClientBuilderHandle,
secs: u64,
) -> i32 {
crate::ffi_guard!(-1, {
let Some(handle) = handle.as_mut() else {
return -1;
};
let timeout = eggfetch_core::Timeout::builder()
.write(std::time::Duration::from_secs(secs))
.build();
update_builder(handle, |builder| builder.merge_timeout(timeout))
})
}
#[no_mangle]
pub unsafe extern "C" fn eggfetch_client_builder_follow_redirects(
handle: *mut ClientBuilderHandle,
follow: i32,
) -> i32 {
crate::ffi_guard!(-1, {
let Some(handle) = handle.as_mut() else {
return -1;
};
update_builder(handle, |builder| builder.follow_redirects(follow != 0))
})
}
#[no_mangle]
pub unsafe extern "C" fn eggfetch_client_builder_max_redirects(
handle: *mut ClientBuilderHandle,
max: usize,
) -> i32 {
crate::ffi_guard!(-1, {
let Some(handle) = handle.as_mut() else {
return -1;
};
update_builder(handle, |builder| builder.max_redirects(max))
})
}
#[no_mangle]
pub unsafe extern "C" fn eggfetch_client_builder_user_agent(
handle: *mut ClientBuilderHandle,
agent: *const std::os::raw::c_char,
) -> i32 {
crate::ffi_guard!(-1, {
let Some(handle) = handle.as_mut() else {
return -1;
};
let Some(agent_str) = crate::handle::cstr_to_string(agent) else {
return -1;
};
update_builder(handle, |builder| builder.user_agent(&agent_str))
})
}
#[no_mangle]
pub unsafe extern "C" fn eggfetch_client_builder_default_header(
handle: *mut ClientBuilderHandle,
name: *const std::os::raw::c_char,
value: *const std::os::raw::c_char,
) -> i32 {
crate::ffi_guard!(-1, {
let Some(handle) = handle.as_mut() else {
return -1;
};
let Some(name_str) = crate::handle::cstr_to_string(name) else {
return -1;
};
let Some(value_str) = crate::handle::cstr_to_string(value) else {
return -1;
};
update_builder_result(handle, |builder| {
builder.default_header(&name_str, &value_str)
})
})
}
#[no_mangle]
pub unsafe extern "C" fn eggfetch_client_builder_http_version(
handle: *mut ClientBuilderHandle,
policy: i32,
) -> i32 {
crate::ffi_guard!(-1, {
let Some(handle) = handle.as_mut() else {
return -1;
};
let version_policy = match policy {
0 => eggfetch_core::HttpVersionPolicy::Http1Only,
1 => eggfetch_core::HttpVersionPolicy::Http2Only,
2 => eggfetch_core::HttpVersionPolicy::Auto { allow_http3: false },
3 => eggfetch_core::HttpVersionPolicy::Auto { allow_http3: true },
_ => return -1,
};
update_builder(handle, |builder| {
builder.http_version_policy(version_policy)
})
})
}
#[no_mangle]
pub unsafe extern "C" fn eggfetch_client_builder_automatic_decompression(
handle: *mut ClientBuilderHandle,
enabled: i32,
) -> i32 {
crate::ffi_guard!(-1, {
let Some(handle) = handle.as_mut() else {
return -1;
};
update_builder(handle, |builder| {
builder.automatic_decompression(enabled != 0)
})
})
}
#[no_mangle]
pub unsafe extern "C" fn eggfetch_client_builder_max_decoded_body_size(
handle: *mut ClientBuilderHandle,
max: usize,
) -> i32 {
crate::ffi_guard!(-1, {
let Some(handle) = handle.as_mut() else {
return -1;
};
update_builder(handle, |builder| builder.max_decoded_body_size(max))
})
}
#[no_mangle]
pub unsafe extern "C" fn eggfetch_client_builder_max_decompression_ratio(
handle: *mut ClientBuilderHandle,
ratio: f64,
) -> i32 {
crate::ffi_guard!(-1, {
let Some(handle) = handle.as_mut() else {
return -1;
};
update_builder(handle, |builder| builder.max_decompression_ratio(ratio))
})
}
#[no_mangle]
pub unsafe extern "C" fn eggfetch_client_builder_max_idle_connections(
handle: *mut ClientBuilderHandle,
max: usize,
) -> i32 {
crate::ffi_guard!(-1, {
let Some(handle) = handle.as_mut() else {
return -1;
};
update_builder(handle, |builder| builder.max_idle_connections(max))
})
}
#[no_mangle]
pub unsafe extern "C" fn eggfetch_client_builder_max_idle_connections_per_host(
handle: *mut ClientBuilderHandle,
max: usize,
) -> i32 {
crate::ffi_guard!(-1, {
let Some(handle) = handle.as_mut() else {
return -1;
};
update_builder(handle, |builder| builder.max_idle_connections_per_host(max))
})
}
#[no_mangle]
pub unsafe extern "C" fn eggfetch_client_builder_danger_accept_invalid_certs(
handle: *mut ClientBuilderHandle,
accept: i32,
) -> i32 {
crate::ffi_guard!(-1, {
#[cfg(not(feature = "tls-rustls"))]
{
let _ = (handle, accept);
return -1;
}
#[cfg(feature = "tls-rustls")]
{
let Some(handle) = handle.as_mut() else {
return -1;
};
update_builder(handle, |builder| {
builder.danger_accept_invalid_certs(accept != 0)
})
}
})
}
#[no_mangle]
pub unsafe extern "C" fn eggfetch_client_builder_basic_auth(
handle: *mut ClientBuilderHandle,
username: *const std::os::raw::c_char,
password: *const std::os::raw::c_char,
) -> i32 {
crate::ffi_guard!(-1, {
let Some(handle) = handle.as_mut() else {
return -1;
};
let Some(username_str) = crate::handle::cstr_to_string(username) else {
return -1;
};
let Some(password_str) = crate::handle::cstr_to_string(password) else {
return -1;
};
let Ok(auth) = eggfetch_core::AuthScheme::basic(username_str, password_str) else {
return -1;
};
update_builder(handle, |builder| builder.auth(auth))
})
}
#[no_mangle]
pub unsafe extern "C" fn eggfetch_client_builder_bearer_auth(
handle: *mut ClientBuilderHandle,
token: *const std::os::raw::c_char,
) -> i32 {
crate::ffi_guard!(-1, {
let Some(handle) = handle.as_mut() else {
return -1;
};
let Some(token_str) = crate::handle::cstr_to_string(token) else {
return -1;
};
let Ok(auth) = eggfetch_core::AuthScheme::bearer(token_str) else {
return -1;
};
update_builder(handle, |builder| builder.auth(auth))
})
}
fn update_builder<F>(handle: &mut ClientBuilderHandle, update: F) -> i32
where
F: FnOnce(eggfetch_core::ClientBuilder) -> eggfetch_core::ClientBuilder,
{
let Some(builder) = handle.0.take() else {
return -1;
};
handle.0 = Some(update(builder));
0
}
fn update_builder_result<F>(handle: &mut ClientBuilderHandle, update: F) -> i32
where
F: FnOnce(eggfetch_core::ClientBuilder) -> eggfetch_core::Result<eggfetch_core::ClientBuilder>,
{
let Some(builder) = handle.0.take() else {
return -1;
};
match update(builder) {
Ok(builder) => {
handle.0 = Some(builder);
0
}
Err(_) => -1,
}
}