grammpars 0.1.0

Offline conversion between Telegram Desktop tdata, Telethon, and grammers sessions
Documentation
use crate::error::{OpenteleError, Result};
use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
use std::io::{Read, Write};

/// Maximum allocation accepted from a length-prefixed Qt value.
pub const MAX_QT_VALUE_SIZE: usize = 64 * 1024 * 1024;

/// A minimal equivalent of Qt's `QByteArray`.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct QByteArray {
    /// Raw byte contents.
    pub data: Vec<u8>,
    /// Whether the value represents Qt's distinct null byte array.
    pub is_null: bool,
}

impl QByteArray {
    /// Creates a non-null byte array.
    pub fn new(data: Vec<u8>) -> Self {
        Self {
            data,
            is_null: false,
        }
    }

    /// Creates Qt's null byte-array value.
    pub fn null() -> Self {
        Self {
            data: vec![],
            is_null: true,
        }
    }
}

/// A reader for the subset of Qt's `QDataStream` used by Telegram Desktop.
pub struct QDataStream<R: Read> {
    reader: R,
}

impl<R: Read> QDataStream<R> {
    /// Wraps a reader using Qt's big-endian wire representation.
    pub fn new(reader: R) -> Self {
        Self { reader }
    }

    /// Reads a signed 32-bit integer.
    ///
    /// # Errors
    ///
    /// Returns an I/O error when the reader cannot provide four bytes.
    pub fn read_i32(&mut self) -> Result<i32> {
        self.reader
            .read_i32::<BigEndian>()
            .map_err(OpenteleError::Io)
    }

    /// Reads an unsigned 32-bit integer.
    ///
    /// # Errors
    ///
    /// Returns an I/O error when the reader cannot provide four bytes.
    pub fn read_u32(&mut self) -> Result<u32> {
        self.reader
            .read_u32::<BigEndian>()
            .map_err(OpenteleError::Io)
    }

    /// Reads an unsigned 64-bit integer.
    ///
    /// # Errors
    ///
    /// Returns an I/O error when the reader cannot provide eight bytes.
    pub fn read_u64(&mut self) -> Result<u64> {
        self.reader
            .read_u64::<BigEndian>()
            .map_err(OpenteleError::Io)
    }

    /// Reads a length-prefixed nullable byte array.
    ///
    /// # Errors
    ///
    /// Returns an error when the length prefix or payload cannot be read, or
    /// when the declared payload exceeds [`MAX_QT_VALUE_SIZE`].
    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))
    }

    /// Reads exactly `len` unprefixed bytes.
    ///
    /// # Errors
    ///
    /// Returns an I/O error when the reader ends before `len` bytes are read.
    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)
    }

    /// Reads a nullable, big-endian UTF-16 Qt string.
    ///
    /// # Errors
    ///
    /// Returns an error for unreadable input, excessive or odd byte lengths,
    /// or invalid UTF-16 data.
    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}"
            )));
        }
        // QDataStream encodes a QString length as its UTF-16 byte count.
        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()))
    }
}

/// Writer for the subset of Qt's `QDataStream` used by Telegram Desktop.
pub struct QDataStreamWriter<W: Write> {
    writer: W,
}

impl<W: Write> QDataStreamWriter<W> {
    /// Wraps a writer using Qt's big-endian wire representation.
    pub fn new(writer: W) -> Self {
        Self { writer }
    }

    /// Writes a signed 32-bit integer.
    ///
    /// # Errors
    ///
    /// Returns an I/O error when the writer rejects the encoded bytes.
    pub fn write_i32(&mut self, v: i32) -> Result<()> {
        self.writer
            .write_i32::<BigEndian>(v)
            .map_err(OpenteleError::Io)
    }

    /// Writes an unsigned 32-bit integer.
    ///
    /// # Errors
    ///
    /// Returns an I/O error when the writer rejects the encoded bytes.
    pub fn write_u32(&mut self, v: u32) -> Result<()> {
        self.writer
            .write_u32::<BigEndian>(v)
            .map_err(OpenteleError::Io)
    }

    /// Writes a length-prefixed nullable byte array.
    ///
    /// # Errors
    ///
    /// Returns an error when the payload exceeds the `u32` length range or the
    /// writer rejects the encoded value.
    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(())
    }

    /// Writes a big-endian UTF-16 Qt string.
    ///
    /// # Errors
    ///
    /// Returns an error when the encoded string exceeds the `u32` length range
    /// or the writer rejects the encoded value.
    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(())
    }

    /// Writes an unsigned 64-bit integer.
    ///
    /// # Errors
    ///
    /// Returns an I/O error when the writer rejects the encoded bytes.
    pub fn write_u64(&mut self, v: u64) -> Result<()> {
        self.writer
            .write_u64::<BigEndian>(v)
            .map_err(OpenteleError::Io)
    }

    /// Writes unprefixed raw bytes.
    ///
    /// # Errors
    ///
    /// Returns an I/O error when the writer cannot accept the complete slice.
    pub fn write_raw_data(&mut self, data: &[u8]) -> Result<()> {
        self.writer.write_all(data).map_err(OpenteleError::Io)
    }
}