/*
- * 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;
};
+/** Stdout/stderr of the executing process is read in chunks of this size. */
#define COMMAND_BUF_SIZE 32768
-struct cmd_task {
- struct task task;
+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() */
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;
static void shutdown_curses(void)
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. */
// 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);
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
reread_conf();
return 1;
case SIGCHLD:
- check_sigchld();
+ task_notify_all(s, E_GUI_SIGCHLD);
return 1;
}
return 1;
}
-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, struct task *t)
+static int exec_post_select(struct sched *s, void *context)
{
- struct cmd_task *ct = container_of(t, struct cmd_task, task);
+ struct exec_task *ct = context;
int i, ret;
- 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],
+ 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;
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 */
- wrefresh(bot.win);
+ 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;
+ close(exec_fds[i]);
+ exec_fds[i] = -1;
ct->flags[i] = 0;
ct->cbo[i] = 0;
- if (command_fds[!i] < 0) /* both fds closed */
+ if (exec_fds[!i] < 0) /* both fds closed */
return 1;
}
if (ct->cbo[i] == COMMAND_BUF_SIZE - 1) {
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;
-
- 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);
-}
+ char *file_and_args;
-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 suitable actions according to any signals received.
+ * For example it refreshes all windows on terminal size changes and resets the
+ * terminal on \p SIGTERM.
+ *
+ * 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 */
projects / paraslash.git / blobdiff