pub(crate) use syslog::module_def;
#[pymodule(name = "syslog")]
mod syslog {
use crate::vm::{
Py, PyObjectRef, PyPayload, PyResult, VirtualMachine,
builtins::{PyStr, PyStrRef},
convert::ToPyException,
utils::ToCString,
};
use rustpython_host_env::syslog as host_syslog;
#[pyattr]
use host_syslog::{
LOG_ALERT, LOG_AUTH, LOG_CONS, LOG_CRIT, LOG_DAEMON, LOG_DEBUG, LOG_EMERG, LOG_ERR,
LOG_INFO, LOG_KERN, LOG_LOCAL0, LOG_LOCAL1, LOG_LOCAL2, LOG_LOCAL3, LOG_LOCAL4, LOG_LOCAL5,
LOG_LOCAL6, LOG_LOCAL7, LOG_LPR, LOG_MAIL, LOG_NDELAY, LOG_NEWS, LOG_NOTICE, LOG_NOWAIT,
LOG_ODELAY, LOG_PID, LOG_SYSLOG, LOG_USER, LOG_UUCP, LOG_WARNING,
};
#[cfg(not(target_os = "redox"))]
#[pyattr]
use host_syslog::{LOG_AUTHPRIV, LOG_CRON, LOG_PERROR};
#[cfg(target_vendor = "apple")]
#[pyattr]
use host_syslog::{LOG_FTP, LOG_INSTALL, LOG_LAUNCHD, LOG_NETINFO, LOG_RAS, LOG_REMOTEAUTH};
fn ident_to_utf8_cstring(
ident: &Py<PyStr>,
vm: &VirtualMachine,
) -> PyResult<alloc::ffi::CString> {
let utf8 = ident.to_str().ok_or_else(|| {
let start = ident
.as_wtf8()
.code_points()
.position(|c| c.to_char().is_none())
.unwrap_or(0);
vm.new_unicode_encode_error(
vm.ctx.new_str("utf-8"),
ident.to_owned(),
start,
start + 1,
vm.ctx.new_str("surrogates not allowed"),
)
})?;
alloc::ffi::CString::new(utf8).map_err(|err| err.to_pyexception(vm))
}
fn get_argv(vm: &VirtualMachine) -> Option<PyStrRef> {
if let Some(argv) = vm.state.config.settings.argv.first()
&& !argv.is_empty()
{
return Some(
PyStr::from(match argv.find('\\') {
Some(value) => &argv[value..],
None => argv,
})
.into_ref(&vm.ctx),
);
}
None
}
#[derive(Default, FromArgs)]
struct OpenLogArgs {
#[pyarg(any, optional)]
ident: Option<PyStrRef>,
#[pyarg(any, default)]
logoption: i32,
#[pyarg(any, default = ::LOG_USER)]
facility: i32,
}
#[pyfunction]
fn openlog(args: OpenLogArgs, vm: &VirtualMachine) -> PyResult<()> {
let logoption = args.logoption;
let facility = args.facility;
let ident = match args.ident.clone() {
Some(ident) => Some(ident_to_utf8_cstring(&ident, vm)?),
None => get_argv(vm)
.map(|argv| ident_to_utf8_cstring(&argv, vm))
.transpose()?,
}
.map(|ident| ident.into_boxed_c_str());
vm.audit("syslog.openlog", || {
let audit_ident: PyObjectRef = args.ident.map_or_else(
|| get_argv(vm).map_or_else(|| vm.ctx.none(), Into::into),
Into::into,
);
(audit_ident, logoption, facility)
})?;
host_syslog::openlog(ident, logoption, facility);
Ok(())
}
#[derive(FromArgs)]
struct SysLogArgs {
#[pyarg(positional)]
priority: PyObjectRef,
#[pyarg(positional, optional)]
message: Option<PyStrRef>,
}
#[pyfunction]
fn syslog(args: SysLogArgs, vm: &VirtualMachine) -> PyResult<()> {
let (priority, msg) = match args.message {
Some(s) => (args.priority.try_into_value(vm)?, s),
None => (LOG_INFO, args.priority.try_into_value(vm)?),
};
vm.audit("syslog.syslog", || (priority, msg.clone()))?;
if !host_syslog::is_open() {
openlog(
OpenLogArgs {
facility: LOG_USER,
..OpenLogArgs::default()
},
vm,
)?;
}
let cmsg = msg.to_cstring(vm)?;
host_syslog::syslog(priority, cmsg.as_c_str());
Ok(())
}
#[pyfunction]
fn closelog(vm: &VirtualMachine) -> PyResult<()> {
vm.audit("syslog.closelog", || ())?;
host_syslog::closelog();
Ok(())
}
#[pyfunction]
fn setlogmask(maskpri: i32, vm: &VirtualMachine) -> PyResult<i32> {
vm.audit("syslog.setlogmask", || (maskpri,))?;
Ok(host_syslog::setlogmask(maskpri))
}
#[inline]
#[pyfunction(name = "LOG_MASK")]
const fn log_mask(pri: i32) -> i32 {
host_syslog::log_mask(pri)
}
#[inline]
#[pyfunction(name = "LOG_UPTO")]
const fn log_upto(pri: i32) -> i32 {
host_syslog::log_upto(pri)
}
}