]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/locale/localed.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
localed: add LANGUAGE= fallback when LANG= is specified
[thirdparty/systemd.git] / src / locale / localed.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4 This file is part of systemd.
5
6 Copyright 2011 Lennart Poettering
7 Copyright 2013 Kay Sievers
8
9 systemd is free software; you can redistribute it and/or modify it
10 under the terms of the GNU Lesser General Public License as published by
11 the Free Software Foundation; either version 2.1 of the License, or
12 (at your option) any later version.
13
14 systemd is distributed in the hope that it will be useful, but
15 WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 Lesser General Public License for more details.
18
19 You should have received a copy of the GNU Lesser General Public License
20 along with systemd; If not, see <http://www.gnu.org/licenses/>.
21 ***/
22
23 #include <errno.h>
24 #include <string.h>
25 #include <unistd.h>
26
27 #include "sd-bus.h"
28
29 #include "util.h"
30 #include "mkdir.h"
31 #include "strv.h"
32 #include "def.h"
33 #include "env-util.h"
34 #include "fileio.h"
35 #include "fileio-label.h"
36 #include "label.h"
37 #include "bus-util.h"
38 #include "bus-error.h"
39 #include "bus-message.h"
40 #include "event-util.h"
41 #include "locale-util.h"
42 #include "selinux-util.h"
43
44 #ifdef HAVE_XKBCOMMON
45 #include <xkbcommon/xkbcommon.h>
46 #endif
47
48 enum {
49 /* We don't list LC_ALL here on purpose. People should be
50 * using LANG instead. */
51 LOCALE_LANG,
52 LOCALE_LANGUAGE,
53 LOCALE_LC_CTYPE,
54 LOCALE_LC_NUMERIC,
55 LOCALE_LC_TIME,
56 LOCALE_LC_COLLATE,
57 LOCALE_LC_MONETARY,
58 LOCALE_LC_MESSAGES,
59 LOCALE_LC_PAPER,
60 LOCALE_LC_NAME,
61 LOCALE_LC_ADDRESS,
62 LOCALE_LC_TELEPHONE,
63 LOCALE_LC_MEASUREMENT,
64 LOCALE_LC_IDENTIFICATION,
65 _LOCALE_MAX
66 };
67
68 static const char * const names[_LOCALE_MAX] = {
69 [LOCALE_LANG] = "LANG",
70 [LOCALE_LANGUAGE] = "LANGUAGE",
71 [LOCALE_LC_CTYPE] = "LC_CTYPE",
72 [LOCALE_LC_NUMERIC] = "LC_NUMERIC",
73 [LOCALE_LC_TIME] = "LC_TIME",
74 [LOCALE_LC_COLLATE] = "LC_COLLATE",
75 [LOCALE_LC_MONETARY] = "LC_MONETARY",
76 [LOCALE_LC_MESSAGES] = "LC_MESSAGES",
77 [LOCALE_LC_PAPER] = "LC_PAPER",
78 [LOCALE_LC_NAME] = "LC_NAME",
79 [LOCALE_LC_ADDRESS] = "LC_ADDRESS",
80 [LOCALE_LC_TELEPHONE] = "LC_TELEPHONE",
81 [LOCALE_LC_MEASUREMENT] = "LC_MEASUREMENT",
82 [LOCALE_LC_IDENTIFICATION] = "LC_IDENTIFICATION"
83 };
84
85 typedef struct Context {
86 char *locale[_LOCALE_MAX];
87
88 char *x11_layout;
89 char *x11_model;
90 char *x11_variant;
91 char *x11_options;
92
93 char *vc_keymap;
94 char *vc_keymap_toggle;
95
96 Hashmap *polkit_registry;
97 } Context;
98
99 static const char* nonempty(const char *s) {
100 return isempty(s) ? NULL : s;
101 }
102
103 static void free_and_replace(char **s, char *v) {
104 free(*s);
105 *s = v;
106 }
107
108 static bool startswith_comma(const char *s, const char *prefix) {
109 const char *t;
110
111 return s && (t = startswith(s, prefix)) && (*t == ',');
112 }
113
114 static void context_free_x11(Context *c) {
115 free_and_replace(&c->x11_layout, NULL);
116 free_and_replace(&c->x11_model, NULL);
117 free_and_replace(&c->x11_variant, NULL);
118 free_and_replace(&c->x11_options, NULL);
119 }
120
121 static void context_free_vconsole(Context *c) {
122 free_and_replace(&c->vc_keymap, NULL);
123 free_and_replace(&c->vc_keymap_toggle, NULL);
124 }
125
126 static void context_free_locale(Context *c) {
127 int p;
128
129 for (p = 0; p < _LOCALE_MAX; p++)
130 free_and_replace(&c->locale[p], NULL);
131 }
132
133 static void context_free(Context *c) {
134 context_free_locale(c);
135 context_free_x11(c);
136 context_free_vconsole(c);
137
138 bus_verify_polkit_async_registry_free(c->polkit_registry);
139 };
140
141 static void locale_simplify(Context *c) {
142 int p;
143
144 for (p = LOCALE_LANG+1; p < _LOCALE_MAX; p++)
145 if (isempty(c->locale[p]) || streq_ptr(c->locale[LOCALE_LANG], c->locale[p]))
146 free_and_replace(&c->locale[p], NULL);
147 }
148
149 static int locale_read_data(Context *c) {
150 int r;
151
152 context_free_locale(c);
153
154 r = parse_env_file("/etc/locale.conf", NEWLINE,
155 "LANG", &c->locale[LOCALE_LANG],
156 "LANGUAGE", &c->locale[LOCALE_LANGUAGE],
157 "LC_CTYPE", &c->locale[LOCALE_LC_CTYPE],
158 "LC_NUMERIC", &c->locale[LOCALE_LC_NUMERIC],
159 "LC_TIME", &c->locale[LOCALE_LC_TIME],
160 "LC_COLLATE", &c->locale[LOCALE_LC_COLLATE],
161 "LC_MONETARY", &c->locale[LOCALE_LC_MONETARY],
162 "LC_MESSAGES", &c->locale[LOCALE_LC_MESSAGES],
163 "LC_PAPER", &c->locale[LOCALE_LC_PAPER],
164 "LC_NAME", &c->locale[LOCALE_LC_NAME],
165 "LC_ADDRESS", &c->locale[LOCALE_LC_ADDRESS],
166 "LC_TELEPHONE", &c->locale[LOCALE_LC_TELEPHONE],
167 "LC_MEASUREMENT", &c->locale[LOCALE_LC_MEASUREMENT],
168 "LC_IDENTIFICATION", &c->locale[LOCALE_LC_IDENTIFICATION],
169 NULL);
170
171 if (r == -ENOENT) {
172 int p;
173
174 /* Fill in what we got passed from systemd. */
175 for (p = 0; p < _LOCALE_MAX; p++) {
176 assert(names[p]);
177
178 r = free_and_strdup(&c->locale[p],
179 nonempty(getenv(names[p])));
180 if (r < 0)
181 return r;
182 }
183
184 r = 0;
185 }
186
187 locale_simplify(c);
188 return r;
189 }
190
191 static int vconsole_read_data(Context *c) {
192 int r;
193
194 context_free_vconsole(c);
195
196 r = parse_env_file("/etc/vconsole.conf", NEWLINE,
197 "KEYMAP", &c->vc_keymap,
198 "KEYMAP_TOGGLE", &c->vc_keymap_toggle,
199 NULL);
200
201 if (r < 0 && r != -ENOENT)
202 return r;
203
204 return 0;
205 }
206
207 static int x11_read_data(Context *c) {
208 _cleanup_fclose_ FILE *f;
209 char line[LINE_MAX];
210 bool in_section = false;
211 int r;
212
213 context_free_x11(c);
214
215 f = fopen("/etc/X11/xorg.conf.d/00-keyboard.conf", "re");
216 if (!f)
217 return errno == ENOENT ? 0 : -errno;
218
219 while (fgets(line, sizeof(line), f)) {
220 char *l;
221
222 char_array_0(line);
223 l = strstrip(line);
224
225 if (l[0] == 0 || l[0] == '#')
226 continue;
227
228 if (in_section && first_word(l, "Option")) {
229 _cleanup_strv_free_ char **a = NULL;
230
231 r = strv_split_quoted(&a, l, false);
232 if (r < 0)
233 return r;
234
235 if (strv_length(a) == 3) {
236 if (streq(a[1], "XkbLayout")) {
237 free_and_replace(&c->x11_layout, a[2]);
238 a[2] = NULL;
239 } else if (streq(a[1], "XkbModel")) {
240 free_and_replace(&c->x11_model, a[2]);
241 a[2] = NULL;
242 } else if (streq(a[1], "XkbVariant")) {
243 free_and_replace(&c->x11_variant, a[2]);
244 a[2] = NULL;
245 } else if (streq(a[1], "XkbOptions")) {
246 free_and_replace(&c->x11_options, a[2]);
247 a[2] = NULL;
248 }
249 }
250
251 } else if (!in_section && first_word(l, "Section")) {
252 _cleanup_strv_free_ char **a = NULL;
253
254 r = strv_split_quoted(&a, l, false);
255 if (r < 0)
256 return -ENOMEM;
257
258 if (strv_length(a) == 2 && streq(a[1], "InputClass"))
259 in_section = true;
260
261 } else if (in_section && first_word(l, "EndSection"))
262 in_section = false;
263 }
264
265 return 0;
266 }
267
268 static int context_read_data(Context *c) {
269 int r, q, p;
270
271 r = locale_read_data(c);
272 q = vconsole_read_data(c);
273 p = x11_read_data(c);
274
275 return r < 0 ? r : q < 0 ? q : p;
276 }
277
278 static int locale_write_data(Context *c, char ***settings) {
279 int r, p;
280 _cleanup_strv_free_ char **l = NULL;
281
282 /* Set values will be returned as strv in *settings on success. */
283
284 r = load_env_file(NULL, "/etc/locale.conf", NULL, &l);
285 if (r < 0 && r != -ENOENT)
286 return r;
287
288 for (p = 0; p < _LOCALE_MAX; p++) {
289 _cleanup_free_ char *t = NULL;
290 char **u;
291
292 assert(names[p]);
293
294 if (isempty(c->locale[p])) {
295 l = strv_env_unset(l, names[p]);
296 continue;
297 }
298
299 if (asprintf(&t, "%s=%s", names[p], c->locale[p]) < 0)
300 return -ENOMEM;
301
302 u = strv_env_set(l, t);
303 if (!u)
304 return -ENOMEM;
305
306 strv_free(l);
307 l = u;
308 }
309
310 if (strv_isempty(l)) {
311 if (unlink("/etc/locale.conf") < 0)
312 return errno == ENOENT ? 0 : -errno;
313
314 return 0;
315 }
316
317 r = write_env_file_label("/etc/locale.conf", l);
318 if (r < 0)
319 return r;
320
321 *settings = l;
322 l = NULL;
323 return 0;
324 }
325
326 static int locale_update_system_manager(Context *c, sd_bus *bus) {
327 _cleanup_free_ char **l_unset = NULL;
328 _cleanup_strv_free_ char **l_set = NULL;
329 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
330 sd_bus_error error = SD_BUS_ERROR_NULL;
331 unsigned c_set, c_unset, p;
332 int r;
333
334 assert(bus);
335
336 l_unset = new0(char*, _LOCALE_MAX);
337 if (!l_unset)
338 return -ENOMEM;
339
340 l_set = new0(char*, _LOCALE_MAX);
341 if (!l_set)
342 return -ENOMEM;
343
344 for (p = 0, c_set = 0, c_unset = 0; p < _LOCALE_MAX; p++) {
345 assert(names[p]);
346
347 if (isempty(c->locale[p]))
348 l_unset[c_set++] = (char*) names[p];
349 else {
350 char *s;
351
352 if (asprintf(&s, "%s=%s", names[p], c->locale[p]) < 0)
353 return -ENOMEM;
354
355 l_set[c_unset++] = s;
356 }
357 }
358
359 assert(c_set + c_unset == _LOCALE_MAX);
360 r = sd_bus_message_new_method_call(bus, &m,
361 "org.freedesktop.systemd1",
362 "/org/freedesktop/systemd1",
363 "org.freedesktop.systemd1.Manager",
364 "UnsetAndSetEnvironment");
365 if (r < 0)
366 return r;
367
368 r = sd_bus_message_append_strv(m, l_unset);
369 if (r < 0)
370 return r;
371
372 r = sd_bus_message_append_strv(m, l_set);
373 if (r < 0)
374 return r;
375
376 r = sd_bus_call(bus, m, 0, &error, NULL);
377 if (r < 0)
378 log_error_errno(r, "Failed to update the manager environment: %m");
379
380 return 0;
381 }
382
383 static int vconsole_write_data(Context *c) {
384 int r;
385 _cleanup_strv_free_ char **l = NULL;
386
387 r = load_env_file(NULL, "/etc/vconsole.conf", NULL, &l);
388 if (r < 0 && r != -ENOENT)
389 return r;
390
391 if (isempty(c->vc_keymap))
392 l = strv_env_unset(l, "KEYMAP");
393 else {
394 _cleanup_free_ char *s = NULL;
395 char **u;
396
397 s = strappend("KEYMAP=", c->vc_keymap);
398 if (!s)
399 return -ENOMEM;
400
401 u = strv_env_set(l, s);
402 if (!u)
403 return -ENOMEM;
404
405 strv_free(l);
406 l = u;
407 }
408
409 if (isempty(c->vc_keymap_toggle))
410 l = strv_env_unset(l, "KEYMAP_TOGGLE");
411 else {
412 _cleanup_free_ char *s = NULL;
413 char **u;
414
415 s = strappend("KEYMAP_TOGGLE=", c->vc_keymap_toggle);
416 if (!s)
417 return -ENOMEM;
418
419 u = strv_env_set(l, s);
420 if (!u)
421 return -ENOMEM;
422
423 strv_free(l);
424 l = u;
425 }
426
427 if (strv_isempty(l)) {
428 if (unlink("/etc/vconsole.conf") < 0)
429 return errno == ENOENT ? 0 : -errno;
430
431 return 0;
432 }
433
434 return write_env_file_label("/etc/vconsole.conf", l);
435 }
436
437 static int x11_write_data(Context *c) {
438 _cleanup_fclose_ FILE *f = NULL;
439 _cleanup_free_ char *temp_path = NULL;
440 int r;
441
442 if (isempty(c->x11_layout) &&
443 isempty(c->x11_model) &&
444 isempty(c->x11_variant) &&
445 isempty(c->x11_options)) {
446
447 if (unlink("/etc/X11/xorg.conf.d/00-keyboard.conf") < 0)
448 return errno == ENOENT ? 0 : -errno;
449
450 return 0;
451 }
452
453 mkdir_p_label("/etc/X11/xorg.conf.d", 0755);
454
455 r = fopen_temporary("/etc/X11/xorg.conf.d/00-keyboard.conf", &f, &temp_path);
456 if (r < 0)
457 return r;
458
459 fchmod(fileno(f), 0644);
460
461 fputs("# Read and parsed by systemd-localed. It's probably wise not to edit this file\n"
462 "# manually too freely.\n"
463 "Section \"InputClass\"\n"
464 " Identifier \"system-keyboard\"\n"
465 " MatchIsKeyboard \"on\"\n", f);
466
467 if (!isempty(c->x11_layout))
468 fprintf(f, " Option \"XkbLayout\" \"%s\"\n", c->x11_layout);
469
470 if (!isempty(c->x11_model))
471 fprintf(f, " Option \"XkbModel\" \"%s\"\n", c->x11_model);
472
473 if (!isempty(c->x11_variant))
474 fprintf(f, " Option \"XkbVariant\" \"%s\"\n", c->x11_variant);
475
476 if (!isempty(c->x11_options))
477 fprintf(f, " Option \"XkbOptions\" \"%s\"\n", c->x11_options);
478
479 fputs("EndSection\n", f);
480 fflush(f);
481
482 if (ferror(f) || rename(temp_path, "/etc/X11/xorg.conf.d/00-keyboard.conf") < 0) {
483 r = -errno;
484 unlink("/etc/X11/xorg.conf.d/00-keyboard.conf");
485 unlink(temp_path);
486 return r;
487 } else
488 return 0;
489 }
490
491 static int vconsole_reload(sd_bus *bus) {
492 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
493 int r;
494
495 assert(bus);
496
497 r = sd_bus_call_method(bus,
498 "org.freedesktop.systemd1",
499 "/org/freedesktop/systemd1",
500 "org.freedesktop.systemd1.Manager",
501 "RestartUnit",
502 &error,
503 NULL,
504 "ss", "systemd-vconsole-setup.service", "replace");
505
506 if (r < 0)
507 log_error("Failed to issue method call: %s", bus_error_message(&error, -r));
508 return r;
509 }
510
511 static const char* strnulldash(const char *s) {
512 return isempty(s) || streq(s, "-") ? NULL : s;
513 }
514
515 static int read_next_mapping(const char* filename,
516 unsigned min_fields, unsigned max_fields,
517 FILE *f, unsigned *n, char ***a) {
518 assert(f);
519 assert(n);
520 assert(a);
521
522 for (;;) {
523 char line[LINE_MAX];
524 char *l, **b;
525 int r;
526 size_t length;
527
528 errno = 0;
529 if (!fgets(line, sizeof(line), f)) {
530
531 if (ferror(f))
532 return errno ? -errno : -EIO;
533
534 return 0;
535 }
536
537 (*n) ++;
538
539 l = strstrip(line);
540 if (l[0] == 0 || l[0] == '#')
541 continue;
542
543 r = strv_split_quoted(&b, l, false);
544 if (r < 0)
545 return r;
546
547 length = strv_length(b);
548 if (length < min_fields || length > max_fields) {
549 log_error("Invalid line %s:%u, ignoring.", filename, *n);
550 strv_free(b);
551 continue;
552
553 }
554
555 *a = b;
556 return 1;
557 }
558 }
559
560 static int vconsole_convert_to_x11(Context *c, sd_bus *bus) {
561 bool modified = false;
562
563 assert(bus);
564
565 if (isempty(c->vc_keymap)) {
566
567 modified =
568 !isempty(c->x11_layout) ||
569 !isempty(c->x11_model) ||
570 !isempty(c->x11_variant) ||
571 !isempty(c->x11_options);
572
573 context_free_x11(c);
574 } else {
575 _cleanup_fclose_ FILE *f = NULL;
576 unsigned n = 0;
577
578 f = fopen(SYSTEMD_KBD_MODEL_MAP, "re");
579 if (!f)
580 return -errno;
581
582 for (;;) {
583 _cleanup_strv_free_ char **a = NULL;
584 int r;
585
586 r = read_next_mapping(SYSTEMD_KBD_MODEL_MAP, 5, UINT_MAX, f, &n, &a);
587 if (r < 0)
588 return r;
589 if (r == 0)
590 break;
591
592 if (!streq(c->vc_keymap, a[0]))
593 continue;
594
595 if (!streq_ptr(c->x11_layout, strnulldash(a[1])) ||
596 !streq_ptr(c->x11_model, strnulldash(a[2])) ||
597 !streq_ptr(c->x11_variant, strnulldash(a[3])) ||
598 !streq_ptr(c->x11_options, strnulldash(a[4]))) {
599
600 if (free_and_strdup(&c->x11_layout, strnulldash(a[1])) < 0 ||
601 free_and_strdup(&c->x11_model, strnulldash(a[2])) < 0 ||
602 free_and_strdup(&c->x11_variant, strnulldash(a[3])) < 0 ||
603 free_and_strdup(&c->x11_options, strnulldash(a[4])) < 0)
604 return -ENOMEM;
605
606 modified = true;
607 }
608
609 break;
610 }
611 }
612
613 if (modified) {
614 int r;
615
616 r = x11_write_data(c);
617 if (r < 0)
618 return log_error_errno(r, "Failed to set X11 keyboard layout: %m");
619
620 log_info("Changed X11 keyboard layout to '%s' model '%s' variant '%s' options '%s'",
621 strempty(c->x11_layout),
622 strempty(c->x11_model),
623 strempty(c->x11_variant),
624 strempty(c->x11_options));
625
626 sd_bus_emit_properties_changed(bus,
627 "/org/freedesktop/locale1",
628 "org.freedesktop.locale1",
629 "X11Layout", "X11Model", "X11Variant", "X11Options", NULL);
630 } else
631 log_debug("X11 keyboard layout was not modified.");
632
633 return 0;
634 }
635
636 static int find_converted_keymap(const char *x11_layout, const char *x11_variant, char **new_keymap) {
637 const char *dir;
638 _cleanup_free_ char *n;
639
640 if (x11_variant)
641 n = strjoin(x11_layout, "-", x11_variant, NULL);
642 else
643 n = strdup(x11_layout);
644 if (!n)
645 return -ENOMEM;
646
647 NULSTR_FOREACH(dir, KBD_KEYMAP_DIRS) {
648 _cleanup_free_ char *p = NULL, *pz = NULL;
649 bool uncompressed;
650
651 p = strjoin(dir, "xkb/", n, ".map", NULL);
652 pz = strjoin(dir, "xkb/", n, ".map.gz", NULL);
653 if (!p || !pz)
654 return -ENOMEM;
655
656 uncompressed = access(p, F_OK) == 0;
657 if (uncompressed || access(pz, F_OK) == 0) {
658 log_debug("Found converted keymap %s at %s",
659 n, uncompressed ? p : pz);
660
661 *new_keymap = n;
662 n = NULL;
663 return 1;
664 }
665 }
666
667 return 0;
668 }
669
670 static int find_legacy_keymap(Context *c, char **new_keymap) {
671 _cleanup_fclose_ FILE *f;
672 unsigned n = 0;
673 unsigned best_matching = 0;
674 int r;
675
676 f = fopen(SYSTEMD_KBD_MODEL_MAP, "re");
677 if (!f)
678 return -errno;
679
680 for (;;) {
681 _cleanup_strv_free_ char **a = NULL;
682 unsigned matching = 0;
683
684 r = read_next_mapping(SYSTEMD_KBD_MODEL_MAP, 5, UINT_MAX, f, &n, &a);
685 if (r < 0)
686 return r;
687 if (r == 0)
688 break;
689
690 /* Determine how well matching this entry is */
691 if (streq_ptr(c->x11_layout, a[1]))
692 /* If we got an exact match, this is best */
693 matching = 10;
694 else {
695 /* We have multiple X layouts, look for an
696 * entry that matches our key with everything
697 * but the first layout stripped off. */
698 if (startswith_comma(c->x11_layout, a[1]))
699 matching = 5;
700 else {
701 char *x;
702
703 /* If that didn't work, strip off the
704 * other layouts from the entry, too */
705 x = strndupa(a[1], strcspn(a[1], ","));
706 if (startswith_comma(c->x11_layout, x))
707 matching = 1;
708 }
709 }
710
711 if (matching > 0) {
712 if (isempty(c->x11_model) || streq_ptr(c->x11_model, a[2])) {
713 matching++;
714
715 if (streq_ptr(c->x11_variant, a[3])) {
716 matching++;
717
718 if (streq_ptr(c->x11_options, a[4]))
719 matching++;
720 }
721 }
722 }
723
724 /* The best matching entry so far, then let's save that */
725 if (matching >= MAX(best_matching, 1u)) {
726 log_debug("Found legacy keymap %s with score %u",
727 a[0], matching);
728
729 if (matching > best_matching) {
730 best_matching = matching;
731
732 r = free_and_strdup(new_keymap, a[0]);
733 if (r < 0)
734 return r;
735 }
736 }
737 }
738
739 if (best_matching < 10 && c->x11_layout) {
740 /* The best match is only the first part of the X11
741 * keymap. Check if we have a converted map which
742 * matches just the first layout.
743 */
744 char *l, *v = NULL, *converted;
745
746 l = strndupa(c->x11_layout, strcspn(c->x11_layout, ","));
747 if (c->x11_variant)
748 v = strndupa(c->x11_variant, strcspn(c->x11_variant, ","));
749 r = find_converted_keymap(l, v, &converted);
750 if (r < 0)
751 return r;
752 if (r > 0)
753 free_and_replace(new_keymap, converted);
754 }
755
756 return 0;
757 }
758
759 static int find_language_fallback(const char *lang, char **language) {
760 _cleanup_fclose_ FILE *f = NULL;
761 unsigned n = 0;
762
763 assert(language);
764
765 f = fopen(SYSTEMD_LANGUAGE_FALLBACK_MAP, "re");
766 if (!f)
767 return -errno;
768
769 for (;;) {
770 _cleanup_strv_free_ char **a = NULL;
771 int r;
772
773 r = read_next_mapping(SYSTEMD_LANGUAGE_FALLBACK_MAP, 2, 2, f, &n, &a);
774 if (r <= 0)
775 return r;
776
777 if (streq(lang, a[0])) {
778 assert(strv_length(a) == 2);
779 *language = a[1];
780 a[1] = NULL;
781 return 1;
782 }
783 }
784
785 assert_not_reached("should not be here");
786 }
787
788 static int x11_convert_to_vconsole(Context *c, sd_bus *bus) {
789 bool modified = false;
790 int r;
791
792 assert(bus);
793
794 if (isempty(c->x11_layout)) {
795
796 modified =
797 !isempty(c->vc_keymap) ||
798 !isempty(c->vc_keymap_toggle);
799
800 context_free_x11(c);
801 } else {
802 char *new_keymap = NULL;
803
804 r = find_converted_keymap(c->x11_layout, c->x11_variant, &new_keymap);
805 if (r < 0)
806 return r;
807 else if (r == 0) {
808 r = find_legacy_keymap(c, &new_keymap);
809 if (r < 0)
810 return r;
811 }
812
813 if (!streq_ptr(c->vc_keymap, new_keymap)) {
814 free_and_replace(&c->vc_keymap, new_keymap);
815 free_and_replace(&c->vc_keymap_toggle, NULL);
816 modified = true;
817 } else
818 free(new_keymap);
819 }
820
821 if (modified) {
822 r = vconsole_write_data(c);
823 if (r < 0)
824 log_error_errno(r, "Failed to set virtual console keymap: %m");
825
826 log_info("Changed virtual console keymap to '%s' toggle '%s'",
827 strempty(c->vc_keymap), strempty(c->vc_keymap_toggle));
828
829 sd_bus_emit_properties_changed(bus,
830 "/org/freedesktop/locale1",
831 "org.freedesktop.locale1",
832 "VConsoleKeymap", "VConsoleKeymapToggle", NULL);
833
834 return vconsole_reload(bus);
835 } else
836 log_debug("Virtual console keymap was not modified.");
837
838 return 0;
839 }
840
841 static int property_get_locale(
842 sd_bus *bus,
843 const char *path,
844 const char *interface,
845 const char *property,
846 sd_bus_message *reply,
847 void *userdata,
848 sd_bus_error *error) {
849
850 Context *c = userdata;
851 _cleanup_strv_free_ char **l = NULL;
852 int p, q;
853
854 l = new0(char*, _LOCALE_MAX+1);
855 if (!l)
856 return -ENOMEM;
857
858 for (p = 0, q = 0; p < _LOCALE_MAX; p++) {
859 char *t;
860
861 if (isempty(c->locale[p]))
862 continue;
863
864 if (asprintf(&t, "%s=%s", names[p], c->locale[p]) < 0)
865 return -ENOMEM;
866
867 l[q++] = t;
868 }
869
870 return sd_bus_message_append_strv(reply, l);
871 }
872
873 static int method_set_locale(sd_bus *bus, sd_bus_message *m, void *userdata, sd_bus_error *error) {
874 Context *c = userdata;
875 _cleanup_strv_free_ char **l = NULL;
876 char **i;
877 const char *lang = NULL;
878 int interactive;
879 bool modified = false;
880 bool have[_LOCALE_MAX] = {};
881 int p;
882 int r;
883
884 r = bus_message_read_strv_extend(m, &l);
885 if (r < 0)
886 return r;
887
888 r = sd_bus_message_read_basic(m, 'b', &interactive);
889 if (r < 0)
890 return r;
891
892 /* Check whether a variable changed and if it is valid */
893 STRV_FOREACH(i, l) {
894 bool valid = false;
895
896 for (p = 0; p < _LOCALE_MAX; p++) {
897 size_t k;
898
899 k = strlen(names[p]);
900 if (startswith(*i, names[p]) &&
901 (*i)[k] == '=' &&
902 locale_is_valid((*i) + k + 1)) {
903 valid = true;
904 have[p] = true;
905
906 if (p == LOCALE_LANG)
907 lang = (*i) + k + 1;
908
909 if (!streq_ptr(*i + k + 1, c->locale[p]))
910 modified = true;
911
912 break;
913 }
914 }
915
916 if (!valid)
917 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid Locale data.");
918 }
919
920 /* If LANG was specified, but not LANGUAGE, check if we should
921 * set it based on the language fallback table. */
922 if (have[LOCALE_LANG] && !have[LOCALE_LANGUAGE]) {
923 _cleanup_free_ char *language = NULL;
924
925 assert(lang);
926
927 (void) find_language_fallback(lang, &language);
928 if (language) {
929 log_debug("Converted LANG=%s to LANGUAGE=%s", lang, language);
930 if (!streq_ptr(language, c->locale[LOCALE_LANGUAGE])) {
931 r = strv_extendf(&l, "LANGUAGE=%s", language);
932 if (r < 0)
933 return r;
934
935 have[LOCALE_LANGUAGE] = true;
936 modified = true;
937 }
938 }
939 }
940
941 /* Check whether a variable is unset */
942 if (!modified)
943 for (p = 0; p < _LOCALE_MAX; p++)
944 if (!isempty(c->locale[p]) && !have[p]) {
945 modified = true;
946 break;
947 }
948
949 if (modified) {
950 _cleanup_strv_free_ char **settings = NULL;
951
952 r = bus_verify_polkit_async(m, CAP_SYS_ADMIN, "org.freedesktop.locale1.set-locale", interactive, &c->polkit_registry, error);
953 if (r < 0)
954 return r;
955 if (r == 0)
956 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
957
958 STRV_FOREACH(i, l)
959 for (p = 0; p < _LOCALE_MAX; p++) {
960 size_t k;
961
962 k = strlen(names[p]);
963 if (startswith(*i, names[p]) && (*i)[k] == '=') {
964 r = free_and_strdup(&c->locale[p], *i + k + 1);
965 if (r < 0)
966 return r;
967 break;
968 }
969 }
970
971 for (p = 0; p < _LOCALE_MAX; p++) {
972 if (have[p])
973 continue;
974
975 free_and_replace(&c->locale[p], NULL);
976 }
977
978 locale_simplify(c);
979
980 r = locale_write_data(c, &settings);
981 if (r < 0) {
982 log_error_errno(r, "Failed to set locale: %m");
983 return sd_bus_error_set_errnof(error, r, "Failed to set locale: %s", strerror(-r));
984 }
985
986 locale_update_system_manager(c, bus);
987
988 if (settings) {
989 _cleanup_free_ char *line;
990
991 line = strv_join(settings, ", ");
992 log_info("Changed locale to %s.", strnull(line));
993 } else
994 log_info("Changed locale to unset.");
995
996 sd_bus_emit_properties_changed(bus,
997 "/org/freedesktop/locale1",
998 "org.freedesktop.locale1",
999 "Locale", NULL);
1000 } else
1001 log_debug("Locale settings were not modified.");
1002
1003
1004 return sd_bus_reply_method_return(m, NULL);
1005 }
1006
1007 static int method_set_vc_keyboard(sd_bus *bus, sd_bus_message *m, void *userdata, sd_bus_error *error) {
1008 Context *c = userdata;
1009 const char *keymap, *keymap_toggle;
1010 int convert, interactive;
1011 int r;
1012
1013 r = sd_bus_message_read(m, "ssbb", &keymap, &keymap_toggle, &convert, &interactive);
1014 if (r < 0)
1015 return r;
1016
1017 if (isempty(keymap))
1018 keymap = NULL;
1019
1020 if (isempty(keymap_toggle))
1021 keymap_toggle = NULL;
1022
1023 if (!streq_ptr(keymap, c->vc_keymap) ||
1024 !streq_ptr(keymap_toggle, c->vc_keymap_toggle)) {
1025
1026 if ((keymap && (!filename_is_valid(keymap) || !string_is_safe(keymap))) ||
1027 (keymap_toggle && (!filename_is_valid(keymap_toggle) || !string_is_safe(keymap_toggle))))
1028 return sd_bus_error_set_errnof(error, -EINVAL, "Received invalid keymap data");
1029
1030 r = bus_verify_polkit_async(m, CAP_SYS_ADMIN, "org.freedesktop.locale1.set-keyboard", interactive, &c->polkit_registry, error);
1031 if (r < 0)
1032 return r;
1033 if (r == 0)
1034 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1035
1036 if (free_and_strdup(&c->vc_keymap, keymap) < 0 ||
1037 free_and_strdup(&c->vc_keymap_toggle, keymap_toggle) < 0)
1038 return -ENOMEM;
1039
1040 r = vconsole_write_data(c);
1041 if (r < 0) {
1042 log_error_errno(r, "Failed to set virtual console keymap: %m");
1043 return sd_bus_error_set_errnof(error, r, "Failed to set virtual console keymap: %s", strerror(-r));
1044 }
1045
1046 log_info("Changed virtual console keymap to '%s' toggle '%s'",
1047 strempty(c->vc_keymap), strempty(c->vc_keymap_toggle));
1048
1049 r = vconsole_reload(bus);
1050 if (r < 0)
1051 log_error_errno(r, "Failed to request keymap reload: %m");
1052
1053 sd_bus_emit_properties_changed(bus,
1054 "/org/freedesktop/locale1",
1055 "org.freedesktop.locale1",
1056 "VConsoleKeymap", "VConsoleKeymapToggle", NULL);
1057
1058 if (convert) {
1059 r = vconsole_convert_to_x11(c, bus);
1060 if (r < 0)
1061 log_error_errno(r, "Failed to convert keymap data: %m");
1062 }
1063 }
1064
1065 return sd_bus_reply_method_return(m, NULL);
1066 }
1067
1068 #ifdef HAVE_XKBCOMMON
1069 static void log_xkb(struct xkb_context *ctx, enum xkb_log_level lvl, const char *format, va_list args) {
1070 const char *fmt;
1071
1072 fmt = strjoina("libxkbcommon: ", format);
1073 log_internalv(LOG_DEBUG, 0, __FILE__, __LINE__, __func__, fmt, args);
1074 }
1075
1076 static int verify_xkb_rmlvo(const char *model, const char *layout, const char *variant, const char *options) {
1077 const struct xkb_rule_names rmlvo = {
1078 .model = model,
1079 .layout = layout,
1080 .variant = variant,
1081 .options = options,
1082 };
1083 struct xkb_context *ctx = NULL;
1084 struct xkb_keymap *km = NULL;
1085 int r;
1086
1087 /* compile keymap from RMLVO information to check out its validity */
1088
1089 ctx = xkb_context_new(XKB_CONTEXT_NO_ENVIRONMENT_NAMES);
1090 if (!ctx) {
1091 r = -ENOMEM;
1092 goto exit;
1093 }
1094
1095 xkb_context_set_log_fn(ctx, log_xkb);
1096
1097 km = xkb_keymap_new_from_names(ctx, &rmlvo, XKB_KEYMAP_COMPILE_NO_FLAGS);
1098 if (!km) {
1099 r = -EINVAL;
1100 goto exit;
1101 }
1102
1103 r = 0;
1104
1105 exit:
1106 xkb_keymap_unref(km);
1107 xkb_context_unref(ctx);
1108 return r;
1109 }
1110 #else
1111 static int verify_xkb_rmlvo(const char *model, const char *layout, const char *variant, const char *options) {
1112 return 0;
1113 }
1114 #endif
1115
1116 static int method_set_x11_keyboard(sd_bus *bus, sd_bus_message *m, void *userdata, sd_bus_error *error) {
1117 Context *c = userdata;
1118 const char *layout, *model, *variant, *options;
1119 int convert, interactive;
1120 int r;
1121
1122 r = sd_bus_message_read(m, "ssssbb", &layout, &model, &variant, &options, &convert, &interactive);
1123 if (r < 0)
1124 return r;
1125
1126 if (isempty(layout))
1127 layout = NULL;
1128
1129 if (isempty(model))
1130 model = NULL;
1131
1132 if (isempty(variant))
1133 variant = NULL;
1134
1135 if (isempty(options))
1136 options = NULL;
1137
1138 if (!streq_ptr(layout, c->x11_layout) ||
1139 !streq_ptr(model, c->x11_model) ||
1140 !streq_ptr(variant, c->x11_variant) ||
1141 !streq_ptr(options, c->x11_options)) {
1142
1143 if ((layout && !string_is_safe(layout)) ||
1144 (model && !string_is_safe(model)) ||
1145 (variant && !string_is_safe(variant)) ||
1146 (options && !string_is_safe(options)))
1147 return sd_bus_error_set_errnof(error, -EINVAL, "Received invalid keyboard data");
1148
1149 r = bus_verify_polkit_async(m, CAP_SYS_ADMIN, "org.freedesktop.locale1.set-keyboard", interactive, &c->polkit_registry, error);
1150 if (r < 0)
1151 return r;
1152 if (r == 0)
1153 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1154
1155 r = verify_xkb_rmlvo(model, layout, variant, options);
1156 if (r < 0) {
1157 log_error_errno(r, "Cannot compile XKB keymap for new x11 keyboard layout ('%s' / '%s' / '%s' / '%s'): %m",
1158 strempty(model), strempty(layout), strempty(variant), strempty(options));
1159 return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Cannot compile XKB keymap, refusing");
1160 }
1161
1162 if (free_and_strdup(&c->x11_layout, layout) < 0 ||
1163 free_and_strdup(&c->x11_model, model) < 0 ||
1164 free_and_strdup(&c->x11_variant, variant) < 0 ||
1165 free_and_strdup(&c->x11_options, options) < 0)
1166 return -ENOMEM;
1167
1168 r = x11_write_data(c);
1169 if (r < 0) {
1170 log_error_errno(r, "Failed to set X11 keyboard layout: %m");
1171 return sd_bus_error_set_errnof(error, r, "Failed to set X11 keyboard layout: %s", strerror(-r));
1172 }
1173
1174 log_info("Changed X11 keyboard layout to '%s' model '%s' variant '%s' options '%s'",
1175 strempty(c->x11_layout),
1176 strempty(c->x11_model),
1177 strempty(c->x11_variant),
1178 strempty(c->x11_options));
1179
1180 sd_bus_emit_properties_changed(bus,
1181 "/org/freedesktop/locale1",
1182 "org.freedesktop.locale1",
1183 "X11Layout", "X11Model", "X11Variant", "X11Options", NULL);
1184
1185 if (convert) {
1186 r = x11_convert_to_vconsole(c, bus);
1187 if (r < 0)
1188 log_error_errno(r, "Failed to convert keymap data: %m");
1189 }
1190 }
1191
1192 return sd_bus_reply_method_return(m, NULL);
1193 }
1194
1195 static const sd_bus_vtable locale_vtable[] = {
1196 SD_BUS_VTABLE_START(0),
1197 SD_BUS_PROPERTY("Locale", "as", property_get_locale, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
1198 SD_BUS_PROPERTY("X11Layout", "s", NULL, offsetof(Context, x11_layout), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
1199 SD_BUS_PROPERTY("X11Model", "s", NULL, offsetof(Context, x11_model), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
1200 SD_BUS_PROPERTY("X11Variant", "s", NULL, offsetof(Context, x11_variant), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
1201 SD_BUS_PROPERTY("X11Options", "s", NULL, offsetof(Context, x11_options), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
1202 SD_BUS_PROPERTY("VConsoleKeymap", "s", NULL, offsetof(Context, vc_keymap), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
1203 SD_BUS_PROPERTY("VConsoleKeymapToggle", "s", NULL, offsetof(Context, vc_keymap_toggle), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
1204 SD_BUS_METHOD("SetLocale", "asb", NULL, method_set_locale, SD_BUS_VTABLE_UNPRIVILEGED),
1205 SD_BUS_METHOD("SetVConsoleKeyboard", "ssbb", NULL, method_set_vc_keyboard, SD_BUS_VTABLE_UNPRIVILEGED),
1206 SD_BUS_METHOD("SetX11Keyboard", "ssssbb", NULL, method_set_x11_keyboard, SD_BUS_VTABLE_UNPRIVILEGED),
1207 SD_BUS_VTABLE_END
1208 };
1209
1210 static int connect_bus(Context *c, sd_event *event, sd_bus **_bus) {
1211 _cleanup_bus_close_unref_ sd_bus *bus = NULL;
1212 int r;
1213
1214 assert(c);
1215 assert(event);
1216 assert(_bus);
1217
1218 r = sd_bus_default_system(&bus);
1219 if (r < 0)
1220 return log_error_errno(r, "Failed to get system bus connection: %m");
1221
1222 r = sd_bus_add_object_vtable(bus, NULL, "/org/freedesktop/locale1", "org.freedesktop.locale1", locale_vtable, c);
1223 if (r < 0)
1224 return log_error_errno(r, "Failed to register object: %m");
1225
1226 r = sd_bus_request_name(bus, "org.freedesktop.locale1", 0);
1227 if (r < 0)
1228 return log_error_errno(r, "Failed to register name: %m");
1229
1230 r = sd_bus_attach_event(bus, event, 0);
1231 if (r < 0)
1232 return log_error_errno(r, "Failed to attach bus to event loop: %m");
1233
1234 *_bus = bus;
1235 bus = NULL;
1236
1237 return 0;
1238 }
1239
1240 int main(int argc, char *argv[]) {
1241 _cleanup_(context_free) Context context = {};
1242 _cleanup_event_unref_ sd_event *event = NULL;
1243 _cleanup_bus_close_unref_ sd_bus *bus = NULL;
1244 int r;
1245
1246 log_set_target(LOG_TARGET_AUTO);
1247 log_parse_environment();
1248 log_open();
1249
1250 umask(0022);
1251 mac_selinux_init("/etc");
1252
1253 if (argc != 1) {
1254 log_error("This program takes no arguments.");
1255 r = -EINVAL;
1256 goto finish;
1257 }
1258
1259 r = sd_event_default(&event);
1260 if (r < 0) {
1261 log_error_errno(r, "Failed to allocate event loop: %m");
1262 goto finish;
1263 }
1264
1265 sd_event_set_watchdog(event, true);
1266
1267 r = connect_bus(&context, event, &bus);
1268 if (r < 0)
1269 goto finish;
1270
1271 r = context_read_data(&context);
1272 if (r < 0) {
1273 log_error_errno(r, "Failed to read locale data: %m");
1274 goto finish;
1275 }
1276
1277 r = bus_event_loop_with_idle(event, bus, "org.freedesktop.locale1", DEFAULT_EXIT_USEC, NULL, NULL);
1278 if (r < 0) {
1279 log_error_errno(r, "Failed to run event loop: %m");
1280 goto finish;
1281 }
1282
1283 finish:
1284 return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
1285 }
Unnamed repository; edit this file 'description' to name the repository.