1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use std::ffi::{c_char, CStr, CString};
use std::fmt::{Debug, Write};

use tracing::field::{Field, Visit};
use tracing::{Event, Level, Subscriber};
use tracing_subscriber::{prelude::*, Layer};

use crate::macros::*;

#[derive(Debug, Clone)]
#[repr(C)]
pub enum LogLevel {
    Trace,
    Debug,
    Info,
    Warn,
    Error,
}

impl<'a> From<&'a Level> for LogLevel {
    fn from(level: &'a Level) -> Self {
        match *level {
            Level::TRACE => Self::Trace,
            Level::DEBUG => Self::Debug,
            Level::INFO => Self::Info,
            Level::WARN => Self::Warn,
            Level::ERROR => Self::Error,
        }
    }
}

#[repr(C)]
pub struct PkgcraftLog {
    message: *mut c_char,
    level: LogLevel,
}

impl<'a> From<&'a Event<'_>> for PkgcraftLog {
    fn from(event: &'a Event<'_>) -> Self {
        let mut message = String::new();
        let mut visitor = MessageVisitor { message: &mut message };
        event.record(&mut visitor);

        Self {
            message: CString::new(message).unwrap().into_raw(),
            level: event.metadata().level().into(),
        }
    }
}

impl Drop for PkgcraftLog {
    fn drop(&mut self) {
        unsafe {
            drop(CString::from_raw(self.message));
        }
    }
}

/// Free a log.
///
/// # Safety
/// The argument must be a non-null PkgcraftLog pointer or NULL.
#[no_mangle]
pub unsafe extern "C" fn pkgcraft_log_free(l: *mut PkgcraftLog) {
    if !l.is_null() {
        unsafe { drop(Box::from_raw(l)) };
    }
}

type LogCallback = extern "C" fn(*mut PkgcraftLog);

pub struct PkgcraftLayer {
    log_cb: LogCallback,
}

impl PkgcraftLayer {
    fn new(log_cb: LogCallback) -> Self {
        Self { log_cb }
    }
}

struct MessageVisitor<'a> {
    message: &'a mut String,
}

impl<'a> Visit for MessageVisitor<'a> {
    fn record_debug(&mut self, field: &Field, value: &dyn Debug) {
        if field.name() == "message" {
            write!(self.message, "{value:?}").unwrap();
        }
    }
}

impl<S> Layer<S> for PkgcraftLayer
where
    S: Subscriber,
{
    fn on_event(&self, event: &Event<'_>, _ctx: tracing_subscriber::layer::Context<'_, S>) {
        (self.log_cb)(Box::into_raw(Box::new(event.into())));
    }
}

/// Enable pkgcraft logging support.
#[no_mangle]
pub extern "C" fn pkgcraft_logging_enable(cb: LogCallback) {
    let layer = PkgcraftLayer::new(cb);
    tracing_subscriber::registry().with(layer).init();
}

/// Replay a given PkgcraftLog object for test purposes.
///
/// # Safety
/// The argument must be a non-null PkgcraftLog pointer.
#[no_mangle]
pub unsafe extern "C" fn pkgcraft_log_test(l: *const PkgcraftLog) {
    let log = null_ptr_check!(l.as_ref());
    let message = unsafe {
        CStr::from_ptr(log.message)
            .to_str()
            .expect("invalid log message")
    };
    use LogLevel::*;
    match log.level {
        Trace => tracing::trace!("{message}"),
        Debug => tracing::debug!("{message}"),
        Info => tracing::info!("{message}"),
        Warn => tracing::warn!("{message}"),
        Error => tracing::error!("{message}"),
    }
}