use std::io::{self, Read, Write}; #[cfg(windows)] pub mod pipe; pub mod identity; pub mod sdk; pub const MAX_FRAME_BYTES: usize = 64 * 1024; const OVERHEAD: usize = 4 + 4 + 1; pub fn wait_for_game( child: &mut std::process::Child, handshake: std::sync::mpsc::Receiver>, ) -> io::Result { use std::sync::mpsc::RecvTimeoutError; loop { match handshake.recv_timeout(std::time::Duration::from_millis(10)) { Ok(Ok(())) => return child.wait(), result @ (Ok(Err(_)) | Err(RecvTimeoutError::Disconnected)) => { let error = match result { Ok(Err(error)) => error, _ => io::Error::new( io::ErrorKind::BrokenPipe, "Rockstar handshake worker stopped", ), }; let _ = child.kill(); child.wait()?; return Err(error); } Err(RecvTimeoutError::Timeout) => { if let Some(status) = child.try_wait()? { return Ok(status); } } } } } #[derive(Clone, Copy)] pub enum Length { Total, Body, } impl Length { fn header_bytes(self) -> usize { match self { Self::Total => 0, Self::Body => 4, } } } #[derive(Debug, PartialEq, Eq)] pub struct Frame { pub tag: [u8; 4], pub payload: Vec, pub nul_terminated: bool, } fn invalid(message: &'static str) -> io::Error { io::Error::new(io::ErrorKind::InvalidData, message) } impl Frame { pub fn read(reader: &mut impl Read, length: Length) -> io::Result { let mut header = [0; 4]; reader.read_exact(&mut header)?; let size = (u32::from_le_bytes(header) as usize) .checked_add(length.header_bytes()) .ok_or_else(|| invalid("invalid Rockstar pipe frame length"))?; if !(OVERHEAD..=MAX_FRAME_BYTES).contains(&size) { return Err(invalid("invalid Rockstar pipe frame length")); } let mut body = vec![0; size - header.len()]; reader.read_exact(&mut body)?; let nul_terminated = body.last() == Some(&0); let end = body.len() - usize::from(nul_terminated); if body[4] != b':' || body[..4].contains(&b':') || body[..end].contains(&0) { return Err(invalid("invalid Rockstar pipe frame envelope")); } Ok(Self { tag: body[..4].try_into().unwrap(), payload: body[5..end].to_vec(), nul_terminated, }) } pub fn write(&self, writer: &mut impl Write, length: Length) -> io::Result<()> { let size = self .payload .len() .checked_add(OVERHEAD + usize::from(self.nul_terminated)) .filter(|size| *size <= MAX_FRAME_BYTES) .ok_or_else(|| invalid("Rockstar pipe frame exceeds size limit"))?; if self.tag.contains(&0) || self.tag.contains(&b':') || self.payload.contains(&0) { return Err(invalid("Rockstar pipe frame contains a delimiter")); } let mut encoded = Vec::with_capacity(size); encoded.extend_from_slice(&((size - length.header_bytes()) as u32).to_le_bytes()); encoded.extend_from_slice(&self.tag); encoded.push(b':'); encoded.extend_from_slice(&self.payload); if self.nul_terminated { encoded.push(0); } writer.write_all(&encoded)?; writer.flush() } } #[cfg(test)] mod tests { use super::*; #[test] fn launcher_era_reply_uses_total_length_and_a_terminator() { let mut bytes = Vec::new(); Frame { tag: *b"DUNN", payload: vec![b'A'; 640], nul_terminated: true, } .write(&mut bytes, Length::Total) .unwrap(); assert_eq!(bytes.len(), 650); assert_eq!(&bytes[..9], &[138, 2, 0, 0, b'D', b'U', b'N', b'N', b':']); assert_eq!(bytes[649], 0); } use std::io::Cursor; #[test] #[ignore] fn sleeping_game() { std::thread::sleep(std::time::Duration::from_secs(30)); } fn sleeping_child() -> std::process::Child { std::process::Command::new(std::env::current_exe().unwrap()) .args(["--exact", "tests::sleeping_game", "--ignored"]) .stdout(std::process::Stdio::null()) .stderr(std::process::Stdio::null()) .spawn() .unwrap() } #[test] fn failed_handshake_terminates_and_reaps_the_game() { let mut child = sleeping_child(); let (sender, receiver) = std::sync::mpsc::channel(); sender .send(Err(io::Error::new(io::ErrorKind::TimedOut, "test timeout"))) .unwrap(); let start = std::time::Instant::now(); assert_eq!( wait_for_game(&mut child, receiver).unwrap_err().kind(), io::ErrorKind::TimedOut ); assert!(start.elapsed() < std::time::Duration::from_secs(3)); assert!(child.try_wait().unwrap().is_some()); } #[test] fn stopped_handshake_worker_terminates_and_reaps_the_game() { let mut child = sleeping_child(); let (sender, receiver) = std::sync::mpsc::channel(); drop(sender); assert_eq!( wait_for_game(&mut child, receiver).unwrap_err().kind(), io::ErrorKind::BrokenPipe ); assert!(child.try_wait().unwrap().is_some()); } #[test] fn an_exited_game_does_not_wait_for_its_handshake() { let mut child = std::process::Command::new(std::env::current_exe().unwrap()) .args(["--exact", "no_test_with_this_name"]) .stdout(std::process::Stdio::null()) .stderr(std::process::Stdio::null()) .spawn() .unwrap(); let (_sender, receiver) = std::sync::mpsc::channel(); assert!(wait_for_game(&mut child, receiver).unwrap().success()); } struct Fragmented(T); impl Read for Fragmented { fn read(&mut self, buffer: &mut [u8]) -> io::Result { let size = buffer.len().min(1); self.0.read(&mut buffer[..size]) } } impl Write for Fragmented { fn write(&mut self, buffer: &[u8]) -> io::Result { self.0.write(&buffer[..buffer.len().min(1)]) } fn flush(&mut self) -> io::Result<()> { self.0.flush() } } #[test] fn reads_observed_greeting_across_partial_reads() { let bytes = b"\x0a\0\0\0COLE:\0"; assert_eq!( Frame::read(&mut Fragmented(&bytes[..]), Length::Total).unwrap(), Frame { tag: *b"COLE", payload: Vec::new(), nul_terminated: true, } ); } #[test] fn writes_the_observed_total_length_even_with_partial_writes() { let mut bytes = Fragmented(Vec::new()); Frame { tag: *b"COLE", payload: Vec::new(), nul_terminated: true, } .write(&mut bytes, Length::Total) .unwrap(); assert_eq!(bytes.0, b"\x0a\0\0\0COLE:\0"); } #[test] fn keeps_colons_in_payload_and_leaves_the_next_frame_unread() { let frame = Frame { tag: *b"DUNN", payload: b"one:two".to_vec(), nul_terminated: false, }; let mut bytes = Vec::new(); frame.write(&mut bytes, Length::Total).unwrap(); bytes.extend_from_slice(b"\x0a\0\0\0COLE:\0"); let mut reader = Cursor::new(bytes); assert_eq!(Frame::read(&mut reader, Length::Total).unwrap(), frame); assert_eq!( Frame::read(&mut reader, Length::Total).unwrap().tag, *b"COLE" ); } #[test] fn rejects_invalid_lengths_before_reading_a_body() { for size in [0u32, 4, 8, MAX_FRAME_BYTES as u32 + 1, u32::MAX] { let mut reader = Cursor::new(size.to_le_bytes()); assert_eq!( Frame::read(&mut reader, Length::Total).unwrap_err().kind(), io::ErrorKind::InvalidData ); assert_eq!(reader.position(), 4); } } #[test] fn rejects_truncated_or_malformed_frames() { for bytes in [&b"\x0a\0\0"[..], &b"\x0a\0\0\0COLE:"[..]] { assert_eq!( Frame::read(&mut &bytes[..], Length::Total) .unwrap_err() .kind(), io::ErrorKind::UnexpectedEof ); } for bytes in [ b"\x0a\0\0\0COLE=\0", b"\x0a\0\0\0CO:E:x", b"\x0a\0\0\0CO\0E:\0", ] { assert_eq!( Frame::read(&mut &bytes[..], Length::Total) .unwrap_err() .kind(), io::ErrorKind::InvalidData ); } } #[test] fn rejects_invalid_output_before_writing_any_bytes() { let mut bytes = Vec::new(); for frame in [ Frame { tag: *b"DUNN", payload: vec![b'x'; MAX_FRAME_BYTES], nul_terminated: false, }, Frame { tag: *b"DUNN", payload: b"one\0two".to_vec(), nul_terminated: false, }, Frame { tag: *b"CO:E", payload: Vec::new(), nul_terminated: false, }, ] { assert!(frame.write(&mut bytes, Length::Total).is_err()); assert!(bytes.is_empty()); } } #[test] fn accepts_the_observed_unterminated_launch_reply_shape() { let payload = vec![b'A'; 640]; let mut bytes = 645u32.to_le_bytes().to_vec(); bytes.extend_from_slice(b"DUNN:"); bytes.extend_from_slice(&payload); let frame = Frame::read(&mut Fragmented(&bytes[..]), Length::Body).unwrap(); assert_eq!(bytes.len(), 649); assert_eq!(frame.tag, *b"DUNN"); assert_eq!(frame.payload, payload); assert!(!frame.nul_terminated); let mut encoded = Vec::new(); frame.write(&mut encoded, Length::Body).unwrap(); assert_eq!(encoded, bytes); } #[test] fn presents_a_complete_reply_to_the_pipe_in_one_write() { struct Writes(Vec); impl Write for Writes { fn write(&mut self, bytes: &[u8]) -> io::Result { self.0.push(bytes.len()); Ok(bytes.len()) } fn flush(&mut self) -> io::Result<()> { Ok(()) } } let mut writer = Writes(Vec::new()); Frame { tag: *b"DUNN", payload: vec![b'A'; 640], nul_terminated: false, } .write(&mut writer, Length::Body) .unwrap(); assert_eq!(writer.0, vec![649]); } }