paavohtl Claude Opus 4.6 (1M context) commited on
Commit
2b1c7a8
Β·
1 Parent(s): bdd14ef

refactor: use Rust native file I/O for replay loading

Browse files

Replace WA CRT file functions with Rust std::fs::File:
- Replay file: std::fs::File::open + read_exact (was wa_fopen/wa_fread)
- playback.thm: std::fs::write (was wa_fopen/wa_fwrite/wa_fclose)
- Log output: convert WA's FILE* to Rust File via _fileno +
_get_osfhandle + FromRawHandle (ManuallyDrop to avoid closing)
- Log writes: File::write_all + flush (was wa_fputs + wa_fflush)

Removed wa_fopen, wa_fclose, wa_fread, wa_fwrite, wa_fileno,
wa_filelengthi64, wa_fputs, as_cstr, SetCurrentDirectoryA.
Simplified ReplayGuard to PayloadGuard (file no longer tracked).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

crates/openwa-wormkit/src/replacements/replay.rs CHANGED
@@ -8,37 +8,44 @@ use crate::log_line;
8
  use openwa_core::address::va;
9
  use openwa_core::engine::replay::{self, ReplayError, ReplayStream};
10
  use openwa_core::rebase::rb;
11
- use openwa_core::wa_alloc::{wa_malloc, wa_free};
12
 
13
  use core::ffi::c_void;
14
  use core::fmt::Write;
15
  use core::ptr;
 
 
 
 
16
 
17
- // ─── WA CRT wrappers (rebased addresses, NOT Rust's UCRT) ───────────────────
 
 
 
18
 
19
  #[allow(non_camel_case_types)]
20
  type FILE = c_void;
21
 
22
- unsafe fn wa_fopen(f: *const u8, m: *const u8) -> *mut FILE {
23
- core::mem::transmute::<_, unsafe extern "cdecl" fn(*const u8, *const u8) -> *mut FILE>(rb(0x5D3271))(f, m)
24
- }
25
- unsafe fn wa_fclose(s: *mut FILE) {
26
- core::mem::transmute::<_, unsafe extern "cdecl" fn(*mut FILE)>(rb(0x5D399B))(s);
27
- }
28
- unsafe fn wa_fread(b: *mut c_void, sz: u32, c: u32, f: *mut FILE) -> u32 {
29
- core::mem::transmute::<_, unsafe extern "cdecl" fn(*mut c_void, u32, u32, *mut FILE) -> u32>(rb(0x5D4531))(b, sz, c, f)
30
- }
31
- unsafe fn wa_fwrite(b: *const c_void, sz: u32, c: u32, f: *mut FILE) -> u32 {
32
- core::mem::transmute::<_, unsafe extern "cdecl" fn(*const c_void, u32, u32, *mut FILE) -> u32>(rb(0x5D3B76))(b, sz, c, f)
33
- }
34
- unsafe fn wa_fileno(s: *mut FILE) -> i32 {
35
- core::mem::transmute::<_, unsafe extern "cdecl" fn(*mut FILE) -> i32>(rb(0x5D5155))(s)
36
- }
37
- unsafe fn wa_filelengthi64(fd: i32) -> i64 {
38
- core::mem::transmute::<_, unsafe extern "cdecl" fn(i32) -> i64>(rb(0x5D4FE1))(fd)
39
  }
40
 
41
- extern "stdcall" { fn SetCurrentDirectoryA(path: *const u8) -> i32; }
 
 
 
 
 
42
 
43
  // ─── Trampoline storage ─────────────────────────────────────────────────────
44
 
@@ -48,16 +55,12 @@ static mut PARSE_POSITION_ORIG: *const () = core::ptr::null();
48
  /// Replay timestamp extracted during parsing (time_t as u32).
49
  static mut REPLAY_TIMESTAMP: u32 = 0;
50
 
51
- // ─── RAII cleanup guard ─────────────────────────────────────────────────────
52
 
53
- struct ReplayGuard { file: *mut FILE, payload: *mut u8 }
54
- impl ReplayGuard { fn new() -> Self { Self { file: ptr::null_mut(), payload: ptr::null_mut() } } }
55
- impl Drop for ReplayGuard {
56
  fn drop(&mut self) {
57
- unsafe {
58
- if !self.payload.is_null() { wa_free(self.payload); }
59
- if !self.file.is_null() { wa_fclose(self.file); }
60
- }
61
  }
62
  }
63
 
@@ -85,20 +88,33 @@ unsafe fn replay_loader_play(state: u32) -> Result<(), ReplayError> {
85
  *s.add(0xDB48) = 1;
86
  *(s.add(0xEF60) as *mut u32) = 0;
87
 
88
- // Open replay file
89
- SetCurrentDirectoryA(rb(0x88E078) as *const u8);
90
- let file = wa_fopen(s.add(0xDB60), b"rb\0".as_ptr());
91
- SetCurrentDirectoryA(rb(0x88E17D) as *const u8);
92
- if file.is_null() { return Err(ReplayError::FileNotFound); }
 
 
 
 
 
 
 
 
93
 
94
- let mut guard = ReplayGuard::new();
95
- guard.file = file;
96
- let fd = wa_fileno(file);
97
- let file_size = wa_filelengthi64(fd) as u64;
 
 
 
 
 
 
98
 
99
  // Header
100
- let mut header: u32 = 0;
101
- if wa_fread(&mut header as *mut u32 as *mut c_void, 4, 1, file) == 0 { return Err(ReplayError::InvalidFormat); }
102
  if (header & 0xFFFF) != replay::REPLAY_MAGIC as u32 { return Err(ReplayError::InvalidFormat); }
103
  let version = header >> 16;
104
  if version == 0 || version > 20 { return Err(ReplayError::VersionTooNew); }
@@ -108,19 +124,19 @@ unsafe fn replay_loader_play(state: u32) -> Result<(), ReplayError> {
108
  *(s.add(0xDB58) as *mut u32) = 0xFFFFFFFF;
109
 
110
  // First payload
111
- let mut payload_size: u32 = 0;
112
- if wa_fread(&mut payload_size as *mut u32 as *mut c_void, 4, 1, file) == 0 { return Err(ReplayError::InvalidFormat); }
113
  if (payload_size as u64 + 8) > file_size { return Err(ReplayError::InvalidFormat); }
114
  let payload = wa_malloc(payload_size);
115
  if payload.is_null() { return Err(ReplayError::MallocFailure); }
116
- guard.payload = payload;
117
- if wa_fread(payload as *mut c_void, payload_size, 1, file) == 0 { return Err(ReplayError::FileNotFound); }
 
118
 
119
  let first_dword = *(payload as *const i32);
120
  *(s.add(0xDB1C) as *mut i32) = first_dword;
121
  if first_dword >= 1 {
122
- let thm = wa_fopen(b"data\\playback.thm\0".as_ptr(), b"wb\0".as_ptr());
123
- if !thm.is_null() { wa_fwrite(payload as *const c_void, 1, payload_size, thm); wa_fclose(thm); }
124
  } else {
125
  *(s.add(0xDB20) as *mut i32) = *(payload.add(4) as *const i32);
126
  if first_dword >= -4 && first_dword < -2 {
@@ -141,19 +157,20 @@ unsafe fn replay_loader_play(state: u32) -> Result<(), ReplayError> {
141
  let _ = log_line(&format!("[Replay] Header: ver={version} payload={payload_size} sub={first_dword}"));
142
 
143
  if version == 1 {
144
- return parse_version1(state, file, &mut guard);
 
145
  }
146
 
147
  // ─── Version 2+: read second payload ─────────────────────────────────
148
 
149
- let mut second_size: u32 = 0;
150
- if wa_fread(&mut second_size as *mut u32 as *mut c_void, 4, 1, file) == 0 { return Err(ReplayError::InvalidFormat); }
151
  if (4u64 + 4 + payload_size as u64 + 4 + second_size as u64) > file_size { return Err(ReplayError::InvalidFormat); }
152
  let p2 = wa_malloc(second_size);
153
  if p2.is_null() { return Err(ReplayError::MallocFailure); }
154
  guard.payload = p2;
155
- if wa_fread(p2 as *mut c_void, second_size, 1, file) == 0 { return Err(ReplayError::InvalidFormat); }
156
- wa_fclose(file); guard.file = ptr::null_mut();
 
157
 
158
  // Parse and write to globals
159
  let data = core::slice::from_raw_parts(p2, second_size as usize);
@@ -162,14 +179,12 @@ unsafe fn replay_loader_play(state: u32) -> Result<(), ReplayError> {
162
 
163
  match result {
164
  Ok(()) => {
165
- let _ = log_line("[Replay] about to call ProcessReplayFlags");
166
  call_usercall_eax(state, rb(va::REPLAY_PROCESS_FLAGS));
167
- let _ = log_line("[Replay] ProcessReplayFlags done");
168
- let log_file = *(rb(0x88C370) as *const *mut FILE);
169
- if !log_file.is_null() {
170
- let _ = log_line("[Replay] writing log output");
171
- write_replay_log(state, log_file)?;
172
- let _ = log_line("[Replay] log output done");
173
  }
174
  let _ = log_line("[Replay] Rust replay loading complete");
175
  Ok(())
@@ -181,8 +196,7 @@ unsafe fn replay_loader_play(state: u32) -> Result<(), ReplayError> {
181
  }
182
  }
183
 
184
- unsafe fn parse_version1(state: u32, _file: *mut FILE, guard: &mut ReplayGuard) -> Result<(), ReplayError> {
185
- wa_fclose(guard.file); guard.file = ptr::null_mut();
186
  delegate_to_original(state)
187
  }
188
 
@@ -596,22 +610,11 @@ unsafe fn parse_and_write_v2plus(
596
 
597
  // ─── Log output formatting ──────────────────────────────────────────────────
598
 
599
- /// Load a string resource by ID using WA's string table.
600
- unsafe fn wa_load_string(id: u32) -> *const u8 {
601
- let f: unsafe extern "stdcall" fn(u32) -> *const u8 =
602
- core::mem::transmute(rb(0x593180));
603
- f(id)
604
- }
605
 
606
- /// Write a C string to the log file via WA's CRT fputs.
607
- unsafe fn wa_fputs(s: *const u8, file: *mut FILE) {
608
- let fputs: unsafe extern "cdecl" fn(*const u8, *mut FILE) -> i32 =
609
- core::mem::transmute(*(rb(0x649468) as *const u32));
610
- fputs(s, file);
611
- }
612
 
613
  /// Write the /getlog replay header to the log file.
614
- unsafe fn write_replay_log(state: u32, log_file: *mut FILE) -> Result<(), ReplayError> {
 
615
  let s = state as *const u8;
616
 
617
  // ── Date/time line ───────────────────────────────────────────────────
@@ -636,7 +639,7 @@ unsafe fn write_replay_log(state: u32, log_file: *mut FILE) -> Result<(), Replay
636
  "Game Started at {:04}-{:02}-{:02} {:02}:{:02}:{:02} GMT\n",
637
  tm[5] + 1900, tm[4] + 1, tm[3], tm[2], tm[1], tm[0]
638
  );
639
- wa_fputs(as_cstr(&mut s), log_file);
640
  }
641
  }
642
 
@@ -675,7 +678,7 @@ unsafe fn write_replay_log(state: u32, log_file: *mut FILE) -> Result<(), Replay
675
  let _ = write!(s, ": ");
676
  push_cstr(&mut s, format_ver_str);
677
  let _ = write!(s, "\n");
678
- wa_fputs(as_cstr(&mut s), log_file);
679
  }
680
 
681
  // ── "Exported with Version" line ─────────────────────────────────────
@@ -693,7 +696,7 @@ unsafe fn write_replay_log(state: u32, log_file: *mut FILE) -> Result<(), Replay
693
  push_cstr(&mut s, ver_literal);
694
  push_cstr(&mut s, ver_suffix);
695
  let _ = write!(s, "\n\n");
696
- wa_fputs(as_cstr(&mut s), log_file);
697
  }
698
 
699
 
@@ -771,16 +774,12 @@ unsafe fn write_replay_log(state: u32, log_file: *mut FILE) -> Result<(), Replay
771
  }
772
 
773
  let _ = write!(s, "\n");
774
- wa_fputs(as_cstr(&mut s), log_file);
775
  }
776
 
777
- wa_fputs(b"\n\0".as_ptr(), log_file);
778
-
779
- // Flush β€” use WA's CRT fflush
780
- let fflush: unsafe extern "cdecl" fn(*mut FILE) -> i32 =
781
- core::mem::transmute(rb(0x5D3792));
782
- fflush(log_file);
783
 
 
784
  Ok(())
785
  }
786
 
@@ -793,19 +792,6 @@ unsafe fn push_cstr<const N: usize>(s: &mut heapless::String<N>, cstr: *const u8
793
  }
794
  }
795
 
796
- /// Get a null-terminated pointer from a heapless::String for C interop.
797
- /// Writes a null byte at position len() in the underlying buffer.
798
- unsafe fn as_cstr<const N: usize>(s: &mut heapless::String<N>) -> *const u8 {
799
- let len = s.len();
800
- let buf = s.as_mut_ptr();
801
- // heapless::String<N> has capacity N, string uses len bytes.
802
- // Write null at position len (safe if len < N).
803
- if len < N {
804
- *buf.add(len) = 0;
805
- }
806
- buf as *const u8
807
- }
808
-
809
  /// Length of a null-terminated C string.
810
  unsafe fn c_strlen(s: *const u8) -> usize {
811
  let mut len = 0;
 
8
  use openwa_core::address::va;
9
  use openwa_core::engine::replay::{self, ReplayError, ReplayStream};
10
  use openwa_core::rebase::rb;
11
+ use openwa_core::wa_alloc::{wa_free, wa_malloc};
12
 
13
  use core::ffi::c_void;
14
  use core::fmt::Write;
15
  use core::ptr;
16
+ use std::io::Read;
17
+ use std::mem::ManuallyDrop;
18
+ use std::os::windows::io::FromRawHandle;
19
+ use std::path::Path;
20
 
21
+ // ─── WA CRT FILE* conversion ────────────────────────────────────────────────
22
+ //
23
+ // WA's CRT FILE* can't be used with Rust's std::fs::File directly, but we can
24
+ // extract the Win32 HANDLE via _fileno + _get_osfhandle and wrap it.
25
 
26
  #[allow(non_camel_case_types)]
27
  type FILE = c_void;
28
 
29
+ /// Convert a WA CRT FILE* to a borrowed Rust File (ManuallyDrop β€” we don't own it).
30
+ unsafe fn wa_file_to_rust(file: *mut FILE) -> Option<ManuallyDrop<std::fs::File>> {
31
+ let fileno: unsafe extern "cdecl" fn(*mut FILE) -> i32 =
32
+ core::mem::transmute(rb(0x5D5155));
33
+ let get_osfhandle: unsafe extern "cdecl" fn(i32) -> isize =
34
+ core::mem::transmute(rb(0x5D7273));
35
+
36
+ let fd = fileno(file);
37
+ if fd < 0 { return None; }
38
+ let handle = get_osfhandle(fd);
39
+ if handle == -1 || handle == -2 { return None; }
40
+ Some(ManuallyDrop::new(std::fs::File::from_raw_handle(handle as *mut core::ffi::c_void)))
 
 
 
 
 
41
  }
42
 
43
+ /// Load a WA string resource by ID (stdcall). Returns null-terminated C string.
44
+ unsafe fn wa_load_string(id: u32) -> *const u8 {
45
+ let f: unsafe extern "stdcall" fn(u32) -> *const u8 =
46
+ core::mem::transmute(rb(0x593180));
47
+ f(id)
48
+ }
49
 
50
  // ─── Trampoline storage ─────────────────────────────────────────────────────
51
 
 
55
  /// Replay timestamp extracted during parsing (time_t as u32).
56
  static mut REPLAY_TIMESTAMP: u32 = 0;
57
 
58
+ // ─── RAII cleanup guard (for wa_malloc'd payload) ───────────────────────────
59
 
60
+ struct PayloadGuard { payload: *mut u8 }
61
+ impl Drop for PayloadGuard {
 
62
  fn drop(&mut self) {
63
+ unsafe { if !self.payload.is_null() { wa_free(self.payload); } }
 
 
 
64
  }
65
  }
66
 
 
88
  *s.add(0xDB48) = 1;
89
  *(s.add(0xEF60) as *mut u32) = 0;
90
 
91
+ // Open replay file using Rust's std::fs::File
92
+ let replay_path = {
93
+ // Build path: game data dir + replay filename from state+0xDB60
94
+ let data_dir = std::ffi::CStr::from_ptr(rb(0x88E078) as *const i8);
95
+ let file_name = std::ffi::CStr::from_ptr(s.add(0xDB60) as *const i8);
96
+ let dir = data_dir.to_str().unwrap_or(".");
97
+ let name = file_name.to_str().unwrap_or("");
98
+ if Path::new(name).is_absolute() {
99
+ std::path::PathBuf::from(name)
100
+ } else {
101
+ Path::new(dir).join(name)
102
+ }
103
+ };
104
 
105
+ let mut file = std::fs::File::open(&replay_path)
106
+ .map_err(|_| ReplayError::FileNotFound)?;
107
+ let file_size = file.metadata().map_err(|_| ReplayError::FileNotFound)?.len();
108
+
109
+ // Helper: read exact bytes from file into a typed value
110
+ fn read_u32(f: &mut std::fs::File) -> Result<u32, ReplayError> {
111
+ let mut buf = [0u8; 4];
112
+ f.read_exact(&mut buf).map_err(|_| ReplayError::InvalidFormat)?;
113
+ Ok(u32::from_le_bytes(buf))
114
+ }
115
 
116
  // Header
117
+ let header = read_u32(&mut file)?;
 
118
  if (header & 0xFFFF) != replay::REPLAY_MAGIC as u32 { return Err(ReplayError::InvalidFormat); }
119
  let version = header >> 16;
120
  if version == 0 || version > 20 { return Err(ReplayError::VersionTooNew); }
 
124
  *(s.add(0xDB58) as *mut u32) = 0xFFFFFFFF;
125
 
126
  // First payload
127
+ let payload_size = read_u32(&mut file)?;
 
128
  if (payload_size as u64 + 8) > file_size { return Err(ReplayError::InvalidFormat); }
129
  let payload = wa_malloc(payload_size);
130
  if payload.is_null() { return Err(ReplayError::MallocFailure); }
131
+ let mut guard = PayloadGuard { payload };
132
+ let payload_slice = core::slice::from_raw_parts_mut(payload, payload_size as usize);
133
+ file.read_exact(payload_slice).map_err(|_| ReplayError::FileNotFound)?;
134
 
135
  let first_dword = *(payload as *const i32);
136
  *(s.add(0xDB1C) as *mut i32) = first_dword;
137
  if first_dword >= 1 {
138
+ // Write payload to playback.thm using Rust File
139
+ let _ = std::fs::write("data\\playback.thm", payload_slice);
140
  } else {
141
  *(s.add(0xDB20) as *mut i32) = *(payload.add(4) as *const i32);
142
  if first_dword >= -4 && first_dword < -2 {
 
157
  let _ = log_line(&format!("[Replay] Header: ver={version} payload={payload_size} sub={first_dword}"));
158
 
159
  if version == 1 {
160
+ drop(file);
161
+ return parse_version1(state);
162
  }
163
 
164
  // ─── Version 2+: read second payload ─────────────────────────────────
165
 
166
+ let second_size = read_u32(&mut file)?;
 
167
  if (4u64 + 4 + payload_size as u64 + 4 + second_size as u64) > file_size { return Err(ReplayError::InvalidFormat); }
168
  let p2 = wa_malloc(second_size);
169
  if p2.is_null() { return Err(ReplayError::MallocFailure); }
170
  guard.payload = p2;
171
+ let p2_slice = core::slice::from_raw_parts_mut(p2, second_size as usize);
172
+ file.read_exact(p2_slice).map_err(|_| ReplayError::InvalidFormat)?;
173
+ drop(file); // Done reading β€” close replay file
174
 
175
  // Parse and write to globals
176
  let data = core::slice::from_raw_parts(p2, second_size as usize);
 
179
 
180
  match result {
181
  Ok(()) => {
 
182
  call_usercall_eax(state, rb(va::REPLAY_PROCESS_FLAGS));
183
+ let wa_log_file = *(rb(0x88C370) as *const *mut FILE);
184
+ if !wa_log_file.is_null() {
185
+ if let Some(mut log_file) = wa_file_to_rust(wa_log_file) {
186
+ write_replay_log(state, &mut *log_file)?;
187
+ }
 
188
  }
189
  let _ = log_line("[Replay] Rust replay loading complete");
190
  Ok(())
 
196
  }
197
  }
198
 
199
+ unsafe fn parse_version1(state: u32) -> Result<(), ReplayError> {
 
200
  delegate_to_original(state)
201
  }
202
 
 
610
 
611
  // ─── Log output formatting ──────────────────────────────────────────────────
612
 
 
 
 
 
 
 
613
 
 
 
 
 
 
 
614
 
615
  /// Write the /getlog replay header to the log file.
616
+ unsafe fn write_replay_log(state: u32, log_file: &mut std::fs::File) -> Result<(), ReplayError> {
617
+ use std::io::Write as IoWrite;
618
  let s = state as *const u8;
619
 
620
  // ── Date/time line ───────────────────────────────────────────────────
 
639
  "Game Started at {:04}-{:02}-{:02} {:02}:{:02}:{:02} GMT\n",
640
  tm[5] + 1900, tm[4] + 1, tm[3], tm[2], tm[1], tm[0]
641
  );
642
+ let _ = log_file.write_all(s.as_bytes());
643
  }
644
  }
645
 
 
678
  let _ = write!(s, ": ");
679
  push_cstr(&mut s, format_ver_str);
680
  let _ = write!(s, "\n");
681
+ let _ = log_file.write_all(s.as_bytes());
682
  }
683
 
684
  // ── "Exported with Version" line ─────────────────────────────────────
 
696
  push_cstr(&mut s, ver_literal);
697
  push_cstr(&mut s, ver_suffix);
698
  let _ = write!(s, "\n\n");
699
+ let _ = log_file.write_all(s.as_bytes());
700
  }
701
 
702
 
 
774
  }
775
 
776
  let _ = write!(s, "\n");
777
+ let _ = log_file.write_all(s.as_bytes());
778
  }
779
 
780
+ let _ = log_file.write_all(b"\n");
 
 
 
 
 
781
 
782
+ let _ = log_file.flush();
783
  Ok(())
784
  }
785
 
 
792
  }
793
  }
794
 
 
 
 
 
 
 
 
 
 
 
 
 
 
795
  /// Length of a null-terminated C string.
796
  unsafe fn c_strlen(s: *const u8) -> usize {
797
  let mut len = 0;