X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=i3bar%2Fsrc%2Fchild.c;h=818ce7841e88969d3a58b34ef97c1fb55e2d95fb;hb=42515308e72e4ea6f6b49508c1ba286263dded64;hp=dce0218fd305fda1ee38be246a47cc2e3618f249;hpb=f691a55923850a4d315450925fc98733d07b69c9;p=i3%2Fi3 diff --git a/i3bar/src/child.c b/i3bar/src/child.c index dce0218f..818ce784 100644 --- a/i3bar/src/child.c +++ b/i3bar/src/child.c @@ -13,6 +13,7 @@ #include #include #include +#include #include #include #include @@ -27,14 +28,13 @@ #include "common.h" /* Global variables for child_*() */ -i3bar_child child = { 0 }; +i3bar_child child; -/* stdin- and sigchild-watchers */ -ev_io *stdin_io; +/* stdin- and SIGCHLD-watchers */ +ev_io *stdin_io; ev_child *child_sig; /* JSON parser for stdin */ -yajl_callbacks callbacks; yajl_handle parser; /* JSON generator for stdout */ @@ -54,23 +54,84 @@ typedef struct parser_ctx { parser_ctx parser_context; -/* The buffer statusline points to */ struct statusline_head statusline_head = TAILQ_HEAD_INITIALIZER(statusline_head); -char *statusline_buffer = NULL; +/* Used temporarily while reading a statusline */ +struct statusline_head statusline_buffer = TAILQ_HEAD_INITIALIZER(statusline_buffer); int child_stdin; /* - * Stop and free() the stdin- and sigchild-watchers + * Remove all blocks from the given statusline. + * If free_resources is set, the fields of each status block will be free'd. + */ +static void clear_statusline(struct statusline_head *head, bool free_resources) { + struct status_block *first; + while (!TAILQ_EMPTY(head)) { + first = TAILQ_FIRST(head); + if (free_resources) { + I3STRING_FREE(first->full_text); + I3STRING_FREE(first->short_text); + FREE(first->color); + FREE(first->name); + FREE(first->instance); + FREE(first->min_width_str); + } + + TAILQ_REMOVE(head, first, blocks); + free(first); + } +} + +static void copy_statusline(struct statusline_head *from, struct statusline_head *to) { + struct status_block *current; + TAILQ_FOREACH(current, from, blocks) { + struct status_block *new_block = smalloc(sizeof(struct status_block)); + memcpy(new_block, current, sizeof(struct status_block)); + TAILQ_INSERT_TAIL(to, new_block, blocks); + } +} + +/* + * Replaces the statusline in memory with an error message. Pass a format + * string and format parameters as you would in `printf'. The next time + * `draw_bars' is called, the error message text will be drawn on the bar in + * the space allocated for the statusline. + */ +__attribute__((format(printf, 1, 2))) static void set_statusline_error(const char *format, ...) { + clear_statusline(&statusline_head, true); + + char *message; + va_list args; + va_start(args, format); + (void)vasprintf(&message, format, args); + + struct status_block *err_block = scalloc(sizeof(struct status_block)); + err_block->full_text = i3string_from_utf8("Error: "); + err_block->name = "error"; + err_block->color = "red"; + err_block->no_separator = true; + + struct status_block *message_block = scalloc(sizeof(struct status_block)); + message_block->full_text = i3string_from_utf8(message); + message_block->name = "error_message"; + message_block->color = "red"; + message_block->no_separator = true; + + TAILQ_INSERT_HEAD(&statusline_head, err_block, blocks); + TAILQ_INSERT_TAIL(&statusline_head, message_block, blocks); + + FREE(message); + va_end(args); +} + +/* + * Stop and free() the stdin- and SIGCHLD-watchers * */ void cleanup(void) { if (stdin_io != NULL) { ev_io_stop(main_loop, stdin_io); FREE(stdin_io); - FREE(statusline_buffer); - /* statusline pointed to memory within statusline_buffer */ - statusline = NULL; } if (child_sig != NULL) { @@ -83,20 +144,12 @@ void cleanup(void) { /* * The start of a new array is the start of a new status line, so we clear all - * previous entries. - * + * previous entries from the buffer. */ static int stdin_start_array(void *context) { - struct status_block *first; - while (!TAILQ_EMPTY(&statusline_head)) { - first = TAILQ_FIRST(&statusline_head); - I3STRING_FREE(first->full_text); - FREE(first->color); - FREE(first->name); - FREE(first->instance); - TAILQ_REMOVE(&statusline_head, first, blocks); - free(first); - } + // the blocks are still used by statusline_head, so we won't free the + // resources here. + clear_statusline(&statusline_buffer, false); return 1; } @@ -109,16 +162,15 @@ static int stdin_start_map(void *context) { memset(&(ctx->block), '\0', sizeof(struct status_block)); /* Default width of the separator block. */ - ctx->block.sep_block_width = 9; + ctx->block.sep_block_width = logical_px(9); + + /* Use markup by default */ + ctx->block.is_markup = true; return 1; } -#if YAJL_MAJOR >= 2 static int stdin_map_key(void *context, const unsigned char *key, size_t len) { -#else -static int stdin_map_key(void *context, const unsigned char *key, unsigned int len) { -#endif parser_ctx *ctx = context; FREE(ctx->last_map_key); sasprintf(&(ctx->last_map_key), "%.*s", len, key); @@ -136,39 +188,42 @@ static int stdin_boolean(void *context, int val) { return 1; } -#if YAJL_MAJOR >= 2 static int stdin_string(void *context, const unsigned char *val, size_t len) { -#else -static int stdin_string(void *context, const unsigned char *val, unsigned int len) { -#endif parser_ctx *ctx = context; if (strcasecmp(ctx->last_map_key, "full_text") == 0) { - ctx->block.full_text = i3string_from_utf8_with_length((const char *)val, len); + ctx->block.full_text = i3string_from_markup_with_length((const char *)val, len); + } + if (strcasecmp(ctx->last_map_key, "short_text") == 0) { + ctx->block.short_text = i3string_from_markup_with_length((const char *)val, len); } if (strcasecmp(ctx->last_map_key, "color") == 0) { sasprintf(&(ctx->block.color), "%.*s", len, val); } + if (strcasecmp(ctx->last_map_key, "markup") == 0) { + ctx->block.is_markup = (len == strlen("pango") && !strncasecmp((const char *)val, "pango", strlen("pango"))); + } if (strcasecmp(ctx->last_map_key, "align") == 0) { - if (len == strlen("left") && !strncmp((const char*)val, "left", strlen("left"))) { - ctx->block.align = ALIGN_LEFT; - } else if (len == strlen("right") && !strncmp((const char*)val, "right", strlen("right"))) { + if (len == strlen("center") && !strncmp((const char *)val, "center", strlen("center"))) { + ctx->block.align = ALIGN_CENTER; + } else if (len == strlen("right") && !strncmp((const char *)val, "right", strlen("right"))) { ctx->block.align = ALIGN_RIGHT; } else { - ctx->block.align = ALIGN_CENTER; + ctx->block.align = ALIGN_LEFT; } } else if (strcasecmp(ctx->last_map_key, "min_width") == 0) { - i3String *text = i3string_from_utf8_with_length((const char *)val, len); - ctx->block.min_width = (uint32_t)predict_text_width(text); - i3string_free(text); + char *copy = (char *)malloc(len + 1); + strncpy(copy, (const char *)val, len); + copy[len] = 0; + ctx->block.min_width_str = copy; } if (strcasecmp(ctx->last_map_key, "name") == 0) { - char *copy = (char*)malloc(len+1); + char *copy = (char *)malloc(len + 1); strncpy(copy, (const char *)val, len); copy[len] = 0; ctx->block.name = copy; } if (strcasecmp(ctx->last_map_key, "instance") == 0) { - char *copy = (char*)malloc(len+1); + char *copy = (char *)malloc(len + 1); strncpy(copy, (const char *)val, len); copy[len] = 0; ctx->block.instance = copy; @@ -176,11 +231,7 @@ static int stdin_string(void *context, const unsigned char *val, unsigned int le return 1; } -#if YAJL_MAJOR >= 2 static int stdin_integer(void *context, long long val) { -#else -static int stdin_integer(void *context, long val) { -#endif parser_ctx *ctx = context; if (strcasecmp(ctx->last_map_key, "min_width") == 0) { ctx->block.min_width = (uint32_t)val; @@ -191,6 +242,10 @@ static int stdin_integer(void *context, long val) { return 1; } +/* + * When a map is finished, we have an entire status block. + * Move it from the parser's context to the statusline buffer. + */ static int stdin_end_map(void *context) { parser_ctx *ctx = context; struct status_block *new_block = smalloc(sizeof(struct status_block)); @@ -198,18 +253,38 @@ static int stdin_end_map(void *context) { /* Ensure we have a full_text set, so that when it is missing (or null), * i3bar doesn’t crash and the user gets an annoying message. */ if (!new_block->full_text) - new_block->full_text = i3string_from_utf8("SPEC VIOLATION (null)"); + new_block->full_text = i3string_from_utf8("SPEC VIOLATION: full_text is NULL!"); if (new_block->urgent) ctx->has_urgent = true; - TAILQ_INSERT_TAIL(&statusline_head, new_block, blocks); + + if (new_block->min_width_str) { + i3String *text = i3string_from_utf8(new_block->min_width_str); + i3string_set_markup(text, new_block->is_markup); + new_block->min_width = (uint32_t)predict_text_width(text); + i3string_free(text); + } + + i3string_set_markup(new_block->full_text, new_block->is_markup); + i3string_set_markup(new_block->short_text, new_block->is_markup); + + TAILQ_INSERT_TAIL(&statusline_buffer, new_block, blocks); return 1; } +/* + * When an array is finished, we have an entire statusline. + * Copy it from the buffer to the actual statusline. + */ static int stdin_end_array(void *context) { + DLOG("copying statusline_buffer to statusline_head\n"); + clear_statusline(&statusline_head, true); + copy_statusline(&statusline_buffer, &statusline_head); + DLOG("dumping statusline:\n"); struct status_block *current; TAILQ_FOREACH(current, &statusline_head, blocks) { DLOG("full_text = %s\n", i3string_as_utf8(current->full_text)); + DLOG("short_text = %s\n", i3string_as_utf8(current->short_text)); DLOG("color = %s\n", current->color); } DLOG("end of dump\n"); @@ -219,15 +294,17 @@ static int stdin_end_array(void *context) { /* * Helper function to read stdin * + * Returns NULL on EOF. + * */ static unsigned char *get_buffer(ev_io *watcher, int *ret_buffer_len) { int fd = watcher->fd; int n = 0; int rec = 0; int buffer_len = STDIN_CHUNK_SIZE; - unsigned char *buffer = smalloc(buffer_len+1); + unsigned char *buffer = smalloc(buffer_len + 1); buffer[0] = '\0'; - while(1) { + while (1) { n = read(fd, buffer + rec, buffer_len - rec); if (n == -1) { if (errno == EAGAIN) { @@ -238,10 +315,7 @@ static unsigned char *get_buffer(ev_io *watcher, int *ret_buffer_len) { exit(EXIT_FAILURE); } if (n == 0) { - /* end of file, kill the watcher */ ELOG("stdin: received EOF\n"); - cleanup(); - draw_bars(false); *ret_buffer_len = -1; return NULL; } @@ -266,22 +340,29 @@ static void read_flat_input(char *buffer, int length) { I3STRING_FREE(first->full_text); /* Remove the trailing newline and terminate the string at the same * time. */ - if (buffer[length-1] == '\n' || buffer[length-1] == '\r') - buffer[length-1] = '\0'; - else buffer[length] = '\0'; - first->full_text = i3string_from_utf8(buffer); + if (buffer[length - 1] == '\n' || buffer[length - 1] == '\r') + buffer[length - 1] = '\0'; + else + buffer[length] = '\0'; + first->full_text = i3string_from_markup(buffer); } static bool read_json_input(unsigned char *input, int length) { yajl_status status = yajl_parse(parser, input, length); bool has_urgent = false; -#if YAJL_MAJOR >= 2 if (status != yajl_status_ok) { -#else - if (status != yajl_status_ok && status != yajl_status_insufficient_data) { -#endif - fprintf(stderr, "[i3bar] Could not parse JSON input (code %d): %.*s\n", - status, length, input); + char *message = (char *)yajl_get_error(parser, 0, input, length); + + /* strip the newline yajl adds to the error message */ + if (message[strlen(message) - 1] == '\n') + message[strlen(message) - 1] = '\0'; + + fprintf(stderr, "[i3bar] Could not parse JSON input (code = %d, message = %s): %.*s\n", + status, message, length, input); + + set_statusline_error("Could not parse JSON (%s)", message); + yajl_free_error(parser, (unsigned char *)message); + draw_bars(false); } else if (parser_context.has_urgent) { has_urgent = true; } @@ -302,7 +383,7 @@ void stdin_io_cb(struct ev_loop *loop, ev_io *watcher, int revents) { if (child.version > 0) { has_urgent = read_json_input(buffer, rec); } else { - read_flat_input((char*)buffer, rec); + read_flat_input((char *)buffer, rec); } free(buffer); draw_bars(has_urgent); @@ -330,13 +411,13 @@ void stdin_io_first_line_cb(struct ev_loop *loop, ev_io *watcher, int revents) { if (config.hide_on_modifier) { stop_child(); } - read_json_input(buffer + consumed, rec - consumed); + draw_bars(read_json_input(buffer + consumed, rec - consumed)); } else { /* In case of plaintext, we just add a single block and change its * full_text pointer later. */ struct status_block *new_block = scalloc(sizeof(struct status_block)); TAILQ_INSERT_TAIL(&statusline_head, new_block, blocks); - read_flat_input((char*)buffer, rec); + read_flat_input((char *)buffer, rec); } free(buffer); ev_io_stop(main_loop, stdin_io); @@ -345,98 +426,117 @@ void stdin_io_first_line_cb(struct ev_loop *loop, ev_io *watcher, int revents) { } /* - * We received a sigchild, meaning, that the child-process terminated. - * We simply free the respective data-structures and don't care for input + * We received a SIGCHLD, meaning, that the child process terminated. + * We simply free the respective data structures and don't care for input * anymore * */ void child_sig_cb(struct ev_loop *loop, ev_child *watcher, int revents) { + int exit_status = WEXITSTATUS(watcher->rstatus); + ELOG("Child (pid: %d) unexpectedly exited with status %d\n", - child.pid, - watcher->rstatus); + child.pid, + exit_status); + + /* this error is most likely caused by a user giving a nonexecutable or + * nonexistent file, so we will handle those cases separately. */ + if (exit_status == 126) + set_statusline_error("status_command is not executable (exit %d)", exit_status); + else if (exit_status == 127) + set_statusline_error("status_command not found or is missing a library dependency (exit %d)", exit_status); + else + set_statusline_error("status_command process exited unexpectedly (exit %d)", exit_status); + cleanup(); + draw_bars(false); } void child_write_output(void) { if (child.click_events) { const unsigned char *output; -#if YAJL_MAJOR < 2 - unsigned int size; -#else size_t size; -#endif + ssize_t n; + yajl_gen_get_buf(gen, &output, &size); - write(child_stdin, output, size); - write(child_stdin, "\n", 1); + + n = writeall(child_stdin, output, size); + if (n != -1) + n = writeall(child_stdin, "\n", 1); + yajl_gen_clear(gen); + + if (n == -1) { + child.click_events = false; + kill_child(); + set_statusline_error("child_write_output failed"); + draw_bars(false); + } } } /* - * Start a child-process with the specified command and reroute stdin. + * Start a child process with the specified command and reroute stdin. * We actually start a $SHELL to execute the command so we don't have to care - * about arguments and such + * about arguments and such. + * + * If `command' is NULL, such as in the case when no `status_command' is given + * in the bar config, no child will be started. * */ void start_child(char *command) { + if (command == NULL) + return; + /* Allocate a yajl parser which will be used to parse stdin. */ - memset(&callbacks, '\0', sizeof(yajl_callbacks)); - callbacks.yajl_map_key = stdin_map_key; - callbacks.yajl_boolean = stdin_boolean; - callbacks.yajl_string = stdin_string; - callbacks.yajl_integer = stdin_integer; - callbacks.yajl_start_array = stdin_start_array; - callbacks.yajl_end_array = stdin_end_array; - callbacks.yajl_start_map = stdin_start_map; - callbacks.yajl_end_map = stdin_end_map; -#if YAJL_MAJOR < 2 - yajl_parser_config parse_conf = { 0, 0 }; - - parser = yajl_alloc(&callbacks, &parse_conf, NULL, (void*)&parser_context); - - gen = yajl_gen_alloc(NULL, NULL); -#else + static yajl_callbacks callbacks = { + .yajl_boolean = stdin_boolean, + .yajl_integer = stdin_integer, + .yajl_string = stdin_string, + .yajl_start_map = stdin_start_map, + .yajl_map_key = stdin_map_key, + .yajl_end_map = stdin_end_map, + .yajl_start_array = stdin_start_array, + .yajl_end_array = stdin_end_array, + }; parser = yajl_alloc(&callbacks, NULL, &parser_context); gen = yajl_gen_alloc(NULL); -#endif - if (command != NULL) { - int pipe_in[2]; /* pipe we read from */ - int pipe_out[2]; /* pipe we write to */ + int pipe_in[2]; /* pipe we read from */ + int pipe_out[2]; /* pipe we write to */ - if (pipe(pipe_in) == -1) - err(EXIT_FAILURE, "pipe(pipe_in)"); - if (pipe(pipe_out) == -1) - err(EXIT_FAILURE, "pipe(pipe_out)"); + if (pipe(pipe_in) == -1) + err(EXIT_FAILURE, "pipe(pipe_in)"); + if (pipe(pipe_out) == -1) + err(EXIT_FAILURE, "pipe(pipe_out)"); - child.pid = fork(); - switch (child.pid) { - case -1: - ELOG("Couldn't fork(): %s\n", strerror(errno)); - exit(EXIT_FAILURE); - case 0: - /* Child-process. Reroute streams and start shell */ + child.pid = fork(); + switch (child.pid) { + case -1: + ELOG("Couldn't fork(): %s\n", strerror(errno)); + exit(EXIT_FAILURE); + case 0: + /* Child-process. Reroute streams and start shell */ - close(pipe_in[0]); - close(pipe_out[1]); + close(pipe_in[0]); + close(pipe_out[1]); - dup2(pipe_in[1], STDOUT_FILENO); - dup2(pipe_out[0], STDIN_FILENO); + dup2(pipe_in[1], STDOUT_FILENO); + dup2(pipe_out[0], STDIN_FILENO); - execl(_PATH_BSHELL, _PATH_BSHELL, "-c", command, (char*) NULL); - return; - default: - /* Parent-process. Reroute streams */ + setpgid(child.pid, 0); + execl(_PATH_BSHELL, _PATH_BSHELL, "-c", command, (char *)NULL); + return; + default: + /* Parent-process. Reroute streams */ - close(pipe_in[1]); - close(pipe_out[0]); + close(pipe_in[1]); + close(pipe_out[0]); - dup2(pipe_in[0], STDIN_FILENO); - child_stdin = pipe_out[1]; + dup2(pipe_in[0], STDIN_FILENO); + child_stdin = pipe_out[1]; - break; - } + break; } /* We set O_NONBLOCK because blocking is evil in event-driven software */ @@ -471,57 +571,59 @@ void child_click_events_key(const char *key) { * */ void send_block_clicked(int button, const char *name, const char *instance, int x, int y) { - if (child.click_events) { - child_click_events_initialize(); + if (!child.click_events) { + return; + } - yajl_gen_map_open(gen); + child_click_events_initialize(); - if (name) { - child_click_events_key("name"); - yajl_gen_string(gen, (const unsigned char *)name, strlen(name)); - } + yajl_gen_map_open(gen); - if (instance) { - child_click_events_key("instance"); - yajl_gen_string(gen, (const unsigned char *)instance, strlen(instance)); - } + if (name) { + child_click_events_key("name"); + yajl_gen_string(gen, (const unsigned char *)name, strlen(name)); + } - child_click_events_key("button"); - yajl_gen_integer(gen, button); + if (instance) { + child_click_events_key("instance"); + yajl_gen_string(gen, (const unsigned char *)instance, strlen(instance)); + } - child_click_events_key("x"); - yajl_gen_integer(gen, x); + child_click_events_key("button"); + yajl_gen_integer(gen, button); - child_click_events_key("y"); - yajl_gen_integer(gen, y); + child_click_events_key("x"); + yajl_gen_integer(gen, x); - yajl_gen_map_close(gen); - child_write_output(); - } + child_click_events_key("y"); + yajl_gen_integer(gen, y); + + yajl_gen_map_close(gen); + child_write_output(); } /* - * kill()s the child-process (if any). Called when exit()ing. + * kill()s the child process (if any). Called when exit()ing. * */ void kill_child_at_exit(void) { if (child.pid > 0) { if (child.cont_signal > 0 && child.stopped) - kill(child.pid, child.cont_signal); - kill(child.pid, SIGTERM); + killpg(child.pid, child.cont_signal); + killpg(child.pid, SIGTERM); } } /* - * kill()s the child-process (if existent) and closes and - * free()s the stdin- and sigchild-watchers + * kill()s the child process (if existent) and closes and + * free()s the stdin- and SIGCHLD-watchers * */ void kill_child(void) { if (child.pid > 0) { if (child.cont_signal > 0 && child.stopped) - kill(child.pid, child.cont_signal); - kill(child.pid, SIGTERM); + killpg(child.pid, child.cont_signal); + killpg(child.pid, SIGTERM); int status; waitpid(child.pid, &status, 0); cleanup(); @@ -529,23 +631,31 @@ void kill_child(void) { } /* - * Sends a SIGSTOP to the child-process (if existent) + * Sends a SIGSTOP to the child process (if existent) * */ void stop_child(void) { if (child.stop_signal > 0 && !child.stopped) { child.stopped = true; - kill(child.pid, child.stop_signal); + killpg(child.pid, child.stop_signal); } } /* - * Sends a SIGCONT to the child-process (if existent) + * Sends a SIGCONT to the child process (if existent) * */ void cont_child(void) { if (child.cont_signal > 0 && child.stopped) { child.stopped = false; - kill(child.pid, child.cont_signal); + killpg(child.pid, child.cont_signal); } } + +/* + * Whether or not the child want click events + * + */ +bool child_want_click_events(void) { + return child.click_events; +}