1 files changed, 280 insertions, 80 deletions

diff --git a/tools/gsr-global-hotkeys/keyboard_event.c b/tools/gsr-global-hotkeys/keyboard_event.c
index 203dc00..b8d94fd 100644
--- a/tools/gsr-global-hotkeys/keyboard_event.c
+++ b/tools/gsr-global-hotkeys/keyboard_event.c
@@ -11,7 +11,7 @@
 #include <fcntl.h>
 #include <unistd.h>
 #include <dirent.h>
-#include <sys/poll.h>
+#include <poll.h>
 
 /* LINUX */
 #include <linux/input.h>
@@ -117,7 +117,44 @@ static void keyboard_event_process_key_state_change(keyboard_event *self, struct
     }
 }
 
-static void keyboard_event_process_input_event_data(keyboard_event *self, event_extra_data *extra_data, int fd, key_callback callback, void *userdata) {
+/* Return true if a global hotkey is assigned to the key combination */
+static bool keyboard_event_on_key_pressed(keyboard_event *self, const struct input_event *event, uint32_t modifiers) {
+    if(event->value != KEYBOARD_BUTTON_PRESSED)
+        return false;
+
+    bool global_hotkey_match = false;
+    for(int i = 0; i < self->num_global_hotkeys; ++i) {
+        if(event->code == self->global_hotkeys[i].key && modifiers == self->global_hotkeys[i].modifiers) {
+            puts(self->global_hotkeys[i].action);
+            fflush(stdout);
+            global_hotkey_match = true;
+        }
+    }
+    return global_hotkey_match;
+}
+
+static inline uint32_t set_bit(uint32_t value, uint32_t bit_flag, bool set) {
+    if(set)
+        return value | bit_flag;
+    else
+        return value & ~bit_flag;
+}
+
+static uint32_t keycode_to_modifier_bit(uint32_t keycode) {
+    switch(keycode) {
+        case KEY_LEFTSHIFT:  return KEYBOARD_MODKEY_LSHIFT;
+        case KEY_RIGHTSHIFT: return KEYBOARD_MODKEY_RSHIFT;
+        case KEY_LEFTCTRL:   return KEYBOARD_MODKEY_LCTRL;
+        case KEY_RIGHTCTRL:  return KEYBOARD_MODKEY_RCTRL;
+        case KEY_LEFTALT:    return KEYBOARD_MODKEY_LALT;
+        case KEY_RIGHTALT:   return KEYBOARD_MODKEY_RALT;
+        case KEY_LEFTMETA:   return KEYBOARD_MODKEY_LSUPER;
+        case KEY_RIGHTMETA:  return KEYBOARD_MODKEY_RSUPER;
+    }
+    return 0;
+}
+
+static void keyboard_event_process_input_event_data(keyboard_event *self, event_extra_data *extra_data, int fd) {
     struct input_event event;
     if(read(fd, &event, sizeof(event)) != sizeof(event)) {
         fprintf(stderr, "Error: failed to read input event data\n");
@@ -136,57 +173,12 @@ static void keyboard_event_process_input_event_data(keyboard_event *self, event_
 
     if(event.type == EV_KEY) {
         keyboard_event_process_key_state_change(self, event, extra_data, fd);
-
-        switch(event.code) {
-            case KEY_LEFTSHIFT:
-                self->lshift_button_state = event.value >= 1 ? KEYBOARD_BUTTON_PRESSED : KEYBOARD_BUTTON_RELEASED;
-                break;
-            case KEY_RIGHTSHIFT:
-                self->rshift_button_state = event.value >= 1 ? KEYBOARD_BUTTON_PRESSED : KEYBOARD_BUTTON_RELEASED;
-                break;
-            case KEY_LEFTCTRL:
-                self->lctrl_button_state = event.value >= 1 ? KEYBOARD_BUTTON_PRESSED : KEYBOARD_BUTTON_RELEASED;
-                break;
-            case KEY_RIGHTCTRL:
-                self->rctrl_button_state = event.value >= 1 ? KEYBOARD_BUTTON_PRESSED : KEYBOARD_BUTTON_RELEASED;
-                break;
-            case KEY_LEFTALT:
-                self->lalt_button_state = event.value >= 1 ? KEYBOARD_BUTTON_PRESSED : KEYBOARD_BUTTON_RELEASED;
-                break;
-            case KEY_RIGHTALT:
-                self->ralt_button_state = event.value >= 1 ? KEYBOARD_BUTTON_PRESSED : KEYBOARD_BUTTON_RELEASED;
-                break;
-            case KEY_LEFTMETA:
-                self->lmeta_button_state = event.value >= 1 ? KEYBOARD_BUTTON_PRESSED : KEYBOARD_BUTTON_RELEASED;
-                break;
-            case KEY_RIGHTMETA:
-                self->rmeta_button_state = event.value >= 1 ? KEYBOARD_BUTTON_PRESSED : KEYBOARD_BUTTON_RELEASED;
-                break;
-            default: {
-                const bool shift_pressed = self->lshift_button_state == KEYBOARD_BUTTON_PRESSED || self->rshift_button_state == KEYBOARD_BUTTON_PRESSED;
-                const bool ctrl_pressed = self->lctrl_button_state == KEYBOARD_BUTTON_PRESSED || self->rctrl_button_state == KEYBOARD_BUTTON_PRESSED;
-                const bool lalt_pressed = self->lalt_button_state == KEYBOARD_BUTTON_PRESSED;
-                const bool ralt_pressed = self->ralt_button_state == KEYBOARD_BUTTON_PRESSED;
-                const bool meta_pressed = self->lmeta_button_state == KEYBOARD_BUTTON_PRESSED || self->rmeta_button_state == KEYBOARD_BUTTON_PRESSED;
-                //fprintf(stderr, "pressed key: %d, state: %d, shift: %s, ctrl: %s, alt: %s, meta: %s\n", event.code, event.value,
-                //   shift_pressed ? "yes" : "no", ctrl_pressed ? "yes" : "no", alt_pressed ? "yes" : "no", meta_pressed ? "yes" : "no");
-                uint32_t modifiers = 0;
-                if(shift_pressed)
-                    modifiers |= KEYBOARD_MODKEY_SHIFT;
-                if(ctrl_pressed)
-                    modifiers |= KEYBOARD_MODKEY_CTRL;
-                if(lalt_pressed)
-                    modifiers |= KEYBOARD_MODKEY_LALT;
-                if(ralt_pressed)
-                    modifiers |= KEYBOARD_MODKEY_RALT;
-                if(meta_pressed)
-                    modifiers |= KEYBOARD_MODKEY_SUPER;
-
-                if(!callback(event.code, modifiers, event.value, userdata))
-                    return;
-
-                break;
-            }
+        const uint32_t modifier_bit = keycode_to_modifier_bit(event.code);
+        if(modifier_bit == 0) {
+            if(keyboard_event_on_key_pressed(self, &event, self->modifier_button_states))
+                return;
+        } else {
+            self->modifier_button_states = set_bit(self->modifier_button_states, modifier_bit, event.value >= 1);
         }
     }
 
@@ -197,6 +189,36 @@ static void keyboard_event_process_input_event_data(keyboard_event *self, event_
     }
 }
 
+/* Retarded linux takes very long time to close /dev/input/eventN files, even though they are virtual and opened read-only */
+static void* keyboard_event_close_fds_callback(void *userdata) {
+    keyboard_event *self = userdata;
+    while(self->running) {
+        pthread_mutex_lock(&self->close_dev_input_mutex);
+        for(int i = 0; i < self->num_close_fds; ++i) {
+            close(self->close_fds[i]);
+        }
+        self->num_close_fds = 0;
+        pthread_mutex_unlock(&self->close_dev_input_mutex);
+
+        usleep(100 * 1000); /* 100 milliseconds */
+    }
+    return NULL;
+}
+
+static bool keyboard_event_try_add_close_fd(keyboard_event *self, int fd) {
+    bool success = false;
+    pthread_mutex_lock(&self->close_dev_input_mutex);
+    if(self->num_close_fds < MAX_CLOSE_FDS) {
+        self->close_fds[self->num_close_fds] = fd;
+        ++self->num_close_fds;
+        success = true;
+    } else {
+        success = false;
+    }
+    pthread_mutex_unlock(&self->close_dev_input_mutex);
+    return success;
+}
+
 /* Returns -1 if invalid format. Expected |dev_input_filepath| to be in format /dev/input/eventN */
 static int get_dev_input_id_from_filepath(const char *dev_input_filepath) {
     if(strncmp(dev_input_filepath, "/dev/input/event", 16) != 0)
@@ -304,7 +326,10 @@ static bool keyboard_event_try_add_device_if_keyboard(keyboard_event *self, cons
         }
     }
 
-    close(fd);
+    if(!keyboard_event_try_add_close_fd(self, fd)) {
+        fprintf(stderr, "Error: failed to add immediately, closing now\n");
+        close(fd);
+    }
     return false;
 }
 
@@ -406,11 +431,19 @@ static int setup_virtual_keyboard_input(const char *name) {
     return fd;
 }
 
-bool keyboard_event_init(keyboard_event *self, bool poll_stdout_error, bool exclusive_grab, keyboard_grab_type grab_type) {
+bool keyboard_event_init(keyboard_event *self, bool exclusive_grab, keyboard_grab_type grab_type) {
     memset(self, 0, sizeof(*self));
-    self->stdout_event_index = -1;
+    self->stdin_event_index = -1;
     self->hotplug_event_index = -1;
     self->grab_type = grab_type;
+    self->running = true;
+
+    pthread_mutex_init(&self->close_dev_input_mutex, NULL);
+    if(pthread_create(&self->close_dev_input_fds_thread, NULL, keyboard_event_close_fds_callback, self) != 0) {
+        self->close_dev_input_fds_thread = 0;
+        fprintf(stderr, "Error: failed to create close fds thread\n");
+        return false;
+    }
 
     if(exclusive_grab) {
         self->uinput_fd = setup_virtual_keyboard_input(GSR_UI_VIRTUAL_KEYBOARD_NAME);
@@ -418,23 +451,21 @@ bool keyboard_event_init(keyboard_event *self, bool poll_stdout_error, bool excl
             fprintf(stderr, "Warning: failed to setup virtual keyboard input for exclusive grab. The focused application will receive keys used for global hotkeys\n");
     }
 
-    if(poll_stdout_error) {
-        self->event_polls[self->num_event_polls] = (struct pollfd) {
-            .fd = STDOUT_FILENO,
-            .events = 0,
-            .revents = 0
-        };
+    self->event_polls[self->num_event_polls] = (struct pollfd) {
+        .fd = STDIN_FILENO,
+        .events = POLLIN,
+        .revents = 0
+    };
 
-        self->event_extra_data[self->num_event_polls] = (event_extra_data) {
-            .dev_input_id = -1,
-            .grabbed = false,
-            .key_states = NULL,
-            .num_keys_pressed = 0
-        };
+    self->event_extra_data[self->num_event_polls] = (event_extra_data) {
+        .dev_input_id = -1,
+        .grabbed = false,
+        .key_states = NULL,
+        .num_keys_pressed = 0
+    };
 
-        self->stdout_event_index = self->num_event_polls;
-        ++self->num_event_polls;
-    }
+    self->stdin_event_index = self->num_event_polls;
+    ++self->num_event_polls;
 
     if(hotplug_event_init(&self->hotplug_ev)) {
         self->event_polls[self->num_event_polls] = (struct pollfd) {
@@ -468,6 +499,13 @@ bool keyboard_event_init(keyboard_event *self, bool poll_stdout_error, bool excl
 }
 
 void keyboard_event_deinit(keyboard_event *self) {
+    self->running = false;
+
+    for(int i = 0; i < self->num_global_hotkeys; ++i) {
+        free(self->global_hotkeys[i].action);
+    }
+    self->num_global_hotkeys = 0;
+
     if(self->uinput_fd > 0) {
         close(self->uinput_fd);
         self->uinput_fd = -1;
@@ -481,22 +519,184 @@ void keyboard_event_deinit(keyboard_event *self) {
     self->num_event_polls = 0;
 
     hotplug_event_deinit(&self->hotplug_ev);
+
+    if(self->close_dev_input_fds_thread > 0) {
+        pthread_join(self->close_dev_input_fds_thread, NULL);
+        self->close_dev_input_fds_thread = 0;
+    }
+
+    pthread_mutex_destroy(&self->close_dev_input_mutex);
 }
 
 static void on_device_added_callback(const char *devname, void *userdata) {
     keyboard_event *keyboard_ev = userdata;
-    char dev_input_filepath[1024];
+    char dev_input_filepath[256];
     snprintf(dev_input_filepath, sizeof(dev_input_filepath), "/dev/%s", devname);
     keyboard_event_try_add_device_if_keyboard(keyboard_ev, dev_input_filepath);
 }
 
-void keyboard_event_poll_events(keyboard_event *self, int timeout_milliseconds, key_callback callback, void *userdata) {
+/* Returns -1 on error */
+static int parse_u8(const char *str, int size) {
+    if(size <= 0)
+        return -1;
+
+    int result = 0;
+    for(int i = 0; i < size; ++i) {
+        char c = str[i];
+        if(c >= '0' && c <= '9') {
+            result = result * 10 + (c - '0');
+            if(result > 255)
+                return -1;
+        } else {
+            return -1;
+        }
+    }
+    return result;
+}
+
+static bool keyboard_event_parse_bind_keys(const char *str, int size, uint8_t *key, uint32_t *modifiers) {
+    *key = 0;
+    *modifiers = 0;
+
+    const char *number_start = str;
+    const char *end = str + size;
+    for(;;) {
+        const char *next = strchr(number_start, '+');
+        if(!next)
+            next = end;
+
+        const int number_len = next - number_start;
+        const int number = parse_u8(number_start, number_len);
+        if(number == -1) {
+            fprintf(stderr, "Error: bind command keys \"%s\" is in invalid format\n", str);
+            return false;
+        }
+
+        const uint32_t modifier_bit = keycode_to_modifier_bit(number);
+        if(modifier_bit == 0) {
+            if(*key != 0) {
+                fprintf(stderr, "Error: can't bind hotkey with multiple non-modifier keys\n");
+                return false;
+            }
+            *key = number;
+        } else {
+            *modifiers = set_bit(*modifiers, modifier_bit, true);
+        }
+
+        number_start = next + 1;
+        if(next == end)
+            break;
+    }
+
+    if(key == 0) {
+        fprintf(stderr, "Error: can't bind hotkey without a non-modifier key\n");
+        return false;
+    }
+
+    if(modifiers == 0) {
+        fprintf(stderr, "Error: can't bind hotkey without a modifier\n");
+        return false;
+    }
+
+    return true;
+}
+
+/* |command| is null-terminated */
+static void keyboard_event_parse_stdin_command(keyboard_event *self, const char *command, int command_size) {
+    if(strncmp(command, "bind ", 5) == 0) {
+        /* Example: |bind show_hide 20+40| */
+        if(self->num_global_hotkeys >= MAX_GLOBAL_HOTKEYS) {
+            fprintf(stderr, "Error: can't add another hotkey. The maximum number of hotkeys (%d) has been reached\n", MAX_GLOBAL_HOTKEYS);
+            return;
+        }
+
+        const char *action_name_end = strchr(command + 5, ' ');
+        if(!action_name_end) {
+            fprintf(stderr, "Error: command \"%s\" is in invalid format\n", command);
+            return;
+        }
+
+        const char *action_name = command + 5;
+        const int action_name_size = action_name_end - action_name;
+
+        uint8_t key = 0;
+        uint32_t modifiers = 0;
+        const char *number_start = action_name_end + 1;
+        const char *end = command + command_size;
+        if(!keyboard_event_parse_bind_keys(number_start, end - number_start, &key, &modifiers))
+            return;
+
+        char *action = strndup(action_name, action_name_size);
+        if(!action) {
+            fprintf(stderr, "Error: failed to duplicate %.*s\n", action_name_size, action_name);
+            return;
+        }
+
+        self->global_hotkeys[self->num_global_hotkeys] = (global_hotkey) {
+            .action = action,
+            .key = key,
+            .modifiers = modifiers
+        };
+        ++self->num_global_hotkeys;
+        fprintf(stderr, "Info: binded hotkey: %s\n", action);
+    } else if(strncmp(command, "unbind_all", 10) == 0) {
+        for(int i = 0; i < self->num_global_hotkeys; ++i) {
+            free(self->global_hotkeys[i].action);
+        }
+        self->num_global_hotkeys = 0;
+        fprintf(stderr, "Info: unbinded all hotkeys\n");
+    } else {
+        fprintf(stderr, "Warning: got invalid command: \"%s\", expected command to start with either \"bind\" or \"unbind_all\"\n", command);
+    }
+}
+
+static void keyboard_event_process_stdin_command_data(keyboard_event *self, int fd) {
+    const int num_bytes_to_read = sizeof(self->stdin_command_data) - self->stdin_command_data_size;
+    if(num_bytes_to_read == 0) {
+        fprintf(stderr, "Error: failed to read data from stdin, buffer is full. Clearing buffer\n");
+        self->stdin_command_data_size = 0;
+        return;
+    }
+
+    const ssize_t bytes_read = read(fd, self->stdin_command_data + self->stdin_command_data_size, num_bytes_to_read);
+    if(bytes_read <= 0)
+        return;
+
+    const char *command_start = self->stdin_command_data;
+    const char *search = self->stdin_command_data + self->stdin_command_data_size;
+    const char *end = search + bytes_read;
+    self->stdin_command_data_size += bytes_read;
+
+    for(;;) {
+        char *next = memchr(search, '\n', end - search);
+        if(!next)
+            break;
+
+        *next = '\0';
+        keyboard_event_parse_stdin_command(self, command_start, next - command_start);
+        search = next + 1;
+        command_start = search;
+        if(next == end)
+            break;
+    }
+
+    const int bytes_parsed = command_start - self->stdin_command_data;
+    if(bytes_parsed > 0) {
+        self->stdin_command_data_size -= bytes_parsed;
+        memmove(self->stdin_command_data, command_start, self->stdin_command_data_size);
+    }
+}
+
+void keyboard_event_poll_events(keyboard_event *self, int timeout_milliseconds) {
     if(poll(self->event_polls, self->num_event_polls, timeout_milliseconds) <= 0)
         return;
 
+    if(self->stdin_failed)
+        return;
+
     for(int i = 0; i < self->num_event_polls; ++i) {
-        if(i == self->stdout_event_index && (self->event_polls[i].revents & (POLLHUP|POLLERR)))
-            self->stdout_failed = true;
+        if(i == self->stdin_event_index && (self->event_polls[i].revents & (POLLHUP|POLLERR)))
+            self->stdin_failed = true;
 
         if(self->event_polls[i].revents & POLLHUP) { /* TODO: What if this is the hotplug fd? */
             keyboard_event_remove_event(self, i);
@@ -510,14 +710,14 @@ void keyboard_event_poll_events(keyboard_event *self, int timeout_milliseconds,
         if(i == self->hotplug_event_index) {
             /* Device is added to end of |event_polls| so it's ok to add while iterating it via index */
             hotplug_event_process_event_data(&self->hotplug_ev, self->event_polls[i].fd, on_device_added_callback, self);
-        } else if(i == self->stdout_event_index) {
-            /* Do nothing, this shouldn't happen anyways since we dont poll for input */
+        } else if(i == self->stdin_event_index) {
+            keyboard_event_process_stdin_command_data(self, self->event_polls[i].fd);
         } else {
-            keyboard_event_process_input_event_data(self, &self->event_extra_data[i], self->event_polls[i].fd, callback, userdata);
+            keyboard_event_process_input_event_data(self, &self->event_extra_data[i], self->event_polls[i].fd);
         }
     }
 }
 
-bool keyboard_event_stdout_has_failed(const keyboard_event *self) {
-    return self->stdout_failed;
+bool keyboard_event_stdin_has_failed(const keyboard_event *self) {
+    return self->stdin_failed;
 }