use crate::error::{OpenteleError, Result};
use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
use std::io::{Read, Write};
pub const MAX_QT_VALUE_SIZE: usize = 64 * 1024 * 1024;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct QByteArray {
pub data: Vec<u8>,
pub is_null: bool,
}
impl QByteArray {
pub fn new(data: Vec<u8>) -> Self {
Self {
data,
is_null: false,
}
}
pub fn null() -> Self {
Self {
data: vec![],
is_null: true,
}
}
}
pub struct QDataStream<R: Read> {
reader: R,
}
impl<R: Read> QDataStream<R> {
pub fn new(reader: R) -> Self {
Self { reader }
}
pub fn read_i32(&mut self) -> Result<i32> {
self.reader
.read_i32::<BigEndian>()
.map_err(OpenteleError::Io)
}
pub fn read_u32(&mut self) -> Result<u32> {
self.reader
.read_u32::<BigEndian>()
.map_err(OpenteleError::Io)
}
pub fn read_u64(&mut self) -> Result<u64> {
self.reader
.read_u64::<BigEndian>()
.map_err(OpenteleError::Io)
}
pub fn read_qbytearray(&mut self) -> Result<QByteArray> {
let len = self.read_u32()?;
if len == 0xFFFFFFFF {
return Ok(QByteArray::null());
}
if len as usize > MAX_QT_VALUE_SIZE {
return Err(OpenteleError::SizeLimit {
actual: u64::from(len),
maximum: MAX_QT_VALUE_SIZE as u64,
});
}
let mut buf = vec![0u8; len as usize];
self.reader
.read_exact(&mut buf)
.map_err(OpenteleError::Io)?;
Ok(QByteArray::new(buf))
}
pub fn read_raw_data(&mut self, len: usize) -> Result<Vec<u8>> {
let mut buf = vec![0u8; len];
self.reader
.read_exact(&mut buf)
.map_err(OpenteleError::Io)?;
Ok(buf)
}
pub fn read_qstring(&mut self) -> Result<String> {
let len = self.read_u32()?;
if len == 0xFFFFFFFF {
return Ok(String::new());
}
if len as usize > MAX_QT_VALUE_SIZE {
return Err(OpenteleError::SizeLimit {
actual: u64::from(len),
maximum: MAX_QT_VALUE_SIZE as u64,
});
}
if len % 2 != 0 {
return Err(OpenteleError::QtParseError(format!(
"QString byte length must be even, got {len}"
)));
}
let mut buf = vec![0u8; len as usize];
self.reader
.read_exact(&mut buf)
.map_err(OpenteleError::Io)?;
let u16_chars: Vec<u16> = buf
.chunks_exact(2)
.map(|chunk| u16::from_be_bytes([chunk[0], chunk[1]]))
.collect();
String::from_utf16(&u16_chars).map_err(|e| OpenteleError::QtParseError(e.to_string()))
}
}
pub struct QDataStreamWriter<W: Write> {
writer: W,
}
impl<W: Write> QDataStreamWriter<W> {
pub fn new(writer: W) -> Self {
Self { writer }
}
pub fn write_i32(&mut self, v: i32) -> Result<()> {
self.writer
.write_i32::<BigEndian>(v)
.map_err(OpenteleError::Io)
}
pub fn write_u32(&mut self, v: u32) -> Result<()> {
self.writer
.write_u32::<BigEndian>(v)
.map_err(OpenteleError::Io)
}
pub fn write_qbytearray(&mut self, qba: &QByteArray) -> Result<()> {
if qba.is_null {
self.write_u32(0xFFFFFFFF)?;
} else {
let len = u32::try_from(qba.data.len()).map_err(|_| {
OpenteleError::QtParseError("QByteArray is larger than u32::MAX".into())
})?;
self.write_u32(len)?;
self.writer
.write_all(&qba.data)
.map_err(OpenteleError::Io)?;
}
Ok(())
}
pub fn write_qstring(&mut self, s: &str) -> Result<()> {
if s.is_empty() {
self.write_u32(0)?;
return Ok(());
}
let u16_chars: Vec<u16> = s.encode_utf16().collect();
let byte_len = u16_chars
.len()
.checked_mul(2)
.and_then(|len| u32::try_from(len).ok())
.ok_or_else(|| OpenteleError::QtParseError("QString is too large".into()))?;
self.write_u32(byte_len)?;
for c in u16_chars {
self.writer
.write_u16::<BigEndian>(c)
.map_err(OpenteleError::Io)?;
}
Ok(())
}
pub fn write_u64(&mut self, v: u64) -> Result<()> {
self.writer
.write_u64::<BigEndian>(v)
.map_err(OpenteleError::Io)
}
pub fn write_raw_data(&mut self, data: &[u8]) -> Result<()> {
self.writer.write_all(data).map_err(OpenteleError::Io)
}
}