usr.sbin/kbdmap/kbdmap.c

   1 /*-
   2  * Copyright (c) 2002 Jonathan Belson <jon@witchspace.com>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 #include <sys/types.h>
  31 #include <sys/queue.h>
  32 #include <sys/sysctl.h>
  33
  34 #include <assert.h>
  35 #include <ctype.h>
  36 #include <dirent.h>
  37 #include <limits.h>
  38 #include <stdio.h>
  39 #include <stdlib.h>
  40 #include <string.h>
  41 #include <stringlist.h>
  42 #include <unistd.h>
  43
  44 #include "kbdmap.h"
  45
  46
  47 static const char *lang_default = DEFAULT_LANG;
  48 static const char *font;
  49 static const char *lang;
  50 static const char *program;
  51 static const char *keymapdir = DEFAULT_VT_KEYMAP_DIR;
  52 static const char *fontdir = DEFAULT_VT_FONT_DIR;
  53 static const char *font_default = DEFAULT_VT_FONT;
  54 static const char *sysconfig = DEFAULT_SYSCONFIG;
  55 static const char *font_current;
  56 static const char *dir;
  57 static const char *menu = "";
  58
  59 static int x11;
  60 static int show;
  61 static int verbose;
  62 static int print;
  63
  64
  65 struct keymap {
  66         char    *desc;
  67         char    *keym;
  68         int     mark;
  69         SLIST_ENTRY(keymap) entries;
  70 };
  71 static SLIST_HEAD(slisthead, keymap) head = SLIST_HEAD_INITIALIZER(head);
  72
  73
  74 /*
  75  * Get keymap entry for 'key', or NULL of not found
  76  */
  77 static struct keymap *
  78 get_keymap(const char *key)
  79 {
  80         struct keymap *km;
  81
  82         SLIST_FOREACH(km, &head, entries)
  83                 if (!strcmp(km->keym, key))
  84                         return km;
  85
  86         return NULL;
  87 }
  88
  89 /*
  90  * Count the number of keymaps we found
  91  */
  92 static int
  93 get_num_keymaps(void)
  94 {
  95         struct keymap *km;
  96         int count = 0;
  97
  98         SLIST_FOREACH(km, &head, entries)
  99                 count++;
 100
 101         return count;
 102 }
 103
 104 /*
 105  * Remove any keymap with given keym
 106  */
 107 static void
 108 remove_keymap(const char *keym)
 109 {
 110         struct keymap *km;
 111
 112         SLIST_FOREACH(km, &head, entries) {
 113                 if (!strcmp(keym, km->keym)) {
 114                         SLIST_REMOVE(&head, km, keymap, entries);
 115                         free(km);
 116                         break;
 117                 }
 118         }
 119 }
 120
 121 /*
 122  * Add to hash with 'key'
 123  */
 124 static void
 125 add_keymap(const char *desc, int mark, const char *keym)
 126 {
 127         struct keymap *km, *km_new;
 128
 129         /* Is there already an entry with this key? */
 130         SLIST_FOREACH(km, &head, entries) {
 131                 if (!strcmp(km->keym, keym)) {
 132                         /* Reuse this entry */
 133                         free(km->desc);
 134                         km->desc = strdup(desc);
 135                         km->mark = mark;
 136                         return;
 137                 }
 138         }
 139
 140         km_new = (struct keymap *) malloc (sizeof(struct keymap));
 141         km_new->desc = strdup(desc);
 142         km_new->keym = strdup(keym);
 143         km_new->mark = mark;
 144
 145         /* Add to keymap list */
 146         SLIST_INSERT_HEAD(&head, km_new, entries);
 147 }
 148
 149 /*
 150  * Return 0 if syscons is in use (to select legacy defaults).
 151  */
 152 static int
 153 check_newcons(void)
 154 {
 155         size_t len;
 156         char term[3];
 157
 158         len = 3;
 159         if (sysctlbyname("kern.vty", &term, &len, NULL, 0) != 0 ||
 160             strcmp(term, "vt") != 0)
 161                 return 0;
 162         return -1;
 163 }
 164
 165 /*
 166  * Figure out the default language to use.
 167  */
 168 static const char *
 169 get_locale(void)
 170 {
 171         const char *locale;
 172
 173         if ((locale = getenv("LC_ALL")) == NULL &&
 174             (locale = getenv("LC_CTYPE")) == NULL &&
 175             (locale = getenv("LANG")) == NULL)
 176                 locale = lang_default;
 177
 178         /* Check for alias */
 179         if (!strcmp(locale, "C"))
 180                 locale = DEFAULT_LANG;
 181
 182         return locale;
 183 }
 184
 185 /*
 186  * Extract filename part
 187  */
 188 static const char *
 189 extract_name(const char *name)
 190 {
 191         char *p;
 192
 193         p = strrchr(name, '/');
 194         if (p != NULL && p[1] != '\0')
 195                 return p + 1;
 196
 197         return name;
 198 }
 199
 200 /*
 201  * Return file extension or NULL
 202  */
 203 static char *
 204 get_extension(const char *name)
 205 {
 206         char *p;
 207
 208         p = strrchr(name, '.');
 209
 210         if (p != NULL && p[1] != '\0')
 211                 return p;
 212
 213         return NULL;
 214 }
 215
 216 /*
 217  * Read font from /etc/rc.conf else return default.
 218  * Freeing the memory is the caller's responsibility.
 219  */
 220 static char *
 221 get_font(void)
 222 {
 223         char line[256], buf[20];
 224         char *fnt = NULL;
 225
 226         FILE *fp = fopen(sysconfig, "r");
 227         if (fp) {
 228                 while (fgets(line, sizeof(line), fp)) {
 229                         int a, b, matches;
 230
 231                         if (line[0] == '#')
 232                                 continue;
 233
 234                         matches = sscanf(line,
 235                             " font%dx%d = \"%20[-.0-9a-zA-Z_]",
 236                             &a, &b, buf);
 237                         if (matches==3) {
 238                                 if (strcmp(buf, "NO")) {
 239                                         if (fnt)
 240                                                 free(fnt);
 241                                         fnt = (char *) malloc(strlen(buf) + 1);
 242                                         strcpy(fnt, buf);
 243                                 }
 244                         }
 245                 }
 246                 fclose(fp);
 247         } else
 248                 fprintf(stderr, "Could not open %s for reading\n", sysconfig);
 249
 250         return fnt;
 251 }
 252
 253 /*
 254  * Set a font using 'vidcontrol'
 255  */
 256 static void
 257 vidcontrol(const char *fnt)
 258 {
 259         char *tmp, *p, *q;
 260         char ch;
 261         int i;
 262
 263         /* syscons test failed */
 264         if (x11)
 265                 return;
 266
 267         tmp = strdup(fnt);
 268
 269         /* Extract font size */
 270         p = strrchr(tmp, '-');
 271         if (p && p[1] != '\0') {
 272                 p++;
 273                 /* Remove any '.fnt' extension */
 274                 if ((q = strstr(p, ".fnt")))
 275                         *q = '\0';
 276
 277                 /*
 278                  * Check font size is valid, with no trailing characters
 279                  *  ('&ch' should not be matched)
 280                  */
 281                 if (sscanf(p, "%dx%d%c", &i, &i, &ch) != 2)
 282                         fprintf(stderr, "Which font size? %s\n", fnt);
 283                 else {
 284                         char *cmd;
 285                         asprintf(&cmd, "vidcontrol -f %s %s", p, fnt);
 286                         if (verbose)
 287                                 fprintf(stderr, "%s\n", cmd);
 288                         system(cmd);
 289                         free(cmd);
 290                 }
 291         } else
 292                 fprintf(stderr, "Which font size? %s\n", fnt);
 293
 294         free(tmp);
 295 }
 296
 297 /*
 298  * Execute 'kbdcontrol' with the appropriate arguments
 299  */
 300 static void
 301 do_kbdcontrol(struct keymap *km)
 302 {
 303         char *kbd_cmd;
 304         asprintf(&kbd_cmd, "kbdcontrol -l %s/%s", dir, km->keym);
 305
 306         if (!x11)
 307                 system(kbd_cmd);
 308
 309         fprintf(stderr, "keymap=\"%s\"\n", km->keym);
 310         free(kbd_cmd);
 311 }
 312
 313 /*
 314  * Call 'vidcontrol' with the appropriate arguments
 315  */
 316 static void
 317 do_vidfont(struct keymap *km)
 318 {
 319         char *vid_cmd, *tmp, *p, *q;
 320
 321         asprintf(&vid_cmd, "%s/%s", dir, km->keym);
 322         vidcontrol(vid_cmd);
 323         free(vid_cmd);
 324
 325         tmp = strdup(km->keym);
 326         p = strrchr(tmp, '-');
 327         if (p && p[1]!='\0') {
 328                 p++;
 329                 q = get_extension(p);
 330                 if (q) {
 331                         *q = '\0';
 332                         printf("font%s=%s\n", p, km->keym);
 333                 }
 334         }
 335         free(tmp);
 336 }
 337
 338 /*
 339  * Display dialog from 'keymaps[]'
 340  */
 341 static void
 342 show_dialog(struct keymap **km_sorted, int num_keymaps)
 343 {
 344         FILE *fp;
 345         char *cmd, *dialog;
 346         char tmp_name[] = "/tmp/_kbd_lang.XXXX";
 347         int fd, i, size;
 348
 349         fd = mkstemp(tmp_name);
 350         if (fd == -1) {
 351                 fprintf(stderr, "Could not open temporary file \"%s\"\n",
 352                     tmp_name);
 353                 exit(1);
 354         }
 355         asprintf(&dialog, "/usr/bin/dialog --clear --title \"Keyboard Menu\" "
 356                           "--menu \"%s\" 0 0 0", menu);
 357
 358         /* start right font, assume that current font is equal
 359          * to default font in /etc/rc.conf
 360          *
 361          * $font is the font which require the language $lang; e.g.
 362          * russian *need* a koi8 font
 363          * $font_current is the current font from /etc/rc.conf
 364          */
 365         if (font && strcmp(font, font_current))
 366                 vidcontrol(font);
 367
 368         /* Build up the command */
 369         size = 0;
 370         for (i=0; i<num_keymaps; i++) {
 371                 /*
 372                  * Each 'font' is passed as ' "font" ""', so allow the
 373                  * extra space
 374                  */
 375                 size += strlen(km_sorted[i]->desc) + 6;
 376         }
 377
 378         /* Allow the space for '2> tmpfilename' redirection */
 379         size += strlen(tmp_name) + 3;
 380
 381         cmd = (char *) malloc(strlen(dialog) + size + 1);
 382         strcpy(cmd, dialog);
 383
 384         for (i=0; i<num_keymaps; i++) {
 385                 strcat(cmd, " \"");
 386                 strcat(cmd, km_sorted[i]->desc);
 387                 strcat(cmd, "\"");
 388                 strcat(cmd, " \"\"");
 389         }
 390
 391         strcat(cmd, " 2>");
 392         strcat(cmd, tmp_name);
 393
 394         /* Show the dialog.. */
 395         system(cmd);
 396
 397         fp = fopen(tmp_name, "r");
 398         if (fp) {
 399                 char choice[64];
 400                 if (fgets(choice, sizeof(choice), fp) != NULL) {
 401                         /* Find key for desc */
 402                         for (i=0; i<num_keymaps; i++) {
 403                                 if (!strcmp(choice, km_sorted[i]->desc)) {
 404                                         if (!strcmp(program, "kbdmap"))
 405                                                 do_kbdcontrol(km_sorted[i]);
 406                                         else
 407                                                 do_vidfont(km_sorted[i]);
 408                                         break;
 409                                 }
 410                         }
 411                 } else {
 412                         if (font != NULL && strcmp(font, font_current))
 413                                 /* Cancelled, restore old font */
 414                                 vidcontrol(font_current);
 415                 }
 416                 fclose(fp);
 417         } else
 418                 fprintf(stderr, "Failed to open temporary file");
 419
 420         /* Tidy up */
 421         remove(tmp_name);
 422         free(cmd);
 423         free(dialog);
 424         close(fd);
 425 }
 426
 427 /*
 428  * Search for 'token' in comma delimited array 'buffer'.
 429  * Return true for found, false for not found.
 430  */
 431 static int
 432 find_token(const char *buffer, const char *token)
 433 {
 434         char *buffer_tmp, *buffer_copy, *inputstring;
 435         char **ap;
 436         int found;
 437
 438         buffer_copy = strdup(buffer);
 439         buffer_tmp = buffer_copy;
 440         inputstring = buffer_copy;
 441         ap = &buffer_tmp;
 442
 443         found = 0;
 444
 445         while ((*ap = strsep(&inputstring, ",")) != NULL) {
 446                 if (strcmp(buffer_tmp, token) == 0) {
 447                         found = 1;
 448                         break;
 449                 }
 450         }
 451
 452         free(buffer_copy);
 453
 454         return found;
 455 }
 456
 457 /*
 458  * Compare function for qsort
 459  */
 460 static int
 461 compare_keymap(const void *a, const void *b)
 462 {
 463
 464         /* We've been passed pointers to pointers, so: */
 465         const struct keymap *km1 = *((const struct keymap * const *) a);
 466         const struct keymap *km2 = *((const struct keymap * const *) b);
 467
 468         return strcmp(km1->desc, km2->desc);
 469 }
 470
 471 /*
 472  * Compare function for qsort
 473  */
 474 static int
 475 compare_lang(const void *a, const void *b)
 476 {
 477         const char *l1 = *((const char * const *) a);
 478         const char *l2 = *((const char * const *) b);
 479
 480         return strcmp(l1, l2);
 481 }
 482
 483 /*
 484  * Change '8x8' to '8x08' so qsort will put it before eg. '8x14'
 485  */
 486 static void
 487 kludge_desc(struct keymap **km_sorted, int num_keymaps)
 488 {
 489         int i;
 490
 491         for (i=0; i<num_keymaps; i++) {
 492                 char *p;
 493                 char *km = km_sorted[i]->desc;
 494                 if ((p = strstr(km, "8x8")) != NULL) {
 495                         int len;
 496                         int j;
 497                         int offset;
 498
 499                         offset = p - km;
 500
 501                         /* Make enough space for the extra '0' */
 502                         len = strlen(km);
 503                         km = realloc(km, len + 2);
 504
 505                         for (j=len; j!=offset+1; j--)
 506                                 km[j + 1] = km[j];
 507
 508                         km[offset+2] = '0';
 509
 510                         km_sorted[i]->desc = km;
 511                 }
 512         }
 513 }
 514
 515 /*
 516  * Reverse 'kludge_desc()' - change '8x08' back to '8x8'
 517  */
 518 static void
 519 unkludge_desc(struct keymap **km_sorted, int num_keymaps)
 520 {
 521         int i;
 522
 523         for (i=0; i<num_keymaps; i++) {
 524                 char *p;
 525                 char *km = km_sorted[i]->desc;
 526                 if ((p = strstr(km, "8x08")) != NULL) {
 527                         p += 2;
 528                         while (*p++)
 529                                 p[-1] = p[0];
 530
 531                         km = realloc(km, p - km - 1);
 532                         km_sorted[i]->desc = km;
 533                 }
 534         }
 535 }
 536
 537 /*
 538  * Return 0 if file exists and is readable, else -1
 539  */
 540 static int
 541 check_file(const char *keym)
 542 {
 543         int status = 0;
 544
 545         if (access(keym, R_OK) == -1) {
 546                 char *fn;
 547                 asprintf(&fn, "%s/%s", dir, keym);
 548                 if (access(fn, R_OK) == -1) {
 549                         if (verbose)
 550                                 fprintf(stderr, "%s not found!\n", fn);
 551                         status = -1;
 552                 }
 553                 free(fn);
 554         } else {
 555                 if (verbose)
 556                         fprintf(stderr, "No read permission for %s!\n", keym);
 557                 status = -1;
 558         }
 559
 560         return status;
 561 }
 562
 563 /*
 564  * Read options from the relevant configuration file, then
 565  *  present to user.
 566  */
 567 static void
 568 menu_read(void)
 569 {
 570         const char *lg;
 571         char *p;
 572         int mark, num_keymaps, items, i;
 573         char buffer[256], filename[PATH_MAX];
 574         char keym[64], lng[64], desc[256];
 575         char dialect[64], lang_abk[64];
 576         struct keymap *km;
 577         struct keymap **km_sorted;
 578         struct dirent *dp;
 579         StringList *lang_list;
 580         FILE *fp;
 581         DIR *dirp;
 582
 583         lang_list = sl_init();
 584
 585         sprintf(filename, "%s/INDEX.%s", dir, extract_name(dir));
 586
 587         /* en_US.ISO8859-1 -> en_..\.ISO8859-1 */
 588         strlcpy(dialect, lang, sizeof(dialect));
 589         if (strlen(dialect) >= 6 && dialect[2] == '_') {
 590                 dialect[3] = '.';
 591                 dialect[4] = '.';
 592         }
 593
 594
 595         /* en_US.ISO8859-1 -> en */
 596         strlcpy(lang_abk, lang, sizeof(lang_abk));
 597         if (strlen(lang_abk) >= 3 && lang_abk[2] == '_')
 598                 lang_abk[2] = '\0';
 599
 600         fprintf(stderr, "lang_default = %s\n", lang_default);
 601         fprintf(stderr, "dialect = %s\n", dialect);
 602         fprintf(stderr, "lang_abk = %s\n", lang_abk);
 603
 604         fp = fopen(filename, "r");
 605         if (fp) {
 606                 int matches;
 607                 while (fgets(buffer, sizeof(buffer), fp)) {
 608                         p = buffer;
 609                         if (p[0] == '#')
 610                                 continue;
 611
 612                         while (isspace(*p))
 613                                 p++;
 614
 615                         if (*p == '\0')
 616                                 continue;
 617
 618                         /* Parse input, removing newline */
 619                         matches = sscanf(p, "%64[^:]:%64[^:]:%256[^:\n]",
 620                             keym, lng, desc);
 621                         if (matches == 3) {
 622                                 if (strcmp(keym, "FONT")
 623                                     && strcmp(keym, "MENU")) {
 624                                         /* Check file exists & is readable */
 625                                         if (check_file(keym) == -1)
 626                                                 continue;
 627                                 }
 628                         }
 629
 630                         if (show) {
 631                                 /*
 632                                  * Take note of supported languages, which
 633                                  * might be in a comma-delimited list
 634                                  */
 635                                 char *tmp = strdup(lng);
 636                                 char *delim = tmp;
 637
 638                                 for (delim = tmp; ; ) {
 639                                         char ch = *delim++;
 640                                         if (ch == ',' || ch == '\0') {
 641                                                 delim[-1] = '\0';
 642                                                 if (!sl_find(lang_list, tmp))
 643                                                         sl_add(lang_list, tmp);
 644                                                 if (ch == '\0')
 645                                                         break;
 646                                                 tmp = delim;
 647                                         }
 648                                 }
 649                         }
 650                         /* Set empty language to default language */
 651                         if (lng[0] == '\0')
 652                                 lg = lang_default;
 653                         else
 654                                 lg = lng;
 655
 656
 657                         /* 4) Your choice if it exists
 658                          * 3) Long match eg. en_GB.ISO8859-1 is equal to
 659                          *      en_..\.ISO8859-1
 660                          * 2) short match 'de'
 661                          * 1) default langlist 'en'
 662                          * 0) any language
 663                          *
 664                          * Language may be a comma separated list
 665                          * A higher match overwrites a lower
 666                          * A later entry overwrites a previous if it exists
 667                          *     twice in the database
 668                          */
 669
 670                         /* Check for favoured language */
 671                         km = get_keymap(keym);
 672                         mark = (km) ? km->mark : 0;
 673
 674                         if (find_token(lg, lang))
 675                                 add_keymap(desc, 4, keym);
 676                         else if (mark <= 3 && find_token(lg, dialect))
 677                                 add_keymap(desc, 3, keym);
 678                         else if (mark <= 2 && find_token(lg, lang_abk))
 679                                 add_keymap(desc, 2, keym);
 680                         else if (mark <= 1 && find_token(lg, lang_default))
 681                                 add_keymap(desc, 1, keym);
 682                         else if (mark <= 0)
 683                                 add_keymap(desc, 0, keym);
 684                 }
 685                 fclose(fp);
 686
 687         } else
 688                 printf("Could not open file\n");
 689
 690         if (show) {
 691                 qsort(lang_list->sl_str, lang_list->sl_cur, sizeof(char*),
 692                     compare_lang);
 693                 printf("Currently supported languages: ");
 694                 for (i=0; i< (int) lang_list->sl_cur; i++)
 695                         printf("%s ", lang_list->sl_str[i]);
 696                 puts("");
 697                 exit(0);
 698         }
 699
 700         km = get_keymap("MENU");
 701         if (km)
 702                 /* Take note of menu title */
 703                 menu = strdup(km->desc);
 704         km = get_keymap("FONT");
 705         if (km)
 706                 /* Take note of language font */
 707                 font = strdup(km->desc);
 708
 709         /* Remove unwanted items from list */
 710         remove_keymap("MENU");
 711         remove_keymap("FONT");
 712
 713         /* Look for keymaps not in database */
 714         dirp = opendir(dir);
 715         if (dirp) {
 716                 while ((dp = readdir(dirp)) != NULL) {
 717                         const char *ext = get_extension(dp->d_name);
 718                         if (ext) {
 719                                 if ((!strcmp(ext, ".fnt") ||
 720                                     !strcmp(ext, ".kbd")) &&
 721                                     !get_keymap(dp->d_name)) {
 722                                         char *q;
 723
 724                                         /* Remove any .fnt or .kbd extension */
 725                                         q = strdup(dp->d_name);
 726                                         *(get_extension(q)) = '\0';
 727                                         add_keymap(q, 0, dp->d_name);
 728                                         free(q);
 729
 730                                         if (verbose)
 731                                                 fprintf(stderr,
 732                                                     "'%s' not in database\n",
 733                                                     dp->d_name);
 734                                 }
 735                         }
 736                 }
 737                 closedir(dirp);
 738         } else
 739                 fprintf(stderr, "Could not open directory '%s'\n", dir);
 740
 741         /* Sort items in keymap */
 742         num_keymaps = get_num_keymaps();
 743
 744         km_sorted = (struct keymap **)
 745             malloc(num_keymaps*sizeof(struct keymap *));
 746
 747         /* Make array of pointers to items in hash */
 748         items = 0;
 749         SLIST_FOREACH(km, &head, entries)
 750                 km_sorted[items++] = km;
 751
 752         /* Change '8x8' to '8x08' so sort works as we might expect... */
 753         kludge_desc(km_sorted, num_keymaps);
 754
 755         qsort(km_sorted, num_keymaps, sizeof(struct keymap *), compare_keymap);
 756
 757         /* ...change back again */
 758         unkludge_desc(km_sorted, num_keymaps);
 759
 760         if (print) {
 761                 for (i=0; i<num_keymaps; i++)
 762                         printf("%s\n", km_sorted[i]->desc);
 763                 exit(0);
 764         }
 765
 766         show_dialog(km_sorted, num_keymaps);
 767
 768         free(km_sorted);
 769 }
 770
 771 /*
 772  * Display usage information and exit
 773  */
 774 static void
 775 usage(void)
 776 {
 777
 778         fprintf(stderr, "usage: %s\t[-K] [-V] [-d|-default] [-h|-help] "
 779             "[-l|-lang language]\n\t\t[-p|-print] [-r|-restore] [-s|-show] "
 780             "[-v|-verbose]\n", program);
 781         exit(1);
 782 }
 783
 784 static void
 785 parse_args(int argc, char **argv)
 786 {
 787         int i;
 788
 789         for (i=1; i<argc; i++) {
 790                 if (argv[i][0] != '-')
 791                         usage();
 792                 else if (!strcmp(argv[i], "-help") || !strcmp(argv[i], "-h"))
 793                         usage();
 794                 else if (!strcmp(argv[i], "-verbose") || !strcmp(argv[i], "-v"))
 795                         verbose = 1;
 796                 else if (!strcmp(argv[i], "-lang") || !strcmp(argv[i], "-l"))
 797                         if (i + 1 == argc)
 798                                 usage();
 799                         else
 800                                 lang = argv[++i];
 801                 else if (!strcmp(argv[i], "-default") || !strcmp(argv[i], "-d"))
 802                         lang = lang_default;
 803                 else if (!strcmp(argv[i], "-show") || !strcmp(argv[i], "-s"))
 804                         show = 1;
 805                 else if (!strcmp(argv[i], "-print") || !strcmp(argv[i], "-p"))
 806                         print = 1;
 807                 else if (!strcmp(argv[i], "-restore") ||
 808                     !strcmp(argv[i], "-r")) {
 809                         vidcontrol(font_current);
 810                         exit(0);
 811                 } else if (!strcmp(argv[i], "-K"))
 812                         dir = keymapdir;
 813                 else if (!strcmp(argv[i], "-V"))
 814                         dir = fontdir;
 815                 else
 816                         usage();
 817         }
 818 }
 819
 820 /*
 821  * A front-end for the 'vidfont' and 'kbdmap' programs.
 822  */
 823 int
 824 main(int argc, char **argv)
 825 {
 826
 827         x11 = system("kbdcontrol -d >/dev/null");
 828
 829         if (x11) {
 830                 fprintf(stderr, "You are not on a virtual console - "
 831                                 "expect certain strange side-effects\n");
 832                 sleep(2);
 833         }
 834
 835         if (check_newcons() == 0) {
 836                 keymapdir = DEFAULT_SC_KEYMAP_DIR;
 837                 fontdir = DEFAULT_SC_FONT_DIR;
 838                 font_default = DEFAULT_SC_FONT;
 839         }
 840
 841         SLIST_INIT(&head);
 842
 843         lang = get_locale();
 844
 845         program = extract_name(argv[0]);
 846
 847         font_current = get_font();
 848         if (font_current == NULL)
 849                 font_current = font_default;
 850
 851         if (strcmp(program, "kbdmap"))
 852                 dir = fontdir;
 853         else
 854                 dir = keymapdir;
 855
 856         /* Parse command line arguments */
 857         parse_args(argc, argv);
 858
 859         /* Read and display options */
 860         menu_read();
 861
 862         return 0;
 863 }