use crate::{ContextHandle, EvenError, QueryHandle, Result};
use ms_ndr::{NdrDecoder, NdrEncoder};
pub const OPNUM_OPEN_LOG_HANDLE: u16 = 0;
pub const OPNUM_REGISTER_LOG_QUERY: u16 = 5;
pub const OPNUM_QUERY_NEXT: u16 = 11;
pub const OPNUM_CLOSE: u16 = 13;
pub fn encode_open_log_handle(channel: &str, flags: u32) -> Vec<u8> {
let mut e = NdrEncoder::new();
e.conformant_varying_wstr(channel);
e.u32(flags);
e.into_bytes()
}
pub fn decode_open_log_handle(resp: &[u8]) -> Result<ContextHandle> {
let mut d = NdrDecoder::new(resp);
let mut h = [0u8; 20];
let attrs = d.u32()?;
let uuid = d.uuid()?;
h[..4].copy_from_slice(&attrs.to_le_bytes());
h[4..].copy_from_slice(&uuid);
if let Ok(status) = d.u32() {
if status != 0 {
return Err(EvenError::Server(status));
}
}
Ok(ContextHandle(h))
}
pub fn encode_register_log_query(xpath: &str, flags: u32) -> Vec<u8> {
let mut e = NdrEncoder::new();
e.u32(0); e.conformant_varying_wstr(xpath);
e.u32(flags);
e.into_bytes()
}
pub fn decode_register_log_query(resp: &[u8]) -> Result<QueryHandle> {
let mut d = NdrDecoder::new(resp);
let attrs = d.u32()?;
let uuid = d.uuid()?;
let mut h = [0u8; 20];
h[..4].copy_from_slice(&attrs.to_le_bytes());
h[4..].copy_from_slice(&uuid);
if resp.len() >= 20 + 4 {
let n = resp.len();
let status = u32::from_le_bytes([resp[n - 4], resp[n - 3], resp[n - 2], resp[n - 1]]);
if status != 0 && status != attrs {
}
}
Ok(QueryHandle(h))
}
pub fn encode_query_next(h: &QueryHandle, n: u32, timeout_ms: u32) -> Vec<u8> {
let mut e = NdrEncoder::new();
e.bytes(&h.0);
e.u32(n);
e.u32(timeout_ms);
e.u32(0); e.into_bytes()
}
pub fn decode_query_next(resp: &[u8]) -> Result<Vec<Vec<u8>>> {
let mut d = NdrDecoder::new(resp);
let n = d.u32()? as usize;
if n == 0 {
return Ok(Vec::new());
}
let mut indices = Vec::with_capacity(n);
let mut sizes = Vec::with_capacity(n);
let _ref_idx = d.u32()?;
let _max_idx = d.u32()?;
for _ in 0..n {
indices.push(d.u32()?);
}
let _ref_sz = d.u32()?;
let _max_sz = d.u32()?;
for _ in 0..n {
sizes.push(d.u32()?);
}
let _result_buffer_size = d.u32()?;
let _ref_rb = d.u32()?;
let _max_rb = d.u32()?;
let mut out = Vec::with_capacity(n);
for i in 0..n {
let off = indices[i] as usize;
let sz = sizes[i] as usize;
let base = d.position();
let start = base + off;
let end = start.checked_add(sz).ok_or(EvenError::Short {
need: sz,
pos: start,
})?;
if end > resp.len() {
return Err(EvenError::Short {
need: end - resp.len(),
pos: resp.len(),
});
}
out.push(resp[start..end].to_vec());
}
Ok(out)
}
pub fn encode_close(handle: &[u8; 20]) -> Vec<u8> {
let mut e = NdrEncoder::new();
e.bytes(handle);
e.into_bytes()
}
pub fn decode_close(resp: &[u8]) -> Result<()> {
let mut d = NdrDecoder::new(resp);
if resp.len() >= 20 {
let _ = d.u32()?;
let _ = d.uuid()?;
}
if let Ok(status) = d.u32() {
if status != 0 {
return Err(EvenError::Server(status));
}
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn open_log_handle_encodes_ndr_shape() {
let bytes = encode_open_log_handle("Security", 1);
assert_eq!(bytes.len(), 36);
assert_eq!(&bytes[0..4], &9u32.to_le_bytes());
assert_eq!(&bytes[4..8], &0u32.to_le_bytes());
assert_eq!(&bytes[8..12], &9u32.to_le_bytes());
assert_eq!(&bytes[12..14], &(b'S' as u16).to_le_bytes());
assert_eq!(&bytes[32..36], &1u32.to_le_bytes());
}
#[test]
fn close_encode_decode_roundtrip() {
let h = [0xAAu8; 20];
let enc = encode_close(&h);
assert_eq!(enc, vec![0xAA; 20]);
let mut reply = vec![0u8; 20];
reply.extend_from_slice(&0u32.to_le_bytes());
assert!(decode_close(&reply).is_ok());
let mut reply2 = vec![0u8; 20];
reply2.extend_from_slice(&0x8007_0005u32.to_le_bytes());
assert!(matches!(
decode_close(&reply2),
Err(EvenError::Server(0x8007_0005))
));
}
}