pub mod binxml;
pub mod gaps;
pub mod opnums;
pub mod transport;
use ms_ndr::NdrError;
pub use binxml::{decode_binxml, Event};
pub use gaps::{detect_gaps, RecordIdGap};
pub use transport::Transport;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Syntax {
pub uuid: [u8; 16],
pub ver_major: u16,
pub ver_minor: u16,
}
pub fn even6_syntax() -> Syntax {
let uuid = [
0xF7, 0xAF, 0xBE, 0xF6, 0x19, 0x1E, 0xBB, 0x4F, 0x9F, 0x8F, 0xB8, 0x9E, 0x20, 0x18, 0x33, 0x7C, ];
Syntax {
uuid,
ver_major: 1,
ver_minor: 0,
}
}
#[derive(Debug, thiserror::Error)]
pub enum EvenError {
#[error("transport: {0}")]
Transport(String),
#[error("event log server returned Win32 status {0:#010x}")]
Server(u32),
#[error("ndr underrun at pos {pos}, need {need}")]
Underrun { need: usize, pos: usize },
#[error("binxml: {0}")]
BinXml(String),
#[error("unexpected token {tok:#04x} at pos {pos}")]
UnexpectedToken { tok: u8, pos: usize },
#[error("short input, need {need} at {pos}")]
Short { need: usize, pos: usize },
#[error("protocol: {0}")]
Protocol(String),
}
impl From<NdrError> for EvenError {
fn from(e: NdrError) -> Self {
match e {
NdrError::Underrun { need, pos } => EvenError::Underrun { need, pos },
}
}
}
pub type Result<T> = std::result::Result<T, EvenError>;
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct ContextHandle(pub [u8; 20]);
impl ContextHandle {
pub const NULL: ContextHandle = ContextHandle([0u8; 20]);
pub fn is_null(&self) -> bool {
self.0 == [0u8; 20]
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct QueryHandle(pub [u8; 20]);
impl QueryHandle {
pub const NULL: QueryHandle = QueryHandle([0u8; 20]);
pub fn is_null(&self) -> bool {
self.0 == [0u8; 20]
}
}
pub struct EvenClient<T: Transport> {
pub transport: T,
}
impl<T: Transport> EvenClient<T> {
pub fn new(transport: T) -> Self {
Self { transport }
}
pub fn open_log_handle(&mut self, channel: &str, flags: u32) -> Result<ContextHandle> {
let stub = opnums::encode_open_log_handle(channel, flags);
let resp = self
.transport
.call(opnums::OPNUM_OPEN_LOG_HANDLE, &stub)
.map_err(EvenError::Transport)?;
opnums::decode_open_log_handle(&resp)
}
pub fn register_log_query(&mut self, xpath: &str, flags: u32) -> Result<QueryHandle> {
let stub = opnums::encode_register_log_query(xpath, flags);
let resp = self
.transport
.call(opnums::OPNUM_REGISTER_LOG_QUERY, &stub)
.map_err(EvenError::Transport)?;
opnums::decode_register_log_query(&resp)
}
pub fn query_next(&mut self, h: &QueryHandle, n: u32, timeout_ms: u32) -> Result<Vec<Event>> {
let stub = opnums::encode_query_next(h, n, timeout_ms);
let resp = self
.transport
.call(opnums::OPNUM_QUERY_NEXT, &stub)
.map_err(EvenError::Transport)?;
let frags = opnums::decode_query_next(&resp)?;
let mut out = Vec::with_capacity(frags.len());
for f in frags {
out.push(decode_binxml(&f)?);
}
Ok(out)
}
pub fn close(&mut self, handle: &[u8; 20]) -> Result<()> {
let stub = opnums::encode_close(handle);
let resp = self
.transport
.call(opnums::OPNUM_CLOSE, &stub)
.map_err(EvenError::Transport)?;
opnums::decode_close(&resp)
}
}