src/locale/localed.c

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