NeroReflex/ROGueENEMY
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Compare commits

base: NeroReflex:5e3a1e4e985c2e4511232b545b7708598e489e4f
Branches Tags
NeroReflex:main
NeroReflex:devel
NeroReflex:enomem
...
compare: NeroReflex:c9354dc3578575743228a9bf73bf9c868221b1ff
Branches Tags
NeroReflex:devel
NeroReflex:main
NeroReflex:enomem

3 commits
5e3a1e4e98 ... c9354dc357

Author SHA1 Message Date
Denis
c9354dc357
keyboard should work now 2023-12-17 02:22:29 +01:00
Denis
c6ecb53bd3
chatgpt blatantly refused to write this so I had to do it myself. 2023-12-17 01:38:06 +01:00
Denis
046f635de6
Removed useless files 2023-12-17 00:35:23 +01:00
12 changed files with 1336 additions and 309 deletions
Download patch file Download diff file Expand all files Collapse all files

2
CMakeLists.txt
View file

@ -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

167
dev_out.c
View file

@ -6,6 +6,7 @@
#include "virt_ds4.h"
#include "virt_ds5.h"
#include "virt_mouse.h"
#include "virt_kbd.h"
#include <libconfig.h>
@ -198,6 +199,140 @@ static void handle_incoming_message_gamepad_set(
}
}
static void handle_incoming_message_keyboard_set(
const dev_out_settings_t *const in_settings,
const in_message_keyboard_set_element_t *const msg_payload,
keyboard_status_t *const inout_kbd
) {
switch (msg_payload->type) {
case KEYBOARD_KEY_Q:
inout_kbd->q = msg_payload->value;
break;
case KEYBOARD_KEY_W:
inout_kbd->w = msg_payload->value;
break;
case KEYBOARD_KEY_E:
inout_kbd->e = msg_payload->value;
break;
case KEYBOARD_KEY_R:
inout_kbd->r = msg_payload->value;
break;
case KEYBOARD_KEY_T:
inout_kbd->t = msg_payload->value;
break;
case KEYBOARD_KEY_Y:
inout_kbd->y = msg_payload->value;
break;
case KEYBOARD_KEY_U:
inout_kbd->u = msg_payload->value;
break;
case KEYBOARD_KEY_I:
inout_kbd->i = msg_payload->value;
break;
case KEYBOARD_KEY_O:
inout_kbd->o = msg_payload->value;
break;
case KEYBOARD_KEY_P:
inout_kbd->p = msg_payload->value;
break;
case KEYBOARD_KEY_A:
inout_kbd->a = msg_payload->value;
break;
case KEYBOARD_KEY_S:
inout_kbd->s = msg_payload->value;
break;
case KEYBOARD_KEY_D:
inout_kbd->d = msg_payload->value;
break;
case KEYBOARD_KEY_F:
inout_kbd->f = msg_payload->value;
break;
case KEYBOARD_KEY_G:
inout_kbd->g = msg_payload->value;
break;
case KEYBOARD_KEY_H:
inout_kbd->h = msg_payload->value;
break;
case KEYBOARD_KEY_J:
inout_kbd->j = msg_payload->value;
break;
case KEYBOARD_KEY_K:
inout_kbd->k = msg_payload->value;
break;
case KEYBOARD_KEY_L:
inout_kbd->l = msg_payload->value;
break;
case KEYBOARD_KEY_Z:
inout_kbd->z = msg_payload->value;
break;
case KEYBOARD_KEY_X:
inout_kbd->x = msg_payload->value;
break;
case KEYBOARD_KEY_C:
inout_kbd->c = msg_payload->value;
break;
case KEYBOARD_KEY_V:
inout_kbd->v = msg_payload->value;
break;
case KEYBOARD_KEY_B:
inout_kbd->b = msg_payload->value;
break;
case KEYBOARD_KEY_N:
inout_kbd->n = msg_payload->value;
break;
case KEYBOARD_KEY_M:
inout_kbd->m = msg_payload->value;
break;
case KEYBOARD_KEY_UP:
inout_kbd->up = msg_payload->value;
break;
case KEYBOARD_KEY_DOWN:
inout_kbd->down = msg_payload->value;
break;
case KEYBOARD_KEY_LEFT:
inout_kbd->left = msg_payload->value;
break;
case KEYBOARD_KEY_RIGHT:
inout_kbd->right = msg_payload->value;
break;
case KEYBOARD_KEY_NUM_0:
inout_kbd->num_0 = msg_payload->value;
break;
case KEYBOARD_KEY_NUM_1:
inout_kbd->num_1 = msg_payload->value;
break;
case KEYBOARD_KEY_NUM_2:
inout_kbd->num_2 = msg_payload->value;
break;
case KEYBOARD_KEY_NUM_3:
inout_kbd->num_3 = msg_payload->value;
break;
case KEYBOARD_KEY_NUM_4:
inout_kbd->num_4 = msg_payload->value;
break;
case KEYBOARD_KEY_NUM_5:
inout_kbd->num_5 = msg_payload->value;
break;
case KEYBOARD_KEY_NUM_6:
inout_kbd->num_6 = msg_payload->value;
break;
case KEYBOARD_KEY_NUM_7:
inout_kbd->num_7 = msg_payload->value;
break;
case KEYBOARD_KEY_NUM_8:
inout_kbd->num_8 = msg_payload->value;
break;
case KEYBOARD_KEY_NUM_9:
inout_kbd->num_9 = msg_payload->value;
break;
case KEYBOARD_KEY_LCRTL:
inout_kbd->lctrl = msg_payload->value;
break;
default:
fprintf(stderr, "key not implemented\n");
}
}
static void handle_incoming_message(
const dev_out_settings_t *const in_settings,
const in_message_t *const msg,
@ -221,6 +356,12 @@ static void handle_incoming_message(
&msg->data.mouse_event,
&dev_stats->mouse
);
} else if (msg->type == KEYBOARD_SET_ELEMENT) {
handle_incoming_message_keyboard_set(
in_settings,
&msg->data.kbd_set,
&dev_stats->kbd
);
}
}
@ -272,6 +413,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 +492,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 +521,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 +626,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 +685,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

