Add option for enforcing single running instance

Author: Systemcluster

README.md

@@ -69,6 +69,8 @@ Options:
         Show or attach to a console window (auto, always, never, attach) [default: auto]
   -w, --current-dir <CURRENT_DIR>
         Working directory of the command (inherit, unpack, runner, command) [default: inherit]
+  -o, --once
+        Allow only one running instance
   -z, --build-dictionary
         Build compression dictionary
   -l, --list-runners
@@ -125,6 +127,7 @@ This option specifies the versioning strategy. Accepted values are:
 * `none`: Packed files are always unpacked and already unpacked files will be overwritten.
 
 It defaults to `sidebyside`. The version is determined by a unique identifier generated during the packing process or specified with the [`version-string`](#version-string) option.
+Using `replace` or `none` might cause unpacking to fail if another instance of the packed executable is already running unless the [`once`](#once) option is set.
 
 #### verification
 
@@ -172,6 +175,12 @@ This option changes the working directory of the packed executable. Accepted val
 
 It defaults to `inherit`.
 
+#### once
+
+This option prevents multiple instances of the packed executable from running at the same time. When set, the runner will check for running processes on the system and will exit immediately if a running instance of the executable is found during startup.
+
+This option currently only affects Windows and Linux runners. On Windows, if the packed executable is a GUI application, the runner will bring its window into the foreground and activate it.
+
 #### build-dictionary
 
 This option builds a zstandard compression dictionary from the input files and stores it in the output executable. This can improve the compression ratio when many small and similar files are packed.
@@ -182,7 +191,7 @@ Building a dictionary can increase the packing time and can in some cases negati
 
 ## Performance
 
-Wrappe is optimized for compression ratio and decompression speed, generally matching or outperforming other packers in terms of both. Packed files are decompressed from the memory-mapped executable directly to disk in parallel, while extraction is skipped when the files are already unpacked. This enables fast startup of packed executables with minimal overhead.
+Wrappe is optimized for compression ratio and decompression speed, generally matching or outperforming other packers in terms of both. It uses a custom metadata format designed for parallel iteration and decompression and compact storage of file information. Packed files are concurrently decompressed from the memory-mapped executable directly to disk, while extraction is skipped when the files are already unpacked to enable fast startup of packed executables with minimal overhead.
 
 > As an example, a 400 MB PyInstaller one-directory output with 1500 files packed with wrappe at maximum compression level results in a 100 MB executable that unpacks and starts in around 500 milliseconds on a modern system on the first run and instantly on subsequent runs. This is around 50% faster and only 5% larger than the same project packed by PyInstaller in one-file mode with UPX compression, which unpacks and loads into memory on every run.
 

src/main.rs

@@ -55,6 +55,9 @@ pub struct Args {
     /// Working directory of the command (inherit, unpack, runner, command)
     #[arg(short = 'w', long, default_value = "inherit")]
     current_dir:      String,
+    /// Only allow one instance of the application to run
+    #[arg(short = 'o', long, default_value = "false")]
+    once:             bool,
     /// Build compression dictionary
     #[arg(short = 'z', long, default_value = "false")]
     build_dictionary: bool,
@@ -331,6 +334,7 @@ fn main() {
         unpack_target,
         versioning,
         unpack_directory,
+        once: if args.once { 1 } else { 0 },
         command,
         arguments,
         wrappe_format: WRAPPE_FORMAT,

src/types.rs

@@ -1,6 +1,6 @@
 pub use zerocopy::AsBytes;
 
-pub const WRAPPE_FORMAT: u8 = 202;
+pub const WRAPPE_FORMAT: u8 = 203;
 pub const WRAPPE_SIGNATURE: [u8; 8] = [0x50, 0x45, 0x33, 0x44, 0x41, 0x54, 0x41, 0x00];
 pub const NAME_SIZE: usize = 128;
 pub const ARGS_SIZE: usize = 512;
@@ -16,6 +16,7 @@ pub struct StarterInfo {
     pub uid:              [u8; 16],
     pub unpack_target:    u8,
     pub versioning:       u8,
+    pub once:             u8,
     pub wrappe_format:    u8,
     pub unpack_directory: [u8; NAME_SIZE],
     pub command:          [u8; NAME_SIZE],

startpe/Cargo.toml

@@ -16,8 +16,9 @@ path = "src/main.rs"
 
 [features]
 
-default = ["prefetch"]
+default = ["prefetch", "once"]
 prefetch = []
+once = ["dep:procfs"]
 
 [profile.release]
 
@@ -34,7 +35,7 @@ strip = "symbols"
 
 dirs = "5.0.1"
 filetime = "0.2.23"
-fslock = "0.2.1"
+fslock-guard = "0.1.3"
 memchr = "2.7.2"
 memmap2 = "0.9.4"
 rayon = "1.10.0"
@@ -44,4 +45,17 @@ zstd = { version = "0.13.1", default-features = false, features = [] }
 
 [target.'cfg(windows)'.dependencies]
 
-winapi = { version = "0.3.9", features = ["wincon", "libloaderapi"] }
+windows-sys = { version = "0.52.0", features = [
+  "Win32_Foundation",
+  "Win32_System_Console",
+  "Win32_System_LibraryLoader",
+  "Win32_System_Threading",
+  "Win32_System_Diagnostics",
+  "Win32_System_Diagnostics_ToolHelp",
+  "Win32_System_ProcessStatus",
+  "Win32_UI_WindowsAndMessaging",
+] }
+
+[target.'cfg(target_os = "linux")'.dependencies]
+
+procfs = { version = "0.16.0", default-features = false, optional = true }

startpe/src/decompress.rs

@@ -12,7 +12,6 @@ use std::{
 use std::os::windows::fs::OpenOptionsExt;
 
 use filetime::{set_file_times, set_symlink_file_times, FileTime};
-use fslock::LockFile;
 use rayon::prelude::*;
 use twox_hash::XxHash64;
 use zerocopy::Ref;
@@ -197,12 +196,6 @@ pub fn decompress(
         );
     }
 
-    create_dir_all(unpack_dir)
-        .unwrap_or_else(|e| panic!("couldn't create directory {}: {}", unpack_dir.display(), e));
-
-    let mut lockfile = LockFile::open(&unpack_dir.join(LOCK_FILE)).unwrap();
-    lockfile.lock().unwrap();
-
     // verify files
     if verification > 0 && !should_extract && file_sections > 0 {
         if show_information >= 2 {

startpe/src/main.rs

@@ -1,6 +1,6 @@
 use std::{
     env::{current_exe, var_os},
-    fs::{read_link, File},
+    fs::{create_dir_all, read_link, File},
     io::Write,
     mem::size_of,
     panic::set_hook,
@@ -17,8 +17,9 @@ use std::os::unix::process::CommandExt;
 use std::process::Stdio;
 
 #[cfg(windows)]
-use winapi::um::wincon::{AttachConsole, ATTACH_PARENT_PROCESS};
+use windows_sys::Win32::System::Console::{AttachConsole, ATTACH_PARENT_PROCESS};
 
+use fslock_guard::LockFileGuard;
 use memchr::memmem;
 use memmap2::MmapOptions;
 use zerocopy::Ref;
@@ -38,6 +39,9 @@ use versioning::*;
 #[cfg(feature = "prefetch")]
 mod prefetch;
 
+#[cfg(feature = "once")]
+mod once;
+
 fn main() {
     set_hook(Box::<_>::new(move |panic| {
         if let Some(message) = panic.payload().downcast_ref::<&str>() {
@@ -194,20 +198,48 @@ fn main() {
         println!("target directory: {}", unpack_dir.display());
     }
 
-    let run_path = &unpack_dir.join(
-        std::str::from_utf8(
-            &info.command[0..(info
-                .command
-                .iter()
-                .position(|&c| c == b'\0')
-                .unwrap_or(info.command.len()))],
-        )
-        .unwrap(),
-    );
+    let command_name = std::str::from_utf8(
+        &info.command[0..(info
+            .command
+            .iter()
+            .position(|&c| c == b'\0')
+            .unwrap_or(info.command.len()))],
+    )
+    .unwrap();
+    let run_path = &unpack_dir.join(command_name);
     if show_information >= 2 {
         println!("runpath: {}", run_path.display());
     }
 
+    create_dir_all(&unpack_dir)
+        .unwrap_or_else(|e| panic!("couldn't create directory {}: {}", unpack_dir.display(), e));
+
+    let lockfile = if info.once == 1 {
+        let lockfile = LockFileGuard::try_lock(unpack_dir.join(LOCK_FILE))
+            .unwrap_or_else(|e| panic!("couldn't lock file: {}", e));
+        if lockfile.is_none() {
+            println!("another instance is already unpacking, exiting...");
+            return;
+        }
+        lockfile.unwrap()
+    } else {
+        LockFileGuard::lock(unpack_dir.join(LOCK_FILE)).unwrap_or_else(|e| {
+            panic!("couldn't lock file: {}", e);
+        })
+    };
+
+    #[cfg(feature = "once")]
+    if info.once == 1 {
+        if show_information >= 2 {
+            println!("checking for running processes...");
+        }
+        let running = once::check_instance(run_path).unwrap();
+        if running {
+            println!("another instance is already running, exiting...");
+            return;
+        }
+    }
+
     let should_extract = match info.versioning {
         0 => get_version(&unpack_dir) != version,
         1 => get_version(&unpack_dir) != version,
@@ -245,6 +277,8 @@ fn main() {
         }
     }
 
+    drop(lockfile);
+
     let baked_arguments = std::str::from_utf8(
         &info.arguments[0..(info
             .arguments

startpe/src/once.rs

@@ -0,0 +1,121 @@
+use std::path::Path;
+
+#[cfg(windows)]
+pub fn check_instance(run_path: &Path) -> Result<bool, std::io::Error> {
+    use std::{ffi::OsString, os::windows::ffi::OsStringExt};
+    use windows_sys::Win32::{
+        System::{
+            Diagnostics::ToolHelp::{
+                CreateToolhelp32Snapshot, Process32FirstW, Process32NextW, PROCESSENTRY32W,
+                TH32CS_SNAPPROCESS,
+            },
+            Threading::{
+                OpenProcess, QueryFullProcessImageNameW, PROCESS_QUERY_LIMITED_INFORMATION,
+            },
+        },
+        UI::WindowsAndMessaging::EnumWindows,
+    };
+
+    unsafe extern "system" fn enum_windows_proc(hwnd: isize, lparam: isize) -> i32 {
+        use windows_sys::Win32::UI::WindowsAndMessaging::{
+            GetWindowThreadProcessId, SetForegroundWindow, ShowWindow, SW_SHOW,
+        };
+        let mut process_id = 0;
+        unsafe {
+            GetWindowThreadProcessId(hwnd, &mut process_id);
+        }
+        if process_id == lparam as u32 {
+            unsafe { ShowWindow(hwnd, SW_SHOW) };
+            let result = unsafe { SetForegroundWindow(hwnd) };
+            if result == 0 {
+                return 1;
+            }
+            0
+        } else {
+            1
+        }
+    }
+
+    let snapshot = unsafe { CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0) };
+    if snapshot == 0 {
+        return Err(std::io::Error::last_os_error());
+    }
+    let mut entry = unsafe { std::mem::zeroed::<PROCESSENTRY32W>() };
+    entry.dwSize = std::mem::size_of::<PROCESSENTRY32W>() as u32;
+    if unsafe { Process32FirstW(snapshot, &mut entry) } != 0 {
+        let command_name = run_path.file_name().unwrap().to_os_string();
+        let mut path = [0u16; 1024];
+        loop {
+            let process_name: &[u16] = unsafe {
+                std::slice::from_raw_parts(
+                    entry.szExeFile.as_ptr().cast::<u16>(),
+                    entry
+                        .szExeFile
+                        .iter()
+                        .take(entry.szExeFile.len())
+                        .position(|&c| c == 0)
+                        .unwrap_or(entry.szExeFile.len()),
+                )
+            };
+            let process_name = OsString::from_wide(process_name);
+            if process_name == command_name {
+                let process = unsafe {
+                    OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, 0, entry.th32ProcessID)
+                };
+                let mut len = path.len() as u32;
+                let result =
+                    unsafe { QueryFullProcessImageNameW(process, 0, path.as_mut_ptr(), &mut len) };
+                if result == 0 {
+                    return Err(std::io::Error::last_os_error());
+                }
+                let path = OsString::from_wide(&path[..len as usize]);
+                if path == run_path.as_os_str() {
+                    let result =
+                        unsafe { EnumWindows(Some(enum_windows_proc), entry.th32ProcessID as _) };
+                    if result == 0 {
+                        let err = std::io::Error::last_os_error();
+                        if err.raw_os_error() != Some(0) {
+                            return Err(err);
+                        }
+                    }
+                    return Ok(true);
+                }
+            }
+            if unsafe { Process32NextW(snapshot, &mut entry) } == 0 {
+                break;
+            }
+        }
+    }
+
+    Ok(false)
+}
+
+#[cfg(target_os = "linux")]
+pub fn check_instance(run_path: &Path) -> Result<bool, std::io::Error> {
+    for proc in procfs::process::all_processes().unwrap() {
+        match proc {
+            Ok(p) => match p.exe() {
+                Ok(exe) => {
+                    if exe == run_path {
+                        return Ok(true);
+                    }
+                }
+                Err(_e) => {
+                    #[cfg(debug_assertions)]
+                    eprintln!("error: {}", _e);
+                    continue;
+                }
+            },
+            Err(_e) => {
+                #[cfg(debug_assertions)]
+                eprintln!("error: {}", _e);
+                continue;
+            }
+        }
+    }
+    Ok(false)
+}
+
+#[cfg(not(any(windows, target_os = "linux")))]
+#[inline(always)]
+pub fn check_instance(_: &Path) -> Result<bool, std::io::Error> { Ok(false) }