X-Git-Url: https://git.sur5r.net/?p=i3%2Fi3;a=blobdiff_plain;f=src%2Fload_layout.c;h=5a340d2c6c28bfc1befb96829a9276172dcd3b74;hp=3835589f58defad34a92ee08e294b526f8b941b6;hb=HEAD;hpb=3b4ae812e3543681a331bb72e6ae50038c4ab7bc diff --git a/src/load_layout.c b/src/load_layout.c index 3835589f..5a340d2c 100644 --- a/src/load_layout.c +++ b/src/load_layout.c @@ -1,10 +1,8 @@ -#undef I3__FILE__ -#define I3__FILE__ "load_layout.c" /* * vim:ts=4:sw=4:expandtab * * i3 - an improved dynamic tiling window manager - * © 2009-2012 Michael Stapelberg and contributors (see also: LICENSE) + * © 2009 Michael Stapelberg and contributors (see also: LICENSE) * * load_layout.c: Restore (parts of) the layout, for example after an inplace * restart. @@ -20,6 +18,7 @@ /* TODO: refactor the whole parsing thing */ static char *last_key; +static int incomplete; static Con *json_node; static Con *to_focus; static bool parsing_swallows; @@ -28,13 +27,19 @@ static bool parsing_deco_rect; static bool parsing_window_rect; static bool parsing_geometry; static bool parsing_focus; +static bool parsing_marks; struct Match *current_swallow; +static bool swallow_is_empty; +static int num_marks; +static char **marks; /* This list is used for reordering the focus stack after parsing the 'focus' * array. */ struct focus_mapping { int old_id; - TAILQ_ENTRY(focus_mapping) focus_mappings; + + TAILQ_ENTRY(focus_mapping) + focus_mappings; }; static TAILQ_HEAD(focus_mappings_head, focus_mapping) focus_mappings = @@ -46,7 +51,9 @@ static int json_start_map(void *ctx) { LOG("creating new swallow\n"); current_swallow = smalloc(sizeof(Match)); match_init(current_swallow); + current_swallow->dock = M_DONTCHECK; TAILQ_INSERT_TAIL(&(json_node->swallow_head), current_swallow, matches); + swallow_is_empty = true; } else { if (!parsing_rect && !parsing_deco_rect && !parsing_window_rect && !parsing_geometry) { if (last_key && strcasecmp(last_key, "floating_nodes") == 0) { @@ -62,6 +69,9 @@ static int json_start_map(void *ctx) { json_node->name = NULL; json_node->parent = parent; } + /* json_node is incomplete and should be removed if parsing fails */ + incomplete++; + DLOG("incomplete = %d\n", incomplete); } } return 1; @@ -84,6 +94,7 @@ static int json_end_map(void *ctx) { Match *match = TAILQ_FIRST(&(json_node->swallow_head)); TAILQ_REMOVE(&(json_node->swallow_head), match, matches); match_free(match); + free(match); } } @@ -97,18 +108,11 @@ static int json_end_map(void *ctx) { /* Prevent name clashes when appending a workspace, e.g. when the * user tries to restore a workspace called “1” but already has a * workspace called “1”. */ - Con *output; - Con *workspace = NULL; - TAILQ_FOREACH(output, &(croot->nodes_head), nodes) - GREP_FIRST(workspace, output_get_content(output), !strcasecmp(child->name, json_node->name)); char *base = sstrdup(json_node->name); int cnt = 1; - while (workspace != NULL) { + while (get_existing_workspace_by_name(json_node->name) != NULL) { FREE(json_node->name); - asprintf(&(json_node->name), "%s_%d", base, cnt++); - workspace = NULL; - TAILQ_FOREACH(output, &(croot->nodes_head), nodes) - GREP_FIRST(workspace, output_get_content(output), !strcasecmp(child->name, json_node->name)); + sasprintf(&(json_node->name), "%s_%d", base, cnt++); } free(base); @@ -116,11 +120,57 @@ static int json_end_map(void *ctx) { json_node->num = ws_name_to_number(json_node->name); } + // When appending JSON layout files that only contain the workspace + // _contents_, we might not have an upfront signal that the + // container we’re currently parsing is a floating container (like + // the “floating_nodes” key of the workspace container itself). + // That’s why we make sure the con is attached at the right place + // in the hierarchy in case it’s floating. + if (json_node->type == CT_FLOATING_CON) { + DLOG("fixing parent which currently is %p / %s\n", json_node->parent, json_node->parent->name); + json_node->parent = con_get_workspace(json_node->parent); + + // Also set a size if none was supplied, otherwise the placeholder + // window cannot be created as X11 requests with width=0 or + // height=0 are invalid. + const Rect zero = {0, 0, 0, 0}; + if (memcmp(&(json_node->rect), &zero, sizeof(Rect)) == 0) { + DLOG("Geometry not set, combining children\n"); + Con *child; + TAILQ_FOREACH(child, &(json_node->nodes_head), nodes) { + DLOG("child geometry: %d x %d\n", child->geometry.width, child->geometry.height); + json_node->rect.width += child->geometry.width; + json_node->rect.height = max(json_node->rect.height, child->geometry.height); + } + } + + floating_check_size(json_node); + } + + if (num_marks > 0) { + for (int i = 0; i < num_marks; i++) { + con_mark(json_node, marks[i], MM_ADD); + free(marks[i]); + } + + FREE(marks); + num_marks = 0; + } + LOG("attaching\n"); con_attach(json_node, json_node->parent, true); LOG("Creating window\n"); - x_con_init(json_node, json_node->depth); + x_con_init(json_node); json_node = json_node->parent; + incomplete--; + DLOG("incomplete = %d\n", incomplete); + } + + if (parsing_swallows && swallow_is_empty) { + /* We parsed an empty swallow definition. This is an invalid layout + * definition, hence we reject it. */ + ELOG("Layout file is invalid: found an empty swallow definition.\n"); + return 0; } parsing_rect = false; @@ -132,12 +182,16 @@ static int json_end_map(void *ctx) { static int json_end_array(void *ctx) { LOG("end of array\n"); - if (!parsing_swallows && !parsing_focus) { + if (!parsing_swallows && !parsing_focus && !parsing_marks) { con_fix_percent(json_node); } if (parsing_swallows) { parsing_swallows = false; } + if (parsing_marks) { + parsing_marks = false; + } + if (parsing_focus) { /* Clear the list of focus mappings */ struct focus_mapping *mapping; @@ -167,7 +221,7 @@ static int json_end_array(void *ctx) { static int json_key(void *ctx, const unsigned char *val, size_t len) { LOG("key: %.*s\n", (int)len, val); FREE(last_key); - last_key = scalloc((len + 1) * sizeof(char)); + last_key = scalloc(len + 1, 1); memcpy(last_key, val, len); if (strcasecmp(last_key, "swallows") == 0) parsing_swallows = true; @@ -187,6 +241,11 @@ static int json_key(void *ctx, const unsigned char *val, size_t len) { if (strcasecmp(last_key, "focus") == 0) parsing_focus = true; + if (strcasecmp(last_key, "marks") == 0) { + num_marks = 0; + parsing_marks = true; + } + return 1; } @@ -197,22 +256,35 @@ static int json_string(void *ctx, const unsigned char *val, size_t len) { sasprintf(&sval, "%.*s", len, val); if (strcasecmp(last_key, "class") == 0) { current_swallow->class = regex_new(sval); + swallow_is_empty = false; } else if (strcasecmp(last_key, "instance") == 0) { current_swallow->instance = regex_new(sval); + swallow_is_empty = false; } else if (strcasecmp(last_key, "window_role") == 0) { current_swallow->window_role = regex_new(sval); + swallow_is_empty = false; } else if (strcasecmp(last_key, "title") == 0) { current_swallow->title = regex_new(sval); + swallow_is_empty = false; } else { ELOG("swallow key %s unknown\n", last_key); } free(sval); + } else if (parsing_marks) { + char *mark; + sasprintf(&mark, "%.*s", (int)len, val); + + marks = srealloc(marks, (++num_marks) * sizeof(char *)); + marks[num_marks - 1] = sstrdup(mark); } else { if (strcasecmp(last_key, "name") == 0) { - json_node->name = scalloc((len + 1) * sizeof(char)); + json_node->name = scalloc(len + 1, 1); memcpy(json_node->name, val, len); + } else if (strcasecmp(last_key, "title_format") == 0) { + json_node->title_format = scalloc(len + 1, 1); + memcpy(json_node->title_format, val, len); } else if (strcasecmp(last_key, "sticky_group") == 0) { - json_node->sticky_group = scalloc((len + 1) * sizeof(char)); + json_node->sticky_group = scalloc(len + 1, 1); memcpy(json_node->sticky_group, val, len); LOG("sticky_group of this container is %s\n", json_node->sticky_group); } else if (strcasecmp(last_key, "orientation") == 0) { @@ -309,9 +381,12 @@ static int json_string(void *ctx, const unsigned char *val, size_t len) { LOG("Unhandled \"last_splitlayout\": %s\n", buf); free(buf); } else if (strcasecmp(last_key, "mark") == 0) { + DLOG("Found deprecated key \"mark\".\n"); + char *buf = NULL; sasprintf(&buf, "%.*s", (int)len, val); - json_node->mark = buf; + + con_mark(json_node, buf, MM_REPLACE); } else if (strcasecmp(last_key, "floating") == 0) { char *buf = NULL; sasprintf(&buf, "%.*s", (int)len, val); @@ -361,7 +436,7 @@ static int json_int(void *ctx, long long val) { json_node->old_id = val; if (parsing_focus) { - struct focus_mapping *focus_mapping = scalloc(sizeof(struct focus_mapping)); + struct focus_mapping *focus_mapping = scalloc(1, sizeof(struct focus_mapping)); focus_mapping->old_id = val; TAILQ_INSERT_TAIL(&focus_mappings, focus_mapping, focus_mappings); } @@ -390,12 +465,15 @@ static int json_int(void *ctx, long long val) { if (parsing_swallows) { if (strcasecmp(last_key, "id") == 0) { current_swallow->id = val; + swallow_is_empty = false; } if (strcasecmp(last_key, "dock") == 0) { current_swallow->dock = val; + swallow_is_empty = false; } if (strcasecmp(last_key, "insert_where") == 0) { current_swallow->insert_where = val; + swallow_is_empty = false; } } @@ -408,9 +486,14 @@ static int json_bool(void *ctx, int val) { to_focus = json_node; } + if (strcasecmp(last_key, "sticky") == 0) + json_node->sticky = val; + if (parsing_swallows) { - if (strcasecmp(last_key, "restart_mode") == 0) + if (strcasecmp(last_key, "restart_mode") == 0) { current_swallow->restart_mode = val; + swallow_is_empty = false; + } } return 1; @@ -425,9 +508,20 @@ static int json_double(void *ctx, double val) { } static json_content_t content_result; +static int content_level; + +static int json_determine_content_deeper(void *ctx) { + content_level++; + return 1; +} + +static int json_determine_content_shallower(void *ctx) { + content_level--; + return 1; +} static int json_determine_content_string(void *ctx, const unsigned char *val, size_t len) { - if (strcasecmp(last_key, "type") != 0) + if (strcasecmp(last_key, "type") != 0 || content_level > 1) return 1; DLOG("string = %.*s, last_key = %s\n", (int)len, val, last_key); @@ -436,84 +530,71 @@ static int json_determine_content_string(void *ctx, const unsigned char *val, si return 0; } +/* + * Returns true if the provided JSON could be parsed by yajl. + * + */ +bool json_validate(const char *buf, const size_t len) { + bool valid = true; + yajl_handle hand = yajl_alloc(NULL, NULL, NULL); + /* Allowing comments allows for more user-friendly layout files. */ + yajl_config(hand, yajl_allow_comments, true); + /* Allow multiple values, i.e. multiple nodes to attach */ + yajl_config(hand, yajl_allow_multiple_values, true); + + setlocale(LC_NUMERIC, "C"); + if (yajl_parse(hand, (const unsigned char *)buf, len) != yajl_status_ok) { + unsigned char *str = yajl_get_error(hand, 1, (const unsigned char *)buf, len); + ELOG("JSON parsing error: %s\n", str); + yajl_free_error(hand, str); + valid = false; + } + setlocale(LC_NUMERIC, ""); + + yajl_complete_parse(hand); + yajl_free(hand); + + return valid; +} + /* Parses the given JSON file until it encounters the first “type” property to * determine whether the file contains workspaces or regular containers, which * is important to know when deciding where (and how) to append the contents. * */ -json_content_t json_determine_content(const char *filename) { - FILE *f; - if ((f = fopen(filename, "r")) == NULL) { - ELOG("Cannot open file \"%s\"\n", filename); - return JSON_CONTENT_UNKNOWN; - } - struct stat stbuf; - if (fstat(fileno(f), &stbuf) != 0) { - ELOG("Cannot fstat() \"%s\"\n", filename); - fclose(f); - return JSON_CONTENT_UNKNOWN; - } - char *buf = smalloc(stbuf.st_size); - int n = fread(buf, 1, stbuf.st_size, f); - if (n != stbuf.st_size) { - ELOG("File \"%s\" could not be read entirely, not loading.\n", filename); - fclose(f); - return JSON_CONTENT_UNKNOWN; - } - DLOG("read %d bytes\n", n); +json_content_t json_determine_content(const char *buf, const size_t len) { // We default to JSON_CONTENT_CON because it is legal to not include // “"type": "con"” in the JSON files for better readability. content_result = JSON_CONTENT_CON; - yajl_gen g; - yajl_handle hand; + content_level = 0; static yajl_callbacks callbacks = { .yajl_string = json_determine_content_string, .yajl_map_key = json_key, + .yajl_start_array = json_determine_content_deeper, + .yajl_start_map = json_determine_content_deeper, + .yajl_end_map = json_determine_content_shallower, + .yajl_end_array = json_determine_content_shallower, }; - g = yajl_gen_alloc(NULL); - hand = yajl_alloc(&callbacks, NULL, (void *)g); + yajl_handle hand = yajl_alloc(&callbacks, NULL, NULL); /* Allowing comments allows for more user-friendly layout files. */ yajl_config(hand, yajl_allow_comments, true); /* Allow multiple values, i.e. multiple nodes to attach */ yajl_config(hand, yajl_allow_multiple_values, true); - yajl_status stat; setlocale(LC_NUMERIC, "C"); - stat = yajl_parse(hand, (const unsigned char *)buf, n); + const yajl_status stat = yajl_parse(hand, (const unsigned char *)buf, len); if (stat != yajl_status_ok && stat != yajl_status_client_canceled) { - unsigned char *str = yajl_get_error(hand, 1, (const unsigned char *)buf, n); + unsigned char *str = yajl_get_error(hand, 1, (const unsigned char *)buf, len); ELOG("JSON parsing error: %s\n", str); yajl_free_error(hand, str); } setlocale(LC_NUMERIC, ""); yajl_complete_parse(hand); - - fclose(f); + yajl_free(hand); return content_result; } -void tree_append_json(Con *con, const char *filename, char **errormsg) { - FILE *f; - if ((f = fopen(filename, "r")) == NULL) { - ELOG("Cannot open file \"%s\"\n", filename); - return; - } - struct stat stbuf; - if (fstat(fileno(f), &stbuf) != 0) { - ELOG("Cannot fstat() \"%s\"\n", filename); - fclose(f); - return; - } - char *buf = smalloc(stbuf.st_size); - int n = fread(buf, 1, stbuf.st_size, f); - if (n != stbuf.st_size) { - ELOG("File \"%s\" could not be read entirely, not loading.\n", filename); - fclose(f); - return; - } - DLOG("read %d bytes\n", n); - yajl_gen g; - yajl_handle hand; +void tree_append_json(Con *con, const char *buf, const size_t len, char **errormsg) { static yajl_callbacks callbacks = { .yajl_boolean = json_bool, .yajl_integer = json_int, @@ -524,29 +605,49 @@ void tree_append_json(Con *con, const char *filename, char **errormsg) { .yajl_end_map = json_end_map, .yajl_end_array = json_end_array, }; - g = yajl_gen_alloc(NULL); - hand = yajl_alloc(&callbacks, NULL, (void *)g); + yajl_handle hand = yajl_alloc(&callbacks, NULL, NULL); /* Allowing comments allows for more user-friendly layout files. */ yajl_config(hand, yajl_allow_comments, true); /* Allow multiple values, i.e. multiple nodes to attach */ yajl_config(hand, yajl_allow_multiple_values, true); - yajl_status stat; + /* We don't need to validate that the input is valid UTF8 here. + * tree_append_json is called in two cases: + * 1. With the append_layout command. json_validate is called first and will + * fail on invalid UTF8 characters so we don't need to recheck. + * 2. With an in-place restart. The rest of the codebase should be + * responsible for producing valid UTF8 JSON output. If not, + * tree_append_json will just preserve invalid UTF8 strings in the tree + * instead of failing to parse the layout file which could lead to + * problems like in #3156. + * Either way, disabling UTF8 validation slightly speeds up yajl. */ + yajl_config(hand, yajl_dont_validate_strings, true); json_node = con; to_focus = NULL; + incomplete = 0; parsing_swallows = false; parsing_rect = false; parsing_deco_rect = false; parsing_window_rect = false; parsing_geometry = false; parsing_focus = false; + parsing_marks = false; setlocale(LC_NUMERIC, "C"); - stat = yajl_parse(hand, (const unsigned char *)buf, n); + const yajl_status stat = yajl_parse(hand, (const unsigned char *)buf, len); if (stat != yajl_status_ok) { - unsigned char *str = yajl_get_error(hand, 1, (const unsigned char *)buf, n); + unsigned char *str = yajl_get_error(hand, 1, (const unsigned char *)buf, len); ELOG("JSON parsing error: %s\n", str); if (errormsg != NULL) *errormsg = sstrdup((const char *)str); yajl_free_error(hand, str); + while (incomplete-- > 0) { + Con *parent = json_node->parent; + DLOG("freeing incomplete container %p\n", json_node); + if (json_node == to_focus) { + to_focus = NULL; + } + con_free(json_node); + json_node = parent; + } } /* In case not all containers were restored, we need to fix the @@ -556,8 +657,9 @@ void tree_append_json(Con *con, const char *filename, char **errormsg) { setlocale(LC_NUMERIC, ""); yajl_complete_parse(hand); + yajl_free(hand); - fclose(f); - if (to_focus) - con_focus(to_focus); + if (to_focus) { + con_activate(to_focus); + } }