procref 0.1.0

//! Windows implementation using Named Semaphores.
//!
//! Windows named semaphores are kernel objects where:
//! - Each process that opens the semaphore gets a handle
//! - The kernel tracks handle reference counts
//! - When a process exits (normally or crashes), handles are auto-closed
//! - When all handles are closed, the semaphore is destroyed
//!
//! This provides automatic cleanup on process crash.

use crate::{Error, RefCounter, Result};
use std::ffi::OsStr;
use std::os::windows::ffi::OsStrExt;
use std::sync::atomic::{AtomicBool, Ordering};
use windows_sys::Win32::Foundation::{CloseHandle, GetLastError, HANDLE, WAIT_OBJECT_0};
use windows_sys::Win32::System::Threading::{
    CreateMutexW, CreateSemaphoreW, OpenMutexW, OpenSemaphoreW, ReleaseMutex, ReleaseSemaphore,
    WaitForSingleObject, MUTEX_ALL_ACCESS, SEMAPHORE_ALL_ACCESS,
};

/// Windows reference counter using named semaphores.
pub struct WindowsRefCounter {
    /// Semaphore handle for reference counting
    sem_handle: HANDLE,
    /// Mutex handle for startup lock
    mutex_handle: HANDLE,
    /// Whether we have a reference
    has_reference: AtomicBool,
    /// Whether we hold the lock
    has_lock: AtomicBool,
    /// Service name
    name: String,
}

// HANDLE is Send + Sync safe on Windows
unsafe impl Send for WindowsRefCounter {}
unsafe impl Sync for WindowsRefCounter {}

impl WindowsRefCounter {
    /// Create a new reference counter for the given service name.
    pub fn new(name: &str) -> Result<Self> {
        let sem_name = format!("Global\\procref-sem-{}", name);
        let mutex_name = format!("Global\\procref-mutex-{}", name);

        let sem_name_wide: Vec<u16> = OsStr::new(&sem_name)
            .encode_wide()
            .chain(std::iter::once(0))
            .collect();
        let mutex_name_wide: Vec<u16> = OsStr::new(&mutex_name)
            .encode_wide()
            .chain(std::iter::once(0))
            .collect();

        // Create or open semaphore
        // Initial count = 0, max count = large number
        let sem_handle = unsafe {
            CreateSemaphoreW(
                std::ptr::null(),
                0,          // Initial count
                i32::MAX,   // Maximum count
                sem_name_wide.as_ptr(),
            )
        };

        if sem_handle == 0 {
            // Try to open existing
            let sem_handle = unsafe {
                OpenSemaphoreW(SEMAPHORE_ALL_ACCESS, 0, sem_name_wide.as_ptr())
            };
            if sem_handle == 0 {
                return Err(Error::RefCounterInit(format!(
                    "Failed to create/open semaphore: {}",
                    unsafe { GetLastError() }
                )));
            }
        }

        // Create or open mutex for startup lock
        let mutex_handle = unsafe {
            CreateMutexW(std::ptr::null(), 0, mutex_name_wide.as_ptr())
        };

        if mutex_handle == 0 {
            let mutex_handle = unsafe {
                OpenMutexW(MUTEX_ALL_ACCESS, 0, mutex_name_wide.as_ptr())
            };
            if mutex_handle == 0 {
                unsafe { CloseHandle(sem_handle) };
                return Err(Error::RefCounterInit(format!(
                    "Failed to create/open mutex: {}",
                    unsafe { GetLastError() }
                )));
            }
        }

        Ok(Self {
            sem_handle,
            mutex_handle,
            has_reference: AtomicBool::new(false),
            has_lock: AtomicBool::new(false),
            name: name.to_string(),
        })
    }
}

impl RefCounter for WindowsRefCounter {
    fn acquire(&self) -> Result<u32> {
        if self.has_reference.load(Ordering::SeqCst) {
            return self.count();
        }

        // Increment semaphore count
        let mut prev_count: i32 = 0;
        let result = unsafe { ReleaseSemaphore(self.sem_handle, 1, &mut prev_count) };

        if result == 0 {
            return Err(Error::Acquire(format!(
                "ReleaseSemaphore failed: {}",
                unsafe { GetLastError() }
            )));
        }

        self.has_reference.store(true, Ordering::SeqCst);
        Ok((prev_count + 1) as u32)
    }

    fn release(&self) -> Result<u32> {
        if !self.has_reference.load(Ordering::SeqCst) {
            return self.count();
        }

        // Decrement semaphore count by waiting on it
        let result = unsafe { WaitForSingleObject(self.sem_handle, 0) };

        if result != WAIT_OBJECT_0 {
            return Err(Error::Release(format!(
                "WaitForSingleObject failed: {}",
                unsafe { GetLastError() }
            )));
        }

        self.has_reference.store(false, Ordering::SeqCst);
        self.count()
    }

    fn count(&self) -> Result<u32> {
        // Windows doesn't have a direct way to query semaphore count
        // We need to do a trick: release and immediately wait
        let mut prev_count: i32 = 0;

        // Try to release with 0 increment just to get the count
        // This won't work directly, so we use a workaround:
        // Release 1, get prev count, then wait to restore
        let result = unsafe { ReleaseSemaphore(self.sem_handle, 0, &mut prev_count) };

        // ReleaseSemaphore with 0 might not work on all Windows versions
        // Fall back to a reasonable estimate based on our state
        if result == 0 {
            // Can't get exact count, return 1 if we have reference, 0 otherwise
            return Ok(if self.has_reference.load(Ordering::SeqCst) {
                1
            } else {
                0
            });
        }

        Ok(prev_count as u32)
    }

    fn try_lock(&self) -> Result<bool> {
        if self.has_lock.load(Ordering::SeqCst) {
            return Ok(true);
        }

        // Try to acquire mutex with 0 timeout (non-blocking)
        let result = unsafe { WaitForSingleObject(self.mutex_handle, 0) };

        if result == WAIT_OBJECT_0 {
            self.has_lock.store(true, Ordering::SeqCst);
            Ok(true)
        } else {
            Ok(false)
        }
    }

    fn unlock(&self) -> Result<()> {
        if !self.has_lock.load(Ordering::SeqCst) {
            return Ok(());
        }

        let result = unsafe { ReleaseMutex(self.mutex_handle) };
        if result == 0 {
            return Err(Error::Lock(format!(
                "ReleaseMutex failed: {}",
                unsafe { GetLastError() }
            )));
        }

        self.has_lock.store(false, Ordering::SeqCst);
        Ok(())
    }
}

impl Drop for WindowsRefCounter {
    fn drop(&mut self) {
        // Release lock if held
        if self.has_lock.load(Ordering::SeqCst) {
            let _ = self.unlock();
        }

        // Close handles - kernel will clean up if we're the last holder
        unsafe {
            CloseHandle(self.sem_handle);
            CloseHandle(self.mutex_handle);
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_windows_ref_counter_basic() {
        let counter = WindowsRefCounter::new("test-procref-windows").unwrap();

        // Acquire
        let count = counter.acquire().unwrap();
        assert!(count >= 1);

        // Release
        let _ = counter.release().unwrap();
    }
}