chiark / gitweb /
systemctl: try to reload daemon after enable/disable only when not running in a chroot
[elogind.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
8   systemd is free software; you can redistribute it and/or modify it
9   under the terms of the GNU Lesser General Public License as published by
10   the Free Software Foundation; either version 2.1 of the License, or
11   (at your option) any later version.
12
13   systemd is distributed in the hope that it will be useful, but
14   WITHOUT ANY WARRANTY; without even the implied warranty of
15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16   Lesser General Public License for more details.
17
18   You should have received a copy of the GNU Lesser General Public License
19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <dbus/dbus.h>
23
24 #include <errno.h>
25 #include <string.h>
26 #include <unistd.h>
27
28 #include "util.h"
29 #include "mkdir.h"
30 #include "strv.h"
31 #include "dbus-common.h"
32 #include "polkit.h"
33 #include "def.h"
34 #include "env-util.h"
35 #include "fileio.h"
36 #include "fileio-label.h"
37 #include "label.h"
38
39 #define INTERFACE                                                       \
40         " <interface name=\"org.freedesktop.locale1\">\n"               \
41         "  <property name=\"Locale\" type=\"as\" access=\"read\"/>\n"   \
42         "  <property name=\"VConsoleKeymap\" type=\"s\" access=\"read\"/>\n" \
43         "  <property name=\"VConsoleKeymapToggle\" type=\"s\" access=\"read\"/>\n" \
44         "  <property name=\"X11Layout\" type=\"s\" access=\"read\"/>\n" \
45         "  <property name=\"X11Model\" type=\"s\" access=\"read\"/>\n"  \
46         "  <property name=\"X11Variant\" type=\"s\" access=\"read\"/>\n" \
47         "  <property name=\"X11Options\" type=\"s\" access=\"read\"/>\n" \
48         "  <method name=\"SetLocale\">\n"                               \
49         "   <arg name=\"locale\" type=\"as\" direction=\"in\"/>\n"      \
50         "   <arg name=\"user_interaction\" type=\"b\" direction=\"in\"/>\n" \
51         "  </method>\n"                                                 \
52         "  <method name=\"SetVConsoleKeyboard\">\n"                      \
53         "   <arg name=\"keymap\" type=\"s\" direction=\"in\"/>\n"       \
54         "   <arg name=\"keymap_toggle\" type=\"s\" direction=\"in\"/>\n" \
55         "   <arg name=\"convert\" type=\"b\" direction=\"in\"/>\n"      \
56         "   <arg name=\"user_interaction\" type=\"b\" direction=\"in\"/>\n" \
57         "  </method>\n"                                                 \
58         "  <method name=\"SetX11Keyboard\">\n"                          \
59         "   <arg name=\"layout\" type=\"s\" direction=\"in\"/>\n"       \
60         "   <arg name=\"model\" type=\"s\" direction=\"in\"/>\n"        \
61         "   <arg name=\"variant\" type=\"s\" direction=\"in\"/>\n"      \
62         "   <arg name=\"options\" type=\"s\" direction=\"in\"/>\n"      \
63         "   <arg name=\"convert\" type=\"b\" direction=\"in\"/>\n"      \
64         "   <arg name=\"user_interaction\" type=\"b\" direction=\"in\"/>\n" \
65         "  </method>\n"                                                 \
66         " </interface>\n"
67
68 #define INTROSPECTION                                                   \
69         DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE                       \
70         "<node>\n"                                                      \
71         INTERFACE                                                       \
72         BUS_PROPERTIES_INTERFACE                                        \
73         BUS_INTROSPECTABLE_INTERFACE                                    \
74         BUS_PEER_INTERFACE                                              \
75         "</node>\n"
76
77 #define INTERFACES_LIST                         \
78         BUS_GENERIC_INTERFACES_LIST             \
79         "org.freedesktop.locale1\0"
80
81 const char locale_interface[] _introspect_("locale1") = INTERFACE;
82
83 enum {
84         /* We don't list LC_ALL here on purpose. People should be
85          * using LANG instead. */
86
87         PROP_LANG,
88         PROP_LANGUAGE,
89         PROP_LC_CTYPE,
90         PROP_LC_NUMERIC,
91         PROP_LC_TIME,
92         PROP_LC_COLLATE,
93         PROP_LC_MONETARY,
94         PROP_LC_MESSAGES,
95         PROP_LC_PAPER,
96         PROP_LC_NAME,
97         PROP_LC_ADDRESS,
98         PROP_LC_TELEPHONE,
99         PROP_LC_MEASUREMENT,
100         PROP_LC_IDENTIFICATION,
101         _PROP_MAX
102 };
103
104 static const char * const names[_PROP_MAX] = {
105         [PROP_LANG] = "LANG",
106         [PROP_LANGUAGE] = "LANGUAGE",
107         [PROP_LC_CTYPE] = "LC_CTYPE",
108         [PROP_LC_NUMERIC] = "LC_NUMERIC",
109         [PROP_LC_TIME] = "LC_TIME",
110         [PROP_LC_COLLATE] = "LC_COLLATE",
111         [PROP_LC_MONETARY] = "LC_MONETARY",
112         [PROP_LC_MESSAGES] = "LC_MESSAGES",
113         [PROP_LC_PAPER] = "LC_PAPER",
114         [PROP_LC_NAME] = "LC_NAME",
115         [PROP_LC_ADDRESS] = "LC_ADDRESS",
116         [PROP_LC_TELEPHONE] = "LC_TELEPHONE",
117         [PROP_LC_MEASUREMENT] = "LC_MEASUREMENT",
118         [PROP_LC_IDENTIFICATION] = "LC_IDENTIFICATION"
119 };
120
121 static char *data[_PROP_MAX] = {
122         NULL,
123         NULL,
124         NULL,
125         NULL,
126         NULL,
127         NULL,
128         NULL,
129         NULL,
130         NULL,
131         NULL,
132         NULL,
133         NULL,
134         NULL
135 };
136
137 typedef struct State {
138         char *x11_layout, *x11_model, *x11_variant, *x11_options;
139         char *vc_keymap, *vc_keymap_toggle;
140 } State;
141
142 static State state;
143
144 static usec_t remain_until = 0;
145
146 static int free_and_set(char **s, const char *v) {
147         int r;
148         char *t;
149
150         assert(s);
151
152         r = strdup_or_null(isempty(v) ? NULL : v, &t);
153         if (r < 0)
154                 return r;
155
156         free(*s);
157         *s = t;
158
159         return 0;
160 }
161
162 static void free_data_locale(void) {
163         int p;
164
165         for (p = 0; p < _PROP_MAX; p++) {
166                 free(data[p]);
167                 data[p] = NULL;
168         }
169 }
170
171 static void free_data_x11(void) {
172         free(state.x11_layout);
173         free(state.x11_model);
174         free(state.x11_variant);
175         free(state.x11_options);
176
177         state.x11_layout = state.x11_model = state.x11_variant = state.x11_options = NULL;
178 }
179
180 static void free_data_vconsole(void) {
181         free(state.vc_keymap);
182         free(state.vc_keymap_toggle);
183
184         state.vc_keymap = state.vc_keymap_toggle = NULL;
185 }
186
187 static void simplify(void) {
188         int p;
189
190         for (p = 1; p < _PROP_MAX; p++)
191                 if (isempty(data[p]) || streq_ptr(data[PROP_LANG], data[p])) {
192                         free(data[p]);
193                         data[p] = NULL;
194                 }
195 }
196
197 static int read_data_locale(void) {
198         int r;
199
200         free_data_locale();
201
202         r = parse_env_file("/etc/locale.conf", NEWLINE,
203                            "LANG",              &data[PROP_LANG],
204                            "LANGUAGE",          &data[PROP_LANGUAGE],
205                            "LC_CTYPE",          &data[PROP_LC_CTYPE],
206                            "LC_NUMERIC",        &data[PROP_LC_NUMERIC],
207                            "LC_TIME",           &data[PROP_LC_TIME],
208                            "LC_COLLATE",        &data[PROP_LC_COLLATE],
209                            "LC_MONETARY",       &data[PROP_LC_MONETARY],
210                            "LC_MESSAGES",       &data[PROP_LC_MESSAGES],
211                            "LC_PAPER",          &data[PROP_LC_PAPER],
212                            "LC_NAME",           &data[PROP_LC_NAME],
213                            "LC_ADDRESS",        &data[PROP_LC_ADDRESS],
214                            "LC_TELEPHONE",      &data[PROP_LC_TELEPHONE],
215                            "LC_MEASUREMENT",    &data[PROP_LC_MEASUREMENT],
216                            "LC_IDENTIFICATION", &data[PROP_LC_IDENTIFICATION],
217                            NULL);
218
219         if (r == -ENOENT) {
220                 int p;
221
222                 /* Fill in what we got passed from systemd. */
223
224                 for (p = 0; p < _PROP_MAX; p++) {
225                         char *e, *d;
226
227                         assert(names[p]);
228
229                         e = getenv(names[p]);
230                         if (e) {
231                                 d = strdup(e);
232                                 if (!d)
233                                         return -ENOMEM;
234                         } else
235                                 d = NULL;
236
237                         free(data[p]);
238                         data[p] = d;
239                 }
240
241                 r = 0;
242         }
243
244         simplify();
245         return r;
246 }
247
248 static void free_data(void) {
249         free_data_locale();
250         free_data_vconsole();
251         free_data_x11();
252 }
253
254 static int read_data_vconsole(void) {
255         int r;
256
257         free_data_vconsole();
258
259         r = parse_env_file("/etc/vconsole.conf", NEWLINE,
260                            "KEYMAP",        &state.vc_keymap,
261                            "KEYMAP_TOGGLE", &state.vc_keymap_toggle,
262                            NULL);
263
264         if (r < 0 && r != -ENOENT)
265                 return r;
266
267         return 0;
268 }
269
270 static int read_data_x11(void) {
271         FILE *f;
272         char line[LINE_MAX];
273         bool in_section = false;
274
275         free_data_x11();
276
277         f = fopen("/etc/X11/xorg.conf.d/00-keyboard.conf", "re");
278         if (!f)
279                 return errno == ENOENT ? 0 : -errno;
280
281         while (fgets(line, sizeof(line), f)) {
282                 char *l;
283
284                 char_array_0(line);
285                 l = strstrip(line);
286
287                 if (l[0] == 0 || l[0] == '#')
288                         continue;
289
290                 if (in_section && first_word(l, "Option")) {
291                         char **a;
292
293                         a = strv_split_quoted(l);
294                         if (!a) {
295                                 fclose(f);
296                                 return -ENOMEM;
297                         }
298
299                         if (strv_length(a) == 3) {
300
301                                 if (streq(a[1], "XkbLayout")) {
302                                         free(state.x11_layout);
303                                         state.x11_layout = a[2];
304                                         a[2] = NULL;
305                                 } else if (streq(a[1], "XkbModel")) {
306                                         free(state.x11_model);
307                                         state.x11_model = a[2];
308                                         a[2] = NULL;
309                                 } else if (streq(a[1], "XkbVariant")) {
310                                         free(state.x11_variant);
311                                         state.x11_variant = a[2];
312                                         a[2] = NULL;
313                                 } else if (streq(a[1], "XkbOptions")) {
314                                         free(state.x11_options);
315                                         state.x11_options = a[2];
316                                         a[2] = NULL;
317                                 }
318                         }
319
320                         strv_free(a);
321
322                 } else if (!in_section && first_word(l, "Section")) {
323                         char **a;
324
325                         a = strv_split_quoted(l);
326                         if (!a) {
327                                 fclose(f);
328                                 return -ENOMEM;
329                         }
330
331                         if (strv_length(a) == 2 && streq(a[1], "InputClass"))
332                                 in_section = true;
333
334                         strv_free(a);
335                 } else if (in_section && first_word(l, "EndSection"))
336                         in_section = false;
337         }
338
339         fclose(f);
340
341         return 0;
342 }
343
344 static int read_data(void) {
345         int r, q, p;
346
347         r = read_data_locale();
348         q = read_data_vconsole();
349         p = read_data_x11();
350
351         return r < 0 ? r : q < 0 ? q : p;
352 }
353
354 static int write_data_locale(void) {
355         int r, p;
356         char **l = NULL;
357
358         r = load_env_file("/etc/locale.conf", &l);
359         if (r < 0 && r != -ENOENT)
360                 return r;
361
362         for (p = 0; p < _PROP_MAX; p++) {
363                 char *t, **u;
364
365                 assert(names[p]);
366
367                 if (isempty(data[p])) {
368                         l = strv_env_unset(l, names[p]);
369                         continue;
370                 }
371
372                 if (asprintf(&t, "%s=%s", names[p], data[p]) < 0) {
373                         strv_free(l);
374                         return -ENOMEM;
375                 }
376
377                 u = strv_env_set(l, t);
378                 free(t);
379                 strv_free(l);
380
381                 if (!u)
382                         return -ENOMEM;
383
384                 l = u;
385         }
386
387         if (strv_isempty(l)) {
388                 strv_free(l);
389
390                 if (unlink("/etc/locale.conf") < 0)
391                         return errno == ENOENT ? 0 : -errno;
392
393                 return 0;
394         }
395
396         r = write_env_file_label("/etc/locale.conf", l);
397         strv_free(l);
398
399         return r;
400 }
401
402 static void push_data(DBusConnection *bus) {
403         char **l_set = NULL, **l_unset = NULL, **t;
404         int c_set = 0, c_unset = 0, p;
405         DBusError error;
406         DBusMessage *m = NULL, *reply = NULL;
407         DBusMessageIter iter, sub;
408
409         dbus_error_init(&error);
410
411         assert(bus);
412
413         l_set = new0(char*, _PROP_MAX);
414         l_unset = new0(char*, _PROP_MAX);
415         if (!l_set || !l_unset) {
416                 log_oom();
417                 goto finish;
418         }
419
420         for (p = 0; p < _PROP_MAX; p++) {
421                 assert(names[p]);
422
423                 if (isempty(data[p]))
424                         l_unset[c_set++] = (char*) names[p];
425                 else {
426                         char *s;
427
428                         if (asprintf(&s, "%s=%s", names[p], data[p]) < 0) {
429                                 log_oom();
430                                 goto finish;
431                         }
432
433                         l_set[c_unset++] = s;
434                 }
435         }
436
437         assert(c_set + c_unset == _PROP_MAX);
438         m = dbus_message_new_method_call("org.freedesktop.systemd1", "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "UnsetAndSetEnvironment");
439         if (!m) {
440                 log_error("Could not allocate message.");
441                 goto finish;
442         }
443
444         dbus_message_iter_init_append(m, &iter);
445
446         if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "s", &sub)) {
447                 log_oom();
448                 goto finish;
449         }
450
451         STRV_FOREACH(t, l_unset)
452                 if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, t)) {
453                         log_oom();
454                         goto finish;
455                 }
456
457         if (!dbus_message_iter_close_container(&iter, &sub) ||
458             !dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "s", &sub)) {
459                 log_oom();
460                 goto finish;
461         }
462
463         STRV_FOREACH(t, l_set)
464                 if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, t)) {
465                         log_oom();
466                         goto finish;
467                 }
468
469         if (!dbus_message_iter_close_container(&iter, &sub)) {
470                 log_oom();
471                 goto finish;
472         }
473
474         reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error);
475         if (!reply) {
476                 log_error("Failed to set locale information: %s", bus_error_message(&error));
477                 goto finish;
478         }
479
480 finish:
481         if (m)
482                 dbus_message_unref(m);
483
484         if (reply)
485                 dbus_message_unref(reply);
486
487         dbus_error_free(&error);
488
489         strv_free(l_set);
490         free(l_unset);
491 }
492
493 static int write_data_vconsole(void) {
494         int r;
495         char **l = NULL;
496
497         r = load_env_file("/etc/vconsole.conf", &l);
498         if (r < 0 && r != -ENOENT)
499                 return r;
500
501         if (isempty(state.vc_keymap))
502                 l = strv_env_unset(l, "KEYMAP");
503         else {
504                 char *s, **u;
505
506                 s = strappend("KEYMAP=", state.vc_keymap);
507                 if (!s) {
508                         strv_free(l);
509                         return -ENOMEM;
510                 }
511
512                 u = strv_env_set(l, s);
513                 free(s);
514                 strv_free(l);
515
516                 if (!u)
517                         return -ENOMEM;
518
519                 l = u;
520         }
521
522         if (isempty(state.vc_keymap_toggle))
523                 l = strv_env_unset(l, "KEYMAP_TOGGLE");
524         else  {
525                 char *s, **u;
526
527                 s = strappend("KEYMAP_TOGGLE=", state.vc_keymap_toggle);
528                 if (!s) {
529                         strv_free(l);
530                         return -ENOMEM;
531                 }
532
533                 u = strv_env_set(l, s);
534                 free(s);
535                 strv_free(l);
536
537                 if (!u)
538                         return -ENOMEM;
539
540                 l = u;
541         }
542
543         if (strv_isempty(l)) {
544                 strv_free(l);
545
546                 if (unlink("/etc/vconsole.conf") < 0)
547                         return errno == ENOENT ? 0 : -errno;
548
549                 return 0;
550         }
551
552         r = write_env_file_label("/etc/vconsole.conf", l);
553         strv_free(l);
554
555         return r;
556 }
557
558 static int write_data_x11(void) {
559         FILE *f;
560         char *temp_path;
561         int r;
562
563         if (isempty(state.x11_layout) &&
564             isempty(state.x11_model) &&
565             isempty(state.x11_variant) &&
566             isempty(state.x11_options)) {
567
568                 if (unlink("/etc/X11/xorg.conf.d/00-keyboard.conf") < 0)
569                         return errno == ENOENT ? 0 : -errno;
570
571                 return 0;
572         }
573
574         mkdir_p_label("/etc/X11/xorg.conf.d", 0755);
575
576         r = fopen_temporary("/etc/X11/xorg.conf.d/00-keyboard.conf", &f, &temp_path);
577         if (r < 0)
578                 return r;
579
580         fchmod(fileno(f), 0644);
581
582         fputs("# Read and parsed by systemd-localed. It's probably wise not to edit this file\n"
583               "# manually too freely.\n"
584               "Section \"InputClass\"\n"
585               "        Identifier \"system-keyboard\"\n"
586               "        MatchIsKeyboard \"on\"\n", f);
587
588         if (!isempty(state.x11_layout))
589                 fprintf(f, "        Option \"XkbLayout\" \"%s\"\n", state.x11_layout);
590
591         if (!isempty(state.x11_model))
592                 fprintf(f, "        Option \"XkbModel\" \"%s\"\n", state.x11_model);
593
594         if (!isempty(state.x11_variant))
595                 fprintf(f, "        Option \"XkbVariant\" \"%s\"\n", state.x11_variant);
596
597         if (!isempty(state.x11_options))
598                 fprintf(f, "        Option \"XkbOptions\" \"%s\"\n", state.x11_options);
599
600         fputs("EndSection\n", f);
601         fflush(f);
602
603         if (ferror(f) || rename(temp_path, "/etc/X11/xorg.conf.d/00-keyboard.conf") < 0) {
604                 r = -errno;
605                 unlink("/etc/X11/xorg.conf.d/00-keyboard.conf");
606                 unlink(temp_path);
607         } else
608                 r = 0;
609
610         fclose(f);
611         free(temp_path);
612
613         return r;
614 }
615
616 static int load_vconsole_keymap(DBusConnection *bus, DBusError *error) {
617         DBusMessage *m = NULL, *reply = NULL;
618         const char *name = "systemd-vconsole-setup.service", *mode = "replace";
619         int r;
620         DBusError _error;
621
622         assert(bus);
623
624         if (!error) {
625                 dbus_error_init(&_error);
626                 error = &_error;
627         }
628
629         m = dbus_message_new_method_call(
630                         "org.freedesktop.systemd1",
631                         "/org/freedesktop/systemd1",
632                         "org.freedesktop.systemd1.Manager",
633                         "RestartUnit");
634         if (!m) {
635                 log_error("Could not allocate message.");
636                 r = -ENOMEM;
637                 goto finish;
638         }
639
640         if (!dbus_message_append_args(m,
641                                       DBUS_TYPE_STRING, &name,
642                                       DBUS_TYPE_STRING, &mode,
643                                       DBUS_TYPE_INVALID)) {
644                 log_error("Could not append arguments to message.");
645                 r = -ENOMEM;
646                 goto finish;
647         }
648
649         reply = dbus_connection_send_with_reply_and_block(bus, m, -1, error);
650         if (!reply) {
651                 log_error("Failed to issue method call: %s", bus_error_message(error));
652                 r = -EIO;
653                 goto finish;
654         }
655
656         r = 0;
657
658 finish:
659         if (m)
660                 dbus_message_unref(m);
661
662         if (reply)
663                 dbus_message_unref(reply);
664
665         if (error == &_error)
666                 dbus_error_free(error);
667
668         return r;
669 }
670
671 static char *strnulldash(const char *s) {
672         return s == NULL || *s == 0 || (s[0] == '-' && s[1] == 0) ? NULL : (char*) s;
673 }
674
675 static int read_next_mapping(FILE *f, unsigned *n, char ***a) {
676         assert(f);
677         assert(n);
678         assert(a);
679
680         for (;;) {
681                 char line[LINE_MAX];
682                 char *l, **b;
683
684                 errno = 0;
685                 if (!fgets(line, sizeof(line), f)) {
686
687                         if (ferror(f))
688                                 return errno ? -errno : -EIO;
689
690                         return 0;
691                 }
692
693                 (*n) ++;
694
695                 l = strstrip(line);
696                 if (l[0] == 0 || l[0] == '#')
697                         continue;
698
699                 b = strv_split_quoted(l);
700                 if (!b)
701                         return -ENOMEM;
702
703                 if (strv_length(b) < 5) {
704                         log_error("Invalid line "SYSTEMD_KBD_MODEL_MAP":%u, ignoring.", *n);
705                         strv_free(b);
706                         continue;
707
708                 }
709
710                 *a = b;
711                 return 1;
712         }
713 }
714
715 static int convert_vconsole_to_x11(DBusConnection *connection) {
716         bool modified = false;
717
718         assert(connection);
719
720         if (isempty(state.vc_keymap)) {
721
722                 modified =
723                         !isempty(state.x11_layout) ||
724                         !isempty(state.x11_model) ||
725                         !isempty(state.x11_variant) ||
726                         !isempty(state.x11_options);
727
728                 free_data_x11();
729         } else {
730                 FILE *f;
731                 unsigned n = 0;
732
733                 f = fopen(SYSTEMD_KBD_MODEL_MAP, "re");
734                 if (!f)
735                         return -errno;
736
737                 for (;;) {
738                         char **a;
739                         int r;
740
741                         r = read_next_mapping(f, &n, &a);
742                         if (r < 0) {
743                                 fclose(f);
744                                 return r;
745                         }
746
747                         if (r == 0)
748                                 break;
749
750                         if (!streq(state.vc_keymap, a[0])) {
751                                 strv_free(a);
752                                 continue;
753                         }
754
755                         if (!streq_ptr(state.x11_layout, strnulldash(a[1])) ||
756                             !streq_ptr(state.x11_model, strnulldash(a[2])) ||
757                             !streq_ptr(state.x11_variant, strnulldash(a[3])) ||
758                             !streq_ptr(state.x11_options, strnulldash(a[4]))) {
759
760                                 if (free_and_set(&state.x11_layout, strnulldash(a[1])) < 0 ||
761                                     free_and_set(&state.x11_model, strnulldash(a[2])) < 0 ||
762                                     free_and_set(&state.x11_variant, strnulldash(a[3])) < 0 ||
763                                     free_and_set(&state.x11_options, strnulldash(a[4])) < 0) {
764                                         strv_free(a);
765                                         fclose(f);
766                                         return -ENOMEM;
767                                 }
768
769                                 modified = true;
770                         }
771
772                         strv_free(a);
773                         break;
774                 }
775
776                 fclose(f);
777         }
778
779         if (modified) {
780                 dbus_bool_t b;
781                 DBusMessage *changed;
782                 int r;
783
784                 r = write_data_x11();
785                 if (r < 0)
786                         log_error("Failed to set X11 keyboard layout: %s", strerror(-r));
787
788                 changed = bus_properties_changed_new(
789                                 "/org/freedesktop/locale1",
790                                 "org.freedesktop.locale1",
791                                 "X11Layout\0"
792                                 "X11Model\0"
793                                 "X11Variant\0"
794                                 "X11Options\0");
795
796                 if (!changed)
797                         return -ENOMEM;
798
799                 b = dbus_connection_send(connection, changed, NULL);
800                 dbus_message_unref(changed);
801
802                 if (!b)
803                         return -ENOMEM;
804         }
805
806         return 0;
807 }
808
809 static int convert_x11_to_vconsole(DBusConnection *connection) {
810         bool modified = false;
811
812         assert(connection);
813
814         if (isempty(state.x11_layout)) {
815
816                 modified =
817                         !isempty(state.vc_keymap) ||
818                         !isempty(state.vc_keymap_toggle);
819
820                 free_data_x11();
821         } else {
822                 FILE *f;
823                 unsigned n = 0;
824                 unsigned best_matching = 0;
825                 char *new_keymap = NULL;
826
827                 f = fopen(SYSTEMD_KBD_MODEL_MAP, "re");
828                 if (!f)
829                         return -errno;
830
831                 for (;;) {
832                         char **a;
833                         unsigned matching = 0;
834                         int r;
835
836                         r = read_next_mapping(f, &n, &a);
837                         if (r < 0) {
838                                 fclose(f);
839                                 return r;
840                         }
841
842                         if (r == 0)
843                                 break;
844
845                         /* Determine how well matching this entry is */
846                         if (streq_ptr(state.x11_layout, a[1]))
847                                 /* If we got an exact match, this is best */
848                                 matching = 10;
849                         else {
850                                 size_t x;
851
852                                 x = strcspn(state.x11_layout, ",");
853
854                                 /* We have multiple X layouts, look
855                                  * for an entry that matches our key
856                                  * with the everything but the first
857                                  * layout stripped off. */
858                                 if (x > 0 &&
859                                     strlen(a[1]) == x &&
860                                     strneq(state.x11_layout, a[1], x))
861                                         matching = 5;
862                                 else  {
863                                         size_t w;
864
865                                         /* If that didn't work, strip
866                                          * off the other layouts from
867                                          * the entry, too */
868
869                                         w = strcspn(a[1], ",");
870
871                                         if (x > 0 && x == w &&
872                                             memcmp(state.x11_layout, a[1], x) == 0)
873                                                 matching = 1;
874                                 }
875                         }
876
877                         if (matching > 0 &&
878                             streq_ptr(state.x11_model, a[2])) {
879                                 matching++;
880
881                                 if (streq_ptr(state.x11_variant, a[3])) {
882                                         matching++;
883
884                                         if (streq_ptr(state.x11_options, a[4]))
885                                                 matching++;
886                                 }
887                         }
888
889                         /* The best matching entry so far, then let's
890                          * save that */
891                         if (matching > best_matching) {
892                                 best_matching = matching;
893
894                                 free(new_keymap);
895                                 new_keymap = strdup(a[0]);
896
897                                 if (!new_keymap) {
898                                         strv_free(a);
899                                         fclose(f);
900                                         return -ENOMEM;
901                                 }
902                         }
903
904                         strv_free(a);
905                 }
906
907                 fclose(f);
908
909                 if (!streq_ptr(state.vc_keymap, new_keymap)) {
910                         free(state.vc_keymap);
911                         state.vc_keymap = new_keymap;
912
913                         free(state.vc_keymap_toggle);
914                         state.vc_keymap_toggle = NULL;
915
916                         modified = true;
917                 } else
918                         free(new_keymap);
919         }
920
921         if (modified) {
922                 dbus_bool_t b;
923                 DBusMessage *changed;
924                 int r;
925
926                 r = write_data_vconsole();
927                 if (r < 0)
928                         log_error("Failed to set virtual console keymap: %s", strerror(-r));
929
930                 changed = bus_properties_changed_new(
931                                 "/org/freedesktop/locale1",
932                                 "org.freedesktop.locale1",
933                                 "VConsoleKeymap\0"
934                                 "VConsoleKeymapToggle\0");
935
936                 if (!changed)
937                         return -ENOMEM;
938
939                 b = dbus_connection_send(connection, changed, NULL);
940                 dbus_message_unref(changed);
941
942                 if (!b)
943                         return -ENOMEM;
944
945                 return load_vconsole_keymap(connection, NULL);
946         }
947
948         return 0;
949 }
950
951 static int append_locale(DBusMessageIter *i, const char *property, void *userdata) {
952         int r, c = 0, p;
953         char **l;
954
955         l = new0(char*, _PROP_MAX+1);
956         if (!l)
957                 return -ENOMEM;
958
959         for (p = 0; p < _PROP_MAX; p++) {
960                 char *t;
961
962                 if (isempty(data[p]))
963                         continue;
964
965                 if (asprintf(&t, "%s=%s", names[p], data[p]) < 0) {
966                         strv_free(l);
967                         return -ENOMEM;
968                 }
969
970                 l[c++] = t;
971         }
972
973         r = bus_property_append_strv(i, property, (void*) l);
974         strv_free(l);
975
976         return r;
977 }
978
979 static const BusProperty bus_locale_properties[] = {
980         { "Locale",               append_locale,             "as", 0 },
981         { "X11Layout",            bus_property_append_string, "s", offsetof(State, x11_layout),       true },
982         { "X11Model",             bus_property_append_string, "s", offsetof(State, x11_model),        true },
983         { "X11Variant",           bus_property_append_string, "s", offsetof(State, x11_variant),      true },
984         { "X11Options",           bus_property_append_string, "s", offsetof(State, x11_options),      true },
985         { "VConsoleKeymap",       bus_property_append_string, "s", offsetof(State, vc_keymap),        true },
986         { "VConsoleKeymapToggle", bus_property_append_string, "s", offsetof(State, vc_keymap_toggle), true },
987         { NULL, }
988 };
989
990 static const BusBoundProperties bps[] = {
991         { "org.freedesktop.locale1", bus_locale_properties, &state },
992         { NULL, }
993 };
994
995 static DBusHandlerResult locale_message_handler(
996                 DBusConnection *connection,
997                 DBusMessage *message,
998                 void *userdata) {
999
1000         DBusMessage *reply = NULL, *changed = NULL;
1001         DBusError error;
1002         int r;
1003
1004         assert(connection);
1005         assert(message);
1006
1007         dbus_error_init(&error);
1008
1009         if (dbus_message_is_method_call(message, "org.freedesktop.locale1", "SetLocale")) {
1010                 char **l = NULL, **i;
1011                 dbus_bool_t interactive;
1012                 DBusMessageIter iter;
1013                 bool modified = false;
1014                 bool passed[_PROP_MAX];
1015                 int p;
1016
1017                 if (!dbus_message_iter_init(message, &iter))
1018                         return bus_send_error_reply(connection, message, NULL, -EINVAL);
1019
1020                 r = bus_parse_strv_iter(&iter, &l);
1021                 if (r < 0) {
1022                         if (r == -ENOMEM)
1023                                 goto oom;
1024
1025                         return bus_send_error_reply(connection, message, NULL, r);
1026                 }
1027
1028                 if (!dbus_message_iter_next(&iter) ||
1029                     dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_BOOLEAN)  {
1030                         strv_free(l);
1031                         return bus_send_error_reply(connection, message, NULL, -EINVAL);
1032                 }
1033
1034                 dbus_message_iter_get_basic(&iter, &interactive);
1035
1036                 zero(passed);
1037
1038                 /* Check whether a variable changed and if so valid */
1039                 STRV_FOREACH(i, l) {
1040                         bool valid = false;
1041
1042                         for (p = 0; p < _PROP_MAX; p++) {
1043                                 size_t k;
1044
1045                                 k = strlen(names[p]);
1046                                 if (startswith(*i, names[p]) &&
1047                                     (*i)[k] == '=' &&
1048                                     string_is_safe((*i) + k + 1)) {
1049                                         valid = true;
1050                                         passed[p] = true;
1051
1052                                         if (!streq_ptr(*i + k + 1, data[p]))
1053                                                 modified = true;
1054
1055                                         break;
1056                                 }
1057                         }
1058
1059                         if (!valid) {
1060                                 strv_free(l);
1061                                 return bus_send_error_reply(connection, message, NULL, -EINVAL);
1062                         }
1063                 }
1064
1065                 /* Check whether a variable is unset */
1066                 if (!modified)  {
1067                         for (p = 0; p < _PROP_MAX; p++)
1068                                 if (!isempty(data[p]) && !passed[p]) {
1069                                         modified = true;
1070                                         break;
1071                                 }
1072                 }
1073
1074                 if (modified) {
1075
1076                         r = verify_polkit(connection, message, "org.freedesktop.locale1.set-locale", interactive, NULL, &error);
1077                         if (r < 0) {
1078                                 strv_free(l);
1079                                 return bus_send_error_reply(connection, message, &error, r);
1080                         }
1081
1082                         STRV_FOREACH(i, l) {
1083                                 for (p = 0; p < _PROP_MAX; p++) {
1084                                         size_t k;
1085
1086                                         k = strlen(names[p]);
1087                                         if (startswith(*i, names[p]) && (*i)[k] == '=') {
1088                                                 char *t;
1089
1090                                                 t = strdup(*i + k + 1);
1091                                                 if (!t) {
1092                                                         strv_free(l);
1093                                                         goto oom;
1094                                                 }
1095
1096                                                 free(data[p]);
1097                                                 data[p] = t;
1098
1099                                                 break;
1100                                         }
1101                                 }
1102                         }
1103
1104                         strv_free(l);
1105
1106                         for (p = 0; p < _PROP_MAX; p++) {
1107                                 if (passed[p])
1108                                         continue;
1109
1110                                 free(data[p]);
1111                                 data[p] = NULL;
1112                         }
1113
1114                         simplify();
1115
1116                         r = write_data_locale();
1117                         if (r < 0) {
1118                                 log_error("Failed to set locale: %s", strerror(-r));
1119                                 return bus_send_error_reply(connection, message, NULL, r);
1120                         }
1121
1122                         push_data(connection);
1123
1124                         log_info("Changed locale information.");
1125
1126                         changed = bus_properties_changed_new(
1127                                         "/org/freedesktop/locale1",
1128                                         "org.freedesktop.locale1",
1129                                         "Locale\0");
1130                         if (!changed)
1131                                 goto oom;
1132                 } else
1133                         strv_free(l);
1134
1135         } else if (dbus_message_is_method_call(message, "org.freedesktop.locale1", "SetVConsoleKeyboard")) {
1136
1137                 const char *keymap, *keymap_toggle;
1138                 dbus_bool_t convert, interactive;
1139
1140                 if (!dbus_message_get_args(
1141                                     message,
1142                                     &error,
1143                                     DBUS_TYPE_STRING, &keymap,
1144                                     DBUS_TYPE_STRING, &keymap_toggle,
1145                                     DBUS_TYPE_BOOLEAN, &convert,
1146                                     DBUS_TYPE_BOOLEAN, &interactive,
1147                                     DBUS_TYPE_INVALID))
1148                         return bus_send_error_reply(connection, message, &error, -EINVAL);
1149
1150                 if (isempty(keymap))
1151                         keymap = NULL;
1152
1153                 if (isempty(keymap_toggle))
1154                         keymap_toggle = NULL;
1155
1156                 if (!streq_ptr(keymap, state.vc_keymap) ||
1157                     !streq_ptr(keymap_toggle, state.vc_keymap_toggle)) {
1158
1159                         if ((keymap && (!filename_is_safe(keymap) || !string_is_safe(keymap))) ||
1160                             (keymap_toggle && (!filename_is_safe(keymap_toggle) || !string_is_safe(keymap_toggle))))
1161                                 return bus_send_error_reply(connection, message, NULL, -EINVAL);
1162
1163                         r = verify_polkit(connection, message, "org.freedesktop.locale1.set-keyboard", interactive, NULL, &error);
1164                         if (r < 0)
1165                                 return bus_send_error_reply(connection, message, &error, r);
1166
1167                         if (free_and_set(&state.vc_keymap, keymap) < 0 ||
1168                             free_and_set(&state.vc_keymap_toggle, keymap_toggle) < 0)
1169                                 goto oom;
1170
1171                         r = write_data_vconsole();
1172                         if (r < 0) {
1173                                 log_error("Failed to set virtual console keymap: %s", strerror(-r));
1174                                 return bus_send_error_reply(connection, message, NULL, r);
1175                         }
1176
1177                         log_info("Changed virtual console keymap to '%s'", strempty(state.vc_keymap));
1178
1179                         r = load_vconsole_keymap(connection, NULL);
1180                         if (r < 0)
1181                                 log_error("Failed to request keymap reload: %s", strerror(-r));
1182
1183                         changed = bus_properties_changed_new(
1184                                         "/org/freedesktop/locale1",
1185                                         "org.freedesktop.locale1",
1186                                         "VConsoleKeymap\0"
1187                                         "VConsoleKeymapToggle\0");
1188                         if (!changed)
1189                                 goto oom;
1190
1191                         if (convert) {
1192                                 r = convert_vconsole_to_x11(connection);
1193
1194                                 if (r < 0)
1195                                         log_error("Failed to convert keymap data: %s", strerror(-r));
1196                         }
1197                 }
1198
1199         } else if (dbus_message_is_method_call(message, "org.freedesktop.locale1", "SetX11Keyboard")) {
1200
1201                 const char *layout, *model, *variant, *options;
1202                 dbus_bool_t convert, interactive;
1203
1204                 if (!dbus_message_get_args(
1205                                     message,
1206                                     &error,
1207                                     DBUS_TYPE_STRING, &layout,
1208                                     DBUS_TYPE_STRING, &model,
1209                                     DBUS_TYPE_STRING, &variant,
1210                                     DBUS_TYPE_STRING, &options,
1211                                     DBUS_TYPE_BOOLEAN, &convert,
1212                                     DBUS_TYPE_BOOLEAN, &interactive,
1213                                     DBUS_TYPE_INVALID))
1214                         return bus_send_error_reply(connection, message, &error, -EINVAL);
1215
1216                 if (isempty(layout))
1217                         layout = NULL;
1218
1219                 if (isempty(model))
1220                         model = NULL;
1221
1222                 if (isempty(variant))
1223                         variant = NULL;
1224
1225                 if (isempty(options))
1226                         options = NULL;
1227
1228                 if (!streq_ptr(layout, state.x11_layout) ||
1229                     !streq_ptr(model, state.x11_model) ||
1230                     !streq_ptr(variant, state.x11_variant) ||
1231                     !streq_ptr(options, state.x11_options)) {
1232
1233                         if ((layout && !string_is_safe(layout)) ||
1234                             (model && !string_is_safe(model)) ||
1235                             (variant && !string_is_safe(variant)) ||
1236                             (options && !string_is_safe(options)))
1237                                 return bus_send_error_reply(connection, message, NULL, -EINVAL);
1238
1239                         r = verify_polkit(connection, message, "org.freedesktop.locale1.set-keyboard", interactive, NULL, &error);
1240                         if (r < 0)
1241                                 return bus_send_error_reply(connection, message, &error, r);
1242
1243                         if (free_and_set(&state.x11_layout, layout) < 0 ||
1244                             free_and_set(&state.x11_model, model) < 0 ||
1245                             free_and_set(&state.x11_variant, variant) < 0 ||
1246                             free_and_set(&state.x11_options, options) < 0)
1247                                 goto oom;
1248
1249                         r = write_data_x11();
1250                         if (r < 0) {
1251                                 log_error("Failed to set X11 keyboard layout: %s", strerror(-r));
1252                                 return bus_send_error_reply(connection, message, NULL, r);
1253                         }
1254
1255                         log_info("Changed X11 keyboard layout to '%s'", strempty(state.x11_layout));
1256
1257                         changed = bus_properties_changed_new(
1258                                         "/org/freedesktop/locale1",
1259                                         "org.freedesktop.locale1",
1260                                         "X11Layout\0"
1261                                         "X11Model\0"
1262                                         "X11Variant\0"
1263                                         "X11Options\0");
1264                         if (!changed)
1265                                 goto oom;
1266
1267                         if (convert) {
1268                                 r = convert_x11_to_vconsole(connection);
1269
1270                                 if (r < 0)
1271                                         log_error("Failed to convert keymap data: %s", strerror(-r));
1272                         }
1273                 }
1274         } else
1275                 return bus_default_message_handler(connection, message, INTROSPECTION, INTERFACES_LIST, bps);
1276
1277         if (!(reply = dbus_message_new_method_return(message)))
1278                 goto oom;
1279
1280         if (!dbus_connection_send(connection, reply, NULL))
1281                 goto oom;
1282
1283         dbus_message_unref(reply);
1284         reply = NULL;
1285
1286         if (changed) {
1287
1288                 if (!dbus_connection_send(connection, changed, NULL))
1289                         goto oom;
1290
1291                 dbus_message_unref(changed);
1292         }
1293
1294         return DBUS_HANDLER_RESULT_HANDLED;
1295
1296 oom:
1297         if (reply)
1298                 dbus_message_unref(reply);
1299
1300         if (changed)
1301                 dbus_message_unref(changed);
1302
1303         dbus_error_free(&error);
1304
1305         return DBUS_HANDLER_RESULT_NEED_MEMORY;
1306 }
1307
1308 static int connect_bus(DBusConnection **_bus) {
1309         static const DBusObjectPathVTable locale_vtable = {
1310                 .message_function = locale_message_handler
1311         };
1312         DBusError error;
1313         DBusConnection *bus = NULL;
1314         int r;
1315
1316         assert(_bus);
1317
1318         dbus_error_init(&error);
1319
1320         bus = dbus_bus_get_private(DBUS_BUS_SYSTEM, &error);
1321         if (!bus) {
1322                 log_error("Failed to get system D-Bus connection: %s", bus_error_message(&error));
1323                 r = -ECONNREFUSED;
1324                 goto fail;
1325         }
1326
1327         dbus_connection_set_exit_on_disconnect(bus, FALSE);
1328
1329         if (!dbus_connection_register_object_path(bus, "/org/freedesktop/locale1", &locale_vtable, NULL) ||
1330             !dbus_connection_add_filter(bus, bus_exit_idle_filter, &remain_until, NULL)) {
1331                 r = log_oom();
1332                 goto fail;
1333         }
1334
1335         r = dbus_bus_request_name(bus, "org.freedesktop.locale1", DBUS_NAME_FLAG_DO_NOT_QUEUE, &error);
1336         if (dbus_error_is_set(&error)) {
1337                 log_error("Failed to register name on bus: %s", bus_error_message(&error));
1338                 r = -EEXIST;
1339                 goto fail;
1340         }
1341
1342         if (r != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
1343                 log_error("Failed to acquire name.");
1344                 r = -EEXIST;
1345                 goto fail;
1346         }
1347
1348         if (_bus)
1349                 *_bus = bus;
1350
1351         return 0;
1352
1353 fail:
1354         dbus_connection_close(bus);
1355         dbus_connection_unref(bus);
1356
1357         dbus_error_free(&error);
1358
1359         return r;
1360 }
1361
1362 int main(int argc, char *argv[]) {
1363         int r;
1364         DBusConnection *bus = NULL;
1365         bool exiting = false;
1366
1367         log_set_target(LOG_TARGET_AUTO);
1368         log_parse_environment();
1369         log_open();
1370         label_init("/etc");
1371         umask(0022);
1372
1373         if (argc == 2 && streq(argv[1], "--introspect")) {
1374                 fputs(DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE
1375                       "<node>\n", stdout);
1376                 fputs(locale_interface, stdout);
1377                 fputs("</node>\n", stdout);
1378                 return 0;
1379         }
1380
1381         if (argc != 1) {
1382                 log_error("This program takes no arguments.");
1383                 r = -EINVAL;
1384                 goto finish;
1385         }
1386
1387         r = read_data();
1388         if (r < 0) {
1389                 log_error("Failed to read locale data: %s", strerror(-r));
1390                 goto finish;
1391         }
1392
1393         r = connect_bus(&bus);
1394         if (r < 0)
1395                 goto finish;
1396
1397         remain_until = now(CLOCK_MONOTONIC) + DEFAULT_EXIT_USEC;
1398         for (;;) {
1399
1400                 if (!dbus_connection_read_write_dispatch(bus, exiting ? -1 : (int) (DEFAULT_EXIT_USEC/USEC_PER_MSEC)))
1401                         break;
1402
1403                 if (!exiting && remain_until < now(CLOCK_MONOTONIC)) {
1404                         exiting = true;
1405                         bus_async_unregister_and_exit(bus, "org.freedesktop.locale1");
1406                 }
1407         }
1408
1409         r = 0;
1410
1411 finish:
1412         free_data();
1413
1414         if (bus) {
1415                 dbus_connection_flush(bus);
1416                 dbus_connection_close(bus);
1417                 dbus_connection_unref(bus);
1418         }
1419
1420         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
1421 }