return SYSTEMD_LANGUAGE_FALLBACK_MAP;
}
+static void x11_context_clear(X11Context *xc) {
+ assert(xc);
+
+ xc->layout = mfree(xc->layout);
+ xc->options = mfree(xc->options);
+ xc->model = mfree(xc->model);
+ xc->variant = mfree(xc->variant);
+}
+
+static bool x11_context_isempty(const X11Context *xc) {
+ assert(xc);
+
+ return
+ isempty(xc->layout) &&
+ isempty(xc->model) &&
+ isempty(xc->variant) &&
+ isempty(xc->options);
+}
+
+void x11_context_empty_to_null(X11Context *xc) {
+ assert(xc);
+
+ /* Do not call x11_context_clear() for the passed object. */
+
+ xc->layout = empty_to_null(xc->layout);
+ xc->model = empty_to_null(xc->model);
+ xc->variant = empty_to_null(xc->variant);
+ xc->options = empty_to_null(xc->options);
+}
+
+bool x11_context_is_safe(const X11Context *xc) {
+ assert(xc);
+
+ return
+ (!xc->layout || string_is_safe(xc->layout)) &&
+ (!xc->model || string_is_safe(xc->model)) &&
+ (!xc->variant || string_is_safe(xc->variant)) &&
+ (!xc->options || string_is_safe(xc->options));
+}
+
+bool x11_context_equal(const X11Context *a, const X11Context *b) {
+ assert(a);
+ assert(b);
+
+ return
+ streq_ptr(a->layout, b->layout) &&
+ streq_ptr(a->model, b->model) &&
+ streq_ptr(a->variant, b->variant) &&
+ streq_ptr(a->options, b->options);
+}
+
+int x11_context_copy(X11Context *dest, const X11Context *src) {
+ bool modified;
+ int r;
+
+ assert(dest);
+
+ if (dest == src)
+ return 0;
+
+ if (!src) {
+ modified = !x11_context_isempty(dest);
+ x11_context_clear(dest);
+ return modified;
+ }
+
+ r = free_and_strdup(&dest->layout, src->layout);
+ if (r < 0)
+ return r;
+ modified = r > 0;
+
+ r = free_and_strdup(&dest->model, src->model);
+ if (r < 0)
+ return r;
+ modified = modified || r > 0;
+
+ r = free_and_strdup(&dest->variant, src->variant);
+ if (r < 0)
+ return r;
+ modified = modified || r > 0;
+
+ r = free_and_strdup(&dest->options, src->options);
+ if (r < 0)
+ return r;
+ modified = modified || r > 0;
+
+ return modified;
+}
+
static void context_clear_x11(Context *c) {
assert(c);
- c->x11_layout = mfree(c->x11_layout);
- c->x11_options = mfree(c->x11_options);
- c->x11_model = mfree(c->x11_model);
- c->x11_variant = mfree(c->x11_variant);
+ x11_context_clear(&c->x11_from_xorg);
}
static void context_clear_vconsole(Context *c) {
c->polkit_registry = bus_verify_polkit_async_registry_free(c->polkit_registry);
};
+static X11Context *context_get_x11_context(Context *c) {
+ assert(c);
+
+ if (!x11_context_isempty(&c->x11_from_xorg))
+ return &c->x11_from_xorg;
+
+ return NULL;
+}
+
+X11Context *context_get_x11_context_safe(Context *c) {
+ return &ASSERT_PTR(c)->x11_from_xorg;
+}
+
int locale_read_data(Context *c, sd_bus_message *m) {
assert(c);
return 0;
c->x11_stat = st;
- context_clear_x11(c);
+ x11_context_clear(&c->x11_from_xorg);
fd_ro = fd_reopen(fd, O_CLOEXEC | O_RDONLY);
if (fd_ro < 0)
char **p = NULL;
if (streq(a[1], "XkbLayout"))
- p = &c->x11_layout;
+ p = &c->x11_from_xorg.layout;
else if (streq(a[1], "XkbModel"))
- p = &c->x11_model;
+ p = &c->x11_from_xorg.model;
else if (streq(a[1], "XkbVariant"))
- p = &c->x11_variant;
+ p = &c->x11_from_xorg.variant;
else if (streq(a[1], "XkbOptions"))
- p = &c->x11_options;
+ p = &c->x11_from_xorg.options;
if (p)
free_and_replace(*p, a[2]);
in_section = false;
}
+ if (!x11_context_isempty(&c->x11_from_xorg))
+ log_debug("XKB settings loaded from xorg.conf.d/00-keyboard.conf.");
+
return 0;
}
int x11_write_data(Context *c) {
_cleanup_fclose_ FILE *f = NULL;
_cleanup_(unlink_and_freep) char *temp_path = NULL;
+ const X11Context *xc;
int r;
assert(c);
- if (isempty(c->x11_layout) &&
- isempty(c->x11_model) &&
- isempty(c->x11_variant) &&
- isempty(c->x11_options)) {
-
+ xc = context_get_x11_context(c);
+ if (!xc) {
if (unlink("/etc/X11/xorg.conf.d/00-keyboard.conf") < 0)
return errno == ENOENT ? 0 : -errno;
" Identifier \"system-keyboard\"\n"
" MatchIsKeyboard \"on\"\n", f);
- if (!isempty(c->x11_layout))
- fprintf(f, " Option \"XkbLayout\" \"%s\"\n", c->x11_layout);
+ if (!isempty(xc->layout))
+ fprintf(f, " Option \"XkbLayout\" \"%s\"\n", xc->layout);
- if (!isempty(c->x11_model))
- fprintf(f, " Option \"XkbModel\" \"%s\"\n", c->x11_model);
+ if (!isempty(xc->model))
+ fprintf(f, " Option \"XkbModel\" \"%s\"\n", xc->model);
- if (!isempty(c->x11_variant))
- fprintf(f, " Option \"XkbVariant\" \"%s\"\n", c->x11_variant);
+ if (!isempty(xc->variant))
+ fprintf(f, " Option \"XkbVariant\" \"%s\"\n", xc->variant);
- if (!isempty(c->x11_options))
- fprintf(f, " Option \"XkbOptions\" \"%s\"\n", c->x11_options);
+ if (!isempty(xc->options))
+ fprintf(f, " Option \"XkbOptions\" \"%s\"\n", xc->options);
fputs("EndSection\n", f);
int vconsole_convert_to_x11(Context *c) {
int r, modified = -1;
+ X11Context *xc;
assert(c);
- if (isempty(c->vc_keymap)) {
- modified =
- !isempty(c->x11_layout) ||
- !isempty(c->x11_model) ||
- !isempty(c->x11_variant) ||
- !isempty(c->x11_options);
+ xc = context_get_x11_context_safe(c);
+ if (isempty(c->vc_keymap)) {
+ modified = !x11_context_isempty(xc);
context_clear_x11(c);
} else {
_cleanup_fclose_ FILE *f = NULL;
if (!streq(c->vc_keymap, a[0]))
continue;
- if (!streq_ptr(c->x11_layout, empty_or_dash_to_null(a[1])) ||
- !streq_ptr(c->x11_model, empty_or_dash_to_null(a[2])) ||
- !streq_ptr(c->x11_variant, empty_or_dash_to_null(a[3])) ||
- !streq_ptr(c->x11_options, empty_or_dash_to_null(a[4]))) {
-
- if (free_and_strdup(&c->x11_layout, empty_or_dash_to_null(a[1])) < 0 ||
- free_and_strdup(&c->x11_model, empty_or_dash_to_null(a[2])) < 0 ||
- free_and_strdup(&c->x11_variant, empty_or_dash_to_null(a[3])) < 0 ||
- free_and_strdup(&c->x11_options, empty_or_dash_to_null(a[4])) < 0)
- return -ENOMEM;
-
- modified = true;
- }
+ r = x11_context_copy(xc,
+ &(X11Context) {
+ .layout = empty_or_dash_to_null(a[1]),
+ .model = empty_or_dash_to_null(a[2]),
+ .variant = empty_or_dash_to_null(a[3]),
+ .options = empty_or_dash_to_null(a[4]),
+ });
+ if (r < 0)
+ return r;
+ modified = r > 0;
break;
}
if (modified > 0)
log_info("Changing X11 keyboard layout to '%s' model '%s' variant '%s' options '%s'",
- strempty(c->x11_layout),
- strempty(c->x11_model),
- strempty(c->x11_variant),
- strempty(c->x11_options));
+ strempty(xc->layout),
+ strempty(xc->model),
+ strempty(xc->variant),
+ strempty(xc->options));
else if (modified < 0)
log_notice("X11 keyboard layout was not modified: no conversion found for \"%s\".",
c->vc_keymap);
return modified > 0;
}
-int find_converted_keymap(const char *x11_layout, const char *x11_variant, char **ret) {
+int find_converted_keymap(const X11Context *xc, char **ret) {
_cleanup_free_ char *n = NULL;
- assert(x11_layout);
+ assert(xc);
+ assert(!isempty(xc->layout));
assert(ret);
- if (x11_variant)
- n = strjoin(x11_layout, "-", x11_variant);
+ if (xc->variant)
+ n = strjoin(xc->layout, "-", xc->variant);
else
- n = strdup(x11_layout);
+ n = strdup(xc->layout);
if (!n)
return -ENOMEM;
return 0;
}
-int find_legacy_keymap(Context *c, char **ret) {
+int find_legacy_keymap(const X11Context *xc, char **ret) {
const char *map;
_cleanup_fclose_ FILE *f = NULL;
_cleanup_free_ char *new_keymap = NULL;
unsigned best_matching = 0;
int r;
- assert(c);
- assert(!isempty(c->x11_layout));
+ assert(xc);
+ assert(!isempty(xc->layout));
map = systemd_kbd_model_map();
f = fopen(map, "re");
break;
/* Determine how well matching this entry is */
- if (streq(c->x11_layout, a[1]))
+ if (streq(xc->layout, a[1]))
/* If we got an exact match, this is the best */
matching = 10;
else {
/* We have multiple X layouts, look for an
* entry that matches our key with everything
* but the first layout stripped off. */
- if (startswith_comma(c->x11_layout, a[1]))
+ if (startswith_comma(xc->layout, a[1]))
matching = 5;
else {
_cleanup_free_ char *x = NULL;
x = strdupcspn(a[1], ",");
if (!x)
return -ENOMEM;
- if (startswith_comma(c->x11_layout, x))
+ if (startswith_comma(xc->layout, x))
matching = 1;
}
}
if (matching > 0) {
- if (isempty(c->x11_model) || streq_ptr(c->x11_model, a[2])) {
+ if (isempty(xc->model) || streq_ptr(xc->model, a[2])) {
matching++;
- if (streq_ptr(c->x11_variant, a[3])) {
+ if (streq_ptr(xc->variant, a[3])) {
matching++;
- if (streq_ptr(c->x11_options, a[4]))
+ if (streq_ptr(xc->options, a[4]))
matching++;
}
}
}
}
- if (best_matching < 10 && !isempty(c->x11_layout)) {
+ if (best_matching < 10 && !isempty(xc->layout)) {
_cleanup_free_ char *l = NULL, *v = NULL, *converted = NULL;
/* The best match is only the first part of the X11
* matches just the first layout.
*/
- l = strndup(c->x11_layout, strcspn(c->x11_layout, ","));
+ l = strndup(xc->layout, strcspn(xc->layout, ","));
if (!l)
return -ENOMEM;
- if (!isempty(c->x11_variant)) {
- v = strndup(c->x11_variant, strcspn(c->x11_variant, ","));
+ if (!isempty(xc->variant)) {
+ v = strndup(xc->variant, strcspn(xc->variant, ","));
if (!v)
return -ENOMEM;
}
- r = find_converted_keymap(l, v, &converted);
+ r = find_converted_keymap(
+ &(X11Context) {
+ .layout = l,
+ .variant = v,
+ },
+ &converted);
if (r < 0)
return r;
if (r > 0)
int x11_convert_to_vconsole(Context *c) {
bool modified = false;
+ const X11Context *xc;
assert(c);
- if (isempty(c->x11_layout)) {
+ xc = context_get_x11_context_safe(c);
+
+ if (isempty(xc->layout)) {
modified =
!isempty(c->vc_keymap) ||
!isempty(c->vc_keymap_toggle);
_cleanup_free_ char *new_keymap = NULL;
int r;
- r = find_converted_keymap(c->x11_layout, c->x11_variant, &new_keymap);
+ r = find_converted_keymap(xc, &new_keymap);
if (r == 0)
- r = find_legacy_keymap(c, &new_keymap);
+ r = find_legacy_keymap(xc, &new_keymap);
if (r < 0)
return r;
if (r == 0)
/* We search for layout-variant match first, but then we also look
* for anything which matches just the layout. So it's accurate to say
* that we couldn't find anything which matches the layout. */
- log_notice("No conversion to virtual console map found for \"%s\".", c->x11_layout);
+ log_notice("No conversion to virtual console map found for \"%s\".", xc->layout);
if (!streq_ptr(c->vc_keymap, new_keymap)) {
context_clear_vconsole(c);
#include "hashmap.h"
#include "locale-setup.h"
+typedef struct X11Context {
+ char *layout;
+ char *model;
+ char *variant;
+ char *options;
+} X11Context;
+
typedef struct Context {
sd_bus_message *locale_cache;
LocaleContext locale_context;
sd_bus_message *x11_cache;
struct stat x11_stat;
- char *x11_layout;
- char *x11_model;
- char *x11_variant;
- char *x11_options;
+ X11Context x11_from_xorg;
sd_bus_message *vc_cache;
struct stat vc_stat;
Hashmap *polkit_registry;
} Context;
-int find_converted_keymap(const char *x11_layout, const char *x11_variant, char **ret);
-int find_legacy_keymap(Context *c, char **ret);
+void x11_context_empty_to_null(X11Context *xc);
+bool x11_context_is_safe(const X11Context *xc);
+bool x11_context_equal(const X11Context *a, const X11Context *b);
+int x11_context_copy(X11Context *dest, const X11Context *src);
+
+X11Context *context_get_x11_context_safe(Context *c);
+
+int find_converted_keymap(const X11Context *xc, char **ret);
+int find_legacy_keymap(const X11Context *xc, char **ret);
int find_language_fallback(const char *lang, char **ret);
int locale_read_data(Context *c, sd_bus_message *m);
sd_bus_error *error) {
Context *c = ASSERT_PTR(userdata);
+ const X11Context *xc;
int r;
assert(property);
if (r < 0)
return r;
+ xc = context_get_x11_context_safe(c);
+
if (streq(property, "X11Layout"))
- return sd_bus_message_append_basic(reply, 's', c->x11_layout);
+ return sd_bus_message_append_basic(reply, 's', xc->layout);
if (streq(property, "X11Model"))
- return sd_bus_message_append_basic(reply, 's', c->x11_model);
+ return sd_bus_message_append_basic(reply, 's', xc->model);
if (streq(property, "X11Variant"))
- return sd_bus_message_append_basic(reply, 's', c->x11_variant);
+ return sd_bus_message_append_basic(reply, 's', xc->variant);
if (streq(property, "X11Options"))
- return sd_bus_message_append_basic(reply, 's', c->x11_options);
+ return sd_bus_message_append_basic(reply, 's', xc->options);
return -EINVAL;
}
static int method_set_x11_keyboard(sd_bus_message *m, void *userdata, sd_bus_error *error) {
Context *c = ASSERT_PTR(userdata);
- const char *layout, *model, *variant, *options;
int convert, interactive, r;
+ X11Context *xc, in;
assert(m);
- r = sd_bus_message_read(m, "ssssbb", &layout, &model, &variant, &options, &convert, &interactive);
+ r = sd_bus_message_read(m, "ssssbb", &in.layout, &in.model, &in.variant, &in.options, &convert, &interactive);
if (r < 0)
return r;
- layout = empty_to_null(layout);
- model = empty_to_null(model);
- variant = empty_to_null(variant);
- options = empty_to_null(options);
+ x11_context_empty_to_null(&in);
r = x11_read_data(c, m);
if (r < 0) {
return sd_bus_error_set(error, SD_BUS_ERROR_FAILED, "Failed to read x11 keyboard layout data");
}
- if (streq_ptr(layout, c->x11_layout) &&
- streq_ptr(model, c->x11_model) &&
- streq_ptr(variant, c->x11_variant) &&
- streq_ptr(options, c->x11_options))
+ xc = context_get_x11_context_safe(c);
+
+ if (x11_context_equal(xc, &in))
return sd_bus_reply_method_return(m, NULL);
- if ((layout && !string_is_safe(layout)) ||
- (model && !string_is_safe(model)) ||
- (variant && !string_is_safe(variant)) ||
- (options && !string_is_safe(options)))
+ if (!x11_context_is_safe(&in))
return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Received invalid keyboard data");
- r = verify_xkb_rmlvo(model, layout, variant, options);
+ r = verify_xkb_rmlvo(in.model, in.layout, in.variant, in.options);
if (r < 0) {
log_error_errno(r, "Cannot compile XKB keymap for new x11 keyboard layout ('%s' / '%s' / '%s' / '%s'): %m",
- strempty(model), strempty(layout), strempty(variant), strempty(options));
+ strempty(in.model), strempty(in.layout), strempty(in.variant), strempty(in.options));
if (r == -EOPNOTSUPP)
return sd_bus_error_set(error, SD_BUS_ERROR_NOT_SUPPORTED, "Local keyboard configuration not supported on this system.");
if (r == 0)
return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
- if (free_and_strdup(&c->x11_layout, layout) < 0 ||
- free_and_strdup(&c->x11_model, model) < 0 ||
- free_and_strdup(&c->x11_variant, variant) < 0 ||
- free_and_strdup(&c->x11_options, options) < 0)
- return -ENOMEM;
+ r = x11_context_copy(xc, &in);
+ if (r < 0)
+ return log_oom();
r = x11_write_data(c);
if (r < 0) {
}
log_info("Changed X11 keyboard layout to '%s' model '%s' variant '%s' options '%s'",
- strempty(c->x11_layout),
- strempty(c->x11_model),
- strempty(c->x11_variant),
- strempty(c->x11_options));
+ strempty(in.layout),
+ strempty(in.model),
+ strempty(in.variant),
+ strempty(in.options));
(void) sd_bus_emit_properties_changed(
sd_bus_message_get_bus(m),
_cleanup_free_ char *ans = NULL, *ans2 = NULL;
int r;
- assert_se(find_converted_keymap("pl", "foobar", &ans) == 0);
+ assert_se(find_converted_keymap(
+ &(X11Context) {
+ .layout = (char*) "pl",
+ .variant = (char*) "foobar",
+ }, &ans) == 0);
assert_se(ans == NULL);
- r = find_converted_keymap("pl", NULL, &ans);
+ r = find_converted_keymap(
+ &(X11Context) {
+ .layout = (char*) "pl",
+ }, &ans);
if (r == 0) {
log_info("Skipping rest of %s: keymaps are not installed", __func__);
return;
assert_se(r == 1);
assert_se(streq(ans, "pl"));
- assert_se(find_converted_keymap("pl", "dvorak", &ans2) == 1);
+ assert_se(find_converted_keymap(
+ &(X11Context) {
+ .layout = (char*) "pl",
+ .variant = (char*) "dvorak",
+ }, &ans2) == 1);
assert_se(streq(ans2, "pl-dvorak"));
}
TEST(find_legacy_keymap) {
- Context c = {};
+ X11Context xc = {};
_cleanup_free_ char *ans = NULL, *ans2 = NULL;
- c.x11_layout = (char*) "foobar";
- assert_se(find_legacy_keymap(&c, &ans) == 0);
+ xc.layout = (char*) "foobar";
+ assert_se(find_legacy_keymap(&xc, &ans) == 0);
assert_se(ans == NULL);
- c.x11_layout = (char*) "pl";
- assert_se(find_legacy_keymap(&c, &ans) == 1);
+ xc.layout = (char*) "pl";
+ assert_se(find_legacy_keymap(&xc, &ans) == 1);
assert_se(streq(ans, "pl2"));
- c.x11_layout = (char*) "pl,ru";
- assert_se(find_legacy_keymap(&c, &ans2) == 1);
+ xc.layout = (char*) "pl,ru";
+ assert_se(find_legacy_keymap(&xc, &ans2) == 1);
assert_se(streq(ans, "pl2"));
}
TEST(vconsole_convert_to_x11) {
_cleanup_(context_clear) Context c = {};
+ X11Context *xc = &c.x11_from_xorg;
log_info("/* test emptying first (:) */");
- assert_se(free_and_strdup(&c.x11_layout, "foo") >= 0);
- assert_se(free_and_strdup(&c.x11_variant, "bar") >= 0);
+ assert_se(free_and_strdup(&xc->layout, "foo") >= 0);
+ assert_se(free_and_strdup(&xc->variant, "bar") >= 0);
assert_se(vconsole_convert_to_x11(&c) == 1);
- assert_se(c.x11_layout == NULL);
- assert_se(c.x11_variant == NULL);
+ assert_se(xc->layout == NULL);
+ assert_se(xc->variant == NULL);
log_info("/* test emptying second (:) */");
assert_se(vconsole_convert_to_x11(&c) == 0);
- assert_se(c.x11_layout == NULL);
- assert_se(c.x11_variant == NULL);
+ assert_se(xc->layout == NULL);
+ assert_se(xc->variant == NULL);
log_info("/* test without variant, new mapping (es:) */");
assert_se(free_and_strdup(&c.vc_keymap, "es") >= 0);
assert_se(vconsole_convert_to_x11(&c) == 1);
- assert_se(streq(c.x11_layout, "es"));
- assert_se(c.x11_variant == NULL);
+ assert_se(streq(xc->layout, "es"));
+ assert_se(xc->variant == NULL);
log_info("/* test with known variant, new mapping (es:dvorak) */");
assert_se(free_and_strdup(&c.vc_keymap, "es-dvorak") >= 0);
assert_se(vconsole_convert_to_x11(&c) == 1);
- assert_se(streq(c.x11_layout, "es"));
- assert_se(streq(c.x11_variant, "dvorak"));
+ assert_se(streq(xc->layout, "es"));
+ assert_se(streq(xc->variant, "dvorak"));
log_info("/* test with old mapping (fr:latin9) */");
assert_se(free_and_strdup(&c.vc_keymap, "fr-latin9") >= 0);
assert_se(vconsole_convert_to_x11(&c) == 1);
- assert_se(streq(c.x11_layout, "fr"));
- assert_se(streq(c.x11_variant, "latin9"));
+ assert_se(streq(xc->layout, "fr"));
+ assert_se(streq(xc->variant, "latin9"));
log_info("/* test with a compound mapping (ru,us) */");
assert_se(free_and_strdup(&c.vc_keymap, "ru") >= 0);
assert_se(vconsole_convert_to_x11(&c) == 1);
- assert_se(streq(c.x11_layout, "ru,us"));
- assert_se(c.x11_variant == NULL);
+ assert_se(streq(xc->layout, "ru,us"));
+ assert_se(xc->variant == NULL);
log_info("/* test with a simple mapping (us) */");
assert_se(free_and_strdup(&c.vc_keymap, "us") >= 0);
assert_se(vconsole_convert_to_x11(&c) == 1);
- assert_se(streq(c.x11_layout, "us"));
- assert_se(c.x11_variant == NULL);
+ assert_se(streq(xc->layout, "us"));
+ assert_se(xc->variant == NULL);
}
TEST(x11_convert_to_vconsole) {
_cleanup_(context_clear) Context c = {};
+ X11Context *xc = &c.x11_from_xorg;
int r;
log_info("/* test emptying first (:) */");
assert_se(c.vc_keymap == NULL);
log_info("/* test without variant, new mapping (es:) */");
- assert_se(free_and_strdup(&c.x11_layout, "es") >= 0);
+ assert_se(free_and_strdup(&xc->layout, "es") >= 0);
assert_se(x11_convert_to_vconsole(&c) == 1);
assert_se(streq(c.vc_keymap, "es"));
log_info("/* test with unknown variant, new mapping (es:foobar) */");
- assert_se(free_and_strdup(&c.x11_variant, "foobar") >= 0);
+ assert_se(free_and_strdup(&xc->variant, "foobar") >= 0);
assert_se(x11_convert_to_vconsole(&c) == 0);
assert_se(streq(c.vc_keymap, "es"));
log_info("/* test with known variant, new mapping (es:dvorak) */");
- assert_se(free_and_strdup(&c.x11_variant, "dvorak") >= 0);
+ assert_se(free_and_strdup(&xc->variant, "dvorak") >= 0);
r = x11_convert_to_vconsole(&c);
if (r == 0) {
assert_se(streq(c.vc_keymap, "es-dvorak"));
log_info("/* test with old mapping (fr:latin9) */");
- assert_se(free_and_strdup(&c.x11_layout, "fr") >= 0);
- assert_se(free_and_strdup(&c.x11_variant, "latin9") >= 0);
+ assert_se(free_and_strdup(&xc->layout, "fr") >= 0);
+ assert_se(free_and_strdup(&xc->variant, "latin9") >= 0);
assert_se(x11_convert_to_vconsole(&c) == 1);
assert_se(streq(c.vc_keymap, "fr-latin9"));
log_info("/* test with a compound mapping (us,ru:) */");
- assert_se(free_and_strdup(&c.x11_layout, "us,ru") >= 0);
- assert_se(free_and_strdup(&c.x11_variant, NULL) >= 0);
+ assert_se(free_and_strdup(&xc->layout, "us,ru") >= 0);
+ assert_se(free_and_strdup(&xc->variant, NULL) >= 0);
assert_se(x11_convert_to_vconsole(&c) == 1);
assert_se(streq(c.vc_keymap, "us"));
log_info("/* test with a compound mapping (ru,us:) */");
- assert_se(free_and_strdup(&c.x11_layout, "ru,us") >= 0);
- assert_se(free_and_strdup(&c.x11_variant, NULL) >= 0);
+ assert_se(free_and_strdup(&xc->layout, "ru,us") >= 0);
+ assert_se(free_and_strdup(&xc->variant, NULL) >= 0);
assert_se(x11_convert_to_vconsole(&c) == 1);
assert_se(streq(c.vc_keymap, "ru"));
/* https://bugzilla.redhat.com/show_bug.cgi?id=1333998 */
log_info("/* test with a simple new mapping (ru:) */");
- assert_se(free_and_strdup(&c.x11_layout, "ru") >= 0);
- assert_se(free_and_strdup(&c.x11_variant, NULL) >= 0);
+ assert_se(free_and_strdup(&xc->layout, "ru") >= 0);
+ assert_se(free_and_strdup(&xc->variant, NULL) >= 0);
assert_se(x11_convert_to_vconsole(&c) == 0);
assert_se(streq(c.vc_keymap, "ru"));
projects / thirdparty / systemd.git / commitdiff
