mirror of https://github.com/nirenjan/libx52.git
340 lines
8.1 KiB
C
340 lines
8.1 KiB
C
/*
|
|
* Saitek X52 Pro MFD & LED driver - Service daemon
|
|
*
|
|
* Copyright (C) 2021 Nirenjan Krishnan (nirenjan@nirenjan.org)
|
|
*
|
|
* SPDX-License-Identifier: GPL-2.0-only WITH Classpath-exception-2.0
|
|
*/
|
|
|
|
#include "config.h"
|
|
#include <stdio.h>
|
|
#include <stdbool.h>
|
|
#include <string.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <signal.h>
|
|
#include <unistd.h>
|
|
#include <errno.h>
|
|
|
|
#include "x52d_clock.h"
|
|
#include "x52d_const.h"
|
|
#include "x52d_config.h"
|
|
#include "x52d_device.h"
|
|
#include "x52d_io.h"
|
|
#include "x52d_mouse.h"
|
|
#include "pinelog.h"
|
|
|
|
static volatile int flag_quit;
|
|
|
|
static void termination_handler(int signum)
|
|
{
|
|
flag_quit = signum;
|
|
}
|
|
|
|
static volatile bool flag_reload;
|
|
static void reload_handler(int signum)
|
|
{
|
|
flag_reload = true;
|
|
}
|
|
|
|
static volatile bool flag_save_cfg;
|
|
static void save_config_handler(int signum)
|
|
{
|
|
flag_save_cfg = true;
|
|
}
|
|
|
|
static void set_log_file(bool foreground, const char *log_file)
|
|
{
|
|
int rc = 0;
|
|
if (log_file != NULL) {
|
|
rc = pinelog_set_output_file(log_file);
|
|
} else {
|
|
if (foreground) {
|
|
rc = pinelog_set_output_stream(stdout);
|
|
} else {
|
|
rc = pinelog_set_output_file(X52D_LOG_FILE);
|
|
}
|
|
}
|
|
|
|
if (rc != 0) {
|
|
fprintf(stderr, _("Error %d setting log file: %s\n"), rc, strerror(rc));
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
}
|
|
|
|
static void listen_signal(int signum, void (*handler)(int))
|
|
{
|
|
struct sigaction action;
|
|
int rc;
|
|
|
|
action.sa_handler = handler;
|
|
sigemptyset(&action.sa_mask);
|
|
action.sa_flags = 0;
|
|
|
|
rc = sigaction(signum, &action, NULL);
|
|
if (rc < 0) {
|
|
PINELOG_FATAL(_("Error %d installing handler for signal %d: %s"),
|
|
errno, signum, strerror(errno));
|
|
}
|
|
}
|
|
|
|
#if HAVE_FUNC_ATTRIBUTE_NORETURN
|
|
__attribute__((noreturn))
|
|
#endif
|
|
static void usage(int exit_code)
|
|
{
|
|
fprintf(stderr,
|
|
_("Usage: %s [-f] [-v] [-q]\n"
|
|
"\t[-l log-file] [-o override]\n"
|
|
"\t[-c config-file] [-p pid-file]\n"),
|
|
X52D_APP_NAME);
|
|
exit(exit_code);
|
|
}
|
|
|
|
static void start_daemon(bool foreground, const char *pid_file)
|
|
{
|
|
pid_t pid;
|
|
FILE *pid_fd;
|
|
|
|
if (pid_file == NULL) {
|
|
pid_file = X52D_PID_FILE;
|
|
}
|
|
|
|
/* Check if there is an existing daemon process running */
|
|
pid_fd = fopen(pid_file, "r");
|
|
if (pid_fd != NULL) {
|
|
int rc;
|
|
|
|
/* File exists, read the PID and check if it exists */
|
|
rc = fscanf(pid_fd, "%u", &pid);
|
|
fclose(pid_fd);
|
|
|
|
if (rc != 1) {
|
|
perror("fscanf");
|
|
} else {
|
|
rc = kill(pid, 0);
|
|
if (rc == 0 || (rc < 0 && errno == EPERM)) {
|
|
PINELOG_FATAL(_("Daemon is already running as PID %u"), pid);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!foreground) {
|
|
/* Fork off the parent process */
|
|
pid = fork();
|
|
if (pid < 0) {
|
|
/* Error occurred during first fork */
|
|
perror("fork");
|
|
exit(EXIT_FAILURE);
|
|
} else if (pid > 0) {
|
|
/* Terminate the parent process */
|
|
exit(EXIT_SUCCESS);
|
|
}
|
|
|
|
/* Make child process a session leader */
|
|
if (setsid() < 0) {
|
|
perror("setsid");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
}
|
|
|
|
/* Initialize signal handlers. This step is the same whether in foreground
|
|
* or background mode
|
|
*/
|
|
listen_signal(SIGINT, termination_handler);
|
|
listen_signal(SIGTERM, termination_handler);
|
|
listen_signal(SIGQUIT, termination_handler);
|
|
listen_signal(SIGHUP, reload_handler);
|
|
listen_signal(SIGUSR1, save_config_handler);
|
|
|
|
if (!foreground) {
|
|
/* Fork off for the second time */
|
|
pid = fork();
|
|
if (pid < 0) {
|
|
/* Error occurred during second fork */
|
|
perror("fork");
|
|
exit(EXIT_FAILURE);
|
|
} else if (pid > 0) {
|
|
/* Terminate the parent */
|
|
exit(EXIT_SUCCESS);
|
|
}
|
|
}
|
|
|
|
/* Write the PID to the pid_file */
|
|
pid_fd = fopen(pid_file, "w");
|
|
if (pid_fd == NULL) {
|
|
/* Unable to open PID file */
|
|
perror("fopen");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
if (fprintf(pid_fd, "%u\n", getpid()) < 0) {
|
|
perror("fprintf");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
if (fclose(pid_fd) != 0) {
|
|
perror("fclose");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
if (!foreground) {
|
|
/* Set new file permissions */
|
|
umask(0);
|
|
|
|
/* Change the working directory */
|
|
if (chdir("/")) {
|
|
/* Error changing the directory */
|
|
perror("chdir");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
/* Close all open file descriptors */
|
|
for (int x = sysconf(_SC_OPEN_MAX); x >= 0; x--) {
|
|
close(x);
|
|
}
|
|
}
|
|
}
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
int verbosity = 0;
|
|
bool quiet = false;
|
|
bool foreground = false;
|
|
char *log_file = NULL;
|
|
char *conf_file = NULL;
|
|
const char *pid_file = NULL;
|
|
int opt;
|
|
|
|
/* Initialize gettext */
|
|
#if ENABLE_NLS
|
|
setlocale(LC_ALL, "");
|
|
bindtextdomain(PACKAGE, LOCALEDIR);
|
|
textdomain(PACKAGE);
|
|
#endif
|
|
|
|
/* Set system defaults */
|
|
pinelog_set_level(PINELOG_LVL_WARNING);
|
|
|
|
/*
|
|
* Parse command line arguments
|
|
*
|
|
* -f run in foreground
|
|
* -c path to config file
|
|
* -o option overrides
|
|
* -v verbose logging
|
|
* -q silent behavior
|
|
* -l path to log file
|
|
* -p path to PID file (only used if running in background)
|
|
*/
|
|
while ((opt = getopt(argc, argv, "fvql:o:c:p:h")) != -1) {
|
|
switch (opt) {
|
|
case 'f':
|
|
foreground = true;
|
|
break;
|
|
|
|
case 'v':
|
|
if (!quiet) {
|
|
if (verbosity <= PINELOG_LVL_TRACE) {
|
|
verbosity++;
|
|
pinelog_set_level(pinelog_get_level() + 1);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 'q':
|
|
quiet = true;
|
|
pinelog_set_level(PINELOG_LVL_ERROR);
|
|
break;
|
|
|
|
case 'l':
|
|
log_file = optarg;
|
|
break;
|
|
|
|
case 'o':
|
|
if (x52d_config_save_override(optarg)) {
|
|
fprintf(stderr,
|
|
_("Unable to parse configuration override '%s'\n"),
|
|
optarg);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
break;
|
|
|
|
case 'c':
|
|
conf_file = optarg;
|
|
break;
|
|
|
|
case 'p':
|
|
pid_file = optarg;
|
|
break;
|
|
|
|
case 'h':
|
|
usage(EXIT_SUCCESS);
|
|
break;
|
|
|
|
default:
|
|
usage(EXIT_FAILURE);
|
|
break;
|
|
}
|
|
}
|
|
|
|
PINELOG_DEBUG(_("Foreground = %s"), foreground ? _("true") : _("false"));
|
|
PINELOG_DEBUG(_("Quiet = %s"), quiet ? _("true") : _("false"));
|
|
PINELOG_DEBUG(_("Verbosity = %d"), verbosity);
|
|
PINELOG_DEBUG(_("Log file = %s"), log_file);
|
|
PINELOG_DEBUG(_("Config file = %s"), conf_file);
|
|
|
|
start_daemon(foreground, pid_file);
|
|
|
|
set_log_file(foreground, log_file);
|
|
x52d_config_load(conf_file);
|
|
|
|
// Start device threads
|
|
x52d_dev_init();
|
|
x52d_clock_init();
|
|
#if defined(HAVE_EVDEV)
|
|
x52d_io_init();
|
|
x52d_mouse_evdev_init();
|
|
#endif
|
|
|
|
// Apply configuration
|
|
x52d_config_apply();
|
|
|
|
flag_quit = 0;
|
|
while(!flag_quit) {
|
|
// TODO: Replace with main event loop
|
|
// Let all threads run in background forever
|
|
sleep(600);
|
|
|
|
/* Check if we need to reload configuration */
|
|
if (flag_reload) {
|
|
PINELOG_INFO(_("Reloading X52 configuration"));
|
|
x52d_config_load(conf_file);
|
|
x52d_config_apply();
|
|
flag_reload = false;
|
|
}
|
|
|
|
if (flag_save_cfg) {
|
|
PINELOG_INFO(_("Saving X52 configuration to disk"));
|
|
x52d_config_save(conf_file);
|
|
flag_save_cfg = false;
|
|
}
|
|
}
|
|
|
|
PINELOG_INFO(_("Received termination signal %s"), strsignal(flag_quit));
|
|
|
|
// Stop device threads
|
|
x52d_clock_exit();
|
|
x52d_dev_exit();
|
|
#if defined(HAVE_EVDEV)
|
|
x52d_mouse_evdev_exit();
|
|
x52d_io_exit();
|
|
#endif
|
|
|
|
// Remove the PID file
|
|
PINELOG_TRACE("Removing PID file %s", pid_file);
|
|
unlink(pid_file);
|
|
|
|
PINELOG_INFO(_("Shutting down X52 daemon"));
|
|
|
|
return 0;
|
|
}
|