47
devices_status.c
View file

@ -1,7 +1,53 @@
#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->up = 0;
stats->down = 0;
stats->left = 0;
stats->right = 0;
stats->lctrl = 0;
}
void mouse_status_init(mouse_status_t *const stats) {
@ -53,6 +99,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);

9
devices_status.h
View file

@ -67,6 +67,15 @@ 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 up, down, left, right;
uint8_t lctrl;
} keyboard_status_t;

54
message.h
View file

@ -82,23 +82,73 @@ 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_UP,
KEYBOARD_KEY_DOWN,
KEYBOARD_KEY_LEFT,
KEYBOARD_KEY_RIGHT,
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;

276
platform.c
View file

@ -1,276 +0,0 @@
#include <asm-generic/errno-base.h>
#include <stdlib.h>
#include <libudev.h>
#include <dirent.h>
#include "platform.h"
static const char* const platform_input_path = "/sys/devices/platform/asus-mcu.0/input/mode";
static int hidraw_cycle_to_mode(const char* const path, int controller_mode) {
int res = 0;
if ((controller_mode < 0) || (controller_mode > 2)) {
res = -EINVAL;
goto hidraw_cycle_to_mode_err_mode;
}
const char* hidraw_subdir = "/hidraw/";
const unsigned long len = strlen(path) + strlen(hidraw_subdir) + 64;
char* hidraw_path = malloc(len + 1);
if (hidraw_path == NULL) {
res = -ENOMEM;
goto hidraw_cycle_to_mode_err_path;
}
memset(hidraw_path, 0, len + 1);
strcat(hidraw_path, path);
strcat(hidraw_path, hidraw_subdir);
DIR *d;
struct dirent *dir;
d = opendir(hidraw_path);
if (d) {
while ((dir = readdir(d)) != NULL) {
if (strstr(dir->d_name, "hidraw") == NULL) { // h as in hidraw
continue;
}
memset(hidraw_path, 0, len + 1);
strcat(hidraw_path, "/dev/");
strcat(hidraw_path, dir->d_name);
//strcat(hidraw_path, dir->d_name);
//strcat(hidraw_path, "/dev");
printf("Using hidraw located at: %s\n", hidraw_path);
int fd = open(hidraw_path, O_RDWR);
if (fd == -1) {
fprintf(stderr, "Error opening hidraw device %s\n", hidraw_path);
res = -EIO;
goto hidraw_cycle_to_mode_err;
}
for (int i = 0; i < 23; ++i) {
const int write_res = write(fd, &rc71l_mode_switch_commands[controller_mode][i][0], 64);
if (write_res != 64) {
fprintf(stderr, "Error writing packet %d/23: %d bytes sent, 64 expected\n", i, write_res);
break;
}
}
close(fd);
if (res == 0) {
printf("Control messages sent successfully.\n");
} else {
goto hidraw_cycle_to_mode_err;
}
}
}
hidraw_cycle_to_mode_err:
free(hidraw_path);
hidraw_cycle_to_mode_err_path:
hidraw_cycle_to_mode_err_mode:
return res;
}
static char* find_device(struct udev *udev) {
struct udev_enumerate *const enumerate = udev_enumerate_new(udev);
if (enumerate == NULL) {
fprintf(stderr, "Error in udev_enumerate_new: mode switch will not be available.\n");
return NULL;
}
const int add_match_subsystem_res = udev_enumerate_add_match_subsystem(enumerate, "hid");
if (add_match_subsystem_res != 0) {
fprintf(stderr, "Error in udev_enumerate_add_match_subsystem: %d\n", add_match_subsystem_res);
udev_enumerate_unref(enumerate);
return NULL;
}
const int add_match_sysattr_res = udev_enumerate_add_match_sysattr(enumerate, "gamepad_mode", NULL);
if (add_match_sysattr_res != 0) {
fprintf(stderr, "Error in udev_enumerate_add_match_sysattr: %d\n", add_match_sysattr_res);
udev_enumerate_unref(enumerate);
return NULL;
}
const int enumerate_scan_devices_res = udev_enumerate_scan_devices(enumerate);
if (enumerate_scan_devices_res != 0) {
fprintf(stderr, "Error in udev_enumerate_scan_devices: %d\n", enumerate_scan_devices_res);
udev_enumerate_unref(enumerate);
return NULL;
}
struct udev_list_entry *const udev_lst_frst = udev_enumerate_get_list_entry(enumerate);
struct udev_list_entry *list_entry = NULL;
udev_list_entry_foreach(list_entry, udev_lst_frst) {
const char* const name = udev_list_entry_get_name(list_entry);
const unsigned long len = strlen(name) + 1;
char *const result = malloc(len);
memset(result, 0, len);
strncat(result, name, len - 1);
udev_enumerate_unref(enumerate);
return result;
}
udev_enumerate_unref(enumerate);
return NULL;
}
int init_platform(rc71l_platform_t *const platform) {
platform->udev = NULL;
if (access(platform_input_path, F_OK) != 0) {
fprintf(stderr, "Unable to find the MCU platform mode file %s: asus-mcu not found.\n", platform_input_path);
/* create udev object */
platform->udev = udev_new();
if (platform->udev == NULL) {
fprintf(stderr, "Cannot create udev context: mode switch will not be available.\n");
platform->mode = -1;
return -ENOENT;
}
char *const dev_name = find_device(platform->udev);
if (dev_name == NULL) {
fprintf(stderr, "Cannot locate asus-mcu device: mode switch will not be available.\n");
platform->mode = -1;
return -ENOENT;
} else {
printf("Asus MCU over hidraw: %s -- mode will be reset\n", dev_name);
platform->platform_mode = rc71l_platform_mode_hidraw;
platform->modes_count = 2;
platform->mode = 0;
// reset to mode 0: game mode
const int reset_res = hidraw_cycle_to_mode(dev_name, 0);
if (reset_res != 0) {
fprintf(stderr, "Unable to reset Asus MCU over hidraw: %d -- Asus MCU will be unavailable.\n", reset_res);
free(dev_name);
return -EIO;
}
// find_device does malloc
free(dev_name);
return 0;
}
return -ENOENT;
}
FILE* mode_file = fopen(platform_input_path, "r");
if (mode_file == NULL) {
fprintf(stderr, "Unable to open the MCU platform mode file %s: modes cannot be switched.\n", platform_input_path);
platform->mode = -1;
return -EINVAL;
}
char mode_str[12];
unsigned long read_bytes = fread((void*)&mode_str[0], 1, sizeof(mode_str), mode_file);
if (read_bytes < 1) {
fprintf(stderr, "Unable to read the MCU platform mode file %s: no bytes.\n", platform_input_path);
fclose(mode_file);
platform->mode = -1;
return -EINVAL;
}
platform->mode = strtoul(&mode_str[0], NULL, 10);
fclose(mode_file);
printf("Asus MCU platform found: current mode %lu\n", platform->mode);
platform->modes_count = 2;
platform->platform_mode = rc71l_platform_mode_asus_mcu;
return 0;
}
int cycle_mode(rc71l_platform_t *const platform) {
if (platform == NULL) {
return -ENOENT;
}
char new_mode_str[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00
};
unsigned long new_mode = (platform->mode + 1) % platform->modes_count;
sprintf(new_mode_str, "%lu\n", new_mode);
if (platform->platform_mode == rc71l_platform_mode_hidraw) {
char *const dev_name = find_device(platform->udev);
if (dev_name == NULL) {
fprintf(stderr, "Unable to locate Asus MCU hidraw to mode-switch. Mode will not be switched.\n");
return -ENOENT;
}
const int next_mode = (platform->mode + 1) % platform->modes_count;
const int reset_res = hidraw_cycle_to_mode(dev_name, next_mode);
if (reset_res != 0) {
fprintf(stderr, "Unable to change mode of Asus MCU over hidraw: %d.\n", reset_res);
}
free(dev_name);
platform->mode = next_mode;
printf("Used hidraw to switch Asus MCU to mode %lu\n", platform->mode);
return reset_res;
} else if (platform->platform_mode == rc71l_platform_mode_asus_mcu) {
FILE* mode_file = fopen(platform_input_path, "w");
if (mode_file == NULL) {
fprintf(stderr, "Unable to open the MCU platform mode file %s: modes cannot be switched.\n", platform_input_path);
return -1;
}
size_t len = strlen(new_mode_str);
const int write_bytes = fwrite((void*)&new_mode_str[0], 1, len, mode_file);
if (write_bytes < len) {
fprintf(stderr, "Error writing new mode: expected to write %d bytes, %d written.\n", (int)len, (int)write_bytes);
return -EIO;
}
platform->mode = new_mode;
printf("Used asus-mcu to switch Asus MCU to mode %lu\n", platform->mode);
fclose(mode_file);
}
return -ENOENT;
}
int is_mouse_mode(rc71l_platform_t *const platform) {
return platform != NULL ? platform->mode == 1 : 0;
}

