chatgpt blatantly refused to write this so I had to do it myself.

CMakeLists.txt

@@ -36,6 +36,7 @@ add_executable(${STRAY_EXECUTABLE_NAME}
                   virt_ds4.c
                   virt_ds5.c
                   virt_mouse.c
+                  virt_kbd.c
                   devices_status.c
 )
 
@@ -46,6 +47,7 @@ add_executable(${ALLINONE_EXECUTABLE_NAME}
                   virt_ds4.c
                   virt_ds5.c
                   virt_mouse.c
+                  virt_kbd.c
                   devices_status.c
                   dev_evdev.c
                   dev_iio.c

dev_out.c

@@ -6,6 +6,7 @@
 #include "virt_ds4.h"
 #include "virt_ds5.h"
 #include "virt_mouse.h"
+#include "virt_kbd.h"
 
 #include <libconfig.h>
 
@@ -272,6 +273,15 @@ void *dev_out_thread_func(void *ptr) {
         printf("Mouse initialized: fd=%d\n", current_mouse_fd);
     }
 
+    virt_kbd_t keyboard_data;
+    const int kbd_init_res = virt_kbd_init(&keyboard_data);
+    if (kbd_init_res < 0) {
+        fprintf(stderr, "Unable to initialize virtual keyboard -- will continue regardless\n");
+    } else {
+        current_keyboard_fd = virt_kbd_get_fd(&keyboard_data);
+        printf("Keyboard initialized: fd=%d\n", current_keyboard_fd);
+    }
+
     const int64_t kbd_report_timing_us = 1125;
     const int64_t mouse_report_timing_us = 950;
     const int64_t gamepad_report_timing_us = 1250;
@@ -342,6 +352,8 @@ void *dev_out_thread_func(void *ptr) {
         } else if (kbd_time_diff_usecs >= kbd_report_timing_us) {
             keyboard_last_hid_report_sent = now;
 
+            virt_kbd_send(&keyboard_data, &dev_out_data->dev_stats.kbd, &now);
+
             // this does reset the for, ensuring every other device has nothing to say
             continue;
         }
@@ -369,7 +381,9 @@ void *dev_out_thread_func(void *ptr) {
             FD_SET(current_mouse_fd, &read_fds);
         }
         
-        // TODO: FD_SET(current_keyboard_fd, &read_fds);
+        if (current_mouse_fd > 0) {
+            FD_SET(current_keyboard_fd, &read_fds);
+        }
 
         if (current_gamepad_fd > 0) {
             FD_SET(current_gamepad_fd, &read_fds);
@@ -472,6 +486,14 @@ void *dev_out_thread_func(void *ptr) {
             }
         }
 
+        if ((current_keyboard_fd > 0) && (FD_ISSET(current_keyboard_fd, &read_fds))) {
+            // TODO: read keyboard events
+        }
+
+        if ((current_mouse_fd > 0) && (FD_ISSET(current_mouse_fd, &read_fds))) {
+            // TODO: read mouse events
+        }
+
         // read and handle incoming data: this data is packed into in_message_t
         if (dev_out_data->communication.type == ipc_unix_pipe) {
             if (FD_ISSET(dev_out_data->communication.endpoint.pipe.in_message_pipe_fd, &read_fds)) {
@@ -523,6 +545,9 @@ void *dev_out_thread_func(void *ptr) {
     // close the mouse device
     virt_mouse_close(&mouse_data);
 
+    // close the keyboard device
+    virt_kbd_close(&keyboard_data);
+
     // end communication
     if (dev_out_data->communication.type == ipc_server_sockets) {
         // close every client socket

devices_status.c

@@ -1,7 +1,48 @@
 #include "devices_status.h"
+#include <pthread.h>
 
 void kbd_status_init(keyboard_status_t *const stats) {
     stats->connected = true;
+
+    stats->q = 0;
+    stats->w = 0;
+    stats->e = 0;
+    stats->r = 0;
+    stats->t = 0;
+    stats->y = 0;
+    stats->u = 0;
+    stats->i = 0;
+    stats->o = 0;
+    stats->p = 0;
+    stats->a = 0;
+    stats->s = 0;
+    stats->d = 0;
+    stats->f = 0;
+    stats->g = 0;
+    stats->h = 0;
+    stats->j = 0;
+    stats->k = 0;
+    stats->l = 0;
+    stats->z = 0;
+    stats->x = 0;
+    stats->c = 0;
+    stats->v = 0;
+    stats->b = 0;
+    stats->n = 0;
+    stats->m = 0;
+
+    stats->num_1 = 0;
+    stats->num_2 = 0;
+    stats->num_3 = 0;
+    stats->num_4 = 0;
+    stats->num_5 = 0;
+    stats->num_6 = 0;
+    stats->num_7 = 0;
+    stats->num_8 = 0;
+    stats->num_9 = 0;
+    stats->num_0 = 0;
+
+    stats->lctrl = 0;
 }
 
 void mouse_status_init(mouse_status_t *const stats) {
@@ -53,6 +94,7 @@ void gamepad_status_init(gamepad_status_t *const stats) {
 }
 
 void devices_status_init(devices_status_t *const stats) {
+    pthread_mutex_init(&stats->mutex, NULL);
     gamepad_status_init(&stats->gamepad);
     kbd_status_init(&stats->kbd);
     mouse_status_init(&stats->mouse);

devices_status.h

@@ -67,6 +67,13 @@ typedef struct gamepad_status {
 
 typedef struct keyboard_status {
     bool connected;
+
+    uint8_t q,w,e,r,t,y,u,i,o,p,a,s,d,f,g,h,j,k,l,z,x,c,v,b,n,m;
+
+    uint8_t num_1, num_2, num_3, num_4, num_5, num_6, num_7, num_8, num_9, num_0;
+
+    uint8_t lctrl;
+
 } keyboard_status_t;
 
 

message.h

@@ -82,23 +82,69 @@ typedef enum in_message_gamepad_action {
     GAMEPAD_ACTION_OPEN_STEAM_QAM,
 } in_message_gamepad_action_t;
 
+typedef enum kbd_element {
+    KEYBOARD_KEY_Q,
+    KEYBOARD_KEY_W,
+    KEYBOARD_KEY_E,
+    KEYBOARD_KEY_R,
+    KEYBOARD_KEY_T,
+    KEYBOARD_KEY_Y,
+    KEYBOARD_KEY_U,
+    KEYBOARD_KEY_I,
+    KEYBOARD_KEY_O,
+    KEYBOARD_KEY_P,
+    KEYBOARD_KEY_A,
+    KEYBOARD_KEY_S,
+    KEYBOARD_KEY_D,
+    KEYBOARD_KEY_F,
+    KEYBOARD_KEY_G,
+    KEYBOARD_KEY_H,
+    KEYBOARD_KEY_J,
+    KEYBOARD_KEY_K,
+    KEYBOARD_KEY_L,
+    KEYBOARD_KEY_Z,
+    KEYBOARD_KEY_X,
+    KEYBOARD_KEY_C,
+    KEYBOARD_KEY_V,
+    KEYBOARD_KEY_B,
+    KEYBOARD_KEY_N,
+    KEYBOARD_KEY_M,
+    KEYBOARD_KEY_NUM_1,
+    KEYBOARD_KEY_NUM_2,
+    KEYBOARD_KEY_NUM_3,
+    KEYBOARD_KEY_NUM_4,
+    KEYBOARD_KEY_NUM_5,
+    KEYBOARD_KEY_NUM_6,
+    KEYBOARD_KEY_NUM_7,
+    KEYBOARD_KEY_NUM_8,
+    KEYBOARD_KEY_NUM_9,
+    KEYBOARD_KEY_NUM_0,
+    KEYBOARD_KEY_LCRTL,
+} kbd_element_t;
+
+typedef struct in_message_keyboard_set_element {
+    kbd_element_t type;
+    uint8_t value;
+} in_message_keyboard_set_element_t;
+
 typedef enum in_in_message_type {
     GAMEPAD_SET_ELEMENT,
     GAMEPAD_ACTION,
     MOUSE_EVENT,
+    KEYBOARD_SET_ELEMENT,
 }  in_message_type_t;
 
 typedef struct in_message {
     in_message_type_t type;
 
     union {
-        //imu_in_message_t imu;
-
         in_message_gamepad_action_t action;
 
         in_message_gamepad_set_element_t gamepad_set;
 
         in_message_mouse_event_t mouse_event;
+
+        in_message_keyboard_set_element_t kbd_set;
     } data;
 
 }  in_message_t;

virt_kbd.c

@@ -0,0 +1,474 @@
+#include "virt_kbd.h"
+#include "message.h"
+#include <linux/input-event-codes.h>
+
+int virt_kbd_init(virt_kbd_t *const kbd) {
+    int ret = -EINVAL;
+
+    memset(kbd, 0, sizeof(virt_kbd_t));
+
+    int fd = open("/dev/uinput", O_RDWR);
+	if(fd < 0) {
+        ret = errno;
+        goto virt_mouse_init_err;
+    }
+
+    ioctl(fd, UI_SET_EVBIT, EV_REL);
+    ioctl(fd, UI_SET_EVBIT, EV_KEY);
+    ioctl(fd, UI_SET_EVBIT, EV_MSC);
+    ioctl(fd, UI_SET_EVBIT, EV_SYN);
+    ioctl(fd, UI_SET_MSCBIT, MSC_TIMESTAMP);
+    ioctl(fd, UI_SET_KEYBIT, KEY_Q);
+    ioctl(fd, UI_SET_KEYBIT, KEY_W);
+    ioctl(fd, UI_SET_KEYBIT, KEY_E);
+    ioctl(fd, UI_SET_KEYBIT, KEY_R);
+    ioctl(fd, UI_SET_KEYBIT, KEY_T);
+    ioctl(fd, UI_SET_KEYBIT, KEY_Y);
+    ioctl(fd, UI_SET_KEYBIT, KEY_U);
+    ioctl(fd, UI_SET_KEYBIT, KEY_I);
+    ioctl(fd, UI_SET_KEYBIT, KEY_O);
+    ioctl(fd, UI_SET_KEYBIT, KEY_P);
+    ioctl(fd, UI_SET_KEYBIT, KEY_A);
+    ioctl(fd, UI_SET_KEYBIT, KEY_S);
+    ioctl(fd, UI_SET_KEYBIT, KEY_D);
+    ioctl(fd, UI_SET_KEYBIT, KEY_F);
+    ioctl(fd, UI_SET_KEYBIT, KEY_G);
+    ioctl(fd, UI_SET_KEYBIT, KEY_H);
+    ioctl(fd, UI_SET_KEYBIT, KEY_J);
+    ioctl(fd, UI_SET_KEYBIT, KEY_K);
+    ioctl(fd, UI_SET_KEYBIT, KEY_L);
+    ioctl(fd, UI_SET_KEYBIT, KEY_Z);
+    ioctl(fd, UI_SET_KEYBIT, KEY_X);
+    ioctl(fd, UI_SET_KEYBIT, KEY_C);
+    ioctl(fd, UI_SET_KEYBIT, KEY_V);
+    ioctl(fd, UI_SET_KEYBIT, KEY_B);
+    ioctl(fd, UI_SET_KEYBIT, KEY_N);
+    ioctl(fd, UI_SET_KEYBIT, KEY_M);
+    ioctl(fd, UI_SET_KEYBIT, KEY_1);
+    ioctl(fd, UI_SET_KEYBIT, KEY_2);
+    ioctl(fd, UI_SET_KEYBIT, KEY_3);
+    ioctl(fd, UI_SET_KEYBIT, KEY_4);
+    ioctl(fd, UI_SET_KEYBIT, KEY_5);
+    ioctl(fd, UI_SET_KEYBIT, KEY_6);
+    ioctl(fd, UI_SET_KEYBIT, KEY_7);
+    ioctl(fd, UI_SET_KEYBIT, KEY_8);
+    ioctl(fd, UI_SET_KEYBIT, KEY_9);
+    ioctl(fd, UI_SET_KEYBIT, KEY_0);
+    ioctl(fd, UI_SET_KEYBIT, KEYBOARD_KEY_LCRTL);
+
+    struct uinput_setup dev = {0};
+	strncpy(dev.name, VIRT_KBD_DEV_NAME, UINPUT_MAX_NAME_SIZE-1);
+    dev.id.bustype = BUS_VIRTUAL;
+    dev.id.vendor = VIRT_KBD_DEV_VENDOR_ID;
+	dev.id.product = VIRT_KBD_DEV_PRODUCT_ID;
+    dev.id.version = VIRT_KBD_DEV_VERSION;
+
+    if(ioctl(fd, UI_DEV_SETUP, &dev) < 0) {
+        ret = errno > 0 ? errno : -1 * errno;
+        ret = ret == 0 ? -EIO : ret;
+        goto virt_mouse_init_err;
+    }
+
+    if(ioctl(fd, UI_DEV_CREATE) < 0) {
+        ret = errno > 0 ? errno : -1 * errno;
+        ret = ret == 0 ? -EIO : ret;
+        goto virt_mouse_init_err;
+    }
+
+    // initialization ok
+    kbd->fd = fd;
+    ret = 0;
+
+virt_mouse_init_err:
+    if (ret != 0) {
+        kbd->fd = -1;
+        close(fd);
+    }
+
+    return ret;
+}
+
+int virt_kbd_get_fd(virt_kbd_t *const kbd) {
+    return kbd->fd;
+}
+
+int virt_kbd_send(virt_kbd_t *const kbd, keyboard_status_t *const status, struct timeval *const now) {
+    int res = 0;
+    
+    struct timeval syn_time;
+    gettimeofday(&syn_time, NULL);
+
+    struct input_event tmp_ev;
+    gettimeofday(&tmp_ev.time, NULL);
+    if (now != NULL) {
+        tmp_ev.time = *now;
+    }
+
+    tmp_ev.type = EV_KEY;
+
+    if (status->q != kbd->prev_q) {
+        tmp_ev.code = KEY_Q;
+        tmp_ev.value = kbd->prev_q = status->q;
+        if (write(kbd->fd, &tmp_ev, sizeof(tmp_ev)) != sizeof(struct input_event)) {
+            res = errno < 0 ? errno : -1 * errno;
+            goto virt_kbd_send_err;
+        }
+    }
+
+    if (status->w != kbd->prev_w) {
+        tmp_ev.code = KEY_W;
+        tmp_ev.value = kbd->prev_w = status->w;
+        if (write(kbd->fd, &tmp_ev, sizeof(tmp_ev)) != sizeof(struct input_event)) {
+            res = errno < 0 ? errno : -1 * errno;
+            goto virt_kbd_send_err;
+        }
+    }
+
+    if (status->e != kbd->prev_e) {
+        tmp_ev.code = KEY_E;
+        tmp_ev.value = kbd->prev_e = status->e;
+        if (write(kbd->fd, &tmp_ev, sizeof(tmp_ev)) != sizeof(struct input_event)) {
+            res = errno < 0 ? errno : -1 * errno;
+            goto virt_kbd_send_err;
+        }
+    }
+
+    if (status->r != kbd->prev_r) {
+        tmp_ev.code = KEY_R;
+        tmp_ev.value = kbd->prev_r = status->r;
+        if (write(kbd->fd, &tmp_ev, sizeof(tmp_ev)) != sizeof(struct input_event)) {
+            res = errno < 0 ? errno : -1 * errno;
+            goto virt_kbd_send_err;
+        }
+    }
+
+    if (status->t != kbd->prev_t) {
+        tmp_ev.code = KEY_T;
+        tmp_ev.value = kbd->prev_t = status->t;
+        if (write(kbd->fd, &tmp_ev, sizeof(tmp_ev)) != sizeof(struct input_event)) {
+            res = errno < 0 ? errno : -1 * errno;
+            goto virt_kbd_send_err;
+        }
+    }
+
+    if (status->y != kbd->prev_y) {
+        tmp_ev.code = KEY_Y;
+        tmp_ev.value = kbd->prev_y = status->y;
+        if (write(kbd->fd, &tmp_ev, sizeof(tmp_ev)) != sizeof(struct input_event)) {
+            res = errno < 0 ? errno : -1 * errno;
+            goto virt_kbd_send_err;
+        }
+    }
+
+    if (status->u != kbd->prev_u) {
+        tmp_ev.code = KEY_U;
+        tmp_ev.value = kbd->prev_u = status->u;
+        if (write(kbd->fd, &tmp_ev, sizeof(tmp_ev)) != sizeof(struct input_event)) {
+            res = errno < 0 ? errno : -1 * errno;
+            goto virt_kbd_send_err;
+        }
+    }
+
+    if (status->i != kbd->prev_i) {
+        tmp_ev.code = KEY_I;
+        tmp_ev.value = kbd->prev_i = status->i;
+        if (write(kbd->fd, &tmp_ev, sizeof(tmp_ev)) != sizeof(struct input_event)) {
+            res = errno < 0 ? errno : -1 * errno;
+            goto virt_kbd_send_err;
+        }
+    }
+
+    if (status->o != kbd->prev_o) {
+        tmp_ev.code = KEY_O;
+        tmp_ev.value = kbd->prev_o = status->o;
+        if (write(kbd->fd, &tmp_ev, sizeof(tmp_ev)) != sizeof(struct input_event)) {
+            res = errno < 0 ? errno : -1 * errno;
+            goto virt_kbd_send_err;
+        }
+    }
+
+    if (status->p != kbd->prev_p) {
+        tmp_ev.code = KEY_P;
+        tmp_ev.value = kbd->prev_p = status->p;
+        if (write(kbd->fd, &tmp_ev, sizeof(tmp_ev)) != sizeof(struct input_event)) {
+            res = errno < 0 ? errno : -1 * errno;
+            goto virt_kbd_send_err;
+        }
+    }
+
+    if (status->a != kbd->prev_a) {
+        tmp_ev.code = KEY_A;
+        tmp_ev.value = kbd->prev_a = status->a;
+        if (write(kbd->fd, &tmp_ev, sizeof(tmp_ev)) != sizeof(struct input_event)) {
+            res = errno < 0 ? errno : -1 * errno;
+            goto virt_kbd_send_err;
+        }
+    }
+
+    if (status->s != kbd->prev_s) {
+        tmp_ev.code = KEY_S;
+        tmp_ev.value = kbd->prev_s = status->s;
+        if (write(kbd->fd, &tmp_ev, sizeof(tmp_ev)) != sizeof(struct input_event)) {
+            res = errno < 0 ? errno : -1 * errno;
+            goto virt_kbd_send_err;
+        }
+    }
+
+
+    if (status->d != kbd->prev_d) {
+        tmp_ev.code = KEY_D;
+        tmp_ev.value = kbd->prev_d = status->d;
+        if (write(kbd->fd, &tmp_ev, sizeof(tmp_ev)) != sizeof(struct input_event)) {
+            res = errno < 0 ? errno : -1 * errno;
+            goto virt_kbd_send_err;
+        }
+    }
+
+    if (status->f != kbd->prev_f) {
+        tmp_ev.code = KEY_F;
+        tmp_ev.value = kbd->prev_f = status->f;
+        if (write(kbd->fd, &tmp_ev, sizeof(tmp_ev)) != sizeof(struct input_event)) {
+            res = errno < 0 ? errno : -1 * errno;
+            goto virt_kbd_send_err;
+        }
+    }
+
+    if (status->g != kbd->prev_g) {
+        tmp_ev.code = KEY_G;
+        tmp_ev.value = kbd->prev_g = status->g;
+        if (write(kbd->fd, &tmp_ev, sizeof(tmp_ev)) != sizeof(struct input_event)) {
+            res = errno < 0 ? errno : -1 * errno;
+            goto virt_kbd_send_err;
+        }
+    }
+
+    if (status->h != kbd->prev_h) {
+        tmp_ev.code = KEY_H;
+        tmp_ev.value = kbd->prev_h = status->h;
+        if (write(kbd->fd, &tmp_ev, sizeof(tmp_ev)) != sizeof(struct input_event)) {
+            res = errno < 0 ? errno : -1 * errno;
+            goto virt_kbd_send_err;
+        }
+    }
+
+    if (status->j != kbd->prev_j) {
+        tmp_ev.code = KEY_J;
+        tmp_ev.value = kbd->prev_j = status->j;
+        if (write(kbd->fd, &tmp_ev, sizeof(tmp_ev)) != sizeof(struct input_event)) {
+            res = errno < 0 ? errno : -1 * errno;
+            goto virt_kbd_send_err;
+        }
+    }
+
+    if (status->k != kbd->prev_k) {
+        tmp_ev.code = KEY_K;
+        tmp_ev.value = kbd->prev_k = status->k;
+        if (write(kbd->fd, &tmp_ev, sizeof(tmp_ev)) != sizeof(struct input_event)) {
+            res = errno < 0 ? errno : -1 * errno;
+            goto virt_kbd_send_err;
+        }
+    }
+
+    if (status->l != kbd->prev_l) {
+        tmp_ev.code = KEY_L;
+        tmp_ev.value = kbd->prev_l = status->l;
+        if (write(kbd->fd, &tmp_ev, sizeof(tmp_ev)) != sizeof(struct input_event)) {
+            res = errno < 0 ? errno : -1 * errno;
+            goto virt_kbd_send_err;
+        }
+    }
+
+    if (status->z != kbd->prev_z) {
+        tmp_ev.code = KEY_Z;
+        tmp_ev.value = kbd->prev_z = status->z;
+        if (write(kbd->fd, &tmp_ev, sizeof(tmp_ev)) != sizeof(struct input_event)) {
+            res = errno < 0 ? errno : -1 * errno;
+            goto virt_kbd_send_err;
+        }
+    }
+
+    if (status->x != kbd->prev_x) {
+        tmp_ev.code = KEY_X;
+        tmp_ev.value = kbd->prev_x = status->x;
+        if (write(kbd->fd, &tmp_ev, sizeof(tmp_ev)) != sizeof(struct input_event)) {
+            res = errno < 0 ? errno : -1 * errno;
+            goto virt_kbd_send_err;
+        }
+    }
+
+    if (status->c != kbd->prev_c) {
+        tmp_ev.code = KEY_C;
+        tmp_ev.value = kbd->prev_c = status->c;
+        if (write(kbd->fd, &tmp_ev, sizeof(tmp_ev)) != sizeof(struct input_event)) {
+            res = errno < 0 ? errno : -1 * errno;
+            goto virt_kbd_send_err;
+        }
+    }
+
+    if (status->v != kbd->prev_v) {
+        tmp_ev.code = KEY_V;
+        tmp_ev.value = kbd->prev_v = status->v;
+        if (write(kbd->fd, &tmp_ev, sizeof(tmp_ev)) != sizeof(struct input_event)) {
+            res = errno < 0 ? errno : -1 * errno;
+            goto virt_kbd_send_err;
+        }
+    }
+
+    if (status->b != kbd->prev_b) {
+        tmp_ev.code = KEY_B;
+        tmp_ev.value = kbd->prev_b = status->b;
+        if (write(kbd->fd, &tmp_ev, sizeof(tmp_ev)) != sizeof(struct input_event)) {
+            res = errno < 0 ? errno : -1 * errno;
+            goto virt_kbd_send_err;
+        }
+    }
+
+    if (status->n != kbd->prev_n) {
+        tmp_ev.code = KEY_N;
+        tmp_ev.value = kbd->prev_n = status->n;
+        if (write(kbd->fd, &tmp_ev, sizeof(tmp_ev)) != sizeof(struct input_event)) {
+            res = errno < 0 ? errno : -1 * errno;
+            goto virt_kbd_send_err;
+        }
+    }
+
+    if (status->m != kbd->prev_m) {
+        tmp_ev.code = KEY_M;
+        tmp_ev.value = kbd->prev_m = status->m;
+        if (write(kbd->fd, &tmp_ev, sizeof(tmp_ev)) != sizeof(struct input_event)) {
+            res = errno < 0 ? errno : -1 * errno;
+            goto virt_kbd_send_err;
+        }
+    }
+
+    if (status->num_0 != kbd->prev_num_0) {
+        tmp_ev.code = KEY_0;
+        tmp_ev.value = kbd->prev_num_0 = status->num_0;
+        if (write(kbd->fd, &tmp_ev, sizeof(tmp_ev)) != sizeof(struct input_event)) {
+            res = errno < 0 ? errno : -1 * errno;
+            goto virt_kbd_send_err;
+        }
+    }
+
+    if (status->num_1 != kbd->prev_num_1) {
+        tmp_ev.code = KEY_1;
+        tmp_ev.value = kbd->prev_num_1 = status->num_1;
+        if (write(kbd->fd, &tmp_ev, sizeof(tmp_ev)) != sizeof(struct input_event)) {
+            res = errno < 0 ? errno : -1 * errno;
+            goto virt_kbd_send_err;
+        }
+    }
+
+    if (status->num_2 != kbd->prev_num_2) {
+        tmp_ev.code = KEY_2;
+        tmp_ev.value = kbd->prev_num_2 = status->num_2;
+        if (write(kbd->fd, &tmp_ev, sizeof(tmp_ev)) != sizeof(struct input_event)) {
+            res = errno < 0 ? errno : -1 * errno;
+            goto virt_kbd_send_err;
+        }
+    }
+
+    if (status->num_3 != kbd->prev_num_3) {
+        tmp_ev.code = KEY_3;
+        tmp_ev.value = kbd->prev_num_3 = status->num_3;
+        if (write(kbd->fd, &tmp_ev, sizeof(tmp_ev)) != sizeof(struct input_event)) {
+            res = errno < 0 ? errno : -1 * errno;
+            goto virt_kbd_send_err;
+        }
+    }
+
+    if (status->num_4 != kbd->prev_num_4) {
+        tmp_ev.code = KEY_4;
+        tmp_ev.value = kbd->prev_num_4 = status->num_4;
+        if (write(kbd->fd, &tmp_ev, sizeof(tmp_ev)) != sizeof(struct input_event)) {
+            res = errno < 0 ? errno : -1 * errno;
+            goto virt_kbd_send_err;
+        }
+    }
+
+    if (status->num_5 != kbd->prev_num_5) {
+        tmp_ev.code = KEY_5;
+        tmp_ev.value = kbd->prev_num_5 = status->num_5;
+        if (write(kbd->fd, &tmp_ev, sizeof(tmp_ev)) != sizeof(struct input_event)) {
+            res = errno < 0 ? errno : -1 * errno;
+            goto virt_kbd_send_err;
+        }
+    }
+
+    if (status->num_6 != kbd->prev_num_6) {
+        tmp_ev.code = KEY_6;
+        tmp_ev.value = kbd->prev_num_6 = status->num_6;
+        if (write(kbd->fd, &tmp_ev, sizeof(tmp_ev)) != sizeof(struct input_event)) {
+            res = errno < 0 ? errno : -1 * errno;
+            goto virt_kbd_send_err;
+        }
+    }
+
+    if (status->num_7 != kbd->prev_num_7) {
+        tmp_ev.code = KEY_7;
+        tmp_ev.value = kbd->prev_num_7 = status->num_7;
+        if (write(kbd->fd, &tmp_ev, sizeof(tmp_ev)) != sizeof(struct input_event)) {
+            res = errno < 0 ? errno : -1 * errno;
+            goto virt_kbd_send_err;
+        }
+    }
+
+    if (status->num_8 != kbd->prev_num_8) {
+        tmp_ev.code = KEY_8;
+        tmp_ev.value = kbd->prev_num_8 = status->num_8;
+        if (write(kbd->fd, &tmp_ev, sizeof(tmp_ev)) != sizeof(struct input_event)) {
+            res = errno < 0 ? errno : -1 * errno;
+            goto virt_kbd_send_err;
+        }
+    }
+
+    if (status->num_9 != kbd->prev_num_9) {
+        tmp_ev.code = KEY_9;
+        tmp_ev.value = kbd->prev_num_9 = status->num_9;
+        if (write(kbd->fd, &tmp_ev, sizeof(tmp_ev)) != sizeof(struct input_event)) {
+            res = errno < 0 ? errno : -1 * errno;
+            goto virt_kbd_send_err;
+        }
+    }
+
+    if (status->lctrl != kbd->prev_lctrl) {
+        tmp_ev.code = KEYBOARD_KEY_LCRTL;
+        tmp_ev.value = kbd->prev_lctrl = status->lctrl;
+        if (write(kbd->fd, &tmp_ev, sizeof(tmp_ev)) != sizeof(struct input_event)) {
+            res = errno < 0 ? errno : -1 * errno;
+            goto virt_kbd_send_err;
+        }
+    }
+
+    #if 0
+	const struct input_event timestamp_ev = {
+		.code = MSC_TIMESTAMP,
+		.type = EV_MSC,
+		.value = (now.tv_sec - secAtInit)*1000000 + (now.tv_usec - usecAtInit),
+		.time = now,
+	};
+	const ssize_t timestamp_written = write(fd, (void*)&timestamp_ev, sizeof(timestamp_ev));
+	if (timestamp_written != sizeof(timestamp_ev)) {
+		fprintf(stderr, "Error in sync: written %ld bytes out of %ld\n", timestamp_written, sizeof(timestamp_ev));
+	}
+    #endif
+
+    syn_time.tv_usec += 1;
+	const struct input_event syn_ev = {
+		.code = SYN_REPORT,
+		.type = EV_SYN,
+		.value = 0,
+		.time = syn_time,
+	};
+	const ssize_t sync_written = write(kbd->fd, (void*)&syn_ev, sizeof(syn_ev));
+	if (sync_written != sizeof(syn_ev)) {
+		fprintf(stderr, "Error in sync: written %ld bytes out of %ld\n", sync_written, sizeof(syn_ev));
+	}
+
+virt_kbd_send_err:
+    return res;
+}
+
+void virt_kbd_close(virt_kbd_t *const kbd) {
+    close(kbd->fd);
+}

virt_kbd.h

@@ -0,0 +1,62 @@
+#pragma once
+
+#include "message.h"
+#include "devices_status.h"
+
+#define VIRT_KBD_DEV_NAME "ROGueENEMY - kbd"
+#define VIRT_KBD_DEV_VENDOR_ID 0x108c
+#define VIRT_KBD_DEV_PRODUCT_ID 0x0323
+#define VIRT_KBD_DEV_VERSION 0x0111
+
+typedef struct virt_kbd {
+    int fd;
+
+    uint8_t prev_q;
+    uint8_t prev_w;
+    uint8_t prev_e;
+    uint8_t prev_r;
+    uint8_t prev_t;
+    uint8_t prev_y;
+    uint8_t prev_u;
+    uint8_t prev_i;
+    uint8_t prev_o;
+    uint8_t prev_p;
+    uint8_t prev_a;
+    uint8_t prev_s;
+    uint8_t prev_d;
+    uint8_t prev_f;
+    uint8_t prev_g;
+    uint8_t prev_h;
+    uint8_t prev_j;
+    uint8_t prev_k;
+    uint8_t prev_l;
+    uint8_t prev_z;
+    uint8_t prev_x;
+    uint8_t prev_c;
+    uint8_t prev_v;
+    uint8_t prev_b;
+    uint8_t prev_n;
+    uint8_t prev_m;
+
+    uint8_t prev_num_1;
+    uint8_t prev_num_2;
+    uint8_t prev_num_3;
+    uint8_t prev_num_4;
+    uint8_t prev_num_5;
+    uint8_t prev_num_6;
+    uint8_t prev_num_7;
+    uint8_t prev_num_8;
+    uint8_t prev_num_9;
+    uint8_t prev_num_0;
+
+    uint8_t prev_lctrl;
+
+} virt_kbd_t;
+
+int virt_kbd_init(virt_kbd_t *const mouse);
+
+int virt_kbd_get_fd(virt_kbd_t *const mouse);
+
+int virt_kbd_send(virt_kbd_t *const mouse, keyboard_status_t *const status, struct timeval *const now);
+
+void virt_kbd_close(virt_kbd_t *const mouse);

virt_mouse.c

@@ -1,7 +1,4 @@
 #include "virt_mouse.h"
-#include <linux/input-event-codes.h>
-#include <linux/input.h>
-#include <sys/time.h>
 
 int virt_mouse_init(virt_mouse_t *const mouse) {
     int ret = -EINVAL;

virt_mouse.h

@@ -4,7 +4,6 @@
 #include "devices_status.h"
 
 #define VIRT_MOUSE_DEV_NAME "ROGueENEMY - mouse"
-
 #define VIRT_MOUSE_DEV_VENDOR_ID 0x108c
 #define VIRT_MOUSE_DEV_PRODUCT_ID 0x0323
 #define VIRT_MOUSE_DEV_VERSION 0x0111