src/locale/localed.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   This file is part of systemd.
   4
   5   Copyright 2011 Lennart Poettering
   6   Copyright 2013 Kay Sievers
   7 ***/
   8
   9 #include <errno.h>
  10 #include <string.h>
  11 #include <unistd.h>
  12
  13 #if HAVE_XKBCOMMON
  14 #include <xkbcommon/xkbcommon.h>
  15 #include <dlfcn.h>
  16 #endif
  17
  18 #include "sd-bus.h"
  19
  20 #include "alloc-util.h"
  21 #include "bus-error.h"
  22 #include "bus-message.h"
  23 #include "bus-util.h"
  24 #include "def.h"
  25 #include "keymap-util.h"
  26 #include "locale-util.h"
  27 #include "macro.h"
  28 #include "path-util.h"
  29 #include "selinux-util.h"
  30 #include "string-util.h"
  31 #include "strv.h"
  32 #include "user-util.h"
  33
  34 static Hashmap *polkit_registry = NULL;
  35
  36 static int locale_update_system_manager(Context *c, sd_bus *bus) {
  37         _cleanup_free_ char **l_unset = NULL;
  38         _cleanup_strv_free_ char **l_set = NULL;
  39         _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
  40         sd_bus_error error = SD_BUS_ERROR_NULL;
  41         unsigned c_set, c_unset, p;
  42         int r;
  43
  44         assert(bus);
  45
  46         l_unset = new0(char*, _VARIABLE_LC_MAX);
  47         if (!l_unset)
  48                 return -ENOMEM;
  49
  50         l_set = new0(char*, _VARIABLE_LC_MAX);
  51         if (!l_set)
  52                 return -ENOMEM;
  53
  54         for (p = 0, c_set = 0, c_unset = 0; p < _VARIABLE_LC_MAX; p++) {
  55                 const char *name;
  56
  57                 name = locale_variable_to_string(p);
  58                 assert(name);
  59
  60                 if (isempty(c->locale[p]))
  61                         l_unset[c_set++] = (char*) name;
  62                 else {
  63                         char *s;
  64
  65                         if (asprintf(&s, "%s=%s", name, c->locale[p]) < 0)
  66                                 return -ENOMEM;
  67
  68                         l_set[c_unset++] = s;
  69                 }
  70         }
  71
  72         assert(c_set + c_unset == _VARIABLE_LC_MAX);
  73         r = sd_bus_message_new_method_call(bus, &m,
  74                         "org.freedesktop.systemd1",
  75                         "/org/freedesktop/systemd1",
  76                         "org.freedesktop.systemd1.Manager",
  77                         "UnsetAndSetEnvironment");
  78         if (r < 0)
  79                 return r;
  80
  81         r = sd_bus_message_append_strv(m, l_unset);
  82         if (r < 0)
  83                 return r;
  84
  85         r = sd_bus_message_append_strv(m, l_set);
  86         if (r < 0)
  87                 return r;
  88
  89         r = sd_bus_call(bus, m, 0, &error, NULL);
  90         if (r < 0)
  91                 log_error_errno(r, "Failed to update the manager environment, ignoring: %m");
  92
  93         return 0;
  94 }
  95
  96 static int vconsole_reload(sd_bus *bus) {
  97         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
  98         int r;
  99
 100         assert(bus);
 101
 102         r = sd_bus_call_method(bus,
 103                         "org.freedesktop.systemd1",
 104                         "/org/freedesktop/systemd1",
 105                         "org.freedesktop.systemd1.Manager",
 106                         "RestartUnit",
 107                         &error,
 108                         NULL,
 109                         "ss", "systemd-vconsole-setup.service", "replace");
 110
 111         if (r < 0)
 112                 log_error("Failed to issue method call: %s", bus_error_message(&error, -r));
 113         return r;
 114 }
 115
 116 static int vconsole_convert_to_x11_and_emit(Context *c, sd_bus_message *m) {
 117         int r;
 118
 119         assert(m);
 120
 121         r = x11_read_data(c, m);
 122         if (r < 0)
 123                 return r;
 124
 125         r = vconsole_convert_to_x11(c);
 126         if (r <= 0)
 127                 return r;
 128
 129         /* modified */
 130         r = x11_write_data(c);
 131         if (r < 0)
 132                 return log_error_errno(r, "Failed to write X11 keyboard layout: %m");
 133
 134         sd_bus_emit_properties_changed(sd_bus_message_get_bus(m),
 135                                        "/org/freedesktop/locale1",
 136                                        "org.freedesktop.locale1",
 137                                        "X11Layout", "X11Model", "X11Variant", "X11Options", NULL);
 138
 139         return 1;
 140 }
 141
 142 static int x11_convert_to_vconsole_and_emit(Context *c, sd_bus_message *m) {
 143         int r;
 144
 145         assert(m);
 146
 147         r = vconsole_read_data(c, m);
 148         if (r < 0)
 149                 return r;
 150
 151         r = x11_convert_to_vconsole(c);
 152         if (r <= 0)
 153                 return r;
 154
 155         /* modified */
 156         r = vconsole_write_data(c);
 157         if (r < 0)
 158                 log_error_errno(r, "Failed to save virtual console keymap: %m");
 159
 160         sd_bus_emit_properties_changed(sd_bus_message_get_bus(m),
 161                                        "/org/freedesktop/locale1",
 162                                        "org.freedesktop.locale1",
 163                                        "VConsoleKeymap", "VConsoleKeymapToggle", NULL);
 164
 165         return vconsole_reload(sd_bus_message_get_bus(m));
 166 }
 167
 168 static int property_get_locale(
 169                 sd_bus *bus,
 170                 const char *path,
 171                 const char *interface,
 172                 const char *property,
 173                 sd_bus_message *reply,
 174                 void *userdata,
 175                 sd_bus_error *error) {
 176
 177         Context *c = userdata;
 178         _cleanup_strv_free_ char **l = NULL;
 179         int p, q, r;
 180
 181         r = locale_read_data(c, reply);
 182         if (r < 0)
 183                 return r;
 184
 185         l = new0(char*, _VARIABLE_LC_MAX+1);
 186         if (!l)
 187                 return -ENOMEM;
 188
 189         for (p = 0, q = 0; p < _VARIABLE_LC_MAX; p++) {
 190                 char *t;
 191                 const char *name;
 192
 193                 name = locale_variable_to_string(p);
 194                 assert(name);
 195
 196                 if (isempty(c->locale[p]))
 197                         continue;
 198
 199                 if (asprintf(&t, "%s=%s", name, c->locale[p]) < 0)
 200                         return -ENOMEM;
 201
 202                 l[q++] = t;
 203         }
 204
 205         return sd_bus_message_append_strv(reply, l);
 206 }
 207
 208 static int property_get_vconsole(
 209                 sd_bus *bus,
 210                 const char *path,
 211                 const char *interface,
 212                 const char *property,
 213                 sd_bus_message *reply,
 214                 void *userdata,
 215                 sd_bus_error *error) {
 216
 217         Context *c = userdata;
 218         int r;
 219
 220         r = vconsole_read_data(c, reply);
 221         if (r < 0)
 222                 return r;
 223
 224         if (streq(property, "VConsoleKeymap"))
 225                 return sd_bus_message_append_basic(reply, 's', c->vc_keymap);
 226         else if (streq(property, "VConsoleKeymapToggle"))
 227                 return sd_bus_message_append_basic(reply, 's', c->vc_keymap_toggle);
 228
 229         return -EINVAL;
 230 }
 231
 232 static int property_get_xkb(
 233                 sd_bus *bus,
 234                 const char *path,
 235                 const char *interface,
 236                 const char *property,
 237                 sd_bus_message *reply,
 238                 void *userdata,
 239                 sd_bus_error *error) {
 240
 241         Context *c = userdata;
 242         int r;
 243
 244         r = x11_read_data(c, reply);
 245         if (r < 0)
 246                 return r;
 247
 248         if (streq(property, "X11Layout"))
 249                 return sd_bus_message_append_basic(reply, 's', c->x11_layout);
 250         else if (streq(property, "X11Model"))
 251                 return sd_bus_message_append_basic(reply, 's', c->x11_model);
 252         else if (streq(property, "X11Variant"))
 253                 return sd_bus_message_append_basic(reply, 's', c->x11_variant);
 254         else if (streq(property, "X11Options"))
 255                 return sd_bus_message_append_basic(reply, 's', c->x11_options);
 256
 257         return -EINVAL;
 258 }
 259
 260 static void locale_free(char ***l) {
 261         int p;
 262
 263         for (p = 0; p < _VARIABLE_LC_MAX; p++)
 264                 (*l)[p] = mfree((*l)[p]);
 265 }
 266
 267 static int method_set_locale(sd_bus_message *m, void *userdata, sd_bus_error *error) {
 268         Context *c = userdata;
 269         _cleanup_strv_free_ char **settings = NULL, **l = NULL;
 270         char *new_locale[_VARIABLE_LC_MAX] = {};
 271         _cleanup_(locale_free) char **dummy = new_locale;
 272         bool modified = false;
 273         int interactive, p, r;
 274         char **i;
 275
 276         assert(m);
 277         assert(c);
 278
 279         r = bus_message_read_strv_extend(m, &l);
 280         if (r < 0)
 281                 return r;
 282
 283         r = sd_bus_message_read_basic(m, 'b', &interactive);
 284         if (r < 0)
 285                 return r;
 286
 287         /* If single locale without variable name is provided, then we assume it is LANG=. */
 288         if (strv_length(l) == 1 && !strchr(*l, '=')) {
 289                 if (!locale_is_valid(*l))
 290                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid Locale data.");
 291
 292                 new_locale[VARIABLE_LANG] = strdup(*l);
 293                 if (!new_locale[VARIABLE_LANG])
 294                         return -ENOMEM;
 295
 296                 l = strv_free(l);
 297         }
 298
 299         /* Check whether a variable is valid */
 300         STRV_FOREACH(i, l) {
 301                 bool valid = false;
 302
 303                 for (p = 0; p < _VARIABLE_LC_MAX; p++) {
 304                         size_t k;
 305                         const char *name;
 306
 307                         name = locale_variable_to_string(p);
 308                         assert(name);
 309
 310                         k = strlen(name);
 311                         if (startswith(*i, name) &&
 312                             (*i)[k] == '=' &&
 313                             locale_is_valid((*i) + k + 1)) {
 314                                 valid = true;
 315
 316                                 new_locale[p] = strdup((*i) + k + 1);
 317                                 if (!new_locale[p])
 318                                         return -ENOMEM;
 319
 320                                 break;
 321                         }
 322                 }
 323
 324                 if (!valid)
 325                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid Locale data.");
 326         }
 327
 328         /* If LANG was specified, but not LANGUAGE, check if we should
 329          * set it based on the language fallback table. */
 330         if (!isempty(new_locale[VARIABLE_LANG]) &&
 331             isempty(new_locale[VARIABLE_LANGUAGE])) {
 332                 _cleanup_free_ char *language = NULL;
 333
 334                 (void) find_language_fallback(new_locale[VARIABLE_LANG], &language);
 335                 if (language) {
 336                         log_debug("Converted LANG=%s to LANGUAGE=%s", new_locale[VARIABLE_LANG], language);
 337                         free_and_replace(new_locale[VARIABLE_LANGUAGE], language);
 338                 }
 339         }
 340
 341         r = locale_read_data(c, m);
 342         if (r < 0) {
 343                 log_error_errno(r, "Failed to read locale data: %m");
 344                 return sd_bus_error_setf(error, SD_BUS_ERROR_FAILED, "Failed to read locale data");
 345         }
 346
 347         /* Merge with the current settings */
 348         for (p = 0; p < _VARIABLE_LC_MAX; p++)
 349                 if (!isempty(c->locale[p]) && isempty(new_locale[p])) {
 350                         new_locale[p] = strdup(c->locale[p]);
 351                         if (!new_locale[p])
 352                                 return -ENOMEM;
 353                 }
 354
 355         locale_simplify(new_locale);
 356
 357         for (p = 0; p < _VARIABLE_LC_MAX; p++)
 358                 if (!streq_ptr(c->locale[p], new_locale[p])) {
 359                         modified = true;
 360                         break;
 361                 }
 362
 363         if (!modified) {
 364                 log_debug("Locale settings were not modified.");
 365                 return sd_bus_reply_method_return(m, NULL);
 366         }
 367
 368         r = bus_verify_polkit_async(
 369                         m,
 370                         CAP_SYS_ADMIN,
 371                         "org.freedesktop.locale1.set-locale",
 372                         NULL,
 373                         interactive,
 374                         UID_INVALID,
 375                         &polkit_registry,
 376                         error);
 377         if (r < 0)
 378                 return r;
 379         if (r == 0)
 380                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
 381
 382         for (p = 0; p < _VARIABLE_LC_MAX; p++)
 383                 free_and_replace(c->locale[p], new_locale[p]);
 384
 385         r = locale_write_data(c, &settings);
 386         if (r < 0) {
 387                 log_error_errno(r, "Failed to set locale: %m");
 388                 return sd_bus_error_set_errnof(error, r, "Failed to set locale: %m");
 389         }
 390
 391         (void) locale_update_system_manager(c, sd_bus_message_get_bus(m));
 392
 393         if (settings) {
 394                 _cleanup_free_ char *line;
 395
 396                 line = strv_join(settings, ", ");
 397                 log_info("Changed locale to %s.", strnull(line));
 398         } else
 399                 log_info("Changed locale to unset.");
 400
 401         (void) sd_bus_emit_properties_changed(
 402                         sd_bus_message_get_bus(m),
 403                         "/org/freedesktop/locale1",
 404                         "org.freedesktop.locale1",
 405                         "Locale", NULL);
 406
 407         return sd_bus_reply_method_return(m, NULL);
 408 }
 409
 410 static int method_set_vc_keyboard(sd_bus_message *m, void *userdata, sd_bus_error *error) {
 411         Context *c = userdata;
 412         const char *keymap, *keymap_toggle;
 413         int convert, interactive, r;
 414
 415         assert(m);
 416         assert(c);
 417
 418         r = sd_bus_message_read(m, "ssbb", &keymap, &keymap_toggle, &convert, &interactive);
 419         if (r < 0)
 420                 return r;
 421
 422         keymap = empty_to_null(keymap);
 423         keymap_toggle = empty_to_null(keymap_toggle);
 424
 425         r = vconsole_read_data(c, m);
 426         if (r < 0) {
 427                 log_error_errno(r, "Failed to read virtual console keymap data: %m");
 428                 return sd_bus_error_setf(error, SD_BUS_ERROR_FAILED, "Failed to read virtual console keymap data");
 429         }
 430
 431         if (streq_ptr(keymap, c->vc_keymap) &&
 432             streq_ptr(keymap_toggle, c->vc_keymap_toggle))
 433                 return sd_bus_reply_method_return(m, NULL);
 434
 435         if ((keymap && (!filename_is_valid(keymap) || !string_is_safe(keymap))) ||
 436             (keymap_toggle && (!filename_is_valid(keymap_toggle) || !string_is_safe(keymap_toggle))))
 437                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Received invalid keymap data");
 438
 439         r = bus_verify_polkit_async(
 440                         m,
 441                         CAP_SYS_ADMIN,
 442                         "org.freedesktop.locale1.set-keyboard",
 443                         NULL,
 444                         interactive,
 445                         UID_INVALID,
 446                         &polkit_registry,
 447                         error);
 448         if (r < 0)
 449                 return r;
 450         if (r == 0)
 451                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
 452
 453         if (free_and_strdup(&c->vc_keymap, keymap) < 0 ||
 454             free_and_strdup(&c->vc_keymap_toggle, keymap_toggle) < 0)
 455                 return -ENOMEM;
 456
 457         r = vconsole_write_data(c);
 458         if (r < 0) {
 459                 log_error_errno(r, "Failed to set virtual console keymap: %m");
 460                 return sd_bus_error_set_errnof(error, r, "Failed to set virtual console keymap: %m");
 461         }
 462
 463         log_info("Changed virtual console keymap to '%s' toggle '%s'",
 464                  strempty(c->vc_keymap), strempty(c->vc_keymap_toggle));
 465
 466         r = vconsole_reload(sd_bus_message_get_bus(m));
 467         if (r < 0)
 468                 log_error_errno(r, "Failed to request keymap reload: %m");
 469
 470         (void) sd_bus_emit_properties_changed(
 471                         sd_bus_message_get_bus(m),
 472                         "/org/freedesktop/locale1",
 473                         "org.freedesktop.locale1",
 474                         "VConsoleKeymap", "VConsoleKeymapToggle", NULL);
 475
 476         if (convert) {
 477                 r = vconsole_convert_to_x11_and_emit(c, m);
 478                 if (r < 0)
 479                         log_error_errno(r, "Failed to convert keymap data: %m");
 480         }
 481
 482         return sd_bus_reply_method_return(m, NULL);
 483 }
 484
 485 #if HAVE_XKBCOMMON
 486
 487 _printf_(3, 0)
 488 static void log_xkb(struct xkb_context *ctx, enum xkb_log_level lvl, const char *format, va_list args) {
 489         const char *fmt;
 490
 491         fmt = strjoina("libxkbcommon: ", format);
 492 #pragma GCC diagnostic push
 493 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
 494         log_internalv(LOG_DEBUG, 0, __FILE__, __LINE__, __func__, fmt, args);
 495 #pragma GCC diagnostic pop
 496 }
 497
 498 #define LOAD_SYMBOL(symbol, dl, name)                                   \
 499         ({                                                              \
 500                 (symbol) = (typeof(symbol)) dlvsym((dl), (name), "V_0.5.0"); \
 501                 (symbol) ? 0 : -EOPNOTSUPP;                             \
 502         })
 503
 504 static int verify_xkb_rmlvo(const char *model, const char *layout, const char *variant, const char *options) {
 505
 506         /* We dlopen() the library in order to make the dependency soft. The library (and what it pulls in) is huge
 507          * after all, hence let's support XKB maps when the library is around, and refuse otherwise. The function
 508          * pointers to the shared library are below: */
 509
 510         struct xkb_context* (*symbol_xkb_context_new)(enum xkb_context_flags flags) = NULL;
 511         void (*symbol_xkb_context_unref)(struct xkb_context *context) = NULL;
 512         void (*symbol_xkb_context_set_log_fn)(struct xkb_context *context, void (*log_fn)(struct xkb_context *context, enum xkb_log_level level, const char *format, va_list args)) = NULL;
 513         struct xkb_keymap* (*symbol_xkb_keymap_new_from_names)(struct xkb_context *context, const struct xkb_rule_names *names, enum xkb_keymap_compile_flags flags) = NULL;
 514         void (*symbol_xkb_keymap_unref)(struct xkb_keymap *keymap) = NULL;
 515
 516         const struct xkb_rule_names rmlvo = {
 517                 .model          = model,
 518                 .layout         = layout,
 519                 .variant        = variant,
 520                 .options        = options,
 521         };
 522         struct xkb_context *ctx = NULL;
 523         struct xkb_keymap *km = NULL;
 524         void *dl;
 525         int r;
 526
 527         /* Compile keymap from RMLVO information to check out its validity */
 528
 529         dl = dlopen("libxkbcommon.so.0", RTLD_LAZY);
 530         if (!dl)
 531                 return -EOPNOTSUPP;
 532
 533         r = LOAD_SYMBOL(symbol_xkb_context_new, dl, "xkb_context_new");
 534         if (r < 0)
 535                 goto finish;
 536
 537         r = LOAD_SYMBOL(symbol_xkb_context_unref, dl, "xkb_context_unref");
 538         if (r < 0)
 539                 goto finish;
 540
 541         r = LOAD_SYMBOL(symbol_xkb_context_set_log_fn, dl, "xkb_context_set_log_fn");
 542         if (r < 0)
 543                 goto finish;
 544
 545         r = LOAD_SYMBOL(symbol_xkb_keymap_new_from_names, dl, "xkb_keymap_new_from_names");
 546         if (r < 0)
 547                 goto finish;
 548
 549         r = LOAD_SYMBOL(symbol_xkb_keymap_unref, dl, "xkb_keymap_unref");
 550         if (r < 0)
 551                 goto finish;
 552
 553         ctx = symbol_xkb_context_new(XKB_CONTEXT_NO_ENVIRONMENT_NAMES);
 554         if (!ctx) {
 555                 r = -ENOMEM;
 556                 goto finish;
 557         }
 558
 559         symbol_xkb_context_set_log_fn(ctx, log_xkb);
 560
 561         km = symbol_xkb_keymap_new_from_names(ctx, &rmlvo, XKB_KEYMAP_COMPILE_NO_FLAGS);
 562         if (!km) {
 563                 r = -EINVAL;
 564                 goto finish;
 565         }
 566
 567         r = 0;
 568
 569 finish:
 570         if (symbol_xkb_keymap_unref && km)
 571                 symbol_xkb_keymap_unref(km);
 572
 573         if (symbol_xkb_context_unref && ctx)
 574                 symbol_xkb_context_unref(ctx);
 575
 576         (void) dlclose(dl);
 577         return r;
 578 }
 579
 580 #else
 581
 582 static int verify_xkb_rmlvo(const char *model, const char *layout, const char *variant, const char *options) {
 583         return 0;
 584 }
 585
 586 #endif
 587
 588 static int method_set_x11_keyboard(sd_bus_message *m, void *userdata, sd_bus_error *error) {
 589         Context *c = userdata;
 590         const char *layout, *model, *variant, *options;
 591         int convert, interactive, r;
 592
 593         assert(m);
 594         assert(c);
 595
 596         r = sd_bus_message_read(m, "ssssbb", &layout, &model, &variant, &options, &convert, &interactive);
 597         if (r < 0)
 598                 return r;
 599
 600         layout = empty_to_null(layout);
 601         model = empty_to_null(model);
 602         variant = empty_to_null(variant);
 603         options = empty_to_null(options);
 604
 605         r = x11_read_data(c, m);
 606         if (r < 0) {
 607                 log_error_errno(r, "Failed to read x11 keyboard layout data: %m");
 608                 return sd_bus_error_setf(error, SD_BUS_ERROR_FAILED, "Failed to read x11 keyboard layout data");
 609         }
 610
 611         if (streq_ptr(layout, c->x11_layout) &&
 612             streq_ptr(model, c->x11_model) &&
 613             streq_ptr(variant, c->x11_variant) &&
 614             streq_ptr(options, c->x11_options))
 615                 return sd_bus_reply_method_return(m, NULL);
 616
 617         if ((layout && !string_is_safe(layout)) ||
 618             (model && !string_is_safe(model)) ||
 619             (variant && !string_is_safe(variant)) ||
 620             (options && !string_is_safe(options)))
 621                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Received invalid keyboard data");
 622
 623         r = verify_xkb_rmlvo(model, layout, variant, options);
 624         if (r < 0) {
 625                 log_error_errno(r, "Cannot compile XKB keymap for new x11 keyboard layout ('%s' / '%s' / '%s' / '%s'): %m",
 626                                 strempty(model), strempty(layout), strempty(variant), strempty(options));
 627
 628                 if (r == -EOPNOTSUPP)
 629                         return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED, "Local keyboard configuration not supported on this system.");
 630
 631                 return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Specified keymap cannot be compiled, refusing as invalid.");
 632         }
 633
 634         r = bus_verify_polkit_async(
 635                         m,
 636                         CAP_SYS_ADMIN,
 637                         "org.freedesktop.locale1.set-keyboard",
 638                         NULL,
 639                         interactive,
 640                         UID_INVALID,
 641                         &polkit_registry,
 642                         error);
 643         if (r < 0)
 644                 return r;
 645         if (r == 0)
 646                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
 647
 648         if (free_and_strdup(&c->x11_layout, layout) < 0 ||
 649             free_and_strdup(&c->x11_model, model) < 0 ||
 650             free_and_strdup(&c->x11_variant, variant) < 0 ||
 651             free_and_strdup(&c->x11_options, options) < 0)
 652                 return -ENOMEM;
 653
 654         r = x11_write_data(c);
 655         if (r < 0) {
 656                 log_error_errno(r, "Failed to set X11 keyboard layout: %m");
 657                 return sd_bus_error_set_errnof(error, r, "Failed to set X11 keyboard layout: %m");
 658         }
 659
 660         log_info("Changed X11 keyboard layout to '%s' model '%s' variant '%s' options '%s'",
 661                  strempty(c->x11_layout),
 662                  strempty(c->x11_model),
 663                  strempty(c->x11_variant),
 664                  strempty(c->x11_options));
 665
 666         (void) sd_bus_emit_properties_changed(
 667                         sd_bus_message_get_bus(m),
 668                         "/org/freedesktop/locale1",
 669                         "org.freedesktop.locale1",
 670                         "X11Layout", "X11Model", "X11Variant", "X11Options", NULL);
 671
 672         if (convert) {
 673                 r = x11_convert_to_vconsole_and_emit(c, m);
 674                 if (r < 0)
 675                         log_error_errno(r, "Failed to convert keymap data: %m");
 676         }
 677
 678         return sd_bus_reply_method_return(m, NULL);
 679 }
 680
 681 static const sd_bus_vtable locale_vtable[] = {
 682         SD_BUS_VTABLE_START(0),
 683         SD_BUS_PROPERTY("Locale", "as", property_get_locale, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 684         SD_BUS_PROPERTY("X11Layout", "s", property_get_xkb, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 685         SD_BUS_PROPERTY("X11Model", "s", property_get_xkb, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 686         SD_BUS_PROPERTY("X11Variant", "s", property_get_xkb, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 687         SD_BUS_PROPERTY("X11Options", "s", property_get_xkb, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 688         SD_BUS_PROPERTY("VConsoleKeymap", "s", property_get_vconsole, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 689         SD_BUS_PROPERTY("VConsoleKeymapToggle", "s", property_get_vconsole, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 690         SD_BUS_METHOD("SetLocale", "asb", NULL, method_set_locale, SD_BUS_VTABLE_UNPRIVILEGED),
 691         SD_BUS_METHOD("SetVConsoleKeyboard", "ssbb", NULL, method_set_vc_keyboard, SD_BUS_VTABLE_UNPRIVILEGED),
 692         SD_BUS_METHOD("SetX11Keyboard", "ssssbb", NULL, method_set_x11_keyboard, SD_BUS_VTABLE_UNPRIVILEGED),
 693         SD_BUS_VTABLE_END
 694 };
 695
 696 static int connect_bus(Context *c, sd_event *event, sd_bus **_bus) {
 697         _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
 698         int r;
 699
 700         assert(c);
 701         assert(event);
 702         assert(_bus);
 703
 704         r = sd_bus_default_system(&bus);
 705         if (r < 0)
 706                 return log_error_errno(r, "Failed to get system bus connection: %m");
 707
 708         r = sd_bus_add_object_vtable(bus, NULL, "/org/freedesktop/locale1", "org.freedesktop.locale1", locale_vtable, c);
 709         if (r < 0)
 710                 return log_error_errno(r, "Failed to register object: %m");
 711
 712         r = sd_bus_request_name_async(bus, NULL, "org.freedesktop.locale1", 0, NULL, NULL);
 713         if (r < 0)
 714                 return log_error_errno(r, "Failed to request name: %m");
 715
 716         r = sd_bus_attach_event(bus, event, 0);
 717         if (r < 0)
 718                 return log_error_errno(r, "Failed to attach bus to event loop: %m");
 719
 720         *_bus = TAKE_PTR(bus);
 721
 722         return 0;
 723 }
 724
 725 int main(int argc, char *argv[]) {
 726         _cleanup_(context_free) Context context = {
 727                 .locale_mtime = USEC_INFINITY,
 728                 .vc_mtime = USEC_INFINITY,
 729                 .x11_mtime = USEC_INFINITY,
 730         };
 731         _cleanup_(sd_event_unrefp) sd_event *event = NULL;
 732         _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
 733         int r;
 734
 735         log_set_target(LOG_TARGET_AUTO);
 736         log_parse_environment();
 737         log_open();
 738
 739         umask(0022);
 740         mac_selinux_init();
 741
 742         if (argc != 1) {
 743                 log_error("This program takes no arguments.");
 744                 r = -EINVAL;
 745                 goto finish;
 746         }
 747
 748         r = sd_event_default(&event);
 749         if (r < 0) {
 750                 log_error_errno(r, "Failed to allocate event loop: %m");
 751                 goto finish;
 752         }
 753
 754         sd_event_set_watchdog(event, true);
 755
 756         r = connect_bus(&context, event, &bus);
 757         if (r < 0)
 758                 goto finish;
 759
 760         r = bus_event_loop_with_idle(event, bus, "org.freedesktop.locale1", DEFAULT_EXIT_USEC, NULL, NULL);
 761         if (r < 0)
 762                 log_error_errno(r, "Failed to run event loop: %m");
 763
 764 finish:
 765         bus_verify_polkit_async_registry_free(polkit_registry);
 766
 767         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
 768 }