23
platform.h
View file

@ -1,23 +0,0 @@
#pragma once
#include "rogue_enemy.h"
typedef enum rc71l_platform_mode {
rc71l_platform_mode_hidraw,
rc71l_platform_mode_asus_mcu,
} rc71l_platform_mode_t;
typedef struct rc71l_platform {
struct udev *udev;
rc71l_platform_mode_t platform_mode;
unsigned long mode;
unsigned int modes_count;
} rc71l_platform_t;
int init_platform(rc71l_platform_t *const platform);
int cycle_mode(rc71l_platform_t *const platform);
int is_mouse_mode(rc71l_platform_t *const platform);

486
rog_ally.c
View file

@ -219,7 +219,7 @@ static int asus_kbd_ev_map(
sscanf(current_mode_str, "%d", &current_mode);
const int new_mode = get_next_mode(current_mode);
printf("Current mode is set to %d (read from %s) -- switching to %d", current_mode, current_mode_str, new_mode);
printf("Current mode is set to %d (read from %s) -- switching to %d\n", current_mode, current_mode_str, new_mode);
char new_mode_str[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
snprintf(new_mode_str, sizeof(new_mode_str) - 1, "%d", new_mode);
@ -236,10 +236,10 @@ static int asus_kbd_ev_map(
}
} else {
close(gamepad_mode_fd);
fprintf(stderr, "Unable to read gamepad_mode file to get current mode: %d", errno);
fprintf(stderr, "Unable to read gamepad_mode file to get current mode: %d\n", errno);
}
} else {
fprintf(stderr, "Unable to open gamepad_mode file in read-only mode to get current mode: %d", errno);
fprintf(stderr, "Unable to open gamepad_mode file in read-only mode to get current mode: %d\n", errno);
}
free(tmp_path);
@ -283,6 +283,486 @@ static int asus_kbd_ev_map(
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_Q) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_Q,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_W) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_W,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_E) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_E,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_R) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_R,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_T) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_T,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_Y) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_Y,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_U) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_U,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_I) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_I,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_O) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_O,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_P) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_P,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_A) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_A,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_S) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_S,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_D) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_D,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_F) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_F,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_G) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_G,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_H) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_H,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_J) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_J,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_K) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_K,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_L) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_L,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_Z) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_Z,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_X) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_X,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_C) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_C,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_V) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_V,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_B) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_B,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_N) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_N,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_M) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_M,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_0) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_NUM_0,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_1) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_NUM_1,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_2) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_NUM_2,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_3) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_NUM_3,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_4) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_NUM_4,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_5) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_NUM_5,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_6) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_NUM_6,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_7) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_NUM_7,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_8) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_NUM_8,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_9) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_NUM_9,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_UP) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_UP,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_DOWN) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_DOWN,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_LEFT) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_LEFT,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_RIGHT) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_RIGHT,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
}
} else if (e->ev[i].type == EV_REL) {

510
virt_kbd.c Normal file
View file

@ -0,0 +1,510 @@
#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 (status->up != kbd->prev_up) {
tmp_ev.code = KEYBOARD_KEY_UP;
tmp_ev.value = kbd->prev_up = status->up;
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->down != kbd->prev_down) {
tmp_ev.code = KEYBOARD_KEY_DOWN;
tmp_ev.value = kbd->prev_down = status->down;
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->left != kbd->prev_left) {
tmp_ev.code = KEYBOARD_KEY_LEFT;
tmp_ev.value = kbd->prev_left = status->left;
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->right != kbd->prev_right) {
tmp_ev.code = KEYBOARD_KEY_RIGHT;
tmp_ev.value = kbd->prev_right = status->right;
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);
}

67
virt_kbd.h Normal file
View file

@ -0,0 +1,67 @@
#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_up;
uint8_t prev_down;
uint8_t prev_left;
uint8_t prev_right;
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);

3
virt_mouse.c
View file

@ -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;

1
virt_mouse.h
View file

@ -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