usr.sbin/kbdmap/kbdmap.c

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