X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=gui.c;h=8e83cc53c6d55f53ccdb0a9dfbb4c89f0bb7525a;hp=ae585b8b3434d6253cc382cf310a3b2560de5ef4;hb=21c6e0b09b42e61e72b741bd726856ab0bcd1d64;hpb=f127354753a643a070958f577f31251a3f58115f diff --git a/gui.c b/gui.c index ae585b8b..8e83cc53 100644 --- a/gui.c +++ b/gui.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 1998-2014 Andre Noll + * Copyright (C) 1998 Andre Noll * * Licensed under the GPL v2. For licencing details see COPYING. */ @@ -26,17 +26,19 @@ #include "ggo.h" #include "version.h" -/** define the array of error lists needed by para_gui */ -INIT_GUI_ERRLISTS; -static char *stat_content[NUM_STAT_ITEMS]; +/** Array of error strings. */ +DEFINE_PARA_ERRLIST; -static int signal_pipe; +static char *stat_content[NUM_STAT_ITEMS]; 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; @@ -46,15 +48,18 @@ static struct ringbuffer *bot_win_rb; static unsigned scroll_position; -static pid_t cmd_pid; +static pid_t exec_pid; -static int command_fds[2] = {-1, -1}; -static int stat_pipe = -1; +static int exec_fds[2] = {-1, -1}; static struct gui_args_info conf; static int loglevel; -enum {GETCH_MODE, COMMAND_MODE, EXTERNAL_MODE}; - +/** 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. */ +}; /** * Codes for various colors. @@ -82,116 +87,67 @@ struct gui_command { static struct gui_theme theme; -static void com_help(void); -static void com_reread_conf(void); -static void com_enlarge_top_win(void); -static void com_shrink_top_win(void); -static void com_version(void); -__noreturn static void com_quit(void); -static void com_refresh(void); -static void com_ll_incr(void); -static void com_ll_decr(void); -static void com_prev_theme(void); -static void com_next_theme(void); -static void com_scroll_up(void); -static void com_scroll_down(void); -static void com_page_up(void); -static void com_page_down(void); -static void com_cancel_scrolling(void); -static void com_scroll_top(void); - -static struct gui_command command_list[] = { - { - .key = "?", - .name = "help", - .description = "print help", - .handler = com_help - }, { - .key = "+", - .name = "enlarge_win", - .description = "enlarge the top window", - .handler = com_enlarge_top_win - }, { - .key = "-", - .name = "shrink_win", - .description = "shrink the top window", - .handler = com_shrink_top_win - }, { - .key = "r", - .name = "reread_conf", - .description = "reread configuration file", - .handler = com_reread_conf - }, { - .key = "q", - .name = "quit", - .description = "exit para_gui", - .handler = com_quit - }, { - .key = "^L", - .name = "refresh", - .description = "redraw the screen", - .handler = com_refresh - }, { - .key = ".", - .name = "next_theme", - .description = "switch to next theme", - .handler = com_next_theme - }, { - .key = ",", - .name = "prev_theme", - .description = "switch to previous stream", - .handler = com_prev_theme - }, { - .key = ">", - .name = "ll_incr", - .description = "increase loglevel (decreases verbosity)", - .handler = com_ll_incr - }, { - .key = "<", - .name = "ll_decr", - .description = "decrease loglevel (increases verbosity)", - .handler = com_ll_decr - }, { - .key = "V", - .name = "version", - .description = "show the para_gui version", - .handler = com_version - }, { - .key = "", - .name = "scroll_up", - .description = "scroll up one line", - .handler = com_scroll_up - }, { - .key = "", - .name = "scroll_down", - .description = "scroll down one line", - .handler = com_scroll_down - }, { - .key = "", - .name = "page_up", - .description = "scroll up one page", - .handler = com_page_up - }, { - .key = "", - .name = "page_down", - .description = "scroll down one page", - .handler = com_page_down - }, { - .key = "", - .name = "scroll_top", - .description = "scroll to top of buffer", - .handler = com_scroll_top - }, { - .key = "", - .name = "cancel_scroll", - .description = "deactivate scroll mode", - .handler = com_cancel_scrolling - }, { - .handler = NULL - } +#define GUI_COMMANDS \ + GUI_COMMAND(help, "?", "print help") \ + GUI_COMMAND(enlarge_top_win, "+", "enlarge the top window") \ + GUI_COMMAND(shrink_top_win, "-", "shrink the top window") \ + GUI_COMMAND(reread_conf, "r", "reread configuration file") \ + GUI_COMMAND(quit, "q", "exit para_gui") \ + GUI_COMMAND(refresh, "^L", "redraw the screen") \ + GUI_COMMAND(next_theme, ".", "switch to next theme") \ + GUI_COMMAND(prev_theme, ",", "switch to previous theme") \ + GUI_COMMAND(ll_incr, ">", "increase loglevel (decreases verbosity)") \ + GUI_COMMAND(ll_decr, "<", "decrease loglevel (increases verbosity)") \ + GUI_COMMAND(version, "V", "show the para_gui version") \ + GUI_COMMAND(scroll_up, "", "scroll up one line") \ + GUI_COMMAND(scroll_down, "", "scroll_down") \ + GUI_COMMAND(page_up, "", "scroll up one page") \ + GUI_COMMAND(page_down, "", "scroll down one page") \ + GUI_COMMAND(scroll_top, "", "scroll to top of buffer") \ + GUI_COMMAND(cancel_scroll, "", "deactivate scroll mode") \ + +/* declare command handlers */ +#define GUI_COMMAND(_c, _k, _d) \ + static void com_ ## _c(void); +GUI_COMMANDS + +#undef GUI_COMMAND + +/* define command array */ +#define GUI_COMMAND(_c, _k, _d) \ + { \ + .key = _k, \ + .name = #_c, \ + .description = _d, \ + .handler = com_ ## _c \ + }, + +static struct gui_command command_list[] = {GUI_COMMANDS {.name = NULL}}; + +struct input_task { + struct task *task; +}; + +struct status_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 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; @@ -291,8 +247,8 @@ static char *km_keyname(int c) /* 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); @@ -300,8 +256,7 @@ static void add_spaces(WINDOW* win, unsigned int num) } if (num > 0) { assert(num < sz); - space[num] = '\0'; - waddstr(win, space); + waddstr(win, space + sz - num); } } @@ -309,44 +264,49 @@ static void add_spaces(WINDOW* win, unsigned int 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; @@ -361,7 +321,7 @@ __printf_2_3 static void print_in_bar(int color, const char *fmt,...) 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) @@ -457,7 +417,7 @@ static void redraw_bot_win(void) waddstr(bot.win, rbe->msg); } out: - wrefresh(bot.win); + refresh_window(&bot); } static void rb_add_entry(int color, char *msg) @@ -504,7 +464,7 @@ __printf_2_3 static void outputf(int color, const char* fmt,...) 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) @@ -531,26 +491,26 @@ static __printf_2_3 void curses_log(int ll, const char *fmt,...) 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 setup_signal_handling(void) -{ - signal_pipe = para_signal_init(); - para_install_sighandler(SIGINT); - para_install_sighandler(SIGTERM); - para_install_sighandler(SIGCHLD); - para_install_sighandler(SIGWINCH); - para_install_sighandler(SIGUSR1); -} - +/* 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(); } @@ -559,13 +519,22 @@ __noreturn __printf_2_3 static void die(int exit_code, const char* fmt, ...) { 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); } @@ -583,11 +552,10 @@ static void print_stat_item(int i) 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) @@ -641,44 +609,84 @@ static void clear_all_items(void) } } -static void status_post_select(fd_set *rfds) +static void status_pre_select(struct sched *s, void *context) { - static char *buf; - static int bufsize, loaded; - int ret, ret2; + struct status_task *st = context; + + if (st->fd >= 0) + 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, void *context) +{ + struct status_task *st = context; size_t sz; + int ret, ret2; - if (stat_pipe < 0) - return; - if (loaded >= bufsize) { - if (bufsize > 1000 * 1000) { - loaded = 0; - return; + 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); } - bufsize += bufsize + 1000; - buf = para_realloc(buf, bufsize); } - assert(loaded < bufsize); - ret = read_nonblock(stat_pipe, buf + loaded, bufsize - loaded, - rfds, &sz); - loaded += sz; - ret2 = for_each_stat_item(buf, loaded, update_item); + 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(&st->pid, conf.stat_cmd_arg, fds); + if (ret < 0) + return 0; + ret = mark_fd_nonblocking(fds[1]); + if (ret < 0) { + close(fds[1]); + return 0; + } + st->fd = fds[1]; + return 0; + } + + if (st->loaded >= st->bufsize) { + if (st->bufsize > 1000 * 1000) { + st->loaded = 0; + return 0; + } + st->bufsize += st->bufsize + 1000; + st->buf = para_realloc(st->buf, st->bufsize); + } + assert(st->loaded < st->bufsize); + ret = read_nonblock(st->fd, st->buf + st->loaded, + st->bufsize - st->loaded, &s->rfds, &sz); + st->loaded += sz; + ret2 = for_each_stat_item(st->buf, st->loaded, update_item); if (ret < 0 || ret2 < 0) { - loaded = 0; - PARA_NOTICE_LOG("closing stat pipe: %s\n", para_strerror(-ret)); - close(stat_pipe); - stat_pipe = -1; + st->loaded = 0; + PARA_NOTICE_LOG("closing stat pipe: %s\n", + para_strerror(ret < 0? -ret : -ret2)); + close(st->fd); + st->fd = -1; clear_all_items(); free(stat_content[SI_BASENAME]); stat_content[SI_BASENAME] = para_strdup("stat command terminated!?"); print_all_items(); - return; + return 0; } sz = ret2; /* what is left */ - if (sz > 0 && sz < loaded) - memmove(buf, buf + loaded - sz, sz); - loaded = sz; + if (sz > 0 && sz < st->loaded) + memmove(st->buf, st->buf + st->loaded - sz, sz); + st->loaded = sz; + return 0; } /* @@ -691,7 +699,7 @@ static void init_wins(int top_lines) 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); @@ -763,16 +771,16 @@ static void init_colors_or_die(void) 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. */ @@ -780,7 +788,7 @@ static void init_curses(void) { 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" @@ -800,20 +808,6 @@ static void init_curses(void) // 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; - goto reap_next_child; -} - /* * This sucker modifies its first argument. *handler and *arg are * pointers to 0-terminated strings (inside line). Crap. @@ -889,15 +883,32 @@ static void parse_config_file_or_die(bool override) } 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 */ @@ -916,209 +927,113 @@ static void reread_conf(void) /* * React to various signal-related events */ -static void handle_signal(int sig) +static int signal_post_select(struct sched *s, __a_unused void *context) { - switch (sig) { + int ret = para_next_signal(&s->rfds); + + if (ret <= 0) + return 0; + switch (ret) { case SIGTERM: die(EXIT_FAILURE, "only the good die young (caught SIGTERM)\n"); - return; - case SIGWINCH: - if (curses_active()) { - shutdown_curses(); - init_curses(); - redraw_bot_win(); - } - return; 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; + return 1; case SIGUSR1: PARA_NOTICE_LOG("got SIGUSR1, rereading configuration\n"); reread_conf(); - return; + return 1; case SIGCHLD: - check_sigchld(); - return; + task_notify_all(s, E_GUI_SIGCHLD); + return 1; } + return 1; } -static void status_pre_select(fd_set *rfds, int *max_fileno, struct timeval *tv) +static enum exec_status exec_status(void) { - static struct timeval next_exec, atm, diff; - int ret, fds[3] = {0, 1, 0}; - pid_t pid; - - if (stat_pipe >= 0) - goto success; - /* Avoid busy loop */ - gettimeofday(&atm, NULL); - if (tv_diff(&next_exec, &atm, &diff) > 0) { - if (tv_diff(&diff, tv, NULL) < 0) - *tv = diff; - return; - } - next_exec.tv_sec = atm.tv_sec + 2; - ret = para_exec_cmdline_pid(&pid, conf.stat_cmd_arg, fds); - if (ret < 0) - return; - ret = mark_fd_nonblocking(fds[1]); - if (ret < 0) { - close(fds[1]); - return; - } - stat_pipe = fds[1]; -success: - para_fd_set(stat_pipe, rfds, max_fileno); + if (exec_fds[0] >= 0 || exec_fds[1] >= 0) + return EXEC_DCMD; + if (exec_pid > 0) + return EXEC_XCMD; + return EXEC_IDLE; } -#define COMMAND_BUF_SIZE 32768 - -static void command_pre_select(int mode, fd_set *rfds, int *max_fileno) +static void exec_pre_select(struct sched *s, void *context) { - /* check command pipe only in COMMAND_MODE */ - if (mode != COMMAND_MODE) - return; - if (command_fds[0] >= 0) - para_fd_set(command_fds[0], rfds, max_fileno); - if (command_fds[1] >= 0) - para_fd_set(command_fds[1], rfds, 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(int mode, fd_set *rfds) +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() */ - if (mode != COMMAND_MODE) - 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], 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) { - 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 */ - return -1; + if (ret < 0 || exec_pid == 0) { + if (ret < 0) + PARA_NOTICE_LOG("closing command fd %d: %s", + i, para_strerror(-ret)); + 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 1; + return 0; } -static void input_pre_select(int mode, fd_set *rfds, int *max_fileno) +static void input_pre_select(struct sched *s, __a_unused void *context) { - if (mode == GETCH_MODE || mode == COMMAND_MODE) - para_fd_set(STDIN_FILENO, rfds, max_fileno); -} - -static int input_post_select(int mode) -{ - int ret; - - switch (mode) { - case COMMAND_MODE: - ret = wgetch(top.win); - if (ret != ERR && ret != KEY_RESIZE) { - if (cmd_pid) - kill(cmd_pid, SIGTERM); - return -1; - } - return 0; - case GETCH_MODE: - ret = wgetch(top.win); - if (ret != ERR && ret != KEY_RESIZE) - return ret; - return 0; - case EXTERNAL_MODE: - if (cmd_pid == 0) - return -1; - return 0; - default: - assert(false); /* bug */ - } -} - -/* - * This is the core select loop. Besides the (internal) signal - * pipe, the following other fds are checked according to the mode: - * - * GETCH_MODE: check stdin, return when key is pressed - * - * COMMAND_MODE: check command fds and stdin. Return when peer has closed both - * stdout and stderr or when any key is pressed. - * - * EXTERNAL_MODE: Check only signal pipe. Used when an external command - * is running. During that time curses is disabled. Returns when - * cmd_pid == 0. - */ -static int do_select(int mode) -{ - fd_set rfds; - int ret, max_fileno; - struct timeval tv; - -repeat: - tv.tv_sec = conf.timeout_arg / 1000; - tv.tv_usec = (conf.timeout_arg % 1000) * 1000; -// ret = refresh_status(); - FD_ZERO(&rfds); - max_fileno = 0; - status_pre_select(&rfds, &max_fileno, &tv); - /* signal pipe */ - para_fd_set(signal_pipe, &rfds, &max_fileno); - command_pre_select(mode, &rfds, &max_fileno); - input_pre_select(mode, &rfds, &max_fileno); - ret = para_select(max_fileno + 1, &rfds, NULL, &tv); - if (ret <= 0) - goto check_return; /* skip fd checks */ - /* signals */ - ret = para_next_signal(&rfds); - if (ret > 0) - handle_signal(ret); - /* read command pipe if ready */ - ret = command_post_select(mode, &rfds); - if (ret < 0) - return 0; - status_post_select(&rfds); -check_return: - ret = input_post_select(mode); - if (ret != 0) - return ret; - goto repeat; + 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]); @@ -1127,50 +1042,118 @@ static void exec_and_display_cmd(const char *cmd) ret = mark_fd_nonblocking(fds[2]); if (ret < 0) goto fail; - command_fds[0] = fds[1]; - command_fds[1] = fds[2]; - if (do_select(COMMAND_MODE) >= 0) - PARA_INFO_LOG("command complete\n"); - else - PARA_NOTICE_LOG("command aborted\n"); - print_in_bar(COLOR_MSG, " "); + 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(); - if (para_exec_cmdline_pid(&cmd_pid, cmd, fds) < 0) + para_exec_cmdline_pid(&exec_pid, file_and_args, fds); +} + +static void handle_command(int c) +{ + int i; + + /* first check user-defined key bindings */ + for (i = 0; i < conf.key_map_given; ++i) { + char *tmp, *handler, *arg; + + tmp = para_strdup(conf.key_map_arg[i]); + if (!split_key_map(tmp, &handler, &arg)) { + free(tmp); + return; + } + if (strcmp(tmp, km_keyname(c))) { + free(tmp); + continue; + } + if (*handler == 'd') + exec_and_display(arg); + else if (*handler == 'x') + exec_external(arg); + else if (*handler == 'p') + exec_para(arg); + else if (*handler == 'i') { + int num = find_cmd_byname(arg); + if (num >= 0) + command_list[num].handler(); + } + free(tmp); return; - do_select(EXTERNAL_MODE); - init_curses(); + } + /* not found, check internal key bindings */ + for (i = 0; command_list[i].handler; i++) { + if (!strcmp(km_keyname(c), command_list[i].key)) { + command_list[i].handler(); + return; + } + } + print_in_bar(COLOR_ERRMSG, "key '%s' is not bound, press ? for help", + km_keyname(c)); +} + +static int input_post_select(__a_unused struct sched *s, __a_unused void *context) +{ + int ret; + enum exec_status exs = exec_status(); + + 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) + return 0; + if (ret == KEY_RESIZE) { + if (curses_active()) { + shutdown_curses(); + init_curses(); + redraw_bot_win(); + } + return 0; + } + if (exs == EXEC_IDLE) + handle_command(ret); + else if (exec_pid > 0) + kill(exec_pid, SIGTERM); + return 0; } static void print_scroll_msg(void) @@ -1178,7 +1161,7 @@ static void print_scroll_msg(void) unsigned lines_total, filled = ringbuffer_filled(bot_win_rb); int first_rbe = first_visible_rbe(&lines_total); - print_in_bar(COLOR_MSG, "scrolled view: %d-%d/%d\n", filled - first_rbe, + print_in_bar(COLOR_MSG, "scrolled view: %u-%u/%u\n", filled - first_rbe, filled - scroll_position, ringbuffer_filled(bot_win_rb)); } @@ -1206,7 +1189,7 @@ static void com_scroll_top(void) print_in_bar(COLOR_ERRMSG, "top of buffer is shown\n"); } -static void com_cancel_scrolling(void) +static void com_cancel_scroll(void) { if (scroll_position == 0) { @@ -1272,7 +1255,7 @@ static void com_scroll_down(void) 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(); } @@ -1309,7 +1292,7 @@ static void com_scroll_up(void) break; i--; } - wrefresh(bot.win); + refresh_window(&bot); print_scroll_msg(); return; err_out: @@ -1432,48 +1415,6 @@ static void com_prev_theme(void) com_refresh(); } -static void handle_command(int c) -{ - int i; - - /* first check user-defined key bindings */ - for (i = 0; i < conf.key_map_given; ++i) { - char *tmp, *handler, *arg; - - tmp = para_strdup(conf.key_map_arg[i]); - if (!split_key_map(tmp, &handler, &arg)) { - free(tmp); - return; - } - if (strcmp(tmp, km_keyname(c))) { - free(tmp); - continue; - } - if (*handler == 'd') - display_cmd(arg); - else if (*handler == 'x') - external_cmd(arg); - else if (*handler == 'p') - para_cmd(arg); - else if (*handler == 'i') { - int num = find_cmd_byname(arg); - if (num >= 0) - command_list[num].handler(); - } - free(tmp); - return; - } - /* not found, check internal key bindings */ - for (i = 0; command_list[i].handler; i++) { - if (!strcmp(km_keyname(c), command_list[i].key)) { - command_list[i].handler(); - return; - } - } - print_in_bar(COLOR_ERRMSG, "key '%s' is not bound, press ? for help", - km_keyname(c)); -} - __noreturn static void print_help_and_die(void) { struct ggo_help h = DEFINE_GGO_HELP(gui); @@ -1483,27 +1424,94 @@ __noreturn static void print_help_and_die(void) exit(0); } -int main(int argc, char *argv[]) +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, + }, + }; + 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(SIGUSR1); + 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 */ loglevel = get_loglevel_by_name(conf.loglevel_arg); version_handle_flag("gui", conf.version_given); if (conf.help_given || conf.detailed_help_given) print_help_and_die(); parse_config_file_or_die(false /* override */); - setup_signal_handling(); bot_win_rb = ringbuffer_new(RINGBUFFER_SIZE); setlocale(LC_CTYPE, ""); initscr(); /* needed only once, always successful */ init_curses(); - for (;;) { - print_status_bar(); - ret = do_select(GETCH_MODE); - if (!ret) - continue; - print_in_bar(COLOR_MSG, " "); - handle_command(ret); - } + return setup_tasks_and_schedule() < 0? EXIT_FAILURE : EXIT_SUCCESS; }