/*
- * Copyright (C) 1998-2014 Andre Noll <maan@systemlinux.org>
+ * Copyright (C) 1998 Andre Noll <maan@tuebingen.mpg.de>
*
* Licensed under the GPL v2. For licencing details see COPYING.
*/
static struct gui_window {
WINDOW *win;
+ bool needs_update;
} top, bot, sb, in, sep;
+/** How many lines of output to remember. */
#define RINGBUFFER_SIZE 512
+
struct rb_entry {
char *msg;
size_t len;
static unsigned scroll_position;
-static pid_t cmd_pid;
+static pid_t exec_pid;
-static int command_fds[2] = {-1, -1};
+static int exec_fds[2] = {-1, -1};
static struct gui_args_info conf;
static int loglevel;
-enum cmd_status {
- CMDS_IDLE, /* no command running */
- CMDS_DCMD, /* para or display command running */
- CMDS_XCMD, /* external command running */
+/** Type of the process currently being executed. */
+enum exec_status {
+ EXEC_IDLE, /**< No process running. */
+ EXEC_DCMD, /**< para or display process running. */
+ EXEC_XCMD, /**< External process running. */
};
/**
static struct gui_command command_list[] = {GUI_COMMANDS {.name = NULL}};
struct input_task {
- struct task task;
+ struct task *task;
};
struct status_task {
- struct task task;
+ struct task *task;
+ pid_t pid;
char *buf;
int bufsize, loaded;
struct timeval next_exec;
int fd;
};
-struct cmd_task {
- struct task task;
+/** Stdout/stderr of the executing process is read in chunks of this size. */
+#define COMMAND_BUF_SIZE 32768
+
+struct exec_task {
+ struct task *task;
+ char command_buf[2][COMMAND_BUF_SIZE]; /* stdout/stderr of command */
+ int cbo[2]; /* command buf offsets */
+ unsigned flags[2]; /* passed to for_each_line() */
};
-static int find_cmd_byname(char *name)
+static int find_cmd_byname(const char *name)
{
int i;
/* Print given number of spaces to curses window. */
static void add_spaces(WINDOW* win, unsigned int num)
{
- char space[] = " ";
- unsigned sz = sizeof(space) - 1; /* number of spaces */
+ const char space[] = " ";
+ const unsigned sz = sizeof(space) - 1; /* number of spaces */
while (num >= sz) {
waddstr(win, space);
}
if (num > 0) {
assert(num < sz);
- space[num] = '\0';
- waddstr(win, space);
+ waddstr(win, space + sz - num);
}
}
* print aligned string to curses window. This function always prints
* exactly len chars.
*/
-static int align_str(WINDOW* win, char *str, unsigned int len,
+static int align_str(WINDOW* win, const char *str, unsigned int len,
unsigned int align)
{
- int ret, i, num; /* of spaces */
+ int ret, num; /* of spaces */
size_t width;
+ char *sstr; /* sanitized string */
if (!win || !str)
return 0;
- ret = strwidth(str, &width);
+ ret = sanitize_str(str, len, &sstr, &width);
if (ret < 0) {
PARA_ERROR_LOG("%s\n", para_strerror(-ret));
width = 0;
- str[0] = '\0';
+ sstr = para_strdup(NULL);
}
+ assert(width <= len);
num = len - width;
- if (num < 0) {
- str[len] = '\0';
- num = 0;
- }
- /* replace control characters by spaces */
- for (i = 0; i < len && str[i]; i++) {
- if (str[i] == '\n' || str[i] == '\r' || str[i] == '\f')
- str[i] = ' ';
- }
if (align == LEFT) {
- waddstr(win, str);
+ waddstr(win, sstr);
add_spaces(win, num);
} else if (align == RIGHT) {
add_spaces(win, num);
- waddstr(win, str);
+ waddstr(win, sstr);
} else {
add_spaces(win, num / 2);
- waddstr(win, str[0]? str: "");
+ waddstr(win, sstr);
add_spaces(win, num - num / 2);
}
+ free(sstr);
return 1;
}
+static void refresh_window(struct gui_window *gw)
+{
+ gw->needs_update = true;
+}
+
+static bool window_update_needed(void)
+{
+ return top.needs_update || bot.needs_update || sb.needs_update ||
+ in.needs_update || sep.needs_update;
+}
+
__printf_2_3 static void print_in_bar(int color, const char *fmt,...)
{
char *msg;
wmove(in.win, 0, 0);
align_str(in.win, msg, get_num_cols(&in), LEFT);
free(msg);
- wrefresh(in.win);
+ refresh_window(&in);
}
static void print_status_bar(void)
waddstr(bot.win, rbe->msg);
}
out:
- wrefresh(bot.win);
+ refresh_window(&bot);
}
static void rb_add_entry(int color, char *msg)
xvasprintf(&msg, fmt, ap);
va_end(ap);
rb_add_entry(color, msg);
- wrefresh(bot.win);
+ refresh_window(&bot);
}
static int add_output_line(char *line, void *data)
if (bytes > 0 && msg[bytes - 1] == '\n')
msg[bytes - 1] = '\0'; /* cut trailing newline */
rb_add_entry(color, msg);
- wrefresh(bot.win);
- } else if (cmd_pid <= 0) /* no external command running */
+ refresh_window(&bot);
+ } else if (exec_pid <= 0) /* no external command running */
vfprintf(stderr, fmt, ap);
va_end(ap);
}
+/** The log function of para_gui, always set to curses_log(). */
__printf_2_3 void (*para_log)(int, const char*, ...) = curses_log;
+/* Call endwin() to reset the terminal into non-visual mode. */
static void shutdown_curses(void)
{
- def_prog_mode();
+ /*
+ * If para_gui received a terminating signal in external mode, the
+ * terminal can be in an unusable state at this point because the child
+ * process might not have caught the signal. In this case endwin() has
+ * already been called and must not be called again. So we first return
+ * to program mode, then call endwin().
+ */
+ if (!curses_active())
+ reset_prog_mode();
endwin();
}
{
va_list argp;
+ /* Kill every process in our process group. */
+ para_sigaction(SIGTERM, SIG_IGN);
+ kill(0, SIGTERM);
+ /* Wait up to two seconds for child processes to die. */
+ alarm(2);
+ while (waitpid(0, NULL, 0) >= 0)
+ ; /* nothing */
+ alarm(0);
+ /* mousemask() exists only in ncurses */
+#ifdef NCURSES_MOUSE_VERSION
+ mousemask(~(mmask_t)0, NULL); /* Avoid bad terminal state with xterm. */
+#endif
shutdown_curses();
va_start(argp, fmt);
vfprintf(stderr, fmt, argp);
va_end(argp);
- /* kill every process in the process group and exit */
- para_sigaction(SIGTERM, SIG_IGN);
- kill(0, SIGTERM);
exit(exit_code);
}
return;
tmp = make_message("%s%s%s", d.prefix, c, d.postfix);
wmove(top.win, d.y * top_lines / 100, d.x * COLS / 100);
- wrefresh(top.win);
wattron(top.win, COLOR_PAIR(i + 1));
align_str(top.win, tmp, d.len * COLS / 100, d.align);
free(tmp);
- wrefresh(top.win);
+ refresh_window(&top);
}
static int update_item(int item_num, char *buf)
}
}
-static void status_pre_select(struct sched *s, struct task *t)
+static void status_pre_select(struct sched *s, void *context)
{
- struct status_task *st = container_of(t, struct status_task, task);
+ struct status_task *st = context;
if (st->fd >= 0)
- return para_fd_set(st->fd, &s->rfds, &s->max_fileno);
- sched_request_barrier_or_min_delay(&st->next_exec, s);
+ para_fd_set(st->fd, &s->rfds, &s->max_fileno);
+ if (task_get_notification(st->task) < 0)
+ return sched_min_delay(s);
+ if (st->fd < 0)
+ sched_request_barrier_or_min_delay(&st->next_exec, s);
}
-static int status_post_select(struct sched *s, struct task *t)
+static int status_post_select(struct sched *s, void *context)
{
- struct status_task *st = container_of(t, struct status_task, task);
+ struct status_task *st = context;
size_t sz;
- pid_t pid;
int ret, ret2;
+ ret = task_get_notification(st->task);
+ if (ret == -E_GUI_SIGCHLD && st->pid > 0) {
+ int exit_status;
+ if (waitpid(st->pid, &exit_status, WNOHANG) == st->pid) {
+ st->pid = 0;
+ PARA_ERROR_LOG("stat command exit status: %d",
+ exit_status);
+ }
+ }
if (st->fd < 0) {
int fds[3] = {0, 1, 0};
+ if (st->pid > 0)
+ return 0;
/* Avoid busy loop */
if (tv_diff(&st->next_exec, now, NULL) > 0)
return 0;
st->next_exec.tv_sec = now->tv_sec + 2;
- ret = para_exec_cmdline_pid(&pid, conf.stat_cmd_arg, fds);
+ ret = para_exec_cmdline_pid(&st->pid, conf.stat_cmd_arg, fds);
if (ret < 0)
return 0;
ret = mark_fd_nonblocking(fds[1]);
ret2 = for_each_stat_item(st->buf, st->loaded, update_item);
if (ret < 0 || ret2 < 0) {
st->loaded = 0;
- PARA_NOTICE_LOG("closing stat pipe: %s\n", para_strerror(-ret));
+ PARA_NOTICE_LOG("closing stat pipe: %s\n",
+ para_strerror(ret < 0? -ret : -ret2));
close(st->fd);
st->fd = -1;
clear_all_items();
int bot_lines = LINES - top_lines - 3, sb_lines = 1, in_lines = 1,
sep_lines = 1;
- assume_default_colors(theme.default_fg, theme.default_bg);
+ assume_default_colors(theme.dflt.fg, theme.dflt.bg);
if (top.win) {
wresize(top.win, top_lines, COLS);
mvwin(top.win, top_y, 0);
die(EXIT_FAILURE, "fatal: failed to start colors\n");
FOR_EACH_STATUS_ITEM(i)
if (theme.data[i].len)
- init_pair_or_die(i + 1, theme.data[i].fg,
- theme.data[i].bg);
- init_pair_or_die(COLOR_STATUSBAR, theme.sb_fg, theme.sb_bg);
- init_pair_or_die(COLOR_COMMAND, theme.cmd_fg, theme.cmd_bg);
- init_pair_or_die(COLOR_OUTPUT, theme.output_fg, theme.output_bg);
- init_pair_or_die(COLOR_MSG, theme.msg_fg, theme.msg_bg);
- init_pair_or_die(COLOR_ERRMSG, theme.err_msg_fg, theme.err_msg_bg);
- init_pair_or_die(COLOR_SEPARATOR, theme.sep_fg, theme.sep_bg);
- init_pair_or_die(COLOR_TOP, theme.default_fg, theme.default_bg);
- init_pair_or_die(COLOR_BOT, theme.default_fg, theme.default_bg);
+ init_pair_or_die(i + 1, theme.data[i].color.fg,
+ theme.data[i].color.bg);
+ init_pair_or_die(COLOR_STATUSBAR, theme.sb.fg, theme.sb.bg);
+ init_pair_or_die(COLOR_COMMAND, theme.cmd.fg, theme.cmd.bg);
+ init_pair_or_die(COLOR_OUTPUT, theme.output.fg, theme.output.bg);
+ init_pair_or_die(COLOR_MSG, theme.msg.fg, theme.msg.bg);
+ init_pair_or_die(COLOR_ERRMSG, theme.err_msg.fg, theme.err_msg.bg);
+ init_pair_or_die(COLOR_SEPARATOR, theme.sep.fg, theme.sep.bg);
+ init_pair_or_die(COLOR_TOP, theme.dflt.fg, theme.dflt.bg);
+ init_pair_or_die(COLOR_BOT, theme.dflt.fg, theme.dflt.bg);
}
/* (Re-)initialize the curses library. */
{
if (curses_active())
return;
- if (top.win && refresh() == ERR) /* refresh is really needed */
+ if (refresh() == ERR) /* refresh is really needed */
die(EXIT_FAILURE, "refresh() failed\n");
if (LINES < theme.lines_min || COLS < theme.cols_min)
die(EXIT_FAILURE, "Terminal (%dx%d) too small"
// noecho(); /* don't echo input */
}
-static void check_sigchld(void)
-{
- int ret;
- pid_t pid;
-
-reap_next_child:
- ret = para_reap_child(&pid);
- if (ret <= 0)
- return;
- if (pid == cmd_pid) {
- cmd_pid = 0;
- init_curses();
- print_in_bar(COLOR_MSG, " ");
- }
- goto reap_next_child;
-}
-
/*
* This sucker modifies its first argument. *handler and *arg are
* pointers to 0-terminated strings (inside line). Crap.
}
goto out;
}
+ /*
+ * When the gengetopt config file parser is called more than once, any
+ * key map arguments found in the config file are _appended_ to the old
+ * values, even though we turn on ->override. We want the new arguments
+ * to replace the old ones, so we must empty the key_map_arg array
+ * first. Unfortunately, this also clears any key map arguments given
+ * at the command line.
+ */
+ if (override) {
+ int i;
+ for (i = 0; i < conf.key_map_given; i++) {
+ free(conf.key_map_arg[i]);
+ conf.key_map_arg[i] = NULL;
+ }
+ conf.key_map_given = 0;
+ }
+
gui_cmdline_parser_config_file(config_file, &conf, ¶ms);
loglevel = get_loglevel_by_name(conf.loglevel_arg);
check_key_map_args_or_die();
- theme_init(conf.theme_arg, &theme);
err = false;
out:
free(config_file);
if (err)
exit(EXIT_FAILURE);
+ theme_init(conf.theme_arg, &theme);
}
/* reread configuration, terminate on errors */
/*
* React to various signal-related events
*/
-static int signal_post_select(struct sched *s, __a_unused struct task *t)
+static int signal_post_select(struct sched *s, __a_unused void *context)
{
int ret = para_next_signal(&s->rfds);
switch (ret) {
case SIGTERM:
die(EXIT_FAILURE, "only the good die young (caught SIGTERM)\n");
- return 1;
- case SIGWINCH:
- if (curses_active()) {
- shutdown_curses();
- init_curses();
- redraw_bot_win();
- }
- return 1;
case SIGINT:
- PARA_WARNING_LOG("caught SIGINT, reset\n");
- /* Nothing to do. SIGINT killed our child which gets noticed
- * by do_select and resets everything.
- */
return 1;
case SIGUSR1:
PARA_NOTICE_LOG("got SIGUSR1, rereading configuration\n");
reread_conf();
return 1;
case SIGCHLD:
- check_sigchld();
+ task_notify_all(s, E_GUI_SIGCHLD);
return 1;
}
return 1;
}
-#define COMMAND_BUF_SIZE 32768
-
-static enum cmd_status cmd_status(void)
+static enum exec_status exec_status(void)
{
- if (command_fds[0] >= 0 || command_fds[1] >= 0)
- return CMDS_DCMD;
- if (cmd_pid > 0)
- return CMDS_XCMD;
- return CMDS_IDLE;
+ if (exec_fds[0] >= 0 || exec_fds[1] >= 0)
+ return EXEC_DCMD;
+ if (exec_pid > 0)
+ return EXEC_XCMD;
+ return EXEC_IDLE;
}
-static void command_pre_select(struct sched *s, __a_unused struct task *t)
+static void exec_pre_select(struct sched *s, void *context)
{
- enum cmd_status cmds = cmd_status();
-
- if (cmds != CMDS_DCMD)
- return;
- if (command_fds[0] >= 0)
- para_fd_set(command_fds[0], &s->rfds, &s->max_fileno);
- if (command_fds[1] >= 0)
- para_fd_set(command_fds[1], &s->rfds, &s->max_fileno);
+ struct exec_task *et = context;
+ if (exec_fds[0] >= 0)
+ para_fd_set(exec_fds[0], &s->rfds, &s->max_fileno);
+ if (exec_fds[1] >= 0)
+ para_fd_set(exec_fds[1], &s->rfds, &s->max_fileno);
+ if (task_get_notification(et->task) < 0)
+ sched_min_delay(s);
}
-static int command_post_select(struct sched *s, __a_unused struct task *t)
+static int exec_post_select(struct sched *s, void *context)
{
+ struct exec_task *ct = context;
int i, ret;
- static char command_buf[2][COMMAND_BUF_SIZE];
- static int cbo[2]; /* command buf offsets */
- static unsigned flags[2]; /* for for_each_line() */
- enum cmd_status cmds = cmd_status();
- if (cmds != CMDS_DCMD)
- return 0;
+ ret = task_get_notification(ct->task);
+ if (ret == -E_GUI_SIGCHLD && exec_pid > 0) {
+ int exit_status;
+ if (waitpid(exec_pid, &exit_status, WNOHANG) == exec_pid) {
+ exec_pid = 0;
+ init_curses();
+ PARA_INFO_LOG("command exit status: %d", exit_status);
+ print_in_bar(COLOR_MSG, " ");
+ }
+ }
for (i = 0; i < 2; i++) {
size_t sz;
- if (command_fds[i] < 0)
+ if (exec_fds[i] < 0)
continue;
- ret = read_nonblock(command_fds[i],
- command_buf[i] + cbo[i],
- COMMAND_BUF_SIZE - 1 - cbo[i], &s->rfds, &sz);
- cbo[i] += sz;
- sz = cbo[i];
- cbo[i] = for_each_line(flags[i], command_buf[i], cbo[i],
- add_output_line, &i);
- if (sz != cbo[i]) { /* at least one line found */
- wrefresh(bot.win);
- flags[i] = 0;
+ ret = read_nonblock(exec_fds[i],
+ ct->command_buf[i] + ct->cbo[i],
+ COMMAND_BUF_SIZE - 1 - ct->cbo[i], &s->rfds, &sz);
+ ct->cbo[i] += sz;
+ sz = ct->cbo[i];
+ ct->cbo[i] = for_each_line(ct->flags[i], ct->command_buf[i],
+ ct->cbo[i], add_output_line, &i);
+ if (sz != ct->cbo[i]) { /* at least one line found */
+ refresh_window(&bot);
+ ct->flags[i] = 0;
}
- if (ret < 0 || cmd_pid == 0) {
+ if (ret < 0 || exec_pid == 0) {
if (ret < 0)
PARA_NOTICE_LOG("closing command fd %d: %s",
i, para_strerror(-ret));
- close(command_fds[i]);
- command_fds[i] = -1;
- flags[i] = 0;
- cbo[i] = 0;
- if (command_fds[!i] < 0) /* both fds closed */
+ close(exec_fds[i]);
+ exec_fds[i] = -1;
+ ct->flags[i] = 0;
+ ct->cbo[i] = 0;
+ if (exec_fds[!i] < 0) /* both fds closed */
return 1;
}
- if (cbo[i] == COMMAND_BUF_SIZE - 1) {
+ if (ct->cbo[i] == COMMAND_BUF_SIZE - 1) {
PARA_NOTICE_LOG("discarding overlong line");
- cbo[i] = 0;
- flags[i] = FELF_DISCARD_FIRST;
+ ct->cbo[i] = 0;
+ ct->flags[i] = FELF_DISCARD_FIRST;
}
}
return 0;
}
-static void input_pre_select(struct sched *s, __a_unused struct task *t)
+static void input_pre_select(struct sched *s, __a_unused void *context)
{
- enum cmd_status cmds = cmd_status();
-
- if (cmds != CMDS_XCMD)
+ if (exec_status() != EXEC_XCMD)
para_fd_set(STDIN_FILENO, &s->rfds, &s->max_fileno);
+ if (window_update_needed())
+ sched_min_delay(s);
}
/* read from command pipe and print data to bot window */
-static void exec_and_display_cmd(const char *cmd)
+static void exec_and_display(const char *file_and_args)
{
int ret, fds[3] = {0, 1, 1};
- outputf(COLOR_COMMAND, "%s", cmd);
- ret = para_exec_cmdline_pid(&cmd_pid, cmd, fds);
+ outputf(COLOR_COMMAND, "%s", file_and_args);
+ ret = para_exec_cmdline_pid(&exec_pid, file_and_args, fds);
if (ret < 0)
return;
ret = mark_fd_nonblocking(fds[1]);
ret = mark_fd_nonblocking(fds[2]);
if (ret < 0)
goto fail;
- command_fds[0] = fds[1];
- command_fds[1] = fds[2];
+ exec_fds[0] = fds[1];
+ exec_fds[1] = fds[2];
+ print_in_bar(COLOR_MSG, "hit any key to abort\n");
return;
fail:
PARA_ERROR_LOG("%s\n", para_strerror(-ret));
- close(command_fds[0]);
- close(command_fds[1]);
+ close(exec_fds[0]);
+ close(exec_fds[1]);
}
-static void para_cmd(char *cmd)
+static void exec_para(const char *args)
{
- char *c;
+ char *file_and_args;
- print_in_bar(COLOR_MSG, "executing client command, hit any key to abort\n");
- c = make_message(BINDIR "/para_client -- %s", cmd);
- exec_and_display_cmd(c);
- free(c);
-}
-
-static void display_cmd(char *cmd)
-{
- print_in_bar(COLOR_MSG, "executing display command, hit any key to abort");
- exec_and_display_cmd(cmd);
+ file_and_args = make_message(BINDIR "/para_client -- %s", args);
+ exec_and_display(file_and_args);
+ free(file_and_args);
}
/*
* shutdown curses and stat pipe before executing external commands
*/
-static void external_cmd(char *cmd)
+static void exec_external(char *file_and_args)
{
int fds[3] = {-1, -1, -1};
- if (cmd_pid)
+ if (exec_pid)
return;
shutdown_curses();
- para_exec_cmdline_pid(&cmd_pid, cmd, fds);
+ para_exec_cmdline_pid(&exec_pid, file_and_args, fds);
}
static void handle_command(int c)
continue;
}
if (*handler == 'd')
- display_cmd(arg);
+ exec_and_display(arg);
else if (*handler == 'x')
- external_cmd(arg);
+ exec_external(arg);
else if (*handler == 'p')
- para_cmd(arg);
+ exec_para(arg);
else if (*handler == 'i') {
int num = find_cmd_byname(arg);
if (num >= 0)
km_keyname(c));
}
-static int input_post_select(__a_unused struct sched *s, __a_unused struct task *t)
+static int input_post_select(__a_unused struct sched *s, __a_unused void *context)
{
int ret;
- enum cmd_status cmds = cmd_status();
+ enum exec_status exs = exec_status();
- if (cmds == CMDS_XCMD)
+ if (exs == EXEC_XCMD)
return 0;
+ if (window_update_needed()) {
+ if (top.needs_update)
+ assert(wnoutrefresh(top.win) == OK);
+ if (bot.needs_update)
+ assert(wnoutrefresh(bot.win) == OK);
+ if (sep.needs_update)
+ assert(wnoutrefresh(sep.win) == OK);
+ if (sb.needs_update)
+ assert(wnoutrefresh(sb.win) == OK);
+ if (in.needs_update)
+ assert(wnoutrefresh(in.win) == OK);
+ doupdate();
+ top.needs_update = bot.needs_update = sb.needs_update =
+ in.needs_update = sep.needs_update = false;
+ }
ret = wgetch(top.win);
- if (ret == ERR || ret == KEY_RESIZE)
+ if (ret == ERR)
return 0;
- if (cmds == CMDS_IDLE) {
- handle_command(ret);
+ if (ret == KEY_RESIZE) {
+ if (curses_active()) {
+ shutdown_curses();
+ init_curses();
+ redraw_bot_win();
+ }
return 0;
}
- if (cmd_pid != 0)
- kill(cmd_pid, SIGTERM);
+ if (exs == EXEC_IDLE)
+ handle_command(ret);
+ else if (exec_pid > 0)
+ kill(exec_pid, SIGTERM);
return 0;
}
-static void signal_pre_select(struct sched *s, struct task *t)
-{
- struct signal_task *st = container_of(t, struct signal_task, task);
- para_fd_set(st->fd, &s->rfds, &s->max_fileno);
-}
-
static void print_scroll_msg(void)
{
unsigned lines_total, filled = ringbuffer_filled(bot_win_rb);
wmove(bot.win, bot_lines - rbe_lines, 0);
wattron(bot.win, COLOR_PAIR(rbe->color));
waddstr(bot.win, rbe->msg);
- wrefresh(bot.win);
+ refresh_window(&bot);
print_scroll_msg();
}
break;
i--;
}
- wrefresh(bot.win);
+ refresh_window(&bot);
print_scroll_msg();
return;
err_out:
static int setup_tasks_and_schedule(void)
{
+ int ret;
+ struct exec_task exec_task = {.task = NULL};
+ struct status_task status_task = {.fd = -1};
+ struct input_task input_task = {.task = NULL};
+ struct signal_task *signal_task;
struct sched sched = {
.default_timeout = {
.tv_sec = conf.timeout_arg / 1000,
.tv_usec = (conf.timeout_arg % 1000) * 1000,
},
};
- struct cmd_task cmd_task = {
- .task = {
- .status = "cmd",
- .pre_select = command_pre_select,
- .post_select = command_post_select,
- },
- };
- struct status_task status_task = {
- .task = {
- .status = "status",
- .pre_select = status_pre_select,
- .post_select = status_post_select,
- },
- .fd = -1
- };
- struct input_task input_task = {
- .task = {
- .status = "input",
- .pre_select = input_pre_select,
- .post_select = input_post_select,
- },
- };
- struct signal_task signal_task = {
- .task = {
- .status = "signal",
- .pre_select = signal_pre_select,
- .post_select = signal_post_select,
- },
- };
- signal_task.fd = para_signal_init();
+
+ exec_task.task = task_register(&(struct task_info) {
+ .name = "exec",
+ .pre_select = exec_pre_select,
+ .post_select = exec_post_select,
+ .context = &exec_task,
+ }, &sched);
+
+ status_task.task = task_register(&(struct task_info) {
+ .name = "status",
+ .pre_select = status_pre_select,
+ .post_select = status_post_select,
+ .context = &status_task,
+ }, &sched);
+
+ input_task.task = task_register(&(struct task_info) {
+ .name = "input",
+ .pre_select = input_pre_select,
+ .post_select = input_post_select,
+ .context = &input_task,
+ }, &sched);
+
+ signal_task = signal_init_or_die();
para_install_sighandler(SIGINT);
para_install_sighandler(SIGTERM);
para_install_sighandler(SIGCHLD);
- para_install_sighandler(SIGWINCH);
para_install_sighandler(SIGUSR1);
-
- register_task(&sched, &cmd_task.task);
- register_task(&sched, &status_task.task);
- register_task(&sched, &input_task.task);
- register_task(&sched, &signal_task.task);
- return schedule(&sched);
+ signal_task->task = task_register(&(struct task_info) {
+ .name = "signal",
+ .pre_select = signal_pre_select,
+ .post_select = signal_post_select,
+ .context = signal_task,
+ }, &sched);
+ ret = schedule(&sched);
+ sched_shutdown(&sched);
+ signal_shutdown(signal_task);
+ return ret;
}
+/**
+ * The main function of para_gui.
+ *
+ * \param argc Usual argument count.
+ * \param argv Usual argument vector.
+ *
+ * After initialization para_gui registers the following tasks to the paraslash
+ * scheduler: status, exec, signal, input.
+ *
+ * The status task executes the para_audioc stat command to obtain the status
+ * of para_server and para_audiod, and displays this information in the top
+ * window of para_gui.
+ *
+ * The exec task is responsible for printing the output of the currently
+ * running executable to the bottom window.
+ *
+ * The signal task performs various actions according to signals received. For
+ * example, it reloads the configuration file on SIGUSR1, and it shuts down the
+ * curses system on SIGTERM to restore the terminal settings before exit.
+ *
+ * The input task reads single key strokes from stdin. For each key pressed, it
+ * executes the command handler associated with this key.
+ *
+ * \return \p EXIT_SUCCESS or \p EXIT_FAILURE.
+ */
int main(int argc, char *argv[])
{
gui_cmdline_parser(argc, argv, &conf); /* exits on errors */