]> 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
bus: let's simplify things by getting rid of unnecessary bus parameters
[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
42 enum {
43 /* We don't list LC_ALL here on purpose. People should be
44 * using LANG instead. */
45 LOCALE_LANG,
46 LOCALE_LANGUAGE,
47 LOCALE_LC_CTYPE,
48 LOCALE_LC_NUMERIC,
49 LOCALE_LC_TIME,
50 LOCALE_LC_COLLATE,
51 LOCALE_LC_MONETARY,
52 LOCALE_LC_MESSAGES,
53 LOCALE_LC_PAPER,
54 LOCALE_LC_NAME,
55 LOCALE_LC_ADDRESS,
56 LOCALE_LC_TELEPHONE,
57 LOCALE_LC_MEASUREMENT,
58 LOCALE_LC_IDENTIFICATION,
59 _LOCALE_MAX
60 };
61
62 static const char * const names[_LOCALE_MAX] = {
63 [LOCALE_LANG] = "LANG",
64 [LOCALE_LANGUAGE] = "LANGUAGE",
65 [LOCALE_LC_CTYPE] = "LC_CTYPE",
66 [LOCALE_LC_NUMERIC] = "LC_NUMERIC",
67 [LOCALE_LC_TIME] = "LC_TIME",
68 [LOCALE_LC_COLLATE] = "LC_COLLATE",
69 [LOCALE_LC_MONETARY] = "LC_MONETARY",
70 [LOCALE_LC_MESSAGES] = "LC_MESSAGES",
71 [LOCALE_LC_PAPER] = "LC_PAPER",
72 [LOCALE_LC_NAME] = "LC_NAME",
73 [LOCALE_LC_ADDRESS] = "LC_ADDRESS",
74 [LOCALE_LC_TELEPHONE] = "LC_TELEPHONE",
75 [LOCALE_LC_MEASUREMENT] = "LC_MEASUREMENT",
76 [LOCALE_LC_IDENTIFICATION] = "LC_IDENTIFICATION"
77 };
78
79 typedef struct Context {
80 char *locale[_LOCALE_MAX];
81
82 char *x11_layout;
83 char *x11_model;
84 char *x11_variant;
85 char *x11_options;
86
87 char *vc_keymap;
88 char *vc_keymap_toggle;
89
90 Hashmap *polkit_registry;
91 } Context;
92
93 static int free_and_copy(char **s, const char *v) {
94 int r;
95 char *t;
96
97 assert(s);
98
99 r = strdup_or_null(isempty(v) ? NULL : v, &t);
100 if (r < 0)
101 return r;
102
103 free(*s);
104 *s = t;
105
106 return 0;
107 }
108
109 static void free_and_replace(char **s, char *v) {
110 free(*s);
111 *s = v;
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, sd_bus *bus) {
134 context_free_locale(c);
135 context_free_x11(c);
136 context_free_vconsole(c);
137
138 bus_verify_polkit_async_registry_free(bus, 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(c->locale[p]);
147 c->locale[p] = NULL;
148 }
149 }
150
151 static int locale_read_data(Context *c) {
152 int r;
153
154 context_free_locale(c);
155
156 r = parse_env_file("/etc/locale.conf", NEWLINE,
157 "LANG", &c->locale[LOCALE_LANG],
158 "LANGUAGE", &c->locale[LOCALE_LANGUAGE],
159 "LC_CTYPE", &c->locale[LOCALE_LC_CTYPE],
160 "LC_NUMERIC", &c->locale[LOCALE_LC_NUMERIC],
161 "LC_TIME", &c->locale[LOCALE_LC_TIME],
162 "LC_COLLATE", &c->locale[LOCALE_LC_COLLATE],
163 "LC_MONETARY", &c->locale[LOCALE_LC_MONETARY],
164 "LC_MESSAGES", &c->locale[LOCALE_LC_MESSAGES],
165 "LC_PAPER", &c->locale[LOCALE_LC_PAPER],
166 "LC_NAME", &c->locale[LOCALE_LC_NAME],
167 "LC_ADDRESS", &c->locale[LOCALE_LC_ADDRESS],
168 "LC_TELEPHONE", &c->locale[LOCALE_LC_TELEPHONE],
169 "LC_MEASUREMENT", &c->locale[LOCALE_LC_MEASUREMENT],
170 "LC_IDENTIFICATION", &c->locale[LOCALE_LC_IDENTIFICATION],
171 NULL);
172
173 if (r == -ENOENT) {
174 int p;
175
176 /* Fill in what we got passed from systemd. */
177 for (p = 0; p < _LOCALE_MAX; p++) {
178 assert(names[p]);
179
180 r = free_and_copy(&c->locale[p], getenv(names[p]));
181 if (r < 0)
182 return r;
183 }
184
185 r = 0;
186 }
187
188 locale_simplify(c);
189 return r;
190 }
191
192 static int vconsole_read_data(Context *c) {
193 int r;
194
195 context_free_vconsole(c);
196
197 r = parse_env_file("/etc/vconsole.conf", NEWLINE,
198 "KEYMAP", &c->vc_keymap,
199 "KEYMAP_TOGGLE", &c->vc_keymap_toggle,
200 NULL);
201
202 if (r < 0 && r != -ENOENT)
203 return r;
204
205 return 0;
206 }
207
208 static int x11_read_data(Context *c) {
209 FILE *f;
210 char line[LINE_MAX];
211 bool in_section = false;
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 char **a;
230
231 a = strv_split_quoted(l);
232 if (!a) {
233 fclose(f);
234 return -ENOMEM;
235 }
236
237 if (strv_length(a) == 3) {
238 if (streq(a[1], "XkbLayout")) {
239 free_and_replace(&c->x11_layout, a[2]);
240 a[2] = NULL;
241 } else if (streq(a[1], "XkbModel")) {
242 free_and_replace(&c->x11_model, a[2]);
243 a[2] = NULL;
244 } else if (streq(a[1], "XkbVariant")) {
245 free_and_replace(&c->x11_variant, a[2]);
246 a[2] = NULL;
247 } else if (streq(a[1], "XkbOptions")) {
248 free_and_replace(&c->x11_options, a[2]);
249 a[2] = NULL;
250 }
251 }
252
253 strv_free(a);
254
255 } else if (!in_section && first_word(l, "Section")) {
256 char **a;
257
258 a = strv_split_quoted(l);
259 if (!a) {
260 fclose(f);
261 return -ENOMEM;
262 }
263
264 if (strv_length(a) == 2 && streq(a[1], "InputClass"))
265 in_section = true;
266
267 strv_free(a);
268 } else if (in_section && first_word(l, "EndSection"))
269 in_section = false;
270 }
271
272 fclose(f);
273
274 return 0;
275 }
276
277 static int context_read_data(Context *c) {
278 int r, q, p;
279
280 r = locale_read_data(c);
281 q = vconsole_read_data(c);
282 p = x11_read_data(c);
283
284 return r < 0 ? r : q < 0 ? q : p;
285 }
286
287 static int locale_write_data(Context *c) {
288 int r, p;
289 char **l = NULL;
290
291 r = load_env_file("/etc/locale.conf", NULL, &l);
292 if (r < 0 && r != -ENOENT)
293 return r;
294
295 for (p = 0; p < _LOCALE_MAX; p++) {
296 char *t, **u;
297
298 assert(names[p]);
299
300 if (isempty(c->locale[p])) {
301 l = strv_env_unset(l, names[p]);
302 continue;
303 }
304
305 if (asprintf(&t, "%s=%s", names[p], c->locale[p]) < 0) {
306 strv_free(l);
307 return -ENOMEM;
308 }
309
310 u = strv_env_set(l, t);
311 free(t);
312 strv_free(l);
313
314 if (!u)
315 return -ENOMEM;
316
317 l = u;
318 }
319
320 if (strv_isempty(l)) {
321 strv_free(l);
322
323 if (unlink("/etc/locale.conf") < 0)
324 return errno == ENOENT ? 0 : -errno;
325
326 return 0;
327 }
328
329 r = write_env_file_label("/etc/locale.conf", l);
330 strv_free(l);
331
332 return r;
333 }
334
335 static int locale_update_system_manager(Context *c, sd_bus *bus) {
336 _cleanup_free_ char **l_unset = NULL;
337 _cleanup_strv_free_ char **l_set = NULL;
338 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
339 sd_bus_error error = SD_BUS_ERROR_NULL;
340 unsigned c_set, c_unset, p;
341 int r;
342
343 assert(bus);
344
345 l_unset = new0(char*, _LOCALE_MAX);
346 if (!l_unset)
347 return -ENOMEM;
348
349 l_set = new0(char*, _LOCALE_MAX);
350 if (!l_set)
351 return -ENOMEM;
352
353 for (p = 0, c_set = 0, c_unset = 0; p < _LOCALE_MAX; p++) {
354 assert(names[p]);
355
356 if (isempty(c->locale[p]))
357 l_unset[c_set++] = (char*) names[p];
358 else {
359 char *s;
360
361 if (asprintf(&s, "%s=%s", names[p], c->locale[p]) < 0)
362 return -ENOMEM;
363
364 l_set[c_unset++] = s;
365 }
366 }
367
368 assert(c_set + c_unset == _LOCALE_MAX);
369 r = sd_bus_message_new_method_call(bus,
370 "org.freedesktop.systemd1",
371 "/org/freedesktop/systemd1",
372 "org.freedesktop.systemd1.Manager",
373 "UnsetAndSetEnvironment", &m);
374 if (r < 0)
375 return r;
376
377 r = sd_bus_message_append_strv(m, l_unset);
378 if (r < 0)
379 return r;
380
381 r = sd_bus_message_append_strv(m, l_set);
382 if (r < 0)
383 return r;
384
385 r = sd_bus_call(bus, m, 0, &error, NULL);
386 if (r < 0)
387 log_error("Failed to update the manager environment: %s", strerror(-r));
388
389 return 0;
390 }
391
392 static int vconsole_write_data(Context *c) {
393 int r;
394 _cleanup_strv_free_ char **l = NULL;
395
396 r = load_env_file("/etc/vconsole.conf", NULL, &l);
397 if (r < 0 && r != -ENOENT)
398 return r;
399
400 if (isempty(c->vc_keymap))
401 l = strv_env_unset(l, "KEYMAP");
402 else {
403 char *s, **u;
404
405 s = strappend("KEYMAP=", c->vc_keymap);
406 if (!s)
407 return -ENOMEM;
408
409 u = strv_env_set(l, s);
410 free(s);
411 strv_free(l);
412
413 if (!u)
414 return -ENOMEM;
415
416 l = u;
417 }
418
419 if (isempty(c->vc_keymap_toggle))
420 l = strv_env_unset(l, "KEYMAP_TOGGLE");
421 else {
422 char *s, **u;
423
424 s = strappend("KEYMAP_TOGGLE=", c->vc_keymap_toggle);
425 if (!s)
426 return -ENOMEM;
427
428 u = strv_env_set(l, s);
429 free(s);
430 strv_free(l);
431
432 if (!u)
433 return -ENOMEM;
434
435 l = u;
436 }
437
438 if (strv_isempty(l)) {
439 if (unlink("/etc/vconsole.conf") < 0)
440 return errno == ENOENT ? 0 : -errno;
441
442 return 0;
443 }
444
445 r = write_env_file_label("/etc/vconsole.conf", l);
446 return r;
447 }
448
449 static int write_data_x11(Context *c) {
450 _cleanup_fclose_ FILE *f = NULL;
451 _cleanup_free_ char *temp_path = NULL;
452 int r;
453
454 if (isempty(c->x11_layout) &&
455 isempty(c->x11_model) &&
456 isempty(c->x11_variant) &&
457 isempty(c->x11_options)) {
458
459 if (unlink("/etc/X11/xorg.conf.d/00-keyboard.conf") < 0)
460 return errno == ENOENT ? 0 : -errno;
461
462 return 0;
463 }
464
465 mkdir_p_label("/etc/X11/xorg.conf.d", 0755);
466
467 r = fopen_temporary("/etc/X11/xorg.conf.d/00-keyboard.conf", &f, &temp_path);
468 if (r < 0)
469 return r;
470
471 fchmod(fileno(f), 0644);
472
473 fputs("# Read and parsed by systemd-localed. It's probably wise not to edit this file\n"
474 "# manually too freely.\n"
475 "Section \"InputClass\"\n"
476 " Identifier \"system-keyboard\"\n"
477 " MatchIsKeyboard \"on\"\n", f);
478
479 if (!isempty(c->x11_layout))
480 fprintf(f, " Option \"XkbLayout\" \"%s\"\n", c->x11_layout);
481
482 if (!isempty(c->x11_model))
483 fprintf(f, " Option \"XkbModel\" \"%s\"\n", c->x11_model);
484
485 if (!isempty(c->x11_variant))
486 fprintf(f, " Option \"XkbVariant\" \"%s\"\n", c->x11_variant);
487
488 if (!isempty(c->x11_options))
489 fprintf(f, " Option \"XkbOptions\" \"%s\"\n", c->x11_options);
490
491 fputs("EndSection\n", f);
492 fflush(f);
493
494 if (ferror(f) || rename(temp_path, "/etc/X11/xorg.conf.d/00-keyboard.conf") < 0) {
495 r = -errno;
496 unlink("/etc/X11/xorg.conf.d/00-keyboard.conf");
497 unlink(temp_path);
498 return r;
499 } else
500 return 0;
501 }
502
503 static int vconsole_reload(sd_bus *bus) {
504 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
505 int r;
506
507 assert(bus);
508
509 r = sd_bus_call_method(bus,
510 "org.freedesktop.systemd1",
511 "/org/freedesktop/systemd1",
512 "org.freedesktop.systemd1.Manager",
513 "RestartUnit",
514 &error,
515 NULL,
516 "ss", "systemd-vconsole-setup.service", "replace");
517
518 if (r < 0)
519 log_error("Failed to issue method call: %s", bus_error_message(&error, -r));
520 return r;
521 }
522
523 static char *strnulldash(const char *s) {
524 return s == NULL || *s == 0 || (s[0] == '-' && s[1] == 0) ? NULL : (char*) s;
525 }
526
527 static int read_next_mapping(FILE *f, unsigned *n, char ***a) {
528 assert(f);
529 assert(n);
530 assert(a);
531
532 for (;;) {
533 char line[LINE_MAX];
534 char *l, **b;
535
536 errno = 0;
537 if (!fgets(line, sizeof(line), f)) {
538
539 if (ferror(f))
540 return errno ? -errno : -EIO;
541
542 return 0;
543 }
544
545 (*n) ++;
546
547 l = strstrip(line);
548 if (l[0] == 0 || l[0] == '#')
549 continue;
550
551 b = strv_split_quoted(l);
552 if (!b)
553 return -ENOMEM;
554
555 if (strv_length(b) < 5) {
556 log_error("Invalid line "SYSTEMD_KBD_MODEL_MAP":%u, ignoring.", *n);
557 strv_free(b);
558 continue;
559
560 }
561
562 *a = b;
563 return 1;
564 }
565 }
566
567 static int vconsole_convert_to_x11(Context *c, sd_bus *bus) {
568 bool modified = false;
569
570 assert(bus);
571
572 if (isempty(c->vc_keymap)) {
573
574 modified =
575 !isempty(c->x11_layout) ||
576 !isempty(c->x11_model) ||
577 !isempty(c->x11_variant) ||
578 !isempty(c->x11_options);
579
580 context_free_x11(c);
581 } else {
582 _cleanup_fclose_ FILE *f = NULL;
583 unsigned n = 0;
584
585 f = fopen(SYSTEMD_KBD_MODEL_MAP, "re");
586 if (!f)
587 return -errno;
588
589 for (;;) {
590 _cleanup_strv_free_ char **a = NULL;
591 int r;
592
593 r = read_next_mapping(f, &n, &a);
594 if (r < 0)
595 return r;
596 if (r == 0)
597 break;
598
599 if (!streq(c->vc_keymap, a[0]))
600 continue;
601
602 if (!streq_ptr(c->x11_layout, strnulldash(a[1])) ||
603 !streq_ptr(c->x11_model, strnulldash(a[2])) ||
604 !streq_ptr(c->x11_variant, strnulldash(a[3])) ||
605 !streq_ptr(c->x11_options, strnulldash(a[4]))) {
606
607 if (free_and_copy(&c->x11_layout, strnulldash(a[1])) < 0 ||
608 free_and_copy(&c->x11_model, strnulldash(a[2])) < 0 ||
609 free_and_copy(&c->x11_variant, strnulldash(a[3])) < 0 ||
610 free_and_copy(&c->x11_options, strnulldash(a[4])) < 0)
611 return -ENOMEM;
612
613 modified = true;
614 }
615
616 break;
617 }
618 }
619
620 if (modified) {
621 int r;
622
623 r = write_data_x11(c);
624 if (r < 0)
625 log_error("Failed to set X11 keyboard layout: %s", strerror(-r));
626
627 sd_bus_emit_properties_changed(bus,
628 "/org/freedesktop/locale1",
629 "org.freedesktop.locale1",
630 "X11Layout", "X11Model", "X11Variant", "X11Options", NULL);
631 }
632
633 return 0;
634 }
635
636 static int find_converted_keymap(Context *c, char **new_keymap) {
637 const char *dir;
638 _cleanup_free_ char *n;
639
640 if (c->x11_variant)
641 n = strjoin(c->x11_layout, "-", c->x11_variant, NULL);
642 else
643 n = strdup(c->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
650 p = strjoin(dir, "xkb/", n, ".map", NULL);
651 pz = strjoin(dir, "xkb/", n, ".map.gz", NULL);
652 if (!p || !pz)
653 return -ENOMEM;
654
655 if (access(p, F_OK) == 0 || access(pz, F_OK) == 0) {
656 *new_keymap = n;
657 n = NULL;
658 return 1;
659 }
660 }
661
662 return 0;
663 }
664
665 static int find_legacy_keymap(Context *c, char **new_keymap) {
666 _cleanup_fclose_ FILE *f;
667 unsigned n = 0;
668 unsigned best_matching = 0;
669
670
671 f = fopen(SYSTEMD_KBD_MODEL_MAP, "re");
672 if (!f)
673 return -errno;
674
675 for (;;) {
676 _cleanup_strv_free_ char **a = NULL;
677 unsigned matching = 0;
678 int r;
679
680 r = read_next_mapping(f, &n, &a);
681 if (r < 0)
682 return r;
683 if (r == 0)
684 break;
685
686 /* Determine how well matching this entry is */
687 if (streq_ptr(c->x11_layout, a[1]))
688 /* If we got an exact match, this is best */
689 matching = 10;
690 else {
691 size_t x;
692
693 x = strcspn(c->x11_layout, ",");
694
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 (x > 0 &&
699 strlen(a[1]) == x &&
700 strneq(c->x11_layout, a[1], x))
701 matching = 5;
702 else {
703 size_t w;
704
705 /* If that didn't work, strip off the
706 * other layouts from the entry, too */
707 w = strcspn(a[1], ",");
708
709 if (x > 0 && x == w &&
710 memcmp(c->x11_layout, a[1], x) == 0)
711 matching = 1;
712 }
713 }
714
715 if (matching > 0 &&
716 streq_ptr(c->x11_model, a[2])) {
717 matching++;
718
719 if (streq_ptr(c->x11_variant, a[3])) {
720 matching++;
721
722 if (streq_ptr(c->x11_options, a[4]))
723 matching++;
724 }
725 }
726
727 /* The best matching entry so far, then let's save that */
728 if (matching > best_matching) {
729 best_matching = matching;
730
731 free(*new_keymap);
732 *new_keymap = strdup(a[0]);
733 if (!*new_keymap)
734 return -ENOMEM;
735 }
736 }
737
738 return 0;
739 }
740
741 static int x11_convert_to_vconsole(Context *c, sd_bus *bus) {
742 bool modified = false;
743 int r;
744
745 assert(bus);
746
747 if (isempty(c->x11_layout)) {
748
749 modified =
750 !isempty(c->vc_keymap) ||
751 !isempty(c->vc_keymap_toggle);
752
753 context_free_x11(c);
754 } else {
755 char *new_keymap = NULL;
756
757 r = find_converted_keymap(c, &new_keymap);
758 if (r < 0)
759 return r;
760 else if (r == 0) {
761 r = find_legacy_keymap(c, &new_keymap);
762 if (r < 0)
763 return r;
764 }
765
766 if (!streq_ptr(c->vc_keymap, new_keymap)) {
767 free_and_replace(&c->vc_keymap, new_keymap);
768 free_and_replace(&c->vc_keymap_toggle, NULL);
769 modified = true;
770 } else
771 free(new_keymap);
772 }
773
774 if (modified) {
775 r = vconsole_write_data(c);
776 if (r < 0)
777 log_error("Failed to set virtual console keymap: %s", strerror(-r));
778
779 sd_bus_emit_properties_changed(bus,
780 "/org/freedesktop/locale1",
781 "org.freedesktop.locale1",
782 "VConsoleKeymap", "VConsoleKeymapToggle", NULL);
783
784 return vconsole_reload(bus);
785 }
786
787 return 0;
788 }
789
790 static int property_get_locale(sd_bus *bus, const char *path, const char *interface,
791 const char *property, sd_bus_message *reply, sd_bus_error *error, void *userdata) {
792 Context *c = userdata;
793 _cleanup_strv_free_ char **l = NULL;
794 int p, q;
795
796 l = new0(char*, _LOCALE_MAX+1);
797 if (!l)
798 return -ENOMEM;
799
800 for (p = 0, q = 0; p < _LOCALE_MAX; p++) {
801 char *t;
802
803 if (isempty(c->locale[p]))
804 continue;
805
806 if (asprintf(&t, "%s=%s", names[p], c->locale[p]) < 0)
807 return -ENOMEM;
808
809 l[q++] = t;
810 }
811
812 return sd_bus_message_append_strv(reply, l);
813 }
814
815 static int method_set_locale(sd_bus *bus, sd_bus_message *m, void *userdata) {
816 Context *c = userdata;
817 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
818 _cleanup_strv_free_ char **l = NULL;
819 char **i;
820 int interactive;
821 bool modified = false;
822 bool passed[_LOCALE_MAX] = {};
823 int p;
824 int r;
825
826 r = bus_message_read_strv_extend(m, &l);
827 if (r < 0)
828 return sd_bus_reply_method_errno(m, r, NULL);
829
830 r = sd_bus_message_read_basic(m, 'b', &interactive);
831 if (r < 0)
832 return sd_bus_reply_method_errno(m, r, NULL);
833
834 /* Check whether a variable changed and if so valid */
835 STRV_FOREACH(i, l) {
836 bool valid = false;
837
838 for (p = 0; p < _LOCALE_MAX; p++) {
839 size_t k;
840
841 k = strlen(names[p]);
842 if (startswith(*i, names[p]) &&
843 (*i)[k] == '=' &&
844 string_is_safe((*i) + k + 1)) {
845 valid = true;
846 passed[p] = true;
847
848 if (!streq_ptr(*i + k + 1, c->locale[p]))
849 modified = true;
850
851 break;
852 }
853 }
854
855 if (!valid)
856 sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INVALID_ARGS, "Invalid Locale data.");
857 }
858
859 /* Check whether a variable is unset */
860 if (!modified) {
861 for (p = 0; p < _LOCALE_MAX; p++)
862 if (!isempty(c->locale[p]) && !passed[p]) {
863 modified = true;
864 break;
865 }
866 }
867
868 if (modified) {
869 r = bus_verify_polkit_async(bus, &c->polkit_registry, m,
870 "org.freedesktop.locale1.set-locale", interactive,
871 &error, method_set_locale, c);
872 if (r < 0)
873 return sd_bus_reply_method_errno(m, r, &error);
874 if (r == 0)
875 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
876
877 STRV_FOREACH(i, l) {
878 for (p = 0; p < _LOCALE_MAX; p++) {
879 size_t k;
880
881 k = strlen(names[p]);
882 if (startswith(*i, names[p]) && (*i)[k] == '=') {
883 char *t;
884
885 t = strdup(*i + k + 1);
886 if (!t)
887 return -ENOMEM;
888
889 free(c->locale[p]);
890 c->locale[p] = t;
891 break;
892 }
893 }
894 }
895
896 for (p = 0; p < _LOCALE_MAX; p++) {
897 if (passed[p])
898 continue;
899
900 free_and_replace(&c->locale[p], NULL);
901 }
902
903 locale_simplify(c);
904
905 r = locale_write_data(c);
906 if (r < 0) {
907 log_error("Failed to set locale: %s", strerror(-r));
908 return sd_bus_reply_method_errnof(m, r, "Failed to set locale: %s", strerror(-r));
909 }
910
911 locale_update_system_manager(c, bus);
912
913 log_info("Changed locale information.");
914
915 sd_bus_emit_properties_changed(bus,
916 "/org/freedesktop/locale1",
917 "org.freedesktop.locale1",
918 "Locale", NULL);
919 }
920
921 return sd_bus_reply_method_return(m, NULL);
922 }
923
924 static int method_set_vc_keyboard(sd_bus *bus, sd_bus_message *m, void *userdata) {
925 Context *c = userdata;
926 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
927 const char *keymap, *keymap_toggle;
928 int convert, interactive;
929 int r;
930
931 r = sd_bus_message_read(m, "ssbb", &keymap, &keymap_toggle, &convert, &interactive);
932 if (r < 0)
933 return sd_bus_reply_method_errno(m, r, NULL);
934
935 if (isempty(keymap))
936 keymap = NULL;
937
938 if (isempty(keymap_toggle))
939 keymap_toggle = NULL;
940
941 if (!streq_ptr(keymap, c->vc_keymap) ||
942 !streq_ptr(keymap_toggle, c->vc_keymap_toggle)) {
943
944 if ((keymap && (!filename_is_safe(keymap) || !string_is_safe(keymap))) ||
945 (keymap_toggle && (!filename_is_safe(keymap_toggle) || !string_is_safe(keymap_toggle))))
946 return sd_bus_reply_method_errnof(m, r, "Received invalid keymap data: %s", -EINVAL);
947
948 r = bus_verify_polkit_async(bus, &c->polkit_registry, m,
949 "org.freedesktop.locale1.set-keyboard",
950 interactive, &error, method_set_vc_keyboard, c);
951 if (r < 0)
952 return sd_bus_reply_method_errno(m, r, &error);
953 if (r == 0)
954 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
955
956 if (free_and_copy(&c->vc_keymap, keymap) < 0 ||
957 free_and_copy(&c->vc_keymap_toggle, keymap_toggle) < 0)
958 return -ENOMEM;
959
960 r = vconsole_write_data(c);
961 if (r < 0) {
962 log_error("Failed to set virtual console keymap: %s", strerror(-r));
963 return sd_bus_reply_method_errnof(m, r, "Failed to set virtual console keymap: %s", strerror(-r));
964 }
965
966 log_info("Changed virtual console keymap to '%s'", strempty(c->vc_keymap));
967
968 r = vconsole_reload(bus);
969 if (r < 0)
970 log_error("Failed to request keymap reload: %s", strerror(-r));
971
972 sd_bus_emit_properties_changed(bus,
973 "/org/freedesktop/locale1",
974 "org.freedesktop.locale1",
975 "VConsoleKeymap", "VConsoleKeymapToggle", NULL);
976
977 if (convert) {
978 r = vconsole_convert_to_x11(c, bus);
979 if (r < 0)
980 log_error("Failed to convert keymap data: %s", strerror(-r));
981 }
982 }
983
984 return sd_bus_reply_method_return(m, NULL);
985 }
986
987 static int method_set_x11_keyboard(sd_bus *bus, sd_bus_message *m, void *userdata) {
988 Context *c = userdata;
989 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
990 const char *layout, *model, *variant, *options;
991 int convert, interactive;
992 int r;
993
994 r = sd_bus_message_read(m, "ssssbb", &layout, &model, &variant, &options, &convert, &interactive);
995 if (r < 0)
996 return sd_bus_reply_method_errno(m, r, NULL);
997
998 if (isempty(layout))
999 layout = NULL;
1000
1001 if (isempty(model))
1002 model = NULL;
1003
1004 if (isempty(variant))
1005 variant = NULL;
1006
1007 if (isempty(options))
1008 options = NULL;
1009
1010 if (!streq_ptr(layout, c->x11_layout) ||
1011 !streq_ptr(model, c->x11_model) ||
1012 !streq_ptr(variant, c->x11_variant) ||
1013 !streq_ptr(options, c->x11_options)) {
1014
1015 if ((layout && !string_is_safe(layout)) ||
1016 (model && !string_is_safe(model)) ||
1017 (variant && !string_is_safe(variant)) ||
1018 (options && !string_is_safe(options)))
1019 return sd_bus_reply_method_errnof(m, r, "Received invalid keyboard data: %s", -EINVAL);
1020
1021 r = bus_verify_polkit_async(bus, &c->polkit_registry, m,
1022 "org.freedesktop.locale1.set-keyboard",
1023 interactive, &error, method_set_x11_keyboard, c);
1024 if (r < 0)
1025 return sd_bus_reply_method_errno(m, r, &error);
1026 if (r == 0)
1027 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1028
1029 if (free_and_copy(&c->x11_layout, layout) < 0 ||
1030 free_and_copy(&c->x11_model, model) < 0 ||
1031 free_and_copy(&c->x11_variant, variant) < 0 ||
1032 free_and_copy(&c->x11_options, options) < 0)
1033 return -ENOMEM;
1034
1035 r = write_data_x11(c);
1036 if (r < 0) {
1037 log_error("Failed to set X11 keyboard layout: %s", strerror(-r));
1038 return sd_bus_reply_method_errnof(m, r, "Failed to set X11 keyboard layout: %s", strerror(-r));
1039 }
1040
1041 log_info("Changed X11 keyboard layout to '%s'", strempty(c->x11_layout));
1042
1043 sd_bus_emit_properties_changed(bus,
1044 "/org/freedesktop/locale1",
1045 "org.freedesktop.locale1",
1046 "X11Layout" "X11Model" "X11Variant" "X11Options", NULL);
1047
1048 if (convert) {
1049 r = x11_convert_to_vconsole(c, bus);
1050 if (r < 0)
1051 log_error("Failed to convert keymap data: %s", strerror(-r));
1052 }
1053 }
1054
1055 return sd_bus_reply_method_return(m, NULL);
1056 }
1057
1058 static const sd_bus_vtable locale_vtable[] = {
1059 SD_BUS_VTABLE_START(0),
1060 SD_BUS_PROPERTY("Locale", "as", property_get_locale, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
1061 SD_BUS_PROPERTY("X11Layout", "s", NULL, offsetof(Context, x11_layout), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
1062 SD_BUS_PROPERTY("X11Model", "s", NULL, offsetof(Context, x11_model), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
1063 SD_BUS_PROPERTY("X11Variant", "s", NULL, offsetof(Context, x11_variant), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
1064 SD_BUS_PROPERTY("X11Options", "s", NULL, offsetof(Context, x11_options), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
1065 SD_BUS_PROPERTY("VConsoleKeymap", "s", NULL, offsetof(Context, vc_keymap), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
1066 SD_BUS_PROPERTY("VConsoleKeymapToggle", "s", NULL, offsetof(Context, vc_keymap_toggle), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
1067 SD_BUS_METHOD("SetLocale", "asb", NULL, method_set_locale, 0),
1068 SD_BUS_METHOD("SetVConsoleKeyboard", "ssbb", NULL, method_set_vc_keyboard, 0),
1069 SD_BUS_METHOD("SetX11Keyboard", "ssssbb", NULL, method_set_x11_keyboard, 0),
1070 SD_BUS_VTABLE_END
1071 };
1072
1073 static int connect_bus(Context *c, sd_event *event, sd_bus **_bus) {
1074 _cleanup_bus_unref_ sd_bus *bus = NULL;
1075 int r;
1076
1077 assert(c);
1078 assert(event);
1079 assert(_bus);
1080
1081 r = sd_bus_default_system(&bus);
1082 if (r < 0) {
1083 log_error("Failed to get system bus connection: %s", strerror(-r));
1084 return r;
1085 }
1086
1087 r = sd_bus_add_object_vtable(bus, "/org/freedesktop/locale1", "org.freedesktop.locale1", locale_vtable, c);
1088 if (r < 0) {
1089 log_error("Failed to register object: %s", strerror(-r));
1090 return r;
1091 }
1092
1093 r = sd_bus_request_name(bus, "org.freedesktop.locale1", SD_BUS_NAME_DO_NOT_QUEUE);
1094 if (r < 0) {
1095 log_error("Failed to register name: %s", strerror(-r));
1096 return r;
1097 }
1098
1099 if (r != SD_BUS_NAME_PRIMARY_OWNER) {
1100 log_error("Failed to acquire name.");
1101 return -EEXIST;
1102 }
1103
1104 r = sd_bus_attach_event(bus, event, 0);
1105 if (r < 0) {
1106 log_error("Failed to attach bus to event loop: %s", strerror(-r));
1107 return r;
1108 }
1109
1110 *_bus = bus;
1111 bus = NULL;
1112
1113 return 0;
1114 }
1115
1116 int main(int argc, char *argv[]) {
1117 Context context = {};
1118 _cleanup_event_unref_ sd_event *event = NULL;
1119 _cleanup_bus_unref_ sd_bus *bus = NULL;
1120 int r;
1121
1122 log_set_target(LOG_TARGET_AUTO);
1123 log_parse_environment();
1124 log_open();
1125
1126 umask(0022);
1127 label_init("/etc");
1128
1129 if (argc != 1) {
1130 log_error("This program takes no arguments.");
1131 r = -EINVAL;
1132 goto finish;
1133 }
1134
1135 r = sd_event_default(&event);
1136 if (r < 0) {
1137 log_error("Failed to allocate event loop: %s", strerror(-r));
1138 goto finish;
1139 }
1140
1141 r = connect_bus(&context, event, &bus);
1142 if (r < 0)
1143 goto finish;
1144
1145 r = context_read_data(&context);
1146 if (r < 0) {
1147 log_error("Failed to read locale data: %s", strerror(-r));
1148 goto finish;
1149 }
1150
1151 r = bus_event_loop_with_idle(event, bus, "org.freedesktop.locale1", DEFAULT_EXIT_USEC);
1152 if (r < 0) {
1153 log_error("Failed to run event loop: %s", strerror(-r));
1154 goto finish;
1155 }
1156
1157 r = 0;
1158
1159 finish:
1160 context_free(&context, bus);
1161
1162 return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
1163 }
Unnamed repository; edit this file 'description' to name the repository.