brian/bscreensaver
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Update all dependencies

Browse Source
This commit is contained in:
Brian Tarricone
2024-08-02 11:21:48 -07:00
parent d0df73a9c7
commit 4ed974335e
23 changed files with 947 additions and 790 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
locker/Cargo.toml
View File

@ -42,13 +42,13 @@ assets = [
[dependencies]
anyhow = "1"
clap = "3"
clap = { version = "4", features = ["derive"] }
bscreensaver-command = { path = "../command" }
bscreensaver-util = { path = "../util" }
libc = "0.2"
log = "0.4"
nix = "0.23"
nix = { version = "0.29", features = ["process", "signal"] }
xcb = { version = "1", features = ["randr", "xkb", "xfixes", "xinput"] }
xcb-xembed = { path = "../xcb-xembed" }
xkb = { version = "0.3", features = ["x11"] }
xkbcommon-sys = { version = "1", feature = "x11" }
xkbcommon-sys = { version = "=1.4.1", features = ["x11"] }

85
locker/src/main.rs
View File

@ -1,23 +1,13 @@
use clap::{Arg, Command as ClapCommand};
use clap::Parser;
use log::{debug, error, info, trace, warn};
use nix::{
poll::{poll, PollFd, PollFlags},
unistd::{execv, fork, setsid, ForkResult},
sys::{
poll::{poll, PollFd, PollFlags, PollTimeout}, sys::{
signal::{sigprocmask, SigSet, SigmaskHow, Signal},
signalfd::{SignalFd, SfdFlags},
},
signalfd::{SfdFlags, SignalFd},
}, unistd::{execv, fork, setsid, ForkResult}
};
use std::{
env,
ffi::CString,
fs::read_link,
io,
os::unix::io::AsRawFd,
rc::Rc,
process::exit,
sync::Mutex,
time::{Duration, Instant}, path::PathBuf,
env, ffi::CString, fs::read_link, io, os::{fd::AsFd, unix::io::AsRawFd}, path::PathBuf, process::exit, rc::Rc, sync::Mutex, time::{Duration, Instant}
};
use xcb::{randr, x, xfixes, xinput};
@ -30,33 +20,35 @@ const LOCKED_ARG: &str = "locked";
macro_rules! maybe_add_fd {
($pfds:expr, $fd:expr) => {
if let Some(fd) = $fd {
$pfds.push(PollFd::new(fd, PollFlags::POLLIN));
Some(fd)
if fd >= 0 {
$pfds.push(PollFd::new(borrow_raw_fd(fd), PollFlags::POLLIN));
Some(fd)
} else {
None
}
} else {
None
}
};
}
#[derive(Parser, Debug)]
#[command(name = "bscreensaver", version, author, about = "Blanks and locks the screen after a period of time", long_about = None)]
struct Args {
/// Starts up in already blanked
#[arg(long = BLANKED_ARG)]
blanked: bool,
/// Stats up already blanked and locked
#[arg(long = LOCKED_ARG)]
locked: bool,
}
fn main() -> anyhow::Result<()> {
init_logging("BSCREENSAVER_LOG");
let config = Configuration::load()?;
let args = ClapCommand::new("Blanks and locks the screen after a period of time")
.author(env!("CARGO_PKG_AUTHORS"))
.version(env!("CARGO_PKG_VERSION"))
.arg(
Arg::new("blanked")
.long(BLANKED_ARG)
.help("Starts up in the blanked screensaver")
)
.arg(
Arg::new("locked")
.long(LOCKED_ARG)
.help("Starts up in the blanked and locked screensaver")
)
.get_matches();
let args = Args::parse();
let mut signal_fd = init_signals()?;
@ -91,12 +83,12 @@ fn main() -> anyhow::Result<()> {
};
let mut screensaver = Screensaver::new(&config, &helper_dir, &command_handlers, &conn, screen)?;
if args.is_present(LOCKED_ARG) {
if args.locked {
match screensaver.lock_screen() {
Err(err) => error!("POSSIBLY FAILED TO LOCK SCREEN ON STARTUP: {}", err),
Ok(_) => debug!("Got --{} arg; screen locked on startup", LOCKED_ARG),
}
} else if args.is_present(BLANKED_ARG) {
} else if args.blanked {
match screensaver.blank_screen() {
Err(err) => warn!("Possibly failed to blank screen on startup: {}", err),
Ok(_) => debug!("Got --{} arg; screen locked on startup", BLANKED_ARG),
@ -120,9 +112,16 @@ fn main() -> anyhow::Result<()> {
warn!("Error handling event: {}", err);
}
let conn_fd = conn.as_raw_fd();
if conn_fd < 0 {
error!("Lost connection to X server; attempting to restart");
(command_handlers.restart_handler)(&mut screensaver, None)?;
}
let conn_fd = borrow_raw_fd(conn_fd);
let mut pfds = Vec::new();
pfds.push(PollFd::new(signal_fd.as_raw_fd(), PollFlags::POLLIN));
pfds.push(PollFd::new(conn.as_raw_fd(), PollFlags::POLLIN));
pfds.push(PollFd::new(borrow_raw_fd(signal_fd.as_raw_fd()), PollFlags::POLLIN));
pfds.push(PollFd::new(conn_fd.as_fd(), PollFlags::POLLIN));
let dbus_service_fd = maybe_add_fd!(&mut pfds, subservices.lock().unwrap().dbus_service().map(|ds| ds.pidfd().as_raw_fd()));
let systemd_service_fd = maybe_add_fd!(&mut pfds, subservices.lock().unwrap().systemd_service().map(|ds| ds.pidfd().as_raw_fd()));
let dialog_fd = maybe_add_fd!(&mut pfds, screensaver.unlock_dialog_pidfd().map(|udpfd| udpfd.as_raw_fd()));
@ -135,21 +134,19 @@ fn main() -> anyhow::Result<()> {
BlankerState::Blanked => Some(config.lock_timeout - since_last_activity),
BlankerState::Locked => None,
};
let poll_timeout = poll_timeout.map(|pt| if pt.as_millis() > i32::MAX as u128 {
i32::MAX
} else {
pt.as_millis() as i32
}).unwrap_or(-1);
let poll_timeout = poll_timeout
.map(|pt| PollTimeout::try_from(pt).unwrap_or(PollTimeout::MAX))
.unwrap_or(PollTimeout::NONE);
trace!("about to poll (timeout={})", poll_timeout);
trace!("about to poll (timeout={})", poll_timeout.as_millis().map(|pt| pt.to_string()).unwrap_or("(?)".into()));
let nready = poll(pfds.as_mut_slice(), poll_timeout)?; // FIXME: maybe shouldn't quit here on errors if screen is locked
trace!("polled; {} FD ready", nready);
if nready > 0 {
for pfd in pfds {
if pfd.revents().filter(|pf| pf.contains(PollFlags::POLLIN)).is_some() {
let result = match pfd.as_raw_fd() {
let result = match pfd.as_fd().as_raw_fd() {
fd if fd == signal_fd.as_raw_fd() => handle_signals(&mut screensaver, &mut subservices.lock().unwrap(), &mut signal_fd),
fd if fd == conn.as_raw_fd() => screensaver.handle_xcb_events(),
fd if fd == conn_fd.as_raw_fd() => screensaver.handle_xcb_events(),
fd if opt_contains(&dbus_service_fd, &fd) => subservices.lock().unwrap().handle_quit(),
fd if opt_contains(&systemd_service_fd, &fd) => subservices.lock().unwrap().handle_quit(),
fd if opt_contains(&dialog_fd, &fd) => screensaver.handle_unlock_dialog_quit(),

2
locker/src/pidfd.rs
View File

@ -12,7 +12,7 @@ fn pidfd_open(pid: RawFd) -> nix::Result<PidFd> {
} else {
// SAFETY: pointer is checked for null; libc must be sane
let errno = unsafe { *errno_location };
Err(nix::errno::Errno::from_i32(errno))
Err(nix::errno::Errno::from_raw(errno))
}
}
}