use std::ffi::{CStr, CString};
use std::os::raw::c_char;
use anyhow::{anyhow, Context};
use serde::Deserialize;
extern "C" {
fn llmman_free(s: *mut c_char);
fn llmman_login(
server: *const c_char,
username: *const c_char,
password: *const c_char,
) -> *mut c_char;
fn llmman_logout(server: *const c_char) -> *mut c_char;
fn llmman_push(layout_dir: *const c_char, reference: *const c_char) -> *mut c_char;
fn llmman_pull(reference: *const c_char, layout_dir: *const c_char) -> *mut c_char;
fn llmman_inspect(reference: *const c_char) -> *mut c_char;
fn llmman_transfer(source: *const c_char, destination: *const c_char) -> *mut c_char;
fn llmman_progress(key: *const c_char) -> *mut c_char;
fn llmman_verify(
reference: *const c_char,
digest: *const c_char,
keys_json: *const c_char,
) -> *mut c_char;
fn llmman_sign(
reference: *const c_char,
digest: *const c_char,
key_path: *const c_char,
password: *const c_char,
) -> *mut c_char;
fn llmman_resolve_digest(reference: *const c_char) -> *mut c_char;
fn llmman_set_registry_mirrors(mirrors_json: *const c_char) -> *mut c_char;
}
#[cfg(feature = "docker")]
extern "C" {
fn llmman_push_session_open(destination: *const c_char) -> *mut c_char;
fn llmman_push_session_close(session: i64) -> *mut c_char;
fn llmman_push_stream_open(
session: i64,
media_type: *const c_char,
digest: *const c_char,
size: i64,
annotations_json: *const c_char,
) -> *mut c_char;
fn llmman_push_stream_wait(handle: i64) -> *mut c_char;
}
#[cfg(all(target_os = "windows", target_env = "msvc", target_arch = "x86_64"))]
extern "C" {
fn _rt0_amd64_windows_lib(argc: i32, argv: *mut *mut u8);
}
#[cfg(all(target_os = "windows", target_env = "msvc", target_arch = "aarch64"))]
extern "C" {
fn _rt0_arm64_windows_lib();
}
pub fn ensure_runtime_init() {
#[cfg(all(target_os = "windows", target_env = "msvc"))]
{
static INIT: std::sync::Once = std::sync::Once::new();
INIT.call_once(|| unsafe {
#[cfg(target_arch = "x86_64")]
_rt0_amd64_windows_lib(0, std::ptr::null_mut());
#[cfg(target_arch = "aarch64")]
_rt0_arm64_windows_lib();
});
}
}
#[derive(Deserialize)]
struct GoResponse {
ok: bool,
#[serde(default)]
data: String,
#[serde(default)]
error: String,
}
fn consume(raw: *mut c_char) -> anyhow::Result<String> {
assert!(!raw.is_null(), "Go shim returned a null pointer");
let json_str = unsafe { CStr::from_ptr(raw).to_string_lossy().into_owned() };
unsafe { llmman_free(raw) };
let resp: GoResponse =
serde_json::from_str(&json_str).context("failed to decode Go shim response")?;
if resp.ok {
Ok(resp.data)
} else {
Err(anyhow!("{}", resp.error))
}
}
fn cstr(s: &str) -> anyhow::Result<CString> {
CString::new(s).context("string contains interior NUL byte")
}
fn ensure_registries_configured() {
static ONCE: std::sync::Once = std::sync::Once::new();
ONCE.call_once(|| {
let mirrors = crate::config::registry_mirrors();
if mirrors.is_empty() {
return;
}
let result = serde_json::to_string(&mirrors)
.context("encode registry mirrors")
.and_then(|json| {
let j = cstr(&json)?;
consume(unsafe { llmman_set_registry_mirrors(j.as_ptr()) })
});
if let Err(e) = result {
eprintln!("[llmman] warning: ignoring registry mirrors: {e}");
}
});
}
fn registry_call(call: impl FnOnce() -> *mut c_char) -> anyhow::Result<String> {
ensure_registries_configured();
consume(call())
}
pub fn login(server: &str, username: &str, password: &str) -> anyhow::Result<()> {
let s = cstr(server)?;
let u = cstr(username)?;
let p = cstr(password)?;
consume(unsafe { llmman_login(s.as_ptr(), u.as_ptr(), p.as_ptr()) }).map(|_| ())
}
pub fn logout(server: &str) -> anyhow::Result<()> {
let s = cstr(server)?;
consume(unsafe { llmman_logout(s.as_ptr()) }).map(|_| ())
}
pub fn push(layout_dir: &str, reference: &str) -> anyhow::Result<()> {
let l = cstr(layout_dir)?;
let r = cstr(reference)?;
registry_call(|| unsafe { llmman_push(l.as_ptr(), r.as_ptr()) }).map(|_| ())
}
pub fn pull(reference: &str, layout_dir: &str) -> anyhow::Result<()> {
let r = cstr(reference)?;
let l = cstr(layout_dir)?;
registry_call(|| unsafe { llmman_pull(r.as_ptr(), l.as_ptr()) }).map(|_| ())
}
pub fn inspect_remote(reference: &str) -> anyhow::Result<String> {
let r = cstr(reference)?;
registry_call(|| unsafe { llmman_inspect(r.as_ptr()) })
}
#[derive(Debug, Clone, Deserialize)]
pub struct TransferOutcome {
pub changed: bool,
#[serde(default)]
pub digest: Option<String>,
}
impl TransferOutcome {
pub fn new(changed: bool, digest: impl Into<String>) -> Self {
Self {
changed,
digest: Some(digest.into()),
}
}
}
pub fn transfer(source: &str, destination: &str) -> anyhow::Result<TransferOutcome> {
let s = cstr(source)?;
let d = cstr(destination)?;
let data = registry_call(|| unsafe { llmman_transfer(s.as_ptr(), d.as_ptr()) })?;
serde_json::from_str(&data).context("decode transfer outcome")
}
#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SignatureMatch {
pub key_path: String,
pub identity: String,
}
#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct VerifyReport {
pub reference: String,
pub digest: String,
pub verified: bool,
pub signatures_found: u32,
pub matches: Vec<SignatureMatch>,
pub reason: String,
}
pub fn verify(reference: &str, digest: &str, keys: &[String]) -> anyhow::Result<VerifyReport> {
let r = cstr(reference)?;
let d = cstr(digest)?;
let k = cstr(&serde_json::to_string(keys).context("encode trusted key list")?)?;
let data = registry_call(|| unsafe { llmman_verify(r.as_ptr(), d.as_ptr(), k.as_ptr()) })?;
serde_json::from_str(&data).context("decode verification report")
}
pub fn sign(
reference: &str,
digest: &str,
key_path: &str,
password: &str,
) -> anyhow::Result<String> {
let r = cstr(reference)?;
let d = cstr(digest)?;
let k = cstr(key_path)?;
let p = cstr(password)?;
registry_call(|| unsafe { llmman_sign(r.as_ptr(), d.as_ptr(), k.as_ptr(), p.as_ptr()) })
}
pub fn resolved_digest_of(reference: &str) -> anyhow::Result<String> {
let r = cstr(reference)?;
registry_call(|| unsafe { llmman_resolve_digest(r.as_ptr()) })
}
#[cfg(feature = "docker")]
pub struct PushSession(i64);
#[cfg(feature = "docker")]
pub fn push_session_open(destination: &str) -> anyhow::Result<PushSession> {
#[derive(Deserialize)]
struct Result_ {
session: i64,
}
let d = cstr(destination)?;
let data = registry_call(|| unsafe { llmman_push_session_open(d.as_ptr()) })?;
let result: Result_ =
serde_json::from_str(&data).context("decode push_session_open response")?;
Ok(PushSession(result.session))
}
#[cfg(feature = "docker")]
impl Drop for PushSession {
fn drop(&mut self) {
if let Err(e) = consume(unsafe { llmman_push_session_close(self.0) }) {
eprintln!("[llmman] close push session: {e:#}");
}
}
}
#[cfg(feature = "docker")]
#[must_use = "must be passed to push_stream_wait, or the Go-side handle and its goroutine leak"]
pub struct PushStream {
pub fd: u64,
handle: i64,
}
#[cfg(feature = "docker")]
#[derive(Deserialize)]
struct PushStreamOpenResult {
fd: u64,
handle: i64,
}
#[cfg(feature = "docker")]
pub fn push_stream_open(
session: &PushSession,
media_type: &str,
digest: &str,
size: i64,
annotations_json: &str,
) -> anyhow::Result<PushStream> {
let m = cstr(media_type)?;
let g = cstr(digest)?;
let a = cstr(annotations_json)?;
let data = consume(unsafe {
llmman_push_stream_open(session.0, m.as_ptr(), g.as_ptr(), size, a.as_ptr())
})?;
let result: PushStreamOpenResult =
serde_json::from_str(&data).context("decode push_stream_open response")?;
Ok(PushStream {
fd: result.fd,
handle: result.handle,
})
}
#[cfg(feature = "docker")]
pub fn push_stream_wait(stream: PushStream) -> anyhow::Result<bool> {
#[derive(Deserialize)]
struct WaitResult {
changed: bool,
}
let data = consume(unsafe { llmman_push_stream_wait(stream.handle) })?;
let result: WaitResult =
serde_json::from_str(&data).context("decode push_stream_wait response")?;
Ok(result.changed)
}
#[derive(Deserialize)]
pub struct ProgressSnapshot {
pub status: String,
pub total: i64,
pub completed: i64,
}
pub fn progress(key: &str) -> anyhow::Result<ProgressSnapshot> {
let k = cstr(key)?;
let data = consume(unsafe { llmman_progress(k.as_ptr()) })?;
serde_json::from_str(&data).context("failed to decode progress snapshot")
}