Update dependency (#738)

kernalix7 · Riey · web-flow · commit 230a8cda6487 · 2026-01-15T15:12:53.000+09:00
* Update cargo dependency versions
- strum 0.24 → 0.26
- enumset 1.0 → 1.1
- num-derive 0.3 → 0.4
- xdg 2.2 → 2.5
- ctrlc 3.1 → 3.4
- fontdb 0.11 → 0.23
- criterion 0.4 → 0.8
- pretty_assertions 1.0 → 1.4
- Normalize version format in Cargo.toml files
- bitflags 1.2 → 2.10: add explicit derive macros
- nix 0.26 → 0.30: migrate RawFd to BorrowedFd
- strum 0.26 → 0.27

* Update unmaintained crates
- kime-check: ansi_term → owo-colors
- kime: daemonize → nix::unistd::daemon()

* add PID file locking with Flock

* EWOULDBLOCK error processing

segmentation error message

Co-authored-by: Riey &lt;creeper844@gmail.com&gt;
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/src/engine/backend/Cargo.toml b/src/engine/backend/Cargo.toml
@@ -6,8 +6,8 @@ edition = "2021"
 license = "GPL-3.0-or-later"
 
 [dependencies]
-bitflags = "1.2.1"
+bitflags = "2.10"
 enum-map = "2"
-enumset = { version = "1", features = ["serde"] }
+enumset = { version = "1.1", features = ["serde"] }
 serde = { version = "1", features = ["derive"] }
-strum = { version = "0.24", features = ["derive"] }
+strum = { version = "0.27", features = ["derive"] }
diff --git a/src/engine/backend/src/input_result.rs b/src/engine/backend/src/input_result.rs
@@ -1,4 +1,5 @@
 bitflags::bitflags! {
+    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
     #[repr(transparent)]
     pub struct InputResult: u32 {
         const CONSUMED = 0b1;
diff --git a/src/engine/backend/src/keycode.rs b/src/engine/backend/src/keycode.rs
@@ -8,6 +8,7 @@ use serde::{
 use strum::{Display, EnumString};
 
 bitflags::bitflags! {
+    #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
     #[repr(transparent)]
     pub struct ModifierState: u32 {
         const SHIFT = 0x1;
diff --git a/src/engine/backends/hangul/Cargo.toml b/src/engine/backends/hangul/Cargo.toml
@@ -7,11 +7,11 @@ license = "GPL-3.0-or-later"
 
 [dependencies]
 kime-engine-backend = { path = "../../backend" }
-enumset = "1.0.6"
-num-derive = "0.3.3"
-num-traits = "0.2.14"
-serde = { version = "1.0.124", features = ["derive"] }
+enumset = "1.1"
+num-derive = "0.4"
+num-traits = "0.2"
+serde = { version = "1.0", features = ["derive"] }
 serde_yaml = "0.9"
 
 [target.'cfg(unix)'.dependencies]
-xdg = "2.2.0"
+xdg = "2.5"
diff --git a/src/engine/candidate/Cargo.toml b/src/engine/candidate/Cargo.toml
@@ -9,4 +9,4 @@ license = "GPL-3.0-or-later"
 kime-engine-dict = { path = "../dict" }
 
 [dependencies]
-nix = "0.26.1"
+nix = { version = "0.30", features = ["poll"] }
diff --git a/src/engine/candidate/src/client.rs b/src/engine/candidate/src/client.rs
@@ -1,14 +1,13 @@
-use nix::poll;
+use nix::poll::{self, PollFd, PollFlags, PollTimeout};
 use std::fmt;
 use std::io::{self, BufWriter, Write};
-use std::os::unix::io::{AsRawFd, RawFd};
+use std::os::unix::io::{AsFd, BorrowedFd};
 use std::process::{Child, Stdio};
 
 pub const CANDIDATE_PROCESS_NAME: &str = "kime-candidate-window";
 
 pub struct Client {
     child: Child,
-    stdout_fd: RawFd,
 }
 
 impl Client {
@@ -32,14 +31,13 @@ impl Client {
 
         drop(stdin);
 
-        let stdout_fd = child.stdout.as_ref().unwrap().as_raw_fd();
-
-        Ok(Self { stdout_fd, child })
+        Ok(Self { child })
     }
 
     pub fn is_ready(&self) -> bool {
-        let fds = &mut [poll::PollFd::new(self.stdout_fd, poll::PollFlags::POLLIN)];
-        poll::poll(fds, 200) == Ok(1)
+        let stdout: BorrowedFd = self.child.stdout.as_ref().unwrap().as_fd();
+        let fds = &mut [PollFd::new(stdout, PollFlags::POLLIN)];
+        poll::poll(fds, PollTimeout::from(200u16)) == Ok(1)
     }
 
     pub fn close(mut self) -> io::Result<Option<String>> {
diff --git a/src/engine/config/Cargo.toml b/src/engine/config/Cargo.toml
@@ -12,8 +12,8 @@ config-serde = ["serde", "enumset/serde", "log/serde"]
 kime-engine-backend = { path = "../backend" }
 kime-engine-backend-hangul = { path = "../backends/hangul" }
 kime-engine-backend-latin = { path = "../backends/latin" }
-log = "0.4.14"
-serde = { version = "1.0.124", features = ["derive"], optional = true }
-enumset = "1.0.6"
+log = "0.4"
+serde = { version = "1.0", features = ["derive"], optional = true }
+enumset = "1.1"
 enum-map = "2"
-maplit = "1.0.2"
+maplit = "1.0"
diff --git a/src/engine/core/Cargo.toml b/src/engine/core/Cargo.toml
@@ -15,15 +15,15 @@ kime-engine-backend-math = { path = "../backends/math", optional = true }
 kime-engine-backend-emoji = { path = "../backends/emoji", optional = true }
 serde_yaml = "0.9"
 parking_lot = "0.12"
-fontdb = { version = "0.11.2", features = ["fontconfig"] }
+fontdb = { version = "0.23", features = ["fontconfig"] }
 
 [target.'cfg(unix)'.dependencies]
-xdg = "2.2.0"
+xdg = "2.5"
 kime-run-dir = { path = "../../tools/run_dir" }
 
 [dev-dependencies]
-criterion = "0.4"
-pretty_assertions = "1.0.0"
+criterion = "0.8"
+pretty_assertions = "1.4"
 
 [[bench]]
 name = "call_key"
diff --git a/src/frontends/wayland/Cargo.toml b/src/frontends/wayland/Cargo.toml
@@ -17,8 +17,8 @@ wayland-protocols = { version = "0.29", features = [
 zwp-virtual-keyboard = "0.2.7"
 xkbcommon = { version = "0.7.0", features = ["wayland"] }
 
-libc = "0.2.82"
-log = "0.4.13"
-pico-args = "0.5.0"
+libc = "0.2"
+log = "0.4"
+pico-args = "0.5"
 mio = { version = "0.7", features = ["os-ext"] }
 mio-timerfd = "0.2"
diff --git a/src/frontends/xim/Cargo.toml b/src/frontends/xim/Cargo.toml
@@ -14,7 +14,7 @@ xim = { version = "0.2", default-features = false, features = ["x11rb-server"] }
 # xim = { path = "../../../../xim-rs", default-features = false, features = ["x11rb-server", "x11rb-xcb"] }
 
 ahash = "0.8"
-log = "0.4.11"
+log = "0.4"
 x11rb = { version = "0.11.0", features = [
     "render",
     "image",
diff --git a/src/tools/check/Cargo.toml b/src/tools/check/Cargo.toml
@@ -6,9 +6,9 @@ edition = "2021"
 license = "GPL-3.0-or-later"
 
 [dependencies]
-ansi_term = "0.12.1"
+owo-colors = "4"
 kime-engine-core = { path = "../../engine/core" }
 pad = "0.1.6"
 serde_yaml = "0.9"
-strum = { version = "0.24", features = ["derive"] }
-xdg = "2.2.0"
+strum = { version = "0.26", features = ["derive"] }
+xdg = "2.5"
diff --git a/src/tools/check/src/main.rs b/src/tools/check/src/main.rs
@@ -1,7 +1,7 @@
 use kime_engine_core::{load_engine_config_from_config_dir, Key, KeyCode, KeyMap};
 
-use ansi_term::Color;
 use kime_engine_core::{Config, InputCategory, InputEngine, InputResult};
+use owo_colors::{OwoColorize, Style};
 use pad::PadStr;
 use std::env;
 use std::io::BufRead;
@@ -19,25 +19,25 @@ impl CondResult {
         matches!(self, Self::Ok | Self::Ignore(..))
     }
 
-    pub fn color(&self) -> Color {
+    pub fn style(&self) -> Style {
         match self {
-            CondResult::Ok => Color::Green,
-            CondResult::Fail(..) => Color::Red,
-            CondResult::Ignore(..) => Color::Purple,
+            CondResult::Ok => Style::new().green(),
+            CondResult::Fail(..) => Style::new().red(),
+            CondResult::Ignore(..) => Style::new().purple(),
         }
     }
 
     pub fn print(&self, message: &str) {
-        let c = self.color();
+        let s = self.style();
         print!(
             "{} {}",
-            c.paint(<&str>::from(self).pad_to_width(8)),
-            Color::White.bold().paint(message.pad_to_width(40))
+            <&str>::from(self).pad_to_width(8).style(s),
+            message.pad_to_width(40).bold().white()
         );
 
         match self {
             CondResult::Ok => println!(),
-            CondResult::Fail(msg) | CondResult::Ignore(msg) => println!("({})", c.paint(msg)),
+            CondResult::Fail(msg) | CondResult::Ignore(msg) => println!("({})", msg.style(s)),
         }
     }
 }
diff --git a/src/tools/indicator/Cargo.toml b/src/tools/indicator/Cargo.toml
@@ -10,7 +10,7 @@ kime-engine-core = { path = "../../engine/core" }
 kime-version = { path = "../version" }
 kime-run-dir = { path = "../run_dir" }
 
-anyhow = "1.0.38"
-pico-args = "0.5.0"
-log = "0.4.14"
-ksni = "0.2.0"
+anyhow = "1.0"
+pico-args = "0.5"
+log = "0.4"
+ksni = "0.2"
diff --git a/src/tools/kime/Cargo.toml b/src/tools/kime/Cargo.toml
@@ -10,7 +10,7 @@ kime-engine-core = { path = "../../engine/core" }
 kime-version = { path = "../version" }
 kime-run-dir = { path = "../run_dir" }
 
-ctrlc = { version = "3.1.8", features = ["termination"] }
-daemonize = "0.5.0"
-log = "0.4.14"
-pico-args = "0.5.0"
+ctrlc = { version = "3.4", features = ["termination"] }
+nix = { version = "0.30", features = ["process", "fs", "signal"] }
+log = "0.4"
+pico-args = "0.5"
diff --git a/src/tools/kime/src/main.rs b/src/tools/kime/src/main.rs
@@ -1,11 +1,14 @@
-use daemonize::Daemonize;
 use kime_engine_core::{load_raw_config_from_config_dir, DaemonModule as Module};
+use nix::fcntl::{Flock, FlockArg};
+use nix::sys::signal::{kill, Signal};
+use nix::unistd::{daemon, Pid};
+use std::os::unix::io::AsRawFd;
 use std::sync::atomic::{AtomicBool, Ordering::SeqCst};
+use std::{fs::File, io::Write, path::Path};
 use std::{
-    env, io,
+    io,
     process::{Command, Stdio},
 };
-use std::{fs::File, path::Path};
 
 const fn process_name(module: Module) -> &'static str {
     match module {
@@ -15,20 +18,22 @@ const fn process_name(module: Module) -> &'static str {
     }
 }
 
-fn kill_daemon(pid: &Path) -> io::Result<()> {
-    let pid = std::fs::read_to_string(pid)?;
-
-    let ret = Command::new("kill")
-        .arg(pid)
-        .spawn()?
-        .wait_with_output()?
-        .status;
+fn kill_daemon(pid_path: &Path) -> io::Result<()> {
+    let pid_str = std::fs::read_to_string(pid_path)?;
+    let pid: i32 = match pid_str.trim().parse() {
+        Ok(pid) => pid,
+        Err(err) => {
+            log::error!("kill return: {}", err);
+            return Err(io::Error::new(io::ErrorKind::Other, "kill command failed"));
+        }
+    };
 
-    if ret.success() {
-        Ok(())
-    } else {
-        log::error!("kill return: {}", ret);
-        Err(io::Error::new(io::ErrorKind::Other, "kill command failed"))
+    match kill(Pid::from_raw(pid), Signal::SIGTERM) {
+        Ok(_) => Ok(()),
+        Err(err) => {
+            log::error!("kill return: {}", err);
+            Err(io::Error::new(io::ErrorKind::Other, "kill command failed"))
+        }
     }
 }
 
@@ -49,28 +54,58 @@ fn main() -> Result<(), ()> {
     }
 
     if !args.contains(["-D", "--no-daemon"]) {
-        let stderr = run_dir.join("kime.err");
-        let stderr_file = match File::create(stderr) {
+        let stderr_path = run_dir.join("kime.err");
+        let stderr_file = match File::create(&stderr_path) {
             Ok(file) => file,
             Err(err) => {
                 log::error!("Can't create stderr file: {}", err);
                 return Err(());
             }
         };
-        match Daemonize::new()
-            .working_directory("/tmp")
-            .stderr(stderr_file)
-            .pid_file(&pid)
-            .start()
-        {
+
+        // Daemonize: fork and detach from terminal (noclose=true to keep fds open)
+        match daemon(true, true) {
             Ok(_) => {}
             Err(err) => {
                 log::error!("Can't daemonize kime: {}", err);
                 return Err(());
             }
         }
+
+        // Change working directory to /tmp
+        let _ = std::env::set_current_dir("/tmp");
+
+        // Redirect stderr to file
+        unsafe {
+            nix::libc::dup2(stderr_file.as_raw_fd(), nix::libc::STDERR_FILENO);
+        }
     }
 
+    // Create PID file and lock it exclusively to prevent duplicate instances
+    // Lock must be held until program exits (like daemonize library behavior)
+    // Possible errors:
+    //   - File::create fails: permission denied, disk full, etc.
+    //   - Flock::lock returns EWOULDBLOCK: another kime instance is running
+    //   - Flock::lock returns other error: unexpected lock failure
+    let _pid_lock = match File::create(&pid).and_then(|file| {
+        Flock::lock(file, FlockArg::LockExclusiveNonblock).map_err(|(_, e)| io::Error::from(e))
+    }) {
+        Ok(mut lock) => {
+            writeln!(lock, "{}", std::process::id()).map_err(|err| {
+                log::error!("Can't daemonize kime: {}", err);
+            })?;
+            Some(lock)
+        }
+        Err(err) if err.kind() == io::ErrorKind::WouldBlock => {
+            log::error!("Another instance of kime daemon is already running.");
+            return Err(());
+        }
+        Err(err) => {
+            log::error!("Can't daemonize kime: {}", err);
+            return Err(());
+        }
+    };
+
     let config = load_raw_config_from_config_dir().daemon;
 
     static RUN: AtomicBool = AtomicBool::new(true);

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`bitflags::bitflags! {`
	`2`	`+ #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]`
`2`	`3`	`#[repr(transparent)]`
`3`	`4`	`pub struct InputResult: u32 {`
`4`	`5`	`const CONSUMED = 0b1;`