src/locale/localectl.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2012 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 <locale.h>
  23 #include <stdlib.h>
  24 #include <stdbool.h>
  25 #include <unistd.h>
  26 #include <getopt.h>
  27 #include <string.h>
  28 #include <ftw.h>
  29 #include <sys/mman.h>
  30 #include <fcntl.h>
  31
  32 #include "dbus-common.h"
  33 #include "util.h"
  34 #include "spawn-polkit-agent.h"
  35 #include "build.h"
  36 #include "strv.h"
  37 #include "pager.h"
  38 #include "set.h"
  39 #include "path-util.h"
  40 #include "utf8.h"
  41
  42 static bool arg_no_pager = false;
  43 static enum transport {
  44         TRANSPORT_NORMAL,
  45         TRANSPORT_SSH,
  46         TRANSPORT_POLKIT
  47 } arg_transport = TRANSPORT_NORMAL;
  48 static bool arg_ask_password = true;
  49 static const char *arg_host = NULL;
  50 static bool arg_convert = true;
  51
  52 static void pager_open_if_enabled(void) {
  53
  54         if (arg_no_pager)
  55                 return;
  56
  57         pager_open(false);
  58 }
  59
  60 static void polkit_agent_open_if_enabled(void) {
  61
  62         /* Open the polkit agent as a child process if necessary */
  63
  64         if (!arg_ask_password)
  65                 return;
  66
  67         polkit_agent_open();
  68 }
  69
  70 typedef struct StatusInfo {
  71         char **locale;
  72         const char *vconsole_keymap;
  73         const char *vconsole_keymap_toggle;
  74         const char *x11_layout;
  75         const char *x11_model;
  76         const char *x11_variant;
  77         const char *x11_options;
  78 } StatusInfo;
  79
  80 static void print_status_info(StatusInfo *i) {
  81         assert(i);
  82
  83         if (strv_isempty(i->locale))
  84                 puts("   System Locale: n/a\n");
  85         else {
  86                 char **j;
  87
  88                 printf("   System Locale: %s\n", i->locale[0]);
  89                 STRV_FOREACH(j, i->locale + 1)
  90                         printf("                  %s\n", *j);
  91         }
  92
  93         printf("       VC Keymap: %s\n", strna(i->vconsole_keymap));
  94         if (!isempty(i->vconsole_keymap_toggle))
  95                 printf("VC Toggle Keymap: %s\n", i->vconsole_keymap_toggle);
  96
  97         printf("      X11 Layout: %s\n", strna(i->x11_layout));
  98         if (!isempty(i->x11_model))
  99                 printf("       X11 Model: %s\n", i->x11_model);
 100         if (!isempty(i->x11_variant))
 101                 printf("     X11 Variant: %s\n", i->x11_variant);
 102         if (!isempty(i->x11_options))
 103                 printf("     X11 Options: %s\n", i->x11_options);
 104 }
 105
 106 static int status_property(const char *name, DBusMessageIter *iter, StatusInfo *i) {
 107         int r;
 108
 109         assert(name);
 110         assert(iter);
 111
 112         switch (dbus_message_iter_get_arg_type(iter)) {
 113
 114         case DBUS_TYPE_STRING: {
 115                 const char *s;
 116
 117                 dbus_message_iter_get_basic(iter, &s);
 118                 if (!isempty(s)) {
 119                         if (streq(name, "VConsoleKeymap"))
 120                                 i->vconsole_keymap = s;
 121                         else if (streq(name, "VConsoleKeymapToggle"))
 122                                 i->vconsole_keymap_toggle = s;
 123                         else if (streq(name, "X11Layout"))
 124                                 i->x11_layout = s;
 125                         else if (streq(name, "X11Model"))
 126                                 i->x11_model = s;
 127                         else if (streq(name, "X11Variant"))
 128                                 i->x11_variant = s;
 129                         else if (streq(name, "X11Options"))
 130                                 i->x11_options = s;
 131                 }
 132                 break;
 133         }
 134
 135         case DBUS_TYPE_ARRAY:
 136
 137                 if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRING) {
 138                         char **l;
 139
 140                         r = bus_parse_strv_iter(iter, &l);
 141                         if (r < 0)
 142                                 return r;
 143
 144                         if (streq(name, "Locale")) {
 145                                 strv_free(i->locale);
 146                                 i->locale = l;
 147                                 l = NULL;
 148                         }
 149
 150                         strv_free(l);
 151                 }
 152         }
 153
 154         return 0;
 155 }
 156
 157 static int show_status(DBusConnection *bus, char **args, unsigned n) {
 158         _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
 159         const char *interface = "";
 160         int r;
 161         DBusMessageIter iter, sub, sub2, sub3;
 162         StatusInfo info = {};
 163
 164         assert(args);
 165
 166         r = bus_method_call_with_reply(
 167                         bus,
 168                         "org.freedesktop.locale1",
 169                         "/org/freedesktop/locale1",
 170                         "org.freedesktop.DBus.Properties",
 171                         "GetAll",
 172                         &reply,
 173                         NULL,
 174                         DBUS_TYPE_STRING, &interface,
 175                         DBUS_TYPE_INVALID);
 176         if (r < 0)
 177                 return r;
 178
 179         if (!dbus_message_iter_init(reply, &iter) ||
 180             dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
 181             dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_DICT_ENTRY)  {
 182                 log_error("Failed to parse reply.");
 183                 return -EIO;
 184         }
 185
 186         dbus_message_iter_recurse(&iter, &sub);
 187
 188         while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
 189                 const char *name;
 190
 191                 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_DICT_ENTRY) {
 192                         log_error("Failed to parse reply.");
 193                         return -EIO;
 194                 }
 195
 196                 dbus_message_iter_recurse(&sub, &sub2);
 197
 198                 if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &name, true) < 0) {
 199                         log_error("Failed to parse reply.");
 200                         return -EIO;
 201                 }
 202
 203                 if (dbus_message_iter_get_arg_type(&sub2) != DBUS_TYPE_VARIANT)  {
 204                         log_error("Failed to parse reply.");
 205                         return -EIO;
 206                 }
 207
 208                 dbus_message_iter_recurse(&sub2, &sub3);
 209
 210                 r = status_property(name, &sub3, &info);
 211                 if (r < 0) {
 212                         log_error("Failed to parse reply.");
 213                         return r;
 214                 }
 215
 216                 dbus_message_iter_next(&sub);
 217         }
 218
 219         print_status_info(&info);
 220         strv_free(info.locale);
 221         return 0;
 222 }
 223
 224 static int set_locale(DBusConnection *bus, char **args, unsigned n) {
 225         _cleanup_dbus_message_unref_ DBusMessage *m = NULL, *reply = NULL;
 226         dbus_bool_t interactive = true;
 227         DBusError error;
 228         DBusMessageIter iter;
 229         int r;
 230
 231         assert(bus);
 232         assert(args);
 233
 234         dbus_error_init(&error);
 235
 236         polkit_agent_open_if_enabled();
 237
 238         m = dbus_message_new_method_call(
 239                         "org.freedesktop.locale1",
 240                         "/org/freedesktop/locale1",
 241                         "org.freedesktop.locale1",
 242                         "SetLocale");
 243         if (!m)
 244                 return log_oom();
 245
 246         dbus_message_iter_init_append(m, &iter);
 247
 248         r = bus_append_strv_iter(&iter, args + 1);
 249         if (r < 0)
 250                 return log_oom();
 251
 252         if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_BOOLEAN, &interactive))
 253                 return log_oom();
 254
 255         reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error);
 256         if (!reply) {
 257                 log_error("Failed to issue method call: %s", bus_error_message(&error));
 258                 r = -EIO;
 259                 goto finish;
 260         }
 261
 262         r = 0;
 263
 264 finish:
 265         dbus_error_free(&error);
 266         return r;
 267 }
 268
 269 static int add_locales_from_archive(Set *locales) {
 270         /* Stolen from glibc... */
 271
 272         struct locarhead {
 273                 uint32_t magic;
 274                 /* Serial number.  */
 275                 uint32_t serial;
 276                 /* Name hash table.  */
 277                 uint32_t namehash_offset;
 278                 uint32_t namehash_used;
 279                 uint32_t namehash_size;
 280                 /* String table.  */
 281                 uint32_t string_offset;
 282                 uint32_t string_used;
 283                 uint32_t string_size;
 284                 /* Table with locale records.  */
 285                 uint32_t locrectab_offset;
 286                 uint32_t locrectab_used;
 287                 uint32_t locrectab_size;
 288                 /* MD5 sum hash table.  */
 289                 uint32_t sumhash_offset;
 290                 uint32_t sumhash_used;
 291                 uint32_t sumhash_size;
 292         };
 293
 294         struct namehashent {
 295                 /* Hash value of the name.  */
 296                 uint32_t hashval;
 297                 /* Offset of the name in the string table.  */
 298                 uint32_t name_offset;
 299                 /* Offset of the locale record.  */
 300                 uint32_t locrec_offset;
 301         };
 302
 303         const struct locarhead *h;
 304         const struct namehashent *e;
 305         const void *p = MAP_FAILED;
 306         _cleanup_close_ int fd = -1;
 307         size_t sz = 0;
 308         struct stat st;
 309         unsigned i;
 310         int r;
 311
 312         fd = open("/usr/lib/locale/locale-archive", O_RDONLY|O_NOCTTY|O_CLOEXEC);
 313         if (fd < 0) {
 314                 if (errno != ENOENT)
 315                         log_error("Failed to open locale archive: %m");
 316                 r = -errno;
 317                 goto finish;
 318         }
 319
 320         if (fstat(fd, &st) < 0) {
 321                 log_error("fstat() failed: %m");
 322                 r = -errno;
 323                 goto finish;
 324         }
 325
 326         if (!S_ISREG(st.st_mode)) {
 327                 log_error("Archive file is not regular");
 328                 r = -EBADMSG;
 329                 goto finish;
 330         }
 331
 332         if (st.st_size < (off_t) sizeof(struct locarhead)) {
 333                 log_error("Archive has invalid size");
 334                 r = -EBADMSG;
 335                 goto finish;
 336         }
 337
 338         p = mmap(NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
 339         if (p == MAP_FAILED) {
 340                 log_error("Failed to map archive: %m");
 341                 r = -errno;
 342                 goto finish;
 343         }
 344
 345         h = (const struct locarhead *) p;
 346         if (h->magic != 0xde020109 ||
 347             h->namehash_offset + h->namehash_size > st.st_size ||
 348             h->string_offset + h->string_size > st.st_size ||
 349             h->locrectab_offset + h->locrectab_size > st.st_size ||
 350             h->sumhash_offset + h->sumhash_size > st.st_size) {
 351                 log_error("Invalid archive file.");
 352                 r = -EBADMSG;
 353                 goto finish;
 354         }
 355
 356         e = (const struct namehashent*) ((const uint8_t*) p + h->namehash_offset);
 357         for (i = 0; i < h->namehash_size; i++) {
 358                 char *z;
 359
 360                 if (e[i].locrec_offset == 0)
 361                         continue;
 362
 363                 if (!utf8_is_valid((char*) p + e[i].name_offset))
 364                         continue;
 365
 366                 z = strdup((char*) p + e[i].name_offset);
 367                 if (!z) {
 368                         r = log_oom();
 369                         goto finish;
 370                 }
 371
 372                 r = set_consume(locales, z);
 373                 if (r < 0) {
 374                         log_error("Failed to add locale: %s", strerror(-r));
 375                         goto finish;
 376                 }
 377         }
 378
 379         r = 0;
 380
 381  finish:
 382         if (p != MAP_FAILED)
 383                 munmap((void*) p, sz);
 384
 385         return r;
 386 }
 387
 388 static int add_locales_from_libdir (Set *locales) {
 389         _cleanup_closedir_ DIR *dir;
 390         struct dirent *entry;
 391         int r;
 392
 393         dir = opendir("/usr/lib/locale");
 394         if (!dir) {
 395                 log_error("Failed to open locale directory: %m");
 396                 return -errno;
 397         }
 398
 399         errno = 0;
 400         while ((entry = readdir(dir))) {
 401                 char *z;
 402
 403                 if (entry->d_type != DT_DIR)
 404                         continue;
 405
 406                 if (ignore_file(entry->d_name))
 407                         continue;
 408
 409                 z = strdup(entry->d_name);
 410                 if (!z)
 411                         return log_oom();
 412
 413                 r = set_consume(locales, z);
 414                 if (r < 0 && r != -EEXIST) {
 415                         log_error("Failed to add locale: %s", strerror(-r));
 416                         return r;
 417                 }
 418
 419                 errno = 0;
 420         }
 421
 422         if (errno > 0) {
 423                 log_error("Failed to read locale directory: %m");
 424                 return -errno;
 425         }
 426
 427         return 0;
 428 }
 429
 430 static int list_locales(DBusConnection *bus, char **args, unsigned n) {
 431         _cleanup_set_free_ Set *locales;
 432         _cleanup_strv_free_ char **l = NULL;
 433         int r;
 434
 435         locales = set_new(string_hash_func, string_compare_func);
 436         if (!locales)
 437                 return log_oom();
 438
 439         r = add_locales_from_archive(locales);
 440         if (r < 0 && r != -ENOENT)
 441                 return r;
 442
 443         r = add_locales_from_libdir(locales);
 444         if (r < 0)
 445                 return r;
 446
 447         l = set_get_strv(locales);
 448         if (!l)
 449                 return log_oom();
 450
 451         strv_sort(l);
 452
 453         pager_open_if_enabled();
 454
 455         strv_print(l);
 456
 457         return 0;
 458 }
 459
 460 static int set_vconsole_keymap(DBusConnection *bus, char **args, unsigned n) {
 461         _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
 462         dbus_bool_t interactive = true, b;
 463         const char *map, *toggle_map;
 464
 465         assert(bus);
 466         assert(args);
 467
 468         if (n > 3) {
 469                 log_error("Too many arguments.");
 470                 return -EINVAL;
 471         }
 472
 473         polkit_agent_open_if_enabled();
 474
 475         map = args[1];
 476         toggle_map = n > 2 ? args[2] : "";
 477         b = arg_convert;
 478
 479         return bus_method_call_with_reply(
 480                         bus,
 481                         "org.freedesktop.locale1",
 482                         "/org/freedesktop/locale1",
 483                         "org.freedesktop.locale1",
 484                         "SetVConsoleKeyboard",
 485                         &reply,
 486                         NULL,
 487                         DBUS_TYPE_STRING, &map,
 488                         DBUS_TYPE_STRING, &toggle_map,
 489                         DBUS_TYPE_BOOLEAN, &b,
 490                         DBUS_TYPE_BOOLEAN, &interactive,
 491                         DBUS_TYPE_INVALID);
 492 }
 493
 494 static Set *keymaps = NULL;
 495
 496 static int nftw_cb(
 497                 const char *fpath,
 498                 const struct stat *sb,
 499                 int tflag,
 500                 struct FTW *ftwbuf) {
 501
 502         char *p, *e;
 503         int r;
 504
 505         if (tflag != FTW_F)
 506                 return 0;
 507
 508         if (!endswith(fpath, ".map") &&
 509             !endswith(fpath, ".map.gz"))
 510                 return 0;
 511
 512         p = strdup(path_get_file_name(fpath));
 513         if (!p)
 514                 return log_oom();
 515
 516         e = endswith(p, ".map");
 517         if (e)
 518                 *e = 0;
 519
 520         e = endswith(p, ".map.gz");
 521         if (e)
 522                 *e = 0;
 523
 524         r = set_consume(keymaps, p);
 525         if (r < 0 && r != -EEXIST) {
 526                 log_error("Can't add keymap: %s", strerror(-r));
 527                 return r;
 528         }
 529
 530         return 0;
 531 }
 532
 533 static int list_vconsole_keymaps(DBusConnection *bus, char **args, unsigned n) {
 534         _cleanup_strv_free_ char **l = NULL;
 535
 536         keymaps = set_new(string_hash_func, string_compare_func);
 537         if (!keymaps)
 538                 return log_oom();
 539
 540         nftw("/usr/share/kbd/keymaps/", nftw_cb, 20, FTW_MOUNT|FTW_PHYS);
 541         nftw("/usr/lib/kbd/keymaps/", nftw_cb, 20, FTW_MOUNT|FTW_PHYS);
 542         nftw("/lib/kbd/keymaps/", nftw_cb, 20, FTW_MOUNT|FTW_PHYS);
 543
 544         l = set_get_strv(keymaps);
 545         if (!l) {
 546                 set_free_free(keymaps);
 547                 return log_oom();
 548         }
 549
 550         set_free(keymaps);
 551
 552         if (strv_isempty(l)) {
 553                 log_error("Couldn't find any console keymaps.");
 554                 return -ENOENT;
 555         }
 556
 557         strv_sort(l);
 558
 559         pager_open_if_enabled();
 560
 561         strv_print(l);
 562
 563         return 0;
 564 }
 565
 566 static int set_x11_keymap(DBusConnection *bus, char **args, unsigned n) {
 567         _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
 568         dbus_bool_t interactive = true, b;
 569         const char *layout, *model, *variant, *options;
 570
 571         assert(bus);
 572         assert(args);
 573
 574         if (n > 5) {
 575                 log_error("Too many arguments.");
 576                 return -EINVAL;
 577         }
 578
 579         polkit_agent_open_if_enabled();
 580
 581         layout = args[1];
 582         model = n > 2 ? args[2] : "";
 583         variant = n > 3 ? args[3] : "";
 584         options = n > 4 ? args[4] : "";
 585         b = arg_convert;
 586
 587         return bus_method_call_with_reply(
 588                         bus,
 589                         "org.freedesktop.locale1",
 590                         "/org/freedesktop/locale1",
 591                         "org.freedesktop.locale1",
 592                         "SetX11Keyboard",
 593                         &reply,
 594                         NULL,
 595                         DBUS_TYPE_STRING, &layout,
 596                         DBUS_TYPE_STRING, &model,
 597                         DBUS_TYPE_STRING, &variant,
 598                         DBUS_TYPE_STRING, &options,
 599                         DBUS_TYPE_BOOLEAN, &b,
 600                         DBUS_TYPE_BOOLEAN, &interactive,
 601                         DBUS_TYPE_INVALID);
 602 }
 603
 604 static int list_x11_keymaps(DBusConnection *bus, char **args, unsigned n) {
 605         _cleanup_fclose_ FILE *f = NULL;
 606         _cleanup_strv_free_ char **list = NULL;
 607         char line[LINE_MAX];
 608         enum {
 609                 NONE,
 610                 MODELS,
 611                 LAYOUTS,
 612                 VARIANTS,
 613                 OPTIONS
 614         } state = NONE, look_for;
 615         int r;
 616
 617         if (n > 2) {
 618                 log_error("Too many arguments.");
 619                 return -EINVAL;
 620         }
 621
 622         f = fopen("/usr/share/X11/xkb/rules/base.lst", "re");
 623         if (!f) {
 624                 log_error("Failed to open keyboard mapping list. %m");
 625                 return -errno;
 626         }
 627
 628         if (streq(args[0], "list-x11-keymap-models"))
 629                 look_for = MODELS;
 630         else if (streq(args[0], "list-x11-keymap-layouts"))
 631                 look_for = LAYOUTS;
 632         else if (streq(args[0], "list-x11-keymap-variants"))
 633                 look_for = VARIANTS;
 634         else if (streq(args[0], "list-x11-keymap-options"))
 635                 look_for = OPTIONS;
 636         else
 637                 assert_not_reached("Wrong parameter");
 638
 639         FOREACH_LINE(line, f, break) {
 640                 char *l, *w;
 641
 642                 l = strstrip(line);
 643
 644                 if (isempty(l))
 645                         continue;
 646
 647                 if (l[0] == '!') {
 648                         if (startswith(l, "! model"))
 649                                 state = MODELS;
 650                         else if (startswith(l, "! layout"))
 651                                 state = LAYOUTS;
 652                         else if (startswith(l, "! variant"))
 653                                 state = VARIANTS;
 654                         else if (startswith(l, "! option"))
 655                                 state = OPTIONS;
 656                         else
 657                                 state = NONE;
 658
 659                         continue;
 660                 }
 661
 662                 if (state != look_for)
 663                         continue;
 664
 665                 w = l + strcspn(l, WHITESPACE);
 666
 667                 if (n > 1) {
 668                         char *e;
 669
 670                         if (*w == 0)
 671                                 continue;
 672
 673                         *w = 0;
 674                         w++;
 675                         w += strspn(w, WHITESPACE);
 676
 677                         e = strchr(w, ':');
 678                         if (!e)
 679                                 continue;
 680
 681                         *e = 0;
 682
 683                         if (!streq(w, args[1]))
 684                                 continue;
 685                 } else
 686                         *w = 0;
 687
 688                  r = strv_extend(&list, l);
 689                  if (r < 0)
 690                          return log_oom();
 691         }
 692
 693         if (strv_isempty(list)) {
 694                 log_error("Couldn't find any entries.");
 695                 return -ENOENT;
 696         }
 697
 698         strv_sort(list);
 699         strv_uniq(list);
 700
 701         pager_open_if_enabled();
 702
 703         strv_print(list);
 704         return 0;
 705 }
 706
 707 static int help(void) {
 708
 709         printf("%s [OPTIONS...] COMMAND ...\n\n"
 710                "Query or change system locale and keyboard settings.\n\n"
 711                "  -h --help                Show this help\n"
 712                "     --version             Show package version\n"
 713                "     --no-convert          Don't convert keyboard mappings\n"
 714                "     --no-pager            Do not pipe output into a pager\n"
 715                "     --no-ask-password     Do not prompt for password\n"
 716                "  -H --host=[USER@]HOST    Operate on remote host\n\n"
 717                "Commands:\n"
 718                "  status                   Show current locale settings\n"
 719                "  set-locale LOCALE...     Set system locale\n"
 720                "  list-locales             Show known locales\n"
 721                "  set-keymap MAP [MAP]     Set virtual console keyboard mapping\n"
 722                "  list-keymaps             Show known virtual console keyboard mappings\n"
 723                "  set-x11-keymap LAYOUT [MODEL] [VARIANT] [OPTIONS]\n"
 724                "                           Set X11 keyboard mapping\n"
 725                "  list-x11-keymap-models   Show known X11 keyboard mapping models\n"
 726                "  list-x11-keymap-layouts  Show known X11 keyboard mapping layouts\n"
 727                "  list-x11-keymap-variants [LAYOUT]\n"
 728                "                           Show known X11 keyboard mapping variants\n"
 729                "  list-x11-keymap-options  Show known X11 keyboard mapping options\n",
 730                program_invocation_short_name);
 731
 732         return 0;
 733 }
 734
 735 static int parse_argv(int argc, char *argv[]) {
 736
 737         enum {
 738                 ARG_VERSION = 0x100,
 739                 ARG_NO_PAGER,
 740                 ARG_NO_CONVERT,
 741                 ARG_NO_ASK_PASSWORD
 742         };
 743
 744         static const struct option options[] = {
 745                 { "help",                no_argument,       NULL, 'h'                     },
 746                 { "version",             no_argument,       NULL, ARG_VERSION             },
 747                 { "no-pager",            no_argument,       NULL, ARG_NO_PAGER            },
 748                 { "host",                required_argument, NULL, 'H'                     },
 749                 { "privileged",          no_argument,       NULL, 'P'                     },
 750                 { "no-ask-password",     no_argument,       NULL, ARG_NO_ASK_PASSWORD     },
 751                 { "no-convert",          no_argument,       NULL, ARG_NO_CONVERT          },
 752                 { NULL,                  0,                 NULL, 0                       }
 753         };
 754
 755         int c;
 756
 757         assert(argc >= 0);
 758         assert(argv);
 759
 760         while ((c = getopt_long(argc, argv, "has:H:P", options, NULL)) >= 0) {
 761
 762                 switch (c) {
 763
 764                 case 'h':
 765                         help();
 766                         return 0;
 767
 768                 case ARG_VERSION:
 769                         puts(PACKAGE_STRING);
 770                         puts(SYSTEMD_FEATURES);
 771                         return 0;
 772
 773                 case 'P':
 774                         arg_transport = TRANSPORT_POLKIT;
 775                         break;
 776
 777                 case 'H':
 778                         arg_transport = TRANSPORT_SSH;
 779                         arg_host = optarg;
 780                         break;
 781
 782                 case ARG_NO_CONVERT:
 783                         arg_convert = false;
 784                         break;
 785
 786                 case ARG_NO_PAGER:
 787                         arg_no_pager = true;
 788                         break;
 789
 790                 case '?':
 791                         return -EINVAL;
 792
 793                 default:
 794                         log_error("Unknown option code %c", c);
 795                         return -EINVAL;
 796                 }
 797         }
 798
 799         return 1;
 800 }
 801
 802 static int localectl_main(DBusConnection *bus, int argc, char *argv[], DBusError *error) {
 803
 804         static const struct {
 805                 const char* verb;
 806                 const enum {
 807                         MORE,
 808                         LESS,
 809                         EQUAL
 810                 } argc_cmp;
 811                 const int argc;
 812                 int (* const dispatch)(DBusConnection *bus, char **args, unsigned n);
 813         } verbs[] = {
 814                 { "status",                   LESS,   1, show_status           },
 815                 { "set-locale",               MORE,   2, set_locale            },
 816                 { "list-locales",             EQUAL,  1, list_locales          },
 817                 { "set-keymap",               MORE,   2, set_vconsole_keymap   },
 818                 { "list-keymaps",             EQUAL,  1, list_vconsole_keymaps },
 819                 { "set-x11-keymap",           MORE,   2, set_x11_keymap        },
 820                 { "list-x11-keymap-models",   EQUAL,  1, list_x11_keymaps      },
 821                 { "list-x11-keymap-layouts",  EQUAL,  1, list_x11_keymaps      },
 822                 { "list-x11-keymap-variants", LESS,   2, list_x11_keymaps      },
 823                 { "list-x11-keymap-options",  EQUAL,  1, list_x11_keymaps      },
 824         };
 825
 826         int left;
 827         unsigned i;
 828
 829         assert(argc >= 0);
 830         assert(argv);
 831         assert(error);
 832
 833         left = argc - optind;
 834
 835         if (left <= 0)
 836                 /* Special rule: no arguments means "status" */
 837                 i = 0;
 838         else {
 839                 if (streq(argv[optind], "help")) {
 840                         help();
 841                         return 0;
 842                 }
 843
 844                 for (i = 0; i < ELEMENTSOF(verbs); i++)
 845                         if (streq(argv[optind], verbs[i].verb))
 846                                 break;
 847
 848                 if (i >= ELEMENTSOF(verbs)) {
 849                         log_error("Unknown operation %s", argv[optind]);
 850                         return -EINVAL;
 851                 }
 852         }
 853
 854         switch (verbs[i].argc_cmp) {
 855
 856         case EQUAL:
 857                 if (left != verbs[i].argc) {
 858                         log_error("Invalid number of arguments.");
 859                         return -EINVAL;
 860                 }
 861
 862                 break;
 863
 864         case MORE:
 865                 if (left < verbs[i].argc) {
 866                         log_error("Too few arguments.");
 867                         return -EINVAL;
 868                 }
 869
 870                 break;
 871
 872         case LESS:
 873                 if (left > verbs[i].argc) {
 874                         log_error("Too many arguments.");
 875                         return -EINVAL;
 876                 }
 877
 878                 break;
 879
 880         default:
 881                 assert_not_reached("Unknown comparison operator.");
 882         }
 883
 884         if (!bus) {
 885                 log_error("Failed to get D-Bus connection: %s", error->message);
 886                 return -EIO;
 887         }
 888
 889         return verbs[i].dispatch(bus, argv + optind, left);
 890 }
 891
 892 int main(int argc, char *argv[]) {
 893         int r, retval = EXIT_FAILURE;
 894         DBusConnection *bus = NULL;
 895         DBusError error;
 896
 897         dbus_error_init(&error);
 898
 899         setlocale(LC_ALL, "");
 900         log_parse_environment();
 901         log_open();
 902
 903         r = parse_argv(argc, argv);
 904         if (r < 0)
 905                 goto finish;
 906         else if (r == 0) {
 907                 retval = EXIT_SUCCESS;
 908                 goto finish;
 909         }
 910
 911         if (arg_transport == TRANSPORT_NORMAL)
 912                 bus = dbus_bus_get_private(DBUS_BUS_SYSTEM, &error);
 913         else if (arg_transport == TRANSPORT_POLKIT)
 914                 bus_connect_system_polkit(&bus, &error);
 915         else if (arg_transport == TRANSPORT_SSH)
 916                 bus_connect_system_ssh(NULL, arg_host, &bus, &error);
 917         else
 918                 assert_not_reached("Uh, invalid transport...");
 919
 920         r = localectl_main(bus, argc, argv, &error);
 921         retval = r < 0 ? EXIT_FAILURE : r;
 922
 923 finish:
 924         if (bus) {
 925                 dbus_connection_flush(bus);
 926                 dbus_connection_close(bus);
 927                 dbus_connection_unref(bus);
 928         }
 929
 930         dbus_error_free(&error);
 931         dbus_shutdown();
 932
 933         pager_close();
 934
 935         return retval;
 936 }