chatmail-core/src/dc_log.rs

use crate::constants::Event;
use crate::dc_context::dc_context_t;
use crate::dc_tools::*;
use crate::types::*;
use crate::x::*;

pub unsafe extern "C" fn dc_log_event(
    context: &dc_context_t,
    event_code: Event,
    data1: libc::c_int,
    msg: *const libc::c_char,
    va: ...
) {
    log_vprintf(context, event_code, data1, msg, va);
}

/* Asynchronous "Thread-errors" are reported by the dc_log_error()
function.  These errors must be shown to the user by a bubble or so.

"Normal" errors are usually returned by a special value (null or so) and are
usually not reported using dc_log_error() - its up to the caller to
decide, what should be reported or done.  However, these "Normal" errors
are usually logged by dc_log_warning(). */
unsafe fn log_vprintf(
    context: &dc_context_t,
    event: Event,
    data1: libc::c_int,
    msg_format: *const libc::c_char,
    va_0: ::std::ffi::VaList,
) {
    let msg: *mut libc::c_char;
    if !msg_format.is_null() {
        let mut tempbuf: [libc::c_char; 1025] = [0; 1025];
        vsnprintf(
            tempbuf.as_mut_ptr(),
            1024i32 as libc::c_ulong,
            msg_format,
            va_0,
        );
        msg = dc_strdup(tempbuf.as_mut_ptr())
    } else {
        msg = dc_mprintf(
            b"event #%i\x00" as *const u8 as *const libc::c_char,
            event as libc::c_int,
        )
    }
    ((*context).cb)(context, event, data1 as uintptr_t, msg as uintptr_t);
    free(msg as *mut libc::c_void);
}

pub unsafe extern "C" fn dc_log_event_seq(
    context: &dc_context_t,
    event_code: Event,
    sequence_start: *mut libc::c_int,
    msg: *const libc::c_char,
    va_0: ...
) {
    if sequence_start.is_null() {
        return;
    }
    log_vprintf(context, event_code, *sequence_start, msg, va_0);
    *sequence_start = 0i32;
}

pub unsafe extern "C" fn dc_log_error(
    context: &dc_context_t,
    data1: libc::c_int,
    msg: *const libc::c_char,
    va_1: ...
) {
    log_vprintf(context, Event::ERROR, data1, msg, va_1);
}

pub unsafe extern "C" fn dc_log_warning(
    context: &dc_context_t,
    data1: libc::c_int,
    msg: *const libc::c_char,
    va_2: ...
) {
    log_vprintf(context, Event::WARNING, data1, msg, va_2);
}

pub unsafe extern "C" fn dc_log_info(
    context: &dc_context_t,
    data1: libc::c_int,
    msg: *const libc::c_char,
    va_3: ...
) {
    log_vprintf(context, Event::INFO, data1, msg, va_3);
}

#[macro_export]
macro_rules! info {
    ($ctx:expr, $data1:expr, $msg:expr) => {
        info!($ctx, $data1, $msg,)
    };
    ($ctx:expr, $data1:expr, $msg:expr, $($args:expr),* $(,)?) => {
        unsafe {
            dc_log_info(
                $ctx,
                $data1,
                std::ffi::CString::new($msg).unwrap().as_ptr(),
                $($args),*
            )
        }
    };
}

#[macro_export]
macro_rules! warn {
    ($ctx:expr, $data1:expr, $msg:expr) => {
        warn!($ctx, $data1, $msg,)
    };
    ($ctx:expr, $data1:expr, $msg:expr, $($args:expr),* $(,)?) => {
        unsafe {
            dc_log_warning(
                $ctx,
                $data1,
                std::ffi::CString::new($msg).unwrap().as_ptr(),
                $($args),*
            )
        }
    };
}

#[macro_export]
macro_rules! error {
    ($ctx:expr, $data1:expr, $msg:expr) => {
        error!($ctx, $data1, $msg,)
    };
    ($ctx:expr, $data1:expr, $msg:expr, $($args:expr),* $(,)?) => {
        unsafe {
            dc_log_error(
                $ctx,
                $data1,
                std::ffi::CString::new($msg).unwrap().as_ptr(),
                $($args),*
            )
        }
    };
}