use std::ffi::{CStr, CString};
use std::os::raw::c_char;
use anyhow::{anyhow, Context};
use serde::{Deserialize, Serialize};
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_push_artifact(
layout_dir: *const c_char,
reference: *const c_char,
subject_json: *const c_char,
) -> *mut c_char;
fn llmman_referrers(reference: *const c_char, digest: *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,
claims: *const c_char,
identity_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,
#[serde(default)]
not_found: bool,
}
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) };
decode_response(&json_str)
}
fn decode_response(json_str: &str) -> anyhow::Result<String> {
let resp: GoResponse =
serde_json::from_str(json_str).context("failed to decode Go shim response")?;
if resp.ok {
Ok(resp.data)
} else if resp.not_found {
Err(crate::storage::oci::source_not_found(anyhow!(
"{}", resp.error
)))
} 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(|_| ())
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "camelCase")]
pub struct RegistryDescriptor {
pub media_type: String,
pub digest: String,
pub size: u64,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub artifact_type: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub annotations: Option<std::collections::HashMap<String, String>>,
}
pub fn push_artifact(
layout_dir: &str,
reference: &str,
subject: &RegistryDescriptor,
) -> anyhow::Result<()> {
let l = cstr(layout_dir)?;
let r = cstr(reference)?;
let s = cstr(&serde_json::to_string(subject).context("encode subject descriptor")?)?;
registry_call(|| unsafe { llmman_push_artifact(l.as_ptr(), r.as_ptr(), s.as_ptr()) })
.map(|_| ())
}
pub fn referrers(reference: &str, digest: &str) -> anyhow::Result<Vec<RegistryDescriptor>> {
let r = cstr(reference)?;
let d = cstr(digest)?;
let data = registry_call(|| unsafe { llmman_referrers(r.as_ptr(), d.as_ptr()) })?;
serde_json::from_str(&data).context("decode referrers")
}
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, PartialEq, Eq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Identity {
#[serde(skip_serializing_if = "Option::is_none")]
pub issuer: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub subject: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub trusted_root: Option<String>,
}
#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SignatureMatch {
pub signer: String,
#[serde(default)]
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],
claims: &str,
identity: Option<&Identity>,
) -> 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 c = cstr(claims)?;
let i = cstr(&match identity {
Some(identity) => serde_json::to_string(identity).context("encode identity policy")?,
None => String::new(),
})?;
let data = registry_call(|| unsafe {
llmman_verify(r.as_ptr(), d.as_ptr(), k.as_ptr(), c.as_ptr(), i.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 {
#[serde(default)]
exists: bool,
#[serde(default)]
fd: u64,
#[serde(default)]
handle: i64,
}
#[cfg(feature = "docker")]
pub enum PushStreamOpen {
Exists,
Stream(PushStream),
}
#[cfg(feature = "docker")]
impl PushStreamOpen {
fn decode(data: &str) -> anyhow::Result<Self> {
let result: PushStreamOpenResult =
serde_json::from_str(data).context("decode push_stream_open response")?;
Ok(if result.exists {
Self::Exists
} else {
Self::Stream(PushStream {
fd: result.fd,
handle: result.handle,
})
})
}
}
#[cfg(feature = "docker")]
pub fn push_stream_open(
session: &PushSession,
media_type: &str,
digest: &str,
size: i64,
annotations_json: &str,
) -> anyhow::Result<PushStreamOpen> {
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())
})?;
PushStreamOpen::decode(&data)
}
#[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")
}
#[cfg(test)]
mod tests {
use super::*;
use crate::storage::oci::is_source_not_found;
#[test]
fn a_successful_envelope_returns_its_data() {
assert_eq!(decode_response(r#"{"ok":true,"data":"x"}"#).unwrap(), "x");
}
#[test]
fn a_failed_envelope_is_the_message_and_nothing_more() {
let err = decode_response(r#"{"ok":false,"error":"dial tcp: no such host"}"#).unwrap_err();
assert_eq!(err.to_string(), "dial tcp: no such host");
assert!(!is_source_not_found(&err));
}
#[test]
fn a_not_found_envelope_is_marked_without_changing_the_message() {
let json =
r#"{"ok":false,"error":"resolve: docker.io/ai/nope:1b: not found","not_found":true}"#;
let err = decode_response(json).unwrap_err();
assert!(is_source_not_found(&err));
assert_eq!(err.to_string(), "resolve: docker.io/ai/nope:1b: not found");
let err = err.context("pull failed");
assert!(is_source_not_found(&err));
assert_eq!(
format!("{err:#}"),
"pull failed: resolve: docker.io/ai/nope:1b: not found"
);
}
#[test]
fn an_envelope_without_not_found_is_not_marked() {
let err = decode_response(r#"{"ok":false,"error":"x: not found"}"#).unwrap_err();
assert!(!is_source_not_found(&err));
}
#[cfg(feature = "docker")]
#[test]
fn push_stream_open_decodes_exists_without_a_stream() {
let open = PushStreamOpen::decode(r#"{"exists":true,"fd":0,"handle":0}"#).unwrap();
assert!(matches!(open, PushStreamOpen::Exists));
}
#[cfg(feature = "docker")]
#[test]
fn push_stream_open_decodes_a_stream() {
let open = PushStreamOpen::decode(r#"{"exists":false,"fd":7,"handle":3}"#).unwrap();
match open {
PushStreamOpen::Stream(s) => assert_eq!((s.fd, s.handle), (7, 3)),
PushStreamOpen::Exists => panic!("expected a stream"),
}
}
#[cfg(feature = "docker")]
#[test]
fn push_stream_open_rejects_garbage() {
assert!(PushStreamOpen::decode("not json").is_err());
}
#[test]
fn identity_crosses_as_camel_case_without_unset_fields() {
let identity = Identity {
issuer: Some("https://issuer".into()),
subject: None,
trusted_root: Some("/etc/llmman/root.json".into()),
};
assert_eq!(
serde_json::to_string(&identity).unwrap(),
r#"{"issuer":"https://issuer","trustedRoot":"/etc/llmman/root.json"}"#
);
}
#[test]
fn a_signature_match_without_a_key_path_decodes() {
let m: SignatureMatch =
serde_json::from_str(r#"{"signer":"https://issuer me@x","identity":"docker.io/a/b"}"#)
.unwrap();
assert_eq!(m.signer, "https://issuer me@x");
assert_eq!(m.key_path, "");
}
}