static int timer_tick(liqcell *self, liqcellmouseeventargs *args, liqcell *context)
{
liqcell_propseti(self,"timerinterval", 32767 );
liqcell_setenabled(self,0);
// now, run the channel? :D
//liqfilemonitor_run((liqcell*)self->tag);
monitor_run(context);
return 0;
}
int main (int argc, char *argv[]) {
char buffer[128];
int fd_client_to_monitor[2];
int fd_monitor_to_client[2];
int fd_loading_to_monitor[2];
int fd_monitor_to_loading[2];
pid_t child_pid;
unsigned int err = 0;
monitor_data data;
if(getenv("LD_PRELOAD")) {
LOG_ERROR_MONITOR("LD_PRELOAD detected, aborting\n");
return -1;
}
if((getenv(ENV_FD_CLIENT_TO_MONITOR)) ||
(getenv(ENV_FD_MONITOR_TO_CLIENT)) ||
(getenv(ENV_FD_LOADING_TO_MONITOR)) ||
(getenv(ENV_FD_MONITOR_TO_LOADING))) {
LOG_ERROR_MONITOR("inception of monitored programs is not supported\n");
return -1;
}
if(argc < 2) {
LOG_ERROR_MONITOR("usage: %s prog [prog_args ...]\n", argv[0]);
return -2;
}
if(getenv(ENV_SM_TRACE)) {
LOG_DEBUG_MONITOR("%s set, so we are keeping traces\n", ENV_SM_TRACE);
OPTION_sm_trace = 1;
}
if(getenv(ENV_SM_DUMP)) {
OPTION_sm_dump = 1;
}
if(pipe2(fd_client_to_monitor, O_DIRECT)) {
LOG_ERROR_MONITOR("failed to create client to monitor pipe : %s\n", strerror(errno));
return -3;
}
if(pipe2(fd_monitor_to_client, O_DIRECT)) {
LOG_ERROR_MONITOR("failed to create monitor to client pipe : %s\n", strerror(errno));
return -3;
}
if(pipe2(fd_loading_to_monitor, O_DIRECT)) {
LOG_ERROR_MONITOR("failed to create loading to monitor pipe : %s\n", strerror(errno));
return -3;
}
if(pipe2(fd_monitor_to_loading, O_DIRECT)) {
LOG_ERROR_MONITOR("failed to create monitor to loading pipe : %s\n", strerror(errno));
return -3;
}
LOG_DEBUG_MONITOR("forking\n");
if((child_pid = fork()) > 0) {
/* monitor process */
close(fd_client_to_monitor[1]);
close(fd_monitor_to_client[0]);
close(fd_loading_to_monitor[1]);
close(fd_monitor_to_loading[0]);
if((err = mask_sigpipe())) {
LOG_ERROR_MONITOR("cannot mask SIGPIPE\n");
} else if((err = monitor_load(child_pid,
fd_client_to_monitor[0],
fd_monitor_to_client[1],
fd_loading_to_monitor[0],
fd_monitor_to_loading[1],
&data))) {
LOG_ERROR_MONITOR("failed to load monitor data\n");
} else {
if(OPTION_nb_preload_monitor_ok_answers > 0) {
const monitor_answer ok_resp = { .event = CFI_OK };
unsigned int i = 0;
LOG_DEBUG_MONITOR("preloading %u OK answers\n", OPTION_nb_preload_monitor_ok_answers);
while((i < OPTION_nb_preload_monitor_ok_answers) && !err) {
WRITE_MONITOR_ANSWER(data.fd_monitor_to_client, ok_resp, err);
++i;
}
}
LOG_DEBUG_MONITOR("main loop\n");
err = monitor_run(data);
if(!err) {
unsigned int i;
unsigned int nb = 0;
for(i = 0; i < data.nb_modules; ++i) {
nb += data.modules[i].nb_entrypoint_finis;
}
i = 0;
LOG_DEBUG_MONITOR("%u finis are expected\n", nb);
while((i < nb) && !err) {
err = monitor_run(data);
++i;
}
}
}
LOG_DEBUG_MONITOR("exits with status = %i\n", err);
if(err) {
LOG_DEBUG_MONITOR("killing client\n");
kill(child_pid, SIGKILL);
}
monitor_data_free(&data);
return err;
} else if(child_pid == 0) {
int main(int argc,char **argv)
{
static struct option longopts[] =
{
{"help",no_argument,NULL,'h'},
{"version",no_argument,NULL,'V'},
{"verbose",no_argument,NULL,'v'},
{"foreground",no_argument,NULL,'f'},
{"evmap",required_argument,NULL,'e'},
{"socket",required_argument,NULL,'s'},
{"mode",required_argument,NULL,'m'},
{"repeat-filter",no_argument,NULL,'R'},
{"release",required_argument,NULL,'r'},
{0, 0, 0, 0}
};
const char *progname = NULL;
int verbose = 0;
bool foreground = false;
const char *input_device_evmap_dir = EVMAP_DIR;
const char *lircd_socket_path = LIRCD_SOCKET;
mode_t lircd_socket_mode = S_IWUSR | S_IRUSR | S_IWGRP | S_IRGRP | S_IWOTH | S_IROTH;
bool input_repeat_filter = false;
const char *lircd_release_suffix = NULL;
int opt;
for (progname = argv[0] ; strchr(progname, '/') != NULL ; progname = strchr(progname, '/') + 1);
openlog(progname, LOG_CONS | LOG_PERROR | LOG_PID, LOG_DAEMON);
while((opt = getopt_long(argc, argv, "hVvfe:s:m:Rr:", longopts, NULL)) != -1)
{
switch(opt)
{
case 'h':
fprintf(stdout, "Usage: %s [options]\n", progname);
fprintf(stdout, " -h --help print this help message and exit\n");
fprintf(stdout, " -V --version print the program version and exit\n");
fprintf(stdout, " -v --verbose increase the output message verbosity (-v, -vv or -vvv)\n");
fprintf(stdout, " -f --foreground run in the foreground\n");
fprintf(stdout, " -e --evmap=<dir> directory containing input device event map files (default is '%s')\n",
input_device_evmap_dir);
fprintf(stdout, " -s --socket=<socket> lircd socket (default is '%s')\n",
lircd_socket_path);
fprintf(stdout, " -m --mode=<mode> lircd socket mode (default is '%04o')\n",
lircd_socket_mode);
fprintf(stdout, " -R --repeat-filter enable repeat filtering (default is '%s')\n",
input_repeat_filter ? "false" : "true");
fprintf(stdout, " -r --release=<suffix> generate key release events suffixed with <suffix>\n");
exit(EX_OK);
break;
case 'V':
fprintf(stdout, PACKAGE_STRING "\n");
break;
case 'v':
if (verbose < 3)
{
verbose++;
}
else
{
syslog(LOG_WARNING, "the highest verbosity level is -vvv\n");
}
case 'f':
foreground = true;
break;
case 'e':
input_device_evmap_dir = optarg;
break;
case 's':
lircd_socket_path = optarg;
break;
case 'm':
lircd_socket_mode = (mode_t)atol(optarg);
break;
case 'R':
input_repeat_filter = true;
break;
case 'r':
lircd_release_suffix = optarg;
break;
default:
fprintf(stderr, "error: unknown option: %c\n", opt);
exit(EX_USAGE);
}
}
if (verbose == 0)
{
setlogmask(0 | LOG_DEBUG | LOG_INFO | LOG_NOTICE);
}
else if (verbose == 1)
{
setlogmask(0 | LOG_DEBUG | LOG_INFO);
}
else if (verbose == 2)
{
setlogmask(0 | LOG_DEBUG);
}
else
{
setlogmask(0);
}
signal(SIGPIPE, SIG_IGN);
if (monitor_init() != 0)
{
exit(EXIT_FAILURE);
}
/* Initialize the lircd socket before daemonizing in order to ensure that programs
started after it damonizes will have an lircd socket with which to connect. */
if (lircd_init(lircd_socket_path, lircd_socket_mode, lircd_release_suffix) != 0)
{
monitor_exit();
exit(EXIT_FAILURE);
}
if (foreground != true)
{
daemon(0, 0);
}
if (input_init(input_device_evmap_dir, input_repeat_filter) != 0)
{
monitor_exit();
lircd_exit();
exit(EXIT_FAILURE);
}
monitor_run();
if (input_exit() != 0)
{
monitor_exit();
lircd_exit();
exit(EXIT_FAILURE);
}
if (lircd_exit() != 0)
{
monitor_exit();
exit(EXIT_FAILURE);
}
if (monitor_exit() != 0)
{
exit(EXIT_FAILURE);
}
exit(EXIT_SUCCESS);
}
static void server_run(void)
{
analy_run();
monitor_run();
log_run();
}
