Merge branch 'master' into render-output-segfault

This commit is contained in:
Ryan Dwyer 2018-09-21 20:05:39 +10:00 committed by GitHub
commit 0798fadff2
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
15 changed files with 297 additions and 216 deletions

View file

@ -70,28 +70,3 @@ char *peek_line(FILE *file, int line_offset, long *position) {
fseek(file, pos, SEEK_SET);
return line;
}
char *read_line_buffer(FILE *file, char *string, size_t string_len) {
size_t length = 0;
if (!string) {
return NULL;
}
while (1) {
int c = getc(file);
if (c == EOF || c == '\n' || c == '\0') {
break;
}
if (c == '\r') {
continue;
}
string[length++] = c;
if (string_len <= length) {
return NULL;
}
}
if (length + 1 == string_len) {
return NULL;
}
string[length] = '\0';
return string;
}

View file

@ -103,6 +103,7 @@ sway_cmd cmd_client_urgent;
sway_cmd cmd_client_placeholder;
sway_cmd cmd_client_background;
sway_cmd cmd_commands;
sway_cmd cmd_create_output;
sway_cmd cmd_debuglog;
sway_cmd cmd_default_border;
sway_cmd cmd_default_floating_border;

View file

@ -61,6 +61,8 @@ struct sway_view {
struct sway_container *container; // NULL if unmapped and transactions finished
struct wlr_surface *surface; // NULL for unmapped views
pid_t pid;
// Geometry of the view itself (excludes borders) in layout coordinates
double x, y;
int width, height;

View file

@ -19,8 +19,8 @@ bool remove_event(int fd);
bool remove_timer(timer_t timer);
// Blocks and returns after sending callbacks
void event_loop_poll();
void event_loop_poll(void);
void init_event_loop();
void init_event_loop(void);
#endif

View file

@ -1,5 +1,6 @@
#ifndef _SWAYBAR_STATUS_LINE_H
#define _SWAYBAR_STATUS_LINE_H
#include <json-c/json.h>
#include <stdint.h>
#include <stdio.h>
#include <stdbool.h>
@ -12,28 +13,6 @@ enum status_protocol {
PROTOCOL_I3BAR,
};
struct text_protocol_state {
char *buffer;
size_t buffer_size;
};
enum json_node_type {
JSON_NODE_UNKNOWN,
JSON_NODE_ARRAY,
JSON_NODE_STRING,
};
struct i3bar_protocol_state {
bool click_events;
char *buffer;
size_t buffer_size;
size_t buffer_index;
const char *current_node;
bool escape;
size_t depth;
enum json_node_type nodes[16];
};
struct i3bar_block {
struct wl_list link;
int ref_count;
@ -63,8 +42,13 @@ struct status_line {
const char *text;
struct wl_list blocks; // i3bar_block::link
struct text_protocol_state text_state;
struct i3bar_protocol_state i3bar_state;
bool click_events;
char *buffer;
size_t buffer_size;
size_t buffer_index;
bool started;
bool expecting_comma;
json_tokener *tokener;
};
struct status_line *status_line_init(char *cmd);

View file

@ -143,6 +143,7 @@ static struct cmd_handler config_handlers[] = {
/* Runtime-only commands. Keep alphabetized */
static struct cmd_handler command_handlers[] = {
{ "border", cmd_border },
{ "create_output", cmd_create_output },
{ "exit", cmd_exit },
{ "floating", cmd_floating },
{ "fullscreen", cmd_fullscreen },
@ -215,18 +216,23 @@ struct cmd_handler *find_handler(char *line, struct cmd_handler *cmd_handlers,
static void set_config_node(struct sway_node *node) {
config->handler_context.node = node;
config->handler_context.container = NULL;
config->handler_context.workspace = NULL;
if (node == NULL) {
return;
}
switch (node->type) {
case N_CONTAINER:
config->handler_context.container = node->sway_container;
config->handler_context.workspace = node->sway_container->workspace;
break;
case N_WORKSPACE:
config->handler_context.container = NULL;
config->handler_context.workspace = node->sway_workspace;
break;
default:
config->handler_context.container = NULL;
config->handler_context.workspace = NULL;
case N_ROOT:
case N_OUTPUT:
break;
}
}

View file

@ -0,0 +1,39 @@
#include <wlr/backend/multi.h>
#include <wlr/backend/wayland.h>
#include <wlr/backend/x11.h>
#include "sway/commands.h"
#include "sway/server.h"
#include "log.h"
static void create_output(struct wlr_backend *backend, void *data) {
bool *done = data;
if (*done) {
return;
}
if (wlr_backend_is_wl(backend)) {
wlr_wl_output_create(backend);
*done = true;
} else if (wlr_backend_is_x11(backend)) {
wlr_x11_output_create(backend);
*done = true;
}
}
/**
* This command is intended for developer use only.
*/
struct cmd_results *cmd_create_output(int argc, char **argv) {
sway_assert(wlr_backend_is_multi(server.backend),
"Expected a multi backend");
bool done = false;
wlr_multi_for_each_backend(server.backend, create_output, &done);
if (!done) {
return cmd_results_new(CMD_INVALID, "create_output",
"Can only create outputs for Wayland or X11 backends");
}
return cmd_results_new(CMD_SUCCESS, NULL, NULL);
}

View file

@ -140,6 +140,13 @@ void free_input_config(struct input_config *ic) {
return;
}
free(ic->identifier);
free(ic->xkb_layout);
free(ic->xkb_model);
free(ic->xkb_options);
free(ic->xkb_rules);
free(ic->xkb_variant);
free(ic->mapped_from_region);
free(ic->mapped_to_output);
free(ic);
}

View file

@ -221,6 +221,8 @@ static const char *describe_container_border(enum sway_container_border border)
}
static void ipc_json_describe_view(struct sway_container *c, json_object *object) {
json_object_object_add(object, "pid", json_object_new_int(c->view->pid));
const char *app_id = view_get_app_id(c->view);
json_object_object_add(object, "app_id",
app_id ? json_object_new_string(app_id) : NULL);

View file

@ -35,6 +35,7 @@ sway_sources = files(
'commands/bind.c',
'commands/border.c',
'commands/client.c',
'commands/create_output.c',
'commands/default_border.c',
'commands/default_floating_border.c',
'commands/default_orientation.c',

View file

@ -470,6 +470,7 @@ static struct sway_workspace *select_workspace(struct sway_view *view) {
wl_resource_get_client(view->surface->resource);
wl_client_get_credentials(client, &pid, NULL, NULL);
#endif
view->pid = pid;
ws = root_workspace_for_pid(pid);
if (ws) {
return ws;

View file

@ -105,7 +105,7 @@ bool remove_timer(timer_t timer) {
return false;
}
void event_loop_poll() {
void event_loop_poll(void) {
poll(event_loop.fds.items, event_loop.fds.length, -1);
for (int i = 0; i < event_loop.fds.length; ++i) {
@ -146,7 +146,7 @@ void event_loop_poll() {
}
}
void init_event_loop() {
void init_event_loop(void) {
event_loop.fds.length = 0;
event_loop.fds.capacity = 10;
event_loop.fds.items = malloc(

View file

@ -1,6 +1,7 @@
#define _POSIX_C_SOURCE 200809L
#include <json-c/json.h>
#include <linux/input-event-codes.h>
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
@ -24,24 +25,19 @@ void i3bar_block_unref(struct i3bar_block *block) {
}
}
static bool i3bar_parse_json(struct status_line *status, const char *text) {
static void i3bar_parse_json(struct status_line *status,
struct json_object *json_array) {
struct i3bar_block *block, *tmp;
wl_list_for_each_safe(block, tmp, &status->blocks, link) {
wl_list_remove(&block->link);
i3bar_block_unref(block);
}
json_object *results = json_tokener_parse(text);
if (!results) {
status_error(status, "[failed to parse i3bar json]");
return false;
}
wlr_log(WLR_DEBUG, "Got i3bar json: '%s'", text);
for (size_t i = 0; i < json_object_array_length(results); ++i) {
for (size_t i = 0; i < json_object_array_length(json_array); ++i) {
json_object *full_text, *short_text, *color, *min_width, *align, *urgent;
json_object *name, *instance, *separator, *separator_block_width;
json_object *background, *border, *border_top, *border_bottom;
json_object *border_left, *border_right, *markup;
json_object *json = json_object_array_get_idx(results, i);
json_object *json = json_object_array_get_idx(json_array, i);
if (!json) {
continue;
}
@ -110,96 +106,149 @@ static bool i3bar_parse_json(struct status_line *status, const char *text) {
json_object_get_int(border_right) : 1;
wl_list_insert(&status->blocks, &block->link);
}
json_object_put(results);
return true;
}
bool i3bar_handle_readable(struct status_line *status) {
struct i3bar_protocol_state *state = &status->i3bar_state;
while (!status->started) { // look for opening bracket
for (size_t c = 0; c < status->buffer_index; ++c) {
if (status->buffer[c] == '[') {
status->started = true;
status->buffer_index -= ++c;
memmove(status->buffer, &status->buffer[c], status->buffer_index);
break;
} else if (!isspace(status->buffer[c])) {
status_error(status, "[invalid json]");
return true;
}
}
if (status->started) {
break;
}
char *cur = &state->buffer[state->buffer_index];
ssize_t n = read(status->read_fd, cur,
state->buffer_size - state->buffer_index);
if (n == -1) {
status_error(status, "[failed to read from status command]");
return false;
}
if (n == (ssize_t)(state->buffer_size - state->buffer_index)) {
state->buffer_size = state->buffer_size * 2;
char *new_buffer = realloc(state->buffer, state->buffer_size);
if (!new_buffer) {
free(state->buffer);
status_error(status, "[failed to allocate buffer]");
errno = 0;
ssize_t read_bytes = read(status->read_fd, status->buffer, status->buffer_size);
if (read_bytes > -1) {
status->buffer_index = read_bytes;
} else if (errno == EAGAIN) {
return false;
} else {
status_error(status, "[error reading from status command]");
return true;
}
state->current_node += new_buffer - state->buffer;
cur += new_buffer - state->buffer;
state->buffer = new_buffer;
}
cur[n] = '\0';
bool redraw = false;
while (*cur) {
if (state->nodes[state->depth] == JSON_NODE_STRING) {
if (!state->escape && *cur == '"') {
--state->depth;
struct json_object *last_object = NULL;
struct json_object *test_object;
size_t buffer_pos = 0;
while (true) {
// since the incoming stream is an infinite array
// parsing is split into two parts
// first, attempt to parse the current object, reading more if the
// parser indicates that the current object is incomplete, and failing
// if the parser fails
// second, look for separating comma, ignoring whitespace, failing if
// any other characters are encountered
if (status->expecting_comma) {
for (; buffer_pos < status->buffer_index; ++buffer_pos) {
if (status->buffer[buffer_pos] == ',') {
status->expecting_comma = false;
++buffer_pos;
break;
} else if (!isspace(status->buffer[buffer_pos])) {
status_error(status, "[invalid i3bar json]");
return true;
}
}
state->escape = !state->escape && *cur == '\\';
if (buffer_pos < status->buffer_index) {
continue; // look for new object without reading more input
}
buffer_pos = status->buffer_index = 0;
} else {
switch (*cur) {
case '[':
++state->depth;
if (state->depth >
sizeof(state->nodes) / sizeof(state->nodes[0])) {
status_error(status, "[i3bar json too deep]");
return false;
test_object = json_tokener_parse_ex(status->tokener,
&status->buffer[buffer_pos], status->buffer_index - buffer_pos);
if (json_tokener_get_error(status->tokener) == json_tokener_success) {
if (json_object_get_type(test_object) == json_type_array) {
if (last_object) {
json_object_put(last_object);
}
last_object = test_object;
} else {
json_object_put(test_object);
}
state->nodes[state->depth] = JSON_NODE_ARRAY;
if (state->depth == 1) {
state->current_node = cur;
// in order to print the json for debugging purposes
// the last character is temporarily replaced with a null character
// (the last character is used in case the buffer is full)
char *last_char_pos =
&status->buffer[buffer_pos + status->tokener->char_offset - 1];
char last_char = *last_char_pos;
while (isspace(last_char)) {
last_char = *--last_char_pos;
}
break;
case ']':
if (state->nodes[state->depth] != JSON_NODE_ARRAY) {
status_error(status, "[failed to parse i3bar json]");
return false;
*last_char_pos = '\0';
size_t offset = strspn(&status->buffer[buffer_pos], " \f\n\r\t\v");
wlr_log(WLR_DEBUG, "Received i3bar json: '%s%c'",
&status->buffer[buffer_pos + offset], last_char);
*last_char_pos = last_char;
buffer_pos += status->tokener->char_offset;
status->expecting_comma = true;
if (buffer_pos < status->buffer_index) {
continue; // look for comma without reading more input
}
--state->depth;
if (state->depth == 0) {
// cur[1] is valid since cur[0] != '\0'
char p = cur[1];
cur[1] = '\0';
redraw = i3bar_parse_json(
status, state->current_node) || redraw;
cur[1] = p;
memmove(state->buffer, cur,
state->buffer_size - (cur - state->buffer));
cur = state->buffer;
state->current_node = cur + 1;
buffer_pos = status->buffer_index = 0;
} else if (json_tokener_get_error(status->tokener) == json_tokener_continue) {
if (status->buffer_index < status->buffer_size) {
// move the object to the start of the buffer
status->buffer_index -= buffer_pos;
memmove(status->buffer, &status->buffer[buffer_pos],
status->buffer_index);
} else {
// expand buffer
status->buffer_size *= 2;
char *new_buffer = realloc(status->buffer, status->buffer_size);
if (new_buffer) {
status->buffer = new_buffer;
} else {
free(status->buffer);
status_error(status, "[failed to allocate buffer]");
return true;
}
}
break;
case '"':
++state->depth;
if (state->depth >
sizeof(state->nodes) / sizeof(state->nodes[0])) {
status_error(status, "[i3bar json too deep]");
return false;
}
state->nodes[state->depth] = JSON_NODE_STRING;
break;
} else {
status_error(status, "[failed to parse i3bar json]");
return true;
}
}
++cur;
errno = 0;
ssize_t read_bytes = read(status->read_fd, &status->buffer[status->buffer_index],
status->buffer_size - status->buffer_index);
if (read_bytes > -1) {
status->buffer_index += read_bytes;
} else if (errno == EAGAIN) {
break;
} else {
status_error(status, "[error reading from status command]");
return true;
}
}
if (last_object) {
wlr_log(WLR_DEBUG, "Rendering last received json");
i3bar_parse_json(status, last_object);
json_object_put(last_object);
return true;
} else {
return false;
}
state->buffer_index = cur - state->buffer;
return redraw;
}
enum hotspot_event_handling i3bar_block_send_click(struct status_line *status,
struct i3bar_block *block, int x, int y, enum x11_button button) {
wlr_log(WLR_DEBUG, "block %s clicked", block->name ? block->name : "(nil)");
if (!block->name || !status->i3bar_state.click_events) {
if (!block->name || !status->click_events) {
return HOTSPOT_PROCESS;
}
@ -214,7 +263,7 @@ enum hotspot_event_handling i3bar_block_send_click(struct status_line *status,
json_object_object_add(event_json, "button", json_object_new_int(button));
json_object_object_add(event_json, "x", json_object_new_int(x));
json_object_object_add(event_json, "y", json_object_new_int(y));
if (dprintf(status->write_fd, "%s\n",
if (dprintf(status->write_fd, "%s,\n",
json_object_to_json_string(event_json)) < 0) {
status_error(status, "[failed to write click event]");
}

View file

@ -120,14 +120,14 @@ static void i3bar_block_unref_callback(void *data) {
}
static uint32_t render_status_block(cairo_t *cairo,
struct swaybar_config *config, struct swaybar_output *output,
struct i3bar_block *block, double *x,
struct swaybar_output *output, struct i3bar_block *block, double *x,
uint32_t surface_height, bool focused, bool edge) {
if (!block->full_text || !*block->full_text) {
return 0;
}
uint32_t height = surface_height * output->scale;
struct swaybar_config *config = output->bar->config;
int text_width, text_height;
get_text_size(cairo, config->font, &text_width, &text_height, NULL,
@ -177,16 +177,18 @@ static uint32_t render_status_block(cairo_t *cairo,
*x -= margin;
}
struct swaybar_hotspot *hotspot = calloc(1, sizeof(struct swaybar_hotspot));
hotspot->x = *x;
hotspot->y = 0;
hotspot->width = width;
hotspot->height = height;
hotspot->callback = block_hotspot_callback;
hotspot->destroy = i3bar_block_unref_callback;
hotspot->data = block;
block->ref_count++;
wl_list_insert(&output->hotspots, &hotspot->link);
if (output->bar->status->click_events) {
struct swaybar_hotspot *hotspot = calloc(1, sizeof(struct swaybar_hotspot));
hotspot->x = *x;
hotspot->y = 0;
hotspot->width = width;
hotspot->height = height;
hotspot->callback = block_hotspot_callback;
hotspot->destroy = i3bar_block_unref_callback;
hotspot->data = block;
block->ref_count++;
wl_list_insert(&output->hotspots, &hotspot->link);
}
double pos = *x;
if (block->background) {
@ -268,7 +270,7 @@ static uint32_t render_status_line_i3bar(cairo_t *cairo,
bool edge = true;
struct i3bar_block *block;
wl_list_for_each(block, &status->blocks, link) {
uint32_t h = render_status_block(cairo, config, output,
uint32_t h = render_status_block(cairo, output,
block, x, surface_height, focused, edge);
max_height = h > max_height ? h : max_height;
edge = false;

View file

@ -7,86 +7,102 @@
#include <unistd.h>
#include <wlr/util/log.h>
#include "swaybar/config.h"
#include "swaybar/event_loop.h"
#include "swaybar/status_line.h"
#include "readline.h"
static void status_line_close_fds(struct status_line *status) {
if (status->read_fd != -1) {
remove_event(status->read_fd);
close(status->read_fd);
status->read_fd = -1;
}
if (status->write_fd != -1) {
close(status->write_fd);
status->write_fd = -1;
}
}
void status_error(struct status_line *status, const char *text) {
close(status->read_fd);
close(status->write_fd);
status_line_close_fds(status);
status->protocol = PROTOCOL_ERROR;
status->text = text;
}
bool status_handle_readable(struct status_line *status) {
char *line;
ssize_t read_bytes = 1;
switch (status->protocol) {
case PROTOCOL_ERROR:
return false;
case PROTOCOL_I3BAR:
if (i3bar_handle_readable(status) > 0) {
case PROTOCOL_UNDEF:
errno = 0;
read_bytes = getline(&status->buffer,
&status->buffer_size, status->read);
if (errno == EAGAIN) {
clearerr(status->read);
} else if (errno) {
status_error(status, "[error reading from status command]");
return true;
}
break;
case PROTOCOL_TEXT:
line = read_line_buffer(status->read,
status->text_state.buffer, status->text_state.buffer_size);
if (!line) {
status_error(status, "[error reading from status command]");
} else {
status->text = line;
}
return true;
case PROTOCOL_UNDEF:
line = read_line_buffer(status->read,
status->text_state.buffer, status->text_state.buffer_size);
if (!line) {
status_error(status, "[error reading from status command]");
return false;
}
if (line[0] == '{') {
json_object *proto = json_tokener_parse(line);
if (proto) {
json_object *version;
if (json_object_object_get_ex(proto, "version", &version)
&& json_object_get_int(version) == 1) {
wlr_log(WLR_DEBUG, "Switched to i3bar protocol.");
status->protocol = PROTOCOL_I3BAR;
}
json_object *click_events;
if (json_object_object_get_ex(
proto, "click_events", &click_events)
&& json_object_get_boolean(click_events)) {
wlr_log(WLR_DEBUG, "Enabled click events.");
status->i3bar_state.click_events = true;
const char *events_array = "[\n";
ssize_t len = strlen(events_array);
if (write(status->write_fd, events_array, len) != len) {
status_error(status,
"[failed to write to status command]");
}
}
json_object_put(proto);
}
// the header must be sent completely the first time round
json_object *header, *version;
if (status->buffer[read_bytes - 1] == '\n'
&& (header = json_tokener_parse(status->buffer))
&& json_object_object_get_ex(header, "version", &version)
&& json_object_get_int(version) == 1) {
wlr_log(WLR_DEBUG, "Using i3bar protocol.");
status->protocol = PROTOCOL_I3BAR;
free(status->text_state.buffer);
json_object *click_events;
if (json_object_object_get_ex(header, "click_events", &click_events)
&& json_object_get_boolean(click_events)) {
wlr_log(WLR_DEBUG, "Enabling click events.");
status->click_events = true;
if (write(status->write_fd, "[\n", 2) != 2) {
status_error(status, "[failed to write to status command]");
json_object_put(header);
return true;
}
}
json_object_put(header);
wl_list_init(&status->blocks);
status->i3bar_state.buffer_size = 4096;
status->i3bar_state.buffer =
malloc(status->i3bar_state.buffer_size);
} else {
status->protocol = PROTOCOL_TEXT;
status->text = line;
status->tokener = json_tokener_new();
status->buffer_index = getdelim(&status->buffer,
&status->buffer_size, EOF, status->read);
return i3bar_handle_readable(status);
}
return true;
wlr_log(WLR_DEBUG, "Using text protocol.");
status->protocol = PROTOCOL_TEXT;
status->text = status->buffer;
// intentional fall-through
case PROTOCOL_TEXT:
errno = 0;
while (true) {
if (status->buffer[read_bytes - 1] == '\n') {
status->buffer[read_bytes - 1] = '\0';
}
read_bytes = getline(&status->buffer,
&status->buffer_size, status->read);
if (errno == EAGAIN) {
clearerr(status->read);
return true;
} else if (errno) {
status_error(status, "[error reading from status command]");
return true;
}
}
case PROTOCOL_I3BAR:
return i3bar_handle_readable(status);
default:
return false;
}
return false;
}
struct status_line *status_line_init(char *cmd) {
struct status_line *status = calloc(1, sizeof(struct status_line));
status->text_state.buffer_size = 8192;
status->text_state.buffer = malloc(status->text_state.buffer_size);
status->buffer_size = 8192;
status->buffer = malloc(status->buffer_size);
int pipe_read_fd[2];
int pipe_write_fd[2];
@ -123,20 +139,16 @@ struct status_line *status_line_init(char *cmd) {
}
void status_line_free(struct status_line *status) {
close(status->read_fd);
close(status->write_fd);
status_line_close_fds(status);
kill(status->pid, SIGTERM);
switch (status->protocol) {
case PROTOCOL_I3BAR:;
if (status->protocol == PROTOCOL_I3BAR) {
struct i3bar_block *block, *tmp;
wl_list_for_each_safe(block, tmp, &status->blocks, link) {
wl_list_remove(&block->link);
i3bar_block_unref(block);
}
free(status->i3bar_state.buffer);
break;
default:
free(status->text_state.buffer);
break;
json_tokener_free(status->tokener);
}
free(status->buffer);
free(status);
}