/*
- * 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_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;
#define COMMAND_BUF_SIZE 32768
struct exec_task {
- struct task 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;
}
/** 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);
}
}
}
-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)
para_fd_set(st->fd, &s->rfds, &s->max_fileno);
- if (task_get_notification(t) < 0)
+ 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;
int ret, ret2;
- ret = task_get_notification(t);
+ 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) {
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();
{
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"
}
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 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");
return EXEC_IDLE;
}
-static void exec_pre_select(struct sched *s, struct task *t)
+static void exec_pre_select(struct sched *s, void *context)
{
+ 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(t) < 0)
+ if (task_get_notification(et->task) < 0)
sched_min_delay(s);
}
-static int exec_post_select(struct sched *s, struct task *t)
+static int exec_post_select(struct sched *s, void *context)
{
- struct exec_task *ct = container_of(t, struct exec_task, task);
+ struct exec_task *ct = context;
int i, ret;
- ret = task_get_notification(t);
+ 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) {
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)
{
if (exec_status() != EXEC_XCMD)
para_fd_set(STDIN_FILENO, &s->rfds, &s->max_fileno);
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 exec_status exs = exec_status();
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);
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 exec_task exec_task = {
- .task = {
- .status = "exec",
- .pre_select = exec_pre_select,
- .post_select = exec_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(SIGUSR1);
-
- register_task(&sched, &exec_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 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 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.
projects / paraslash.git / blobdiff