lmu-shared-memory 0.1.0

Safe Rust reader for Le Mans Ultimate shared memory telemetry and standings
Documentation
use crate::{Error, Result};

#[cfg(windows)]
mod platform {
    use std::sync::atomic::{AtomicI32, Ordering};

    use super::*;
    use windows::{
        Win32::{
            Foundation::{CloseHandle, HANDLE, HWND, INVALID_HANDLE_VALUE},
            System::{
                Memory::{
                    CreateFileMappingW, FILE_MAP_ALL_ACCESS, FILE_MAP_READ,
                    MEMORY_MAPPED_VIEW_ADDRESS, MapViewOfFile, OpenFileMappingW, PAGE_READWRITE,
                    UnmapViewOfFile,
                },
                Threading::{CreateEventW, SetEvent},
            },
            UI::WindowsAndMessaging::IsWindow,
        },
        core::HSTRING,
    };

    const LOCK_MAPPING_NAME: &str = "LMU_SharedMemoryLockData";
    const LOCK_EVENT_NAME: &str = "LMU_SharedMemoryLockEvent";
    const LOCK_DATA_SIZE: usize = 8;
    const MAX_LOCK_SPINS: usize = 64;

    pub struct SharedMemory {
        name: String,
        handle: HANDLE,
        view: MEMORY_MAPPED_VIEW_ADDRESS,
        size: usize,
    }

    impl SharedMemory {
        pub fn open(name: &str, size: usize) -> Result<Self> {
            let name_wide = HSTRING::from(name);
            let handle = unsafe { OpenFileMappingW(FILE_MAP_READ.0, false, &name_wide) }.map_err(
                |error| Error::SharedMemoryUnavailable {
                    name: name.into(),
                    source: error.to_string(),
                },
            )?;
            let view = unsafe { MapViewOfFile(handle, FILE_MAP_READ, 0, 0, size) };
            if view.Value.is_null() {
                let _ = unsafe { CloseHandle(handle) };
                return Err(Error::MapViewFailed { name: name.into() });
            }
            Ok(Self {
                name: name.into(),
                handle,
                view,
                size,
            })
        }
        pub fn read<T: Copy>(&self, offset: usize) -> Result<T> {
            let value_size = std::mem::size_of::<T>();
            if offset
                .checked_add(value_size)
                .is_none_or(|end| end > self.size)
            {
                return Err(Error::OutOfBounds {
                    name: self.name.clone(),
                    offset,
                    value_size,
                    mapping_size: self.size,
                });
            }
            let pointer = unsafe { self.view.Value.cast::<u8>().add(offset).cast::<T>() };
            Ok(unsafe { pointer.read_unaligned() })
        }
        pub fn len(&self) -> usize {
            self.size
        }
        pub fn is_empty(&self) -> bool {
            self.size == 0
        }
    }
    impl Drop for SharedMemory {
        fn drop(&mut self) {
            let _ = unsafe { UnmapViewOfFile(self.view) };
            let _ = unsafe { CloseHandle(self.handle) };
        }
    }
    unsafe impl Send for SharedMemory {}
    unsafe impl Sync for SharedMemory {}

    pub fn source_window_alive(raw: u64) -> bool {
        raw != 0 && unsafe { IsWindow(Some(HWND(raw as usize as *mut _))).as_bool() }
    }

    pub struct SharedMemoryLock {
        handle: HANDLE,
        view: MEMORY_MAPPED_VIEW_ADDRESS,
        event: HANDLE,
    }
    impl SharedMemoryLock {
        pub fn open() -> Result<Self> {
            let mapping = HSTRING::from(LOCK_MAPPING_NAME);
            let handle = unsafe {
                CreateFileMappingW(
                    INVALID_HANDLE_VALUE,
                    None,
                    PAGE_READWRITE,
                    0,
                    LOCK_DATA_SIZE as u32,
                    &mapping,
                )
            }
            .map_err(|error| Error::SharedMemoryUnavailable {
                name: LOCK_MAPPING_NAME.into(),
                source: error.to_string(),
            })?;
            let view = unsafe { MapViewOfFile(handle, FILE_MAP_ALL_ACCESS, 0, 0, LOCK_DATA_SIZE) };
            if view.Value.is_null() {
                let _ = unsafe { CloseHandle(handle) };
                return Err(Error::MapViewFailed {
                    name: LOCK_MAPPING_NAME.into(),
                });
            }
            let event =
                unsafe { CreateEventW(None, false, false, &HSTRING::from(LOCK_EVENT_NAME)) }
                    .map_err(|error| Error::SharedMemoryUnavailable {
                        name: LOCK_EVENT_NAME.into(),
                        source: error.to_string(),
                    })?;
            Ok(Self {
                handle,
                view,
                event,
            })
        }
        pub fn try_lock(&self) -> Option<SharedMemoryGuard<'_>> {
            for _ in 0..MAX_LOCK_SPINS {
                if self
                    .busy()
                    .compare_exchange(0, 1, Ordering::Acquire, Ordering::Relaxed)
                    .is_ok()
                {
                    return Some(SharedMemoryGuard { lock: self });
                }
                std::hint::spin_loop();
            }
            None
        }
        fn waiters(&self) -> &AtomicI32 {
            unsafe { &*self.view.Value.cast::<AtomicI32>() }
        }
        fn busy(&self) -> &AtomicI32 {
            unsafe { &*self.view.Value.cast::<u8>().add(4).cast::<AtomicI32>() }
        }
    }
    impl Drop for SharedMemoryLock {
        fn drop(&mut self) {
            let _ = unsafe { CloseHandle(self.event) };
            let _ = unsafe { UnmapViewOfFile(self.view) };
            let _ = unsafe { CloseHandle(self.handle) };
        }
    }
    unsafe impl Send for SharedMemoryLock {}
    unsafe impl Sync for SharedMemoryLock {}
    pub struct SharedMemoryGuard<'a> {
        lock: &'a SharedMemoryLock,
    }
    impl Drop for SharedMemoryGuard<'_> {
        fn drop(&mut self) {
            self.lock.busy().store(0, Ordering::Release);
            if self.lock.waiters().load(Ordering::Acquire) > 0 {
                let _ = unsafe { SetEvent(self.lock.event) };
            }
        }
    }
}

#[cfg(not(windows))]
mod platform {
    use super::*;
    pub struct SharedMemory;
    pub struct SharedMemoryLock;
    pub struct SharedMemoryGuard;
    pub fn source_window_alive(_: u64) -> bool {
        false
    }
    impl SharedMemory {
        pub fn open(_: &str, _: usize) -> Result<Self> {
            Err(Error::UnsupportedPlatform)
        }
        pub fn read<T: Copy>(&self, _: usize) -> Result<T> {
            Err(Error::UnsupportedPlatform)
        }
        pub fn len(&self) -> usize {
            0
        }
        pub fn is_empty(&self) -> bool {
            true
        }
    }
    impl SharedMemoryLock {
        pub fn open() -> Result<Self> {
            Err(Error::UnsupportedPlatform)
        }
        pub fn try_lock(&self) -> Option<SharedMemoryGuard> {
            None
        }
    }
}

pub(crate) use platform::source_window_alive;
pub use platform::{SharedMemory, SharedMemoryGuard, SharedMemoryLock};