bfbb 0.3.0

Library for interacting with SpongeBob SquarePants: Battle for Bikini Bottom
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

use std::borrow::Cow;

use bytemuck::CheckedBitPattern;
use process_memory::{Architecture, CopyAddress, Memory, ProcessHandle, PutAddress};

use crate::endian::EndianAware;

const GCN_BASE_ADDRESS: usize = 0x8000_0000;

/// A specialized version of `DataMember` from the `process_memory` crate,
/// meant for reading/writing to emulated GameCube memory within Dolphin.
///
/// Offsets are constructed as if they were in the GameCube's memory space.
pub(crate) struct DataMember<T> {
    offsets: Vec<usize>,
    process: ProcessHandle,
    emulated_region_address: usize,
    _phantom: std::marker::PhantomData<T>,
}

impl<T> DataMember<T> {
    #[must_use]
    pub fn new_offset(
        handle: ProcessHandle,
        emulated_region_address: usize,
        offsets: Vec<usize>,
    ) -> Self {
        Self {
            offsets,
            process: handle,
            emulated_region_address,
            _phantom: std::marker::PhantomData,
        }
    }
}

/// Provides a safe variant of `Memory::read` that will fail if it encounters an invalid bit-pattern
pub trait CheckedMemory<T>: Memory<T> {
    fn checked_read(&self) -> std::io::Result<T>;
}

impl<T: Copy + EndianAware> DataMember<T> {
    /// Read the pointed at value into a byte buffer and return it as-is.
    fn read_bytes(&self) -> std::io::Result<Vec<u8>> {
        let offset = self.get_offset()?;
        let mut buffer = vec![0u8; std::mem::size_of::<T>()];
        self.process.copy_address(offset, &mut buffer)?;
        if T::NEEDS_SWAP {
            buffer.reverse();
        }
        Ok(buffer)
    }
}

impl<T: Copy + EndianAware> Memory<T> for DataMember<T> {
    fn set_offset(&mut self, new_offsets: Vec<usize>) {
        self.offsets = new_offsets;
    }

    fn get_offset(&self) -> std::io::Result<usize> {
        // We cannot call `self.process.get_offset` as it assumes that the
        // endianness of the pointers it traverses are the same as the host
        // system, which is not the case with Dolphin running on a little endian system.

        let mut offset = 0;
        let noffsets = self.offsets.len();
        let mut copy = [0u8; Architecture::Arch32Bit as usize];
        for next_offset in self.offsets.iter().take(noffsets - 1) {
            offset += next_offset;
            offset = offset.checked_sub(GCN_BASE_ADDRESS).ok_or_else(|| {
                std::io::Error::new(
                    std::io::ErrorKind::InvalidData,
                    "Attempt to dereference an invalid pointer.",
                )
            })?;
            offset += self.emulated_region_address;
            self.process.copy_address(offset, &mut copy)?;
            offset = u32::from_be_bytes(copy) as usize;
        }

        offset += self.offsets[noffsets - 1];
        offset = offset.checked_sub(GCN_BASE_ADDRESS).ok_or_else(|| {
            std::io::Error::new(
                std::io::ErrorKind::InvalidData,
                "Attempt to dereference an invalid pointer.",
            )
        })?;
        offset += self.emulated_region_address;
        Ok(offset)
    }

    unsafe fn read(&self) -> std::io::Result<T> {
        let buffer = self.read_bytes()?;
        Ok(buffer.as_ptr().cast::<T>().read_unaligned())
    }

    fn write(&self, value: &T) -> std::io::Result<()> {
        use std::slice;
        let offset = self.get_offset()?;
        let mut buffer = Cow::Borrowed(unsafe {
            slice::from_raw_parts((value as *const T).cast::<u8>(), std::mem::size_of::<T>())
        });
        if T::NEEDS_SWAP {
            buffer.to_mut().reverse();
        }
        self.process.put_address(offset, &buffer)
    }
}

impl<T: CheckedBitPattern + EndianAware> CheckedMemory<T> for DataMember<T> {
    fn checked_read(&self) -> std::io::Result<T> {
        let buffer = self.read_bytes()?;
        let val = bytemuck::checked::try_from_bytes(&buffer[..])
            .map_err(|_| std::io::ErrorKind::InvalidData)?;
        Ok(*val)
    }
}