Skip to main content

mysql_replication/protocol/mysql/
file.rs

1//! Bounded, reusable offline binlog framing. Truncated tails are errors, never EOF.
2use crate::protocol::mysql::event_type as event;
3use crate::{Error, Result, error::invalid, protocol::mysql::wire::Cursor};
4use std::io::Read;
5
6pub const MAX_EVENT_BYTES: usize = 64 * 1024 * 1024;
7
8#[derive(Debug, Clone, Copy)]
9pub struct EventView<'a> {
10    /// Raw MySQL event code; compare with constants in [`crate::protocol::mysql::event_type`].
11    pub event_type: u8,
12    pub flags: u16,
13    pub log_pos: u32,
14    pub data: &'a [u8],
15}
16
17pub struct BinlogFile<R> {
18    reader: R,
19    buffer: Vec<u8>,
20    crc32: Option<bool>,
21}
22impl<R: Read> BinlogFile<R> {
23    pub fn new(mut reader: R) -> Result<Self> {
24        let mut magic = [0; 4];
25        reader.read_exact(&mut magic)?;
26        if magic != [0xfe, b'b', b'i', b'n'] {
27            return Err(invalid("binlog magic"));
28        }
29        Ok(Self {
30            reader,
31            buffer: Vec::new(),
32            crc32: None,
33        })
34    }
35    pub fn next_event(&mut self) -> Result<Option<EventView<'_>>> {
36        let mut header = [0; 19];
37        loop {
38            match self.reader.read(&mut header[..1]) {
39                Ok(0) => {
40                    return if self.crc32.is_some() {
41                        Ok(None)
42                    } else {
43                        Err(invalid("binlog has no FORMAT_DESCRIPTION"))
44                    };
45                }
46                Ok(_) => break,
47                Err(e) if e.kind() == std::io::ErrorKind::Interrupted => continue,
48                Err(e) => return Err(e.into()),
49            }
50        }
51        self.reader.read_exact(&mut header[1..])?;
52        let mut cursor = Cursor::new(&header);
53        cursor.take(4)?;
54        let event_type = cursor.byte()?;
55        cursor.take(4)?;
56        let len = cursor.le(4)? as usize;
57        let log_pos = cursor.le(4)? as u32;
58        let flags = cursor.le(2)? as u16;
59        if !(19..=MAX_EVENT_BYTES).contains(&len) {
60            return Err(invalid("event size outside 19..64MiB"));
61        }
62        self.buffer.resize(len - 19, 0);
63        self.reader.read_exact(&mut self.buffer)?;
64        let is_fde = event_type == event::FORMAT_DESCRIPTION_EVENT;
65        if is_fde {
66            // Supported servers (5.7+) always store the algorithm byte + 4-byte
67            // trailer in FDE, including when binlog_checksum=NONE.
68            if self.buffer.len() < 57 + 32 + 5 {
69                return Err(invalid("short FORMAT_DESCRIPTION"));
70            }
71            let alg = self.buffer[self.buffer.len() - 5];
72            self.crc32 = Some(match alg {
73                0 => false,
74                1 => true,
75                _ => return Err(Error::Unsupported(format!("checksum algorithm {alg}"))),
76            });
77        }
78        let crc32 = self
79            .crc32
80            .ok_or_else(|| invalid("offline binlog must begin with FORMAT_DESCRIPTION"))?;
81        let trailer = if is_fde {
82            5
83        } else if crc32 {
84            4
85        } else {
86            0
87        };
88        let body_len = self
89            .buffer
90            .len()
91            .checked_sub(trailer)
92            .ok_or_else(|| invalid("missing checksum"))?;
93        if crc32 {
94            let mut hash = crc32fast::Hasher::new();
95            if is_fde {
96                header[17] &= !1;
97            }
98            hash.update(&header);
99            hash.update(&self.buffer[..self.buffer.len() - 4]);
100            let mut checksum = Cursor::new(&self.buffer[self.buffer.len() - 4..]);
101            if u64::from(hash.finalize()) != checksum.le(4)? {
102                return Err(Error::Checksum);
103            }
104        }
105        Ok(Some(EventView {
106            event_type,
107            flags,
108            log_pos,
109            data: &self.buffer[..body_len],
110        }))
111    }
112}
113
114pub fn validate_format(body: &[u8]) -> Result<()> {
115    let format = crate::protocol::mysql::version::FormatDescription::parse(body)?;
116    crate::protocol::mysql::version::VersionRegistry::default()
117        .resolve(&format.server, None)?
118        .validate_format(&format)
119}