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 "kbd-util.h"
  23 #include "keymap-util.h"
  24 #include "locale-util.h"
  25 #include "macro.h"
  26 #include "main-func.h"
  27 #include "missing_capability.h"
  28 #include "path-util.h"
  29 #include "selinux-util.h"
  30 #include "service-util.h"
  31 #include "signal-util.h"
  32 #include "string-util.h"
  33 #include "strv.h"
  34 #include "user-util.h"
  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         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
  41         size_t c_set = 0, c_unset = 0;
  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 (LocaleVariable p = 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 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 (LocaleVariable 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         bool use_localegen;
 350
 351         assert(m);
 352         assert(c);
 353
 354         r = sd_bus_message_read_strv(m, &l);
 355         if (r < 0)
 356                 return r;
 357
 358         r = sd_bus_message_read_basic(m, 'b', &interactive);
 359         if (r < 0)
 360                 return r;
 361
 362         use_localegen = locale_gen_check_available();
 363
 364         /* If single locale without variable name is provided, then we assume it is LANG=. */
 365         if (strv_length(l) == 1 && !strchr(l[0], '=')) {
 366                 if (!locale_is_valid(l[0]))
 367                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid locale specification: %s", l[0]);
 368                 if (!use_localegen && locale_is_installed(l[0]) <= 0)
 369                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Specified locale is not installed: %s", l[0]);
 370
 371                 new_locale[VARIABLE_LANG] = strdup(l[0]);
 372                 if (!new_locale[VARIABLE_LANG])
 373                         return -ENOMEM;
 374
 375                 l = strv_free(l);
 376         }
 377
 378         /* Check whether a variable is valid */
 379         STRV_FOREACH(i, l) {
 380                 r = process_locale_list_item(*i, new_locale, use_localegen, error);
 381                 if (r < 0)
 382                         return r;
 383         }
 384
 385         /* If LANG was specified, but not LANGUAGE, check if we should
 386          * set it based on the language fallback table. */
 387         if (!isempty(new_locale[VARIABLE_LANG]) &&
 388             isempty(new_locale[VARIABLE_LANGUAGE])) {
 389                 _cleanup_free_ char *language = NULL;
 390
 391                 (void) find_language_fallback(new_locale[VARIABLE_LANG], &language);
 392                 if (language) {
 393                         log_debug("Converted LANG=%s to LANGUAGE=%s", new_locale[VARIABLE_LANG], language);
 394                         free_and_replace(new_locale[VARIABLE_LANGUAGE], language);
 395                 }
 396         }
 397
 398         r = locale_read_data(c, m);
 399         if (r < 0) {
 400                 log_error_errno(r, "Failed to read locale data: %m");
 401                 return sd_bus_error_set(error, SD_BUS_ERROR_FAILED, "Failed to read locale data");
 402         }
 403
 404         /* Merge with the current settings */
 405         for (LocaleVariable p = 0; p < _VARIABLE_LC_MAX; p++)
 406                 if (!isempty(c->locale[p]) && isempty(new_locale[p])) {
 407                         new_locale[p] = strdup(c->locale[p]);
 408                         if (!new_locale[p])
 409                                 return -ENOMEM;
 410                 }
 411
 412         locale_simplify(new_locale);
 413
 414         for (LocaleVariable p = 0; p < _VARIABLE_LC_MAX; p++)
 415                 if (!streq_ptr(c->locale[p], new_locale[p])) {
 416                         modified = true;
 417                         break;
 418                 }
 419
 420         if (!modified) {
 421                 log_debug("Locale settings were not modified.");
 422                 return sd_bus_reply_method_return(m, NULL);
 423         }
 424
 425         r = bus_verify_polkit_async(
 426                         m,
 427                         CAP_SYS_ADMIN,
 428                         "org.freedesktop.locale1.set-locale",
 429                         NULL,
 430                         interactive,
 431                         UID_INVALID,
 432                         &c->polkit_registry,
 433                         error);
 434         if (r < 0)
 435                 return r;
 436         if (r == 0)
 437                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
 438
 439         /* Generate locale in case it is missing and the system is using locale-gen */
 440         if (use_localegen) {
 441                 r = locale_gen_process_locale(new_locale, error);
 442                 if (r < 0)
 443                         return r;
 444         }
 445
 446         for (LocaleVariable p = 0; p < _VARIABLE_LC_MAX; p++)
 447                 free_and_replace(c->locale[p], new_locale[p]);
 448
 449         /* Write locale configuration */
 450         r = locale_write_data(c, &settings);
 451         if (r < 0) {
 452                 log_error_errno(r, "Failed to set locale: %m");
 453                 return sd_bus_error_set_errnof(error, r, "Failed to set locale: %m");
 454         }
 455
 456         (void) locale_update_system_manager(c, sd_bus_message_get_bus(m));
 457
 458         if (settings) {
 459                 _cleanup_free_ char *line = NULL;
 460
 461                 line = strv_join(settings, ", ");
 462                 log_info("Changed locale to %s.", strnull(line));
 463         } else
 464                 log_info("Changed locale to unset.");
 465
 466         (void) sd_bus_emit_properties_changed(
 467                         sd_bus_message_get_bus(m),
 468                         "/org/freedesktop/locale1",
 469                         "org.freedesktop.locale1",
 470                         "Locale", NULL);
 471
 472         return sd_bus_reply_method_return(m, NULL);
 473 }
 474
 475 static int method_set_vc_keyboard(sd_bus_message *m, void *userdata, sd_bus_error *error) {
 476         Context *c = userdata;
 477         const char *name, *keymap, *keymap_toggle;
 478         int convert, interactive, r;
 479
 480         assert(m);
 481         assert(c);
 482
 483         r = sd_bus_message_read(m, "ssbb", &keymap, &keymap_toggle, &convert, &interactive);
 484         if (r < 0)
 485                 return r;
 486
 487         keymap = empty_to_null(keymap);
 488         keymap_toggle = empty_to_null(keymap_toggle);
 489
 490         r = vconsole_read_data(c, m);
 491         if (r < 0) {
 492                 log_error_errno(r, "Failed to read virtual console keymap data: %m");
 493                 return sd_bus_error_set_errnof(error, r, "Failed to read virtual console keymap data: %m");
 494         }
 495
 496         FOREACH_STRING(name, keymap ?: keymap_toggle, keymap ? keymap_toggle : NULL) {
 497                 r = keymap_exists(name); /* This also verifies that the keymap name is kosher. */
 498                 if (r < 0) {
 499                         log_error_errno(r, "Failed to check keymap %s: %m", name);
 500                         return sd_bus_error_set_errnof(error, r, "Failed to check keymap %s: %m", name);
 501                 }
 502                 if (r == 0)
 503                         return sd_bus_error_setf(error, SD_BUS_ERROR_FAILED, "Keymap %s is not installed.", name);
 504         }
 505
 506         if (streq_ptr(keymap, c->vc_keymap) &&
 507             streq_ptr(keymap_toggle, c->vc_keymap_toggle))
 508                 return sd_bus_reply_method_return(m, NULL);
 509
 510         r = bus_verify_polkit_async(
 511                         m,
 512                         CAP_SYS_ADMIN,
 513                         "org.freedesktop.locale1.set-keyboard",
 514                         NULL,
 515                         interactive,
 516                         UID_INVALID,
 517                         &c->polkit_registry,
 518                         error);
 519         if (r < 0)
 520                 return r;
 521         if (r == 0)
 522                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
 523
 524         if (free_and_strdup(&c->vc_keymap, keymap) < 0 ||
 525             free_and_strdup(&c->vc_keymap_toggle, keymap_toggle) < 0)
 526                 return -ENOMEM;
 527
 528         r = vconsole_write_data(c);
 529         if (r < 0) {
 530                 log_error_errno(r, "Failed to set virtual console keymap: %m");
 531                 return sd_bus_error_set_errnof(error, r, "Failed to set virtual console keymap: %m");
 532         }
 533
 534         log_info("Changed virtual console keymap to '%s' toggle '%s'",
 535                  strempty(c->vc_keymap), strempty(c->vc_keymap_toggle));
 536
 537         (void) vconsole_reload(sd_bus_message_get_bus(m));
 538
 539         (void) sd_bus_emit_properties_changed(
 540                         sd_bus_message_get_bus(m),
 541                         "/org/freedesktop/locale1",
 542                         "org.freedesktop.locale1",
 543                         "VConsoleKeymap", "VConsoleKeymapToggle", NULL);
 544
 545         if (convert) {
 546                 r = vconsole_convert_to_x11_and_emit(c, m);
 547                 if (r < 0)
 548                         log_error_errno(r, "Failed to convert keymap data: %m");
 549         }
 550
 551         return sd_bus_reply_method_return(m, NULL);
 552 }
 553
 554 #if HAVE_XKBCOMMON
 555
 556 _printf_(3, 0)
 557 static void log_xkb(struct xkb_context *ctx, enum xkb_log_level lvl, const char *format, va_list args) {
 558         const char *fmt;
 559
 560         fmt = strjoina("libxkbcommon: ", format);
 561         DISABLE_WARNING_FORMAT_NONLITERAL;
 562         log_internalv(LOG_DEBUG, 0, PROJECT_FILE, __LINE__, __func__, fmt, args);
 563         REENABLE_WARNING;
 564 }
 565
 566 #define LOAD_SYMBOL(symbol, dl, name)                                   \
 567         ({                                                              \
 568                 (symbol) = (typeof(symbol)) dlvsym((dl), (name), "V_0.5.0"); \
 569                 (symbol) ? 0 : -EOPNOTSUPP;                             \
 570         })
 571
 572 static int verify_xkb_rmlvo(const char *model, const char *layout, const char *variant, const char *options) {
 573
 574         /* We dlopen() the library in order to make the dependency soft. The library (and what it pulls in) is huge
 575          * after all, hence let's support XKB maps when the library is around, and refuse otherwise. The function
 576          * pointers to the shared library are below: */
 577
 578         struct xkb_context* (*symbol_xkb_context_new)(enum xkb_context_flags flags) = NULL;
 579         void (*symbol_xkb_context_unref)(struct xkb_context *context) = NULL;
 580         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;
 581         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;
 582         void (*symbol_xkb_keymap_unref)(struct xkb_keymap *keymap) = NULL;
 583
 584         const struct xkb_rule_names rmlvo = {
 585                 .model          = model,
 586                 .layout         = layout,
 587                 .variant        = variant,
 588                 .options        = options,
 589         };
 590         struct xkb_context *ctx = NULL;
 591         struct xkb_keymap *km = NULL;
 592         _cleanup_(dlclosep) void *dl = NULL;
 593         int r;
 594
 595         /* Compile keymap from RMLVO information to check out its validity */
 596
 597         dl = dlopen("libxkbcommon.so.0", RTLD_LAZY);
 598         if (!dl)
 599                 return -EOPNOTSUPP;
 600
 601         r = LOAD_SYMBOL(symbol_xkb_context_new, dl, "xkb_context_new");
 602         if (r < 0)
 603                 goto finish;
 604
 605         r = LOAD_SYMBOL(symbol_xkb_context_unref, dl, "xkb_context_unref");
 606         if (r < 0)
 607                 goto finish;
 608
 609         r = LOAD_SYMBOL(symbol_xkb_context_set_log_fn, dl, "xkb_context_set_log_fn");
 610         if (r < 0)
 611                 goto finish;
 612
 613         r = LOAD_SYMBOL(symbol_xkb_keymap_new_from_names, dl, "xkb_keymap_new_from_names");
 614         if (r < 0)
 615                 goto finish;
 616
 617         r = LOAD_SYMBOL(symbol_xkb_keymap_unref, dl, "xkb_keymap_unref");
 618         if (r < 0)
 619                 goto finish;
 620
 621         ctx = symbol_xkb_context_new(XKB_CONTEXT_NO_ENVIRONMENT_NAMES);
 622         if (!ctx) {
 623                 r = -ENOMEM;
 624                 goto finish;
 625         }
 626
 627         symbol_xkb_context_set_log_fn(ctx, log_xkb);
 628
 629         km = symbol_xkb_keymap_new_from_names(ctx, &rmlvo, XKB_KEYMAP_COMPILE_NO_FLAGS);
 630         if (!km) {
 631                 r = -EINVAL;
 632                 goto finish;
 633         }
 634
 635         r = 0;
 636
 637 finish:
 638         if (symbol_xkb_keymap_unref && km)
 639                 symbol_xkb_keymap_unref(km);
 640
 641         if (symbol_xkb_context_unref && ctx)
 642                 symbol_xkb_context_unref(ctx);
 643
 644         return r;
 645 }
 646
 647 #else
 648
 649 static int verify_xkb_rmlvo(const char *model, const char *layout, const char *variant, const char *options) {
 650         return 0;
 651 }
 652
 653 #endif
 654
 655 static int method_set_x11_keyboard(sd_bus_message *m, void *userdata, sd_bus_error *error) {
 656         Context *c = userdata;
 657         const char *layout, *model, *variant, *options;
 658         int convert, interactive, r;
 659
 660         assert(m);
 661         assert(c);
 662
 663         r = sd_bus_message_read(m, "ssssbb", &layout, &model, &variant, &options, &convert, &interactive);
 664         if (r < 0)
 665                 return r;
 666
 667         layout = empty_to_null(layout);
 668         model = empty_to_null(model);
 669         variant = empty_to_null(variant);
 670         options = empty_to_null(options);
 671
 672         r = x11_read_data(c, m);
 673         if (r < 0) {
 674                 log_error_errno(r, "Failed to read x11 keyboard layout data: %m");
 675                 return sd_bus_error_set(error, SD_BUS_ERROR_FAILED, "Failed to read x11 keyboard layout data");
 676         }
 677
 678         if (streq_ptr(layout, c->x11_layout) &&
 679             streq_ptr(model, c->x11_model) &&
 680             streq_ptr(variant, c->x11_variant) &&
 681             streq_ptr(options, c->x11_options))
 682                 return sd_bus_reply_method_return(m, NULL);
 683
 684         if ((layout && !string_is_safe(layout)) ||
 685             (model && !string_is_safe(model)) ||
 686             (variant && !string_is_safe(variant)) ||
 687             (options && !string_is_safe(options)))
 688                 return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Received invalid keyboard data");
 689
 690         r = verify_xkb_rmlvo(model, layout, variant, options);
 691         if (r < 0) {
 692                 log_error_errno(r, "Cannot compile XKB keymap for new x11 keyboard layout ('%s' / '%s' / '%s' / '%s'): %m",
 693                                 strempty(model), strempty(layout), strempty(variant), strempty(options));
 694
 695                 if (r == -EOPNOTSUPP)
 696                         return sd_bus_error_set(error, SD_BUS_ERROR_NOT_SUPPORTED, "Local keyboard configuration not supported on this system.");
 697
 698                 return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Specified keymap cannot be compiled, refusing as invalid.");
 699         }
 700
 701         r = bus_verify_polkit_async(
 702                         m,
 703                         CAP_SYS_ADMIN,
 704                         "org.freedesktop.locale1.set-keyboard",
 705                         NULL,
 706                         interactive,
 707                         UID_INVALID,
 708                         &c->polkit_registry,
 709                         error);
 710         if (r < 0)
 711                 return r;
 712         if (r == 0)
 713                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
 714
 715         if (free_and_strdup(&c->x11_layout, layout) < 0 ||
 716             free_and_strdup(&c->x11_model, model) < 0 ||
 717             free_and_strdup(&c->x11_variant, variant) < 0 ||
 718             free_and_strdup(&c->x11_options, options) < 0)
 719                 return -ENOMEM;
 720
 721         r = x11_write_data(c);
 722         if (r < 0) {
 723                 log_error_errno(r, "Failed to set X11 keyboard layout: %m");
 724                 return sd_bus_error_set_errnof(error, r, "Failed to set X11 keyboard layout: %m");
 725         }
 726
 727         log_info("Changed X11 keyboard layout to '%s' model '%s' variant '%s' options '%s'",
 728                  strempty(c->x11_layout),
 729                  strempty(c->x11_model),
 730                  strempty(c->x11_variant),
 731                  strempty(c->x11_options));
 732
 733         (void) sd_bus_emit_properties_changed(
 734                         sd_bus_message_get_bus(m),
 735                         "/org/freedesktop/locale1",
 736                         "org.freedesktop.locale1",
 737                         "X11Layout", "X11Model", "X11Variant", "X11Options", NULL);
 738
 739         if (convert) {
 740                 r = x11_convert_to_vconsole_and_emit(c, m);
 741                 if (r < 0)
 742                         log_error_errno(r, "Failed to convert keymap data: %m");
 743         }
 744
 745         return sd_bus_reply_method_return(m, NULL);
 746 }
 747
 748 static const sd_bus_vtable locale_vtable[] = {
 749         SD_BUS_VTABLE_START(0),
 750         SD_BUS_PROPERTY("Locale", "as", property_get_locale, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 751         SD_BUS_PROPERTY("X11Layout", "s", property_get_xkb, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 752         SD_BUS_PROPERTY("X11Model", "s", property_get_xkb, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 753         SD_BUS_PROPERTY("X11Variant", "s", property_get_xkb, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 754         SD_BUS_PROPERTY("X11Options", "s", property_get_xkb, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 755         SD_BUS_PROPERTY("VConsoleKeymap", "s", property_get_vconsole, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 756         SD_BUS_PROPERTY("VConsoleKeymapToggle", "s", property_get_vconsole, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 757
 758         SD_BUS_METHOD_WITH_NAMES("SetLocale",
 759                                  "asb",
 760                                  SD_BUS_PARAM(locale)
 761                                  SD_BUS_PARAM(interactive),
 762                                  NULL,,
 763                                  method_set_locale,
 764                                  SD_BUS_VTABLE_UNPRIVILEGED),
 765         SD_BUS_METHOD_WITH_NAMES("SetVConsoleKeyboard",
 766                                  "ssbb",
 767                                  SD_BUS_PARAM(keymap)
 768                                  SD_BUS_PARAM(keymap_toggle)
 769                                  SD_BUS_PARAM(convert)
 770                                  SD_BUS_PARAM(interactive),
 771                                  NULL,,
 772                                  method_set_vc_keyboard,
 773                                  SD_BUS_VTABLE_UNPRIVILEGED),
 774         SD_BUS_METHOD_WITH_NAMES("SetX11Keyboard",
 775                                  "ssssbb",
 776                                  SD_BUS_PARAM(layout)
 777                                  SD_BUS_PARAM(model)
 778                                  SD_BUS_PARAM(variant)
 779                                  SD_BUS_PARAM(options)
 780                                  SD_BUS_PARAM(convert)
 781                                  SD_BUS_PARAM(interactive),
 782                                  NULL,,
 783                                  method_set_x11_keyboard,
 784                                  SD_BUS_VTABLE_UNPRIVILEGED),
 785
 786         SD_BUS_VTABLE_END
 787 };
 788
 789 static const BusObjectImplementation manager_object = {
 790         "/org/freedesktop/locale1",
 791         "org.freedesktop.locale1",
 792         .vtables = BUS_VTABLES(locale_vtable),
 793 };
 794
 795 static int connect_bus(Context *c, sd_event *event, sd_bus **_bus) {
 796         _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
 797         int r;
 798
 799         assert(c);
 800         assert(event);
 801         assert(_bus);
 802
 803         r = sd_bus_default_system(&bus);
 804         if (r < 0)
 805                 return log_error_errno(r, "Failed to get system bus connection: %m");
 806
 807         r = bus_add_implementation(bus, &manager_object, c);
 808         if (r < 0)
 809                 return r;
 810
 811         r = bus_log_control_api_register(bus);
 812         if (r < 0)
 813                 return r;
 814
 815         r = sd_bus_request_name_async(bus, NULL, "org.freedesktop.locale1", 0, NULL, NULL);
 816         if (r < 0)
 817                 return log_error_errno(r, "Failed to request name: %m");
 818
 819         r = sd_bus_attach_event(bus, event, 0);
 820         if (r < 0)
 821                 return log_error_errno(r, "Failed to attach bus to event loop: %m");
 822
 823         *_bus = TAKE_PTR(bus);
 824
 825         return 0;
 826 }
 827
 828 static int run(int argc, char *argv[]) {
 829         _cleanup_(context_clear) Context context = {
 830                 .locale_mtime = USEC_INFINITY,
 831                 .vc_mtime = USEC_INFINITY,
 832                 .x11_mtime = USEC_INFINITY,
 833         };
 834         _cleanup_(sd_event_unrefp) sd_event *event = NULL;
 835         _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
 836         int r;
 837
 838         log_setup();
 839
 840         r = service_parse_argv("systemd-localed.service",
 841                                "Manage system locale settings and key mappings.",
 842                                BUS_IMPLEMENTATIONS(&manager_object,
 843                                                    &log_control_object),
 844                                argc, argv);
 845         if (r <= 0)
 846                 return r;
 847
 848         umask(0022);
 849
 850         r = mac_selinux_init();
 851         if (r < 0)
 852                 return r;
 853
 854         assert_se(sigprocmask_many(SIG_BLOCK, NULL, SIGTERM, SIGINT, -1) >= 0);
 855
 856         r = sd_event_default(&event);
 857         if (r < 0)
 858                 return log_error_errno(r, "Failed to allocate event loop: %m");
 859
 860         (void) sd_event_set_watchdog(event, true);
 861
 862         r = sd_event_add_signal(event, NULL, SIGINT, NULL, NULL);
 863         if (r < 0)
 864                 return log_error_errno(r, "Failed to install SIGINT handler: %m");
 865
 866         r = sd_event_add_signal(event, NULL, SIGTERM, NULL, NULL);
 867         if (r < 0)
 868                 return log_error_errno(r, "Failed to install SIGTERM handler: %m");
 869
 870         r = connect_bus(&context, event, &bus);
 871         if (r < 0)
 872                 return r;
 873
 874         r = bus_event_loop_with_idle(event, bus, "org.freedesktop.locale1", DEFAULT_EXIT_USEC, NULL, NULL);
 875         if (r < 0)
 876                 return log_error_errno(r, "Failed to run event loop: %m");
 877
 878         return 0;
 879 }
 880
 881 DEFINE_MAIN_FUNCTION(run);