Xtea/Xtea.c

/**
 * Xtea is a program that executes a given command or program after a given
 * time if no X11 keybord or mouse input happend in the given time.
 *
 * Author: Johannes Findeisen <you@hanez.org> - 2025
 * License: Apache-2.0 (see LICENSE)
 */

#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>
#include <X11/extensions/XInput2.h>
#include <X11/Xlib.h>

#define VERSION "0.1.0"

void print_help(const char *program_name)
{
    printf("Usage: %s [-d] [-v] [-h] <seconds> <program> [arguments...]\n", program_name);
    printf("\n");
    printf("Options:\n");
    printf("  -d             Run in daemon mode. Restart the program after inactivity.\n");
    printf("  -v             Show the program version and exit.\n");
    printf("  -h             Show this help message and exit.\n");
    printf("\n");
    printf("Arguments:\n");
    printf("  <seconds>      Time (in seconds) to wait after inactivity before running the program.\n");
    printf("  <program>      Program to execute after the specified delay.\n");
    printf("  [arguments...] Optional arguments to pass to the program.\n");
    printf("\n");
    printf("Examples:\n");
    printf("  %s 5 ls -ls    Execute 'ls -l' after 5 seconds of inactivity.\n", program_name);
    printf("  %s -d 10 echo 'Hello'    Run 'echo Hello' in daemon mode after 10 seconds of inactivity.\n", program_name);
}

int main(int argc, char *argv[])
{
    if (argc < 2) {
        print_help(argv[0]);
        return EXIT_FAILURE;
    }

    // Check for version or help flags
    if (strcmp(argv[1], "-v") == 0) {
        printf("%s: %s\n", argv[0], VERSION);
        return EXIT_SUCCESS;
    }

    if (strcmp(argv[1], "-h") == 0) {
        print_help(argv[0]);
        return EXIT_SUCCESS;
    }

    // Check for daemon mode
    int daemon_mode = 0;
    int arg_offset = 1;

    if (strcmp(argv[1], "-d") == 0) {
        daemon_mode = 1;
        arg_offset = 2; // Adjust argument offset for parsing other parameters
    }

    if (argc < arg_offset + 2) {
        print_help(argv[0]);
        return EXIT_FAILURE;
    }

    // Validate the first parameter (wait time)
    char *endptr;
    long wait_time = strtol(argv[arg_offset], &endptr, 10);
    if (*endptr != '\0' || wait_time <= 0 || wait_time > INT_MAX) {
        fprintf(stderr, "Error: First argument must be a positive integer within the range 1 to %d.\n", INT_MAX);
        return EXIT_FAILURE;
    }

    // Safely cast the wait_time to an int
    int wait_time_seconds = (int)wait_time;

    // Initialize X11 display
    Display *display = XOpenDisplay(NULL);
    if (!display) {
        fprintf(stderr, "Error: Unable to open X display.\n");
        return EXIT_FAILURE;
    }

    // Check for XInput2 support
    int opcode, event, error;
    if (!XQueryExtension(display, "XInputExtension", &opcode, &event, &error)) {
        fprintf(stderr, "Error: X Input Extension is not supported on this display.\n");
        XCloseDisplay(display);
        return EXIT_FAILURE;
    }

    // Select events to monitor (keyboard, mouse clicks, and motion)
    Window root = DefaultRootWindow(display);
    XIEventMask evmask;
    unsigned char mask[(XI_LASTEVENT + 7) / 8] = {0};
    evmask.deviceid = XIAllDevices;
    evmask.mask_len = sizeof(mask);
    evmask.mask = mask;

    XISetMask(mask, XI_KeyPress);
    XISetMask(mask, XI_KeyRelease);
    XISetMask(mask, XI_ButtonPress);
    XISetMask(mask, XI_ButtonRelease);
    XISetMask(mask, XI_Motion); // Listen for mouse motion events

    if (XISelectEvents(display, root, &evmask, 1) != Success) {
        fprintf(stderr, "Error: Unable to select input events.\n");
        XCloseDisplay(display);
        return EXIT_FAILURE;
    }

    do {
        // Timer logic with input monitoring
        time_t start_time, current_time;
        start_time = time(NULL);

        while (1) {
            current_time = time(NULL);

            // Check if the timer has expired
            if (current_time - start_time >= wait_time_seconds) {
                break;
            }

            // Check for input events
            while (XPending(display) > 0) {
                XEvent event;
                XNextEvent(display, &event);

                if (event.xcookie.type == GenericEvent &&
                    event.xcookie.extension == opcode &&
                    XGetEventData(display, &event.xcookie)) {
                    XIDeviceEvent *xi_event = (XIDeviceEvent *)event.xcookie.data;
                    if (xi_event->evtype == XI_KeyPress ||
                        xi_event->evtype == XI_ButtonPress ||
                        xi_event->evtype == XI_Motion) {
                        // Reset the timer on input or mouse movement
                        start_time = time(NULL);
                    }
                    XFreeEventData(display, &event.xcookie);
                }
            }

            // Sleep briefly to reduce CPU usage
            usleep(10000); // 10 milliseconds
        }

        // Execute the program with optional arguments
        pid_t pid = fork();
        if (pid == 0) {
            execvp(argv[arg_offset + 1], &argv[arg_offset + 1]);

            // If execvp returns, an error occurred
            perror("Error executing program");
            exit(EXIT_FAILURE);
        } else if (pid < 0) {
            perror("Error forking to execute program");
        } else {
            // Wait for the child process to finish
            waitpid(pid, NULL, 0);
        }
    } while (daemon_mode);

    // Close the X display
    XCloseDisplay(display);

    return EXIT_SUCCESS;
}