refactor: use Rust native file I/O for replay loading
Browse filesReplace 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::{
|
| 12 |
|
| 13 |
use core::ffi::c_void;
|
| 14 |
use core::fmt::Write;
|
| 15 |
use core::ptr;
|
|
|
|
|
|
|
|
|
|
|
|
|
| 16 |
|
| 17 |
-
// βββ WA CRT
|
|
|
|
|
|
|
|
|
|
| 18 |
|
| 19 |
#[allow(non_camel_case_types)]
|
| 20 |
type FILE = c_void;
|
| 21 |
|
| 22 |
-
|
| 23 |
-
|
| 24 |
-
|
| 25 |
-
|
| 26 |
-
|
| 27 |
-
|
| 28 |
-
|
| 29 |
-
|
| 30 |
-
}
|
| 31 |
-
|
| 32 |
-
|
| 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 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 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
|
| 54 |
-
impl
|
| 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 |
-
|
| 90 |
-
|
| 91 |
-
|
| 92 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 93 |
|
| 94 |
-
let mut
|
| 95 |
-
|
| 96 |
-
let
|
| 97 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 98 |
|
| 99 |
// Header
|
| 100 |
-
let
|
| 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
|
| 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
|
| 117 |
-
|
|
|
|
| 118 |
|
| 119 |
let first_dword = *(payload as *const i32);
|
| 120 |
*(s.add(0xDB1C) as *mut i32) = first_dword;
|
| 121 |
if first_dword >= 1 {
|
| 122 |
-
|
| 123 |
-
|
| 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 |
-
|
|
|
|
| 145 |
}
|
| 146 |
|
| 147 |
// βββ Version 2+: read second payload βββββββββββββββββββββββββββββββββ
|
| 148 |
|
| 149 |
-
let
|
| 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 |
-
|
| 156 |
-
|
|
|
|
| 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
|
| 168 |
-
|
| 169 |
-
|
| 170 |
-
|
| 171 |
-
|
| 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
|
| 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:
|
|
|
|
| 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 |
-
|
| 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 |
-
|
| 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 |
-
|
| 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 |
-
|
| 775 |
}
|
| 776 |
|
| 777 |
-
|
| 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;
|