usr.sbin/kbdcontrol/kbdcontrol.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause
   3  *
   4  * Copyright (c) 1994-1995 Søren Schmidt
   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  *    in this position and unchanged.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. The name of the author may not be used to endorse or promote products
  17  *    derived from this software without specific prior written permission
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  20  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  21  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  22  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  23  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  24  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  28  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include <sys/cdefs.h>
  32 #include <ctype.h>
  33 #include <err.h>
  34 #include <stdio.h>
  35 #include <stdlib.h>
  36 #include <string.h>
  37 #include <unistd.h>
  38 #include <fcntl.h>
  39 #include <sys/kbio.h>
  40 #include <sys/consio.h>
  41 #include <sys/param.h>
  42 #include <sys/queue.h>
  43 #include <sys/sysctl.h>
  44 #include "path.h"
  45 #include "lex.h"
  46
  47 #define SPECIAL         0x80000000
  48
  49 #ifndef BOOTSTRAP_KBDCONTROL
  50 static const char ctrl_names[32][4] = {
  51         "nul", "soh", "stx", "etx", "eot", "enq", "ack", "bel",
  52         "bs ", "ht ", "nl ", "vt ", "ff ", "cr ", "so ", "si ",
  53         "dle", "dc1", "dc2", "dc3", "dc4", "nak", "syn", "etb",
  54         "can", "em ", "sub", "esc", "fs ", "gs ", "rs ", "us "
  55         };
  56 #endif
  57
  58 static const char acc_names[15][5] = {
  59         "dgra", "dacu", "dcir", "dtil", "dmac", "dbre", "ddot",
  60         "duml", "dsla", "drin", "dced", "dapo", "ddac", "dogo",
  61         "dcar",
  62         };
  63
  64 static const char acc_names_u[15][5] = {
  65         "DGRA", "DACU", "DCIR", "DTIL", "DMAC", "DBRE", "DDOT",
  66         "DUML", "DSLA", "DRIN", "DCED", "DAPO", "DDAC", "DOGO",
  67         "DCAR",
  68         };
  69
  70 #ifndef BOOTSTRAP_KBDCONTROL
  71 static const char fkey_table[96][MAXFK] = {
  72 /* 01-04 */     "\033[M", "\033[N", "\033[O", "\033[P",
  73 /* 05-08 */     "\033[Q", "\033[R", "\033[S", "\033[T",
  74 /* 09-12 */     "\033[U", "\033[V", "\033[W", "\033[X",
  75 /* 13-16 */     "\033[Y", "\033[Z", "\033[a", "\033[b",
  76 /* 17-20 */     "\033[c", "\033[d", "\033[e", "\033[f",
  77 /* 21-24 */     "\033[g", "\033[h", "\033[i", "\033[j",
  78 /* 25-28 */     "\033[k", "\033[l", "\033[m", "\033[n",
  79 /* 29-32 */     "\033[o", "\033[p", "\033[q", "\033[r",
  80 /* 33-36 */     "\033[s", "\033[t", "\033[u", "\033[v",
  81 /* 37-40 */     "\033[w", "\033[x", "\033[y", "\033[z",
  82 /* 41-44 */     "\033[@", "\033[[", "\033[\\","\033[]",
  83 /* 45-48 */     "\033[^", "\033[_", "\033[`", "\033[{",
  84 /* 49-52 */     "\033[H", "\033[A", "\033[I", "-"     ,
  85 /* 53-56 */     "\033[D", "\033[E", "\033[C", "+"     ,
  86 /* 57-60 */     "\033[F", "\033[B", "\033[G", "\033[L",
  87 /* 61-64 */     "\177",   "\033[J", "\033[~", "\033[}",
  88 /* 65-68 */     ""      , ""      , ""      , ""      ,
  89 /* 69-72 */     ""      , ""      , ""      , ""      ,
  90 /* 73-76 */     ""      , ""      , ""      , ""      ,
  91 /* 77-80 */     ""      , ""      , ""      , ""      ,
  92 /* 81-84 */     ""      , ""      , ""      , ""      ,
  93 /* 85-88 */     ""      , ""      , ""      , ""      ,
  94 /* 89-92 */     ""      , ""      , ""      , ""      ,
  95 /* 93-96 */     ""      , ""      , ""      , ""      ,
  96         };
  97 #endif
  98
  99 #ifndef BOOTSTRAP_KBDCONTROL
 100 static const int ndelays = nitems(kbdelays);
 101 static const int nrepeats = nitems(kbrates);
 102 static int      hex = 0;
 103 #endif
 104 static int      paths_configured = 0;
 105 static int      token;
 106
 107 int             number;
 108 char            letter;
 109
 110 static void     add_keymap_path(const char *path);
 111 static void     dump_accent_definition(char *name, accentmap_t *accentmap);
 112 static void     dump_entry(int value);
 113 static void     dump_key_definition(char *name, keymap_t *keymap);
 114 static int      get_accent_definition_line(accentmap_t *);
 115 static int      get_entry(void);
 116 static int      get_key_definition_line(keymap_t *);
 117 static void     load_keymap(char *opt, int dumponly);
 118 #ifndef BOOTSTRAP_KBDCONTROL
 119 static void     load_default_functionkeys(void);
 120 #endif
 121 static char *   nextarg(int ac, char **av, int *indp, int oc);
 122 static char *   mkfullname(const char *s1, const char *s2, const char *s3);
 123 #ifndef BOOTSTRAP_KBDCONTROL
 124 static void     print_accent_definition_line(FILE *fp, int accent,
 125                 struct acc_t *key);
 126 static void     print_entry(FILE *fp, int value);
 127 static void     print_key_definition_line(FILE *fp, int scancode,
 128                 struct keyent_t *key);
 129 static void     print_keymap(void);
 130 static void     release_keyboard(void);
 131 static void     mux_keyboard(u_int op, char *kbd);
 132 static void     set_bell_values(char *opt);
 133 static void     set_functionkey(char *keynumstr, char *string);
 134 static void     set_keyboard(char *device);
 135 static void     set_keyrates(char *opt);
 136 static void     show_kbd_info(void);
 137 #endif
 138 static void     usage(void) __dead2;
 139
 140 struct pathent {
 141         STAILQ_ENTRY(pathent) next;
 142         char *path;
 143 };
 144 static STAILQ_HEAD(, pathent) pathlist = STAILQ_HEAD_INITIALIZER(pathlist);
 145
 146 #ifndef BOOTSTRAP_KBDCONTROL
 147 /* Detect presence of vt(4). */
 148 static int
 149 is_vt4(void)
 150 {
 151         char vty_name[4] = "";
 152         size_t len = sizeof(vty_name);
 153
 154         if (sysctlbyname("kern.vty", vty_name, &len, NULL, 0) != 0)
 155                 return (0);
 156         return (strcmp(vty_name, "vt") == 0);
 157 }
 158 #endif
 159
 160 static char *
 161 nextarg(int ac, char **av, int *indp, int oc)
 162 {
 163         if (*indp < ac)
 164                 return(av[(*indp)++]);
 165         warnx("option requires two arguments -- %c", oc);
 166         usage();
 167 }
 168
 169
 170 static char *
 171 mkfullname(const char *s1, const char *s2, const char *s3)
 172 {
 173         static char     *buf = NULL;
 174         static int      bufl = 0;
 175         int             f;
 176
 177         f = strlen(s1) + strlen(s2) + strlen(s3) + 1;
 178         if (f > bufl) {
 179                 if (buf)
 180                         buf = (char *)realloc(buf, f);
 181                 else
 182                         buf = (char *)malloc(f);
 183         }
 184         if (!buf) {
 185                 bufl = 0;
 186                 return(NULL);
 187         }
 188
 189         bufl = f;
 190         strcpy(buf, s1);
 191         strcat(buf, s2);
 192         strcat(buf, s3);
 193         return(buf);
 194 }
 195
 196
 197 static int
 198 get_entry(void)
 199 {
 200         switch ((token = yylex())) {
 201         case TNOP:
 202                 return NOP | SPECIAL;
 203         case TLSH:
 204                 return LSH | SPECIAL;
 205         case TRSH:
 206                 return RSH | SPECIAL;
 207         case TCLK:
 208                 return CLK | SPECIAL;
 209         case TNLK:
 210                 return NLK | SPECIAL;
 211         case TSLK:
 212                 return SLK | SPECIAL;
 213         case TBTAB:
 214                 return BTAB | SPECIAL;
 215         case TLALT:
 216                 return LALT | SPECIAL;
 217         case TLCTR:
 218                 return LCTR | SPECIAL;
 219         case TNEXT:
 220                 return NEXT | SPECIAL;
 221         case TPREV:
 222                 return PREV | SPECIAL;
 223         case TRCTR:
 224                 return RCTR | SPECIAL;
 225         case TRALT:
 226                 return RALT | SPECIAL;
 227         case TALK:
 228                 return ALK | SPECIAL;
 229         case TASH:
 230                 return ASH | SPECIAL;
 231         case TMETA:
 232                 return META | SPECIAL;
 233         case TRBT:
 234                 return RBT | SPECIAL;
 235         case TDBG:
 236                 return DBG | SPECIAL;
 237         case TSUSP:
 238                 return SUSP | SPECIAL;
 239         case TSPSC:
 240                 return SPSC | SPECIAL;
 241         case TPANIC:
 242                 return PNC | SPECIAL;
 243         case TLSHA:
 244                 return LSHA | SPECIAL;
 245         case TRSHA:
 246                 return RSHA | SPECIAL;
 247         case TLCTRA:
 248                 return LCTRA | SPECIAL;
 249         case TRCTRA:
 250                 return RCTRA | SPECIAL;
 251         case TLALTA:
 252                 return LALTA | SPECIAL;
 253         case TRALTA:
 254                 return RALTA | SPECIAL;
 255         case THALT:
 256                 return HALT | SPECIAL;
 257         case TPDWN:
 258                 return PDWN | SPECIAL;
 259         case TPASTE:
 260                 return PASTE | SPECIAL;
 261         case TACC:
 262                 if (ACC(number) > L_ACC)
 263                         return -1;
 264                 return ACC(number) | SPECIAL;
 265         case TFUNC:
 266                 if (F(number) > L_FN)
 267                         return -1;
 268                 return F(number) | SPECIAL;
 269         case TSCRN:
 270                 if (S(number) > L_SCR)
 271                         return -1;
 272                 return S(number) | SPECIAL;
 273         case TLET:
 274                 return (unsigned char)letter;
 275         case TNUM:
 276                 if (number < 0x000000 || number > 0x10FFFF)
 277                         return -1;
 278                 return number;
 279         default:
 280                 return -1;
 281         }
 282 }
 283
 284 static int
 285 get_definition_line(FILE *file, keymap_t *keymap, accentmap_t *accentmap)
 286 {
 287         int c;
 288
 289         yyin = file;
 290
 291         if (token < 0)
 292                 token = yylex();
 293         switch (token) {
 294         case TNUM:
 295                 c = get_key_definition_line(keymap);
 296                 if (c < 0)
 297                         errx(1, "invalid key definition");
 298                 if (c > keymap->n_keys)
 299                         keymap->n_keys = c;
 300                 break;
 301         case TACC:
 302                 c = get_accent_definition_line(accentmap);
 303                 if (c < 0)
 304                         errx(1, "invalid accent key definition");
 305                 if (c > accentmap->n_accs)
 306                         accentmap->n_accs = c;
 307                 break;
 308         case 0:
 309                 /* EOF */
 310                 return -1;
 311         default:
 312                 errx(1, "illegal definition line");
 313         }
 314         return c;
 315 }
 316
 317 static int
 318 get_key_definition_line(keymap_t *map)
 319 {
 320         int i, def, scancode;
 321
 322         /* check scancode number */
 323         if (number < 0 || number >= NUM_KEYS)
 324                 return -1;
 325         scancode = number;
 326
 327         /* get key definitions */
 328         map->key[scancode].spcl = 0;
 329         for (i=0; i<NUM_STATES; i++) {
 330                 if ((def = get_entry()) == -1)
 331                         return -1;
 332                 if (def & SPECIAL)
 333                         map->key[scancode].spcl |= (0x80 >> i);
 334                 map->key[scancode].map[i] = def & ~SPECIAL;
 335         }
 336         /* get lock state key def */
 337         if ((token = yylex()) != TFLAG)
 338                 return -1;
 339         map->key[scancode].flgs = number;
 340         token = yylex();
 341         return (scancode + 1);
 342 }
 343
 344 static int
 345 get_accent_definition_line(accentmap_t *map)
 346 {
 347         int accent;
 348         int c1, c2;
 349         int i;
 350
 351         if (ACC(number) < F_ACC || ACC(number) > L_ACC)
 352                 /* number out of range */
 353                 return -1;
 354         accent = number;
 355         if (map->acc[accent].accchar != 0) {
 356                 /* this entry has already been defined before! */
 357                 errx(1, "duplicated accent key definition");
 358         }
 359
 360         switch ((token = yylex())) {
 361         case TLET:
 362                 map->acc[accent].accchar = letter;
 363                 break;
 364         case TNUM:
 365                 map->acc[accent].accchar = number;
 366                 break;
 367         default:
 368                 return -1;
 369         }
 370
 371         for (i = 0; (token = yylex()) == '(';) {
 372                 switch ((token = yylex())) {
 373                 case TLET:
 374                         c1 = letter;
 375                         break;
 376                 case TNUM:
 377                         c1 = number;
 378                         break;
 379                 default:
 380                         return -1;
 381                 }
 382                 switch ((token = yylex())) {
 383                 case TLET:
 384                         c2 = letter;
 385                         break;
 386                 case TNUM:
 387                         c2 = number;
 388                         break;
 389                 default:
 390                         return -1;
 391                 }
 392                 if ((token = yylex()) != ')')
 393                         return -1;
 394                 if (i >= NUM_ACCENTCHARS) {
 395                         warnx("too many accented characters, ignored");
 396                         continue;
 397                 }
 398                 map->acc[accent].map[i][0] = c1;
 399                 map->acc[accent].map[i][1] = c2;
 400                 ++i;
 401         }
 402         return (accent + 1);
 403 }
 404
 405 #ifndef BOOTSTRAP_KBDCONTROL
 406 static void
 407 print_entry(FILE *fp, int value)
 408 {
 409         int val = value & ~SPECIAL;
 410
 411         switch (value) {
 412         case NOP | SPECIAL:
 413                 fprintf(fp, " nop   ");
 414                 break;
 415         case LSH | SPECIAL:
 416                 fprintf(fp, " lshift");
 417                 break;
 418         case RSH | SPECIAL:
 419                 fprintf(fp, " rshift");
 420                 break;
 421         case CLK | SPECIAL:
 422                 fprintf(fp, " clock ");
 423                 break;
 424         case NLK | SPECIAL:
 425                 fprintf(fp, " nlock ");
 426                 break;
 427         case SLK | SPECIAL:
 428                 fprintf(fp, " slock ");
 429                 break;
 430         case BTAB | SPECIAL:
 431                 fprintf(fp, " btab  ");
 432                 break;
 433         case LALT | SPECIAL:
 434                 fprintf(fp, " lalt  ");
 435                 break;
 436         case LCTR | SPECIAL:
 437                 fprintf(fp, " lctrl ");
 438                 break;
 439         case NEXT | SPECIAL:
 440                 fprintf(fp, " nscr  ");
 441                 break;
 442         case PREV | SPECIAL:
 443                 fprintf(fp, " pscr  ");
 444                 break;
 445         case RCTR | SPECIAL:
 446                 fprintf(fp, " rctrl ");
 447                 break;
 448         case RALT | SPECIAL:
 449                 fprintf(fp, " ralt  ");
 450                 break;
 451         case ALK | SPECIAL:
 452                 fprintf(fp, " alock ");
 453                 break;
 454         case ASH | SPECIAL:
 455                 fprintf(fp, " ashift");
 456                 break;
 457         case META | SPECIAL:
 458                 fprintf(fp, " meta  ");
 459                 break;
 460         case RBT | SPECIAL:
 461                 fprintf(fp, " boot  ");
 462                 break;
 463         case DBG | SPECIAL:
 464                 fprintf(fp, " debug ");
 465                 break;
 466         case SUSP | SPECIAL:
 467                 fprintf(fp, " susp  ");
 468                 break;
 469         case SPSC | SPECIAL:
 470                 fprintf(fp, " saver ");
 471                 break;
 472         case PNC | SPECIAL:
 473                 fprintf(fp, " panic ");
 474                 break;
 475         case LSHA | SPECIAL:
 476                 fprintf(fp, " lshifta");
 477                 break;
 478         case RSHA | SPECIAL:
 479                 fprintf(fp, " rshifta");
 480                 break;
 481         case LCTRA | SPECIAL:
 482                 fprintf(fp, " lctrla");
 483                 break;
 484         case RCTRA | SPECIAL:
 485                 fprintf(fp, " rctrla");
 486                 break;
 487         case LALTA | SPECIAL:
 488                 fprintf(fp, " lalta ");
 489                 break;
 490         case RALTA | SPECIAL:
 491                 fprintf(fp, " ralta ");
 492                 break;
 493         case HALT | SPECIAL:
 494                 fprintf(fp, " halt  ");
 495                 break;
 496         case PDWN | SPECIAL:
 497                 fprintf(fp, " pdwn  ");
 498                 break;
 499         case PASTE | SPECIAL:
 500                 fprintf(fp, " paste ");
 501                 break;
 502         default:
 503                 if (value & SPECIAL) {
 504                         if (val >= F_FN && val <= L_FN)
 505                                 fprintf(fp, " fkey%02d", val - F_FN + 1);
 506                         else if (val >= F_SCR && val <= L_SCR)
 507                                 fprintf(fp, " scr%02d ", val - F_SCR + 1);
 508                         else if (val >= F_ACC && val <= L_ACC)
 509                                 fprintf(fp, " %-6s", acc_names[val - F_ACC]);
 510                         else if (hex)
 511                                 fprintf(fp, " 0x%02x  ", val);
 512                         else
 513                                 fprintf(fp, " %3d   ", val);
 514                 }
 515                 else {
 516                         if (val < ' ')
 517                                 fprintf(fp, " %s   ", ctrl_names[val]);
 518                         else if (val == 127)
 519                                 fprintf(fp, " del   ");
 520                         else if (isascii(val) && isprint(val))
 521                                 fprintf(fp, " '%c'   ", val);
 522                         else if (hex)
 523                                 fprintf(fp, " 0x%02x  ", val);
 524                         else
 525                                 fprintf(fp, " %3d   ", val);
 526                 }
 527         }
 528 }
 529
 530 static void
 531 print_key_definition_line(FILE *fp, int scancode, struct keyent_t *key)
 532 {
 533         int i;
 534
 535         /* print scancode number */
 536         if (hex)
 537                 fprintf(fp, " 0x%02x  ", scancode);
 538         else
 539                 fprintf(fp, "  %03d  ", scancode);
 540
 541         /* print key definitions */
 542         for (i=0; i<NUM_STATES; i++) {
 543                 if (key->spcl & (0x80 >> i))
 544                         print_entry(fp, key->map[i] | SPECIAL);
 545                 else
 546                         print_entry(fp, key->map[i]);
 547         }
 548
 549         /* print lock state key def */
 550         switch (key->flgs) {
 551         case 0:
 552                 fprintf(fp, "  O\n");
 553                 break;
 554         case 1:
 555                 fprintf(fp, "  C\n");
 556                 break;
 557         case 2:
 558                 fprintf(fp, "  N\n");
 559                 break;
 560         case 3:
 561                 fprintf(fp, "  B\n");
 562                 break;
 563         }
 564 }
 565
 566 static void
 567 print_accent_definition_line(FILE *fp, int accent, struct acc_t *key)
 568 {
 569         int c;
 570         int i;
 571
 572         if (key->accchar == 0)
 573                 return;
 574
 575         /* print accent number */
 576         fprintf(fp, "  %-6s", acc_names[accent]);
 577         if (isascii(key->accchar) && isprint(key->accchar))
 578                 fprintf(fp, "'%c'  ", key->accchar);
 579         else if (hex)
 580                 fprintf(fp, "0x%02x ", key->accchar);
 581         else
 582                 fprintf(fp, "%03d  ", key->accchar);
 583
 584         for (i = 0; i < NUM_ACCENTCHARS; ++i) {
 585                 c = key->map[i][0];
 586                 if (c == 0)
 587                         break;
 588                 if ((i > 0) && ((i % 4) == 0))
 589                         fprintf(fp, "\n             ");
 590                 if (isascii(c) && isprint(c))
 591                         fprintf(fp, "( '%c' ", c);
 592                 else if (hex)
 593                         fprintf(fp, "(0x%02x ", c);
 594                 else
 595                         fprintf(fp, "( %03d ", c);
 596                 c = key->map[i][1];
 597                 if (isascii(c) && isprint(c))
 598                         fprintf(fp, "'%c' ) ", c);
 599                 else if (hex)
 600                         fprintf(fp, "0x%02x) ", c);
 601                 else
 602                         fprintf(fp, "%03d ) ", c);
 603         }
 604         fprintf(fp, "\n");
 605 }
 606 #endif
 607
 608 static void
 609 dump_entry(int value)
 610 {
 611         if (value & SPECIAL) {
 612                 value &= ~SPECIAL;
 613                 switch (value) {
 614                 case NOP:
 615                         printf("  NOP, ");
 616                         break;
 617                 case LSH:
 618                         printf("  LSH, ");
 619                         break;
 620                 case RSH:
 621                         printf("  RSH, ");
 622                         break;
 623                 case CLK:
 624                         printf("  CLK, ");
 625                         break;
 626                 case NLK:
 627                         printf("  NLK, ");
 628                         break;
 629                 case SLK:
 630                         printf("  SLK, ");
 631                         break;
 632                 case BTAB:
 633                         printf(" BTAB, ");
 634                         break;
 635                 case LALT:
 636                         printf(" LALT, ");
 637                         break;
 638                 case LCTR:
 639                         printf(" LCTR, ");
 640                         break;
 641                 case NEXT:
 642                         printf(" NEXT, ");
 643                         break;
 644                 case PREV:
 645                         printf(" PREV, ");
 646                         break;
 647                 case RCTR:
 648                         printf(" RCTR, ");
 649                         break;
 650                 case RALT:
 651                         printf(" RALT, ");
 652                         break;
 653                 case ALK:
 654                         printf("  ALK, ");
 655                         break;
 656                 case ASH:
 657                         printf("  ASH, ");
 658                         break;
 659                 case META:
 660                         printf(" META, ");
 661                         break;
 662                 case RBT:
 663                         printf("  RBT, ");
 664                         break;
 665                 case DBG:
 666                         printf("  DBG, ");
 667                         break;
 668                 case SUSP:
 669                         printf(" SUSP, ");
 670                         break;
 671                 case SPSC:
 672                         printf(" SPSC, ");
 673                         break;
 674                 case PNC:
 675                         printf("  PNC, ");
 676                         break;
 677                 case LSHA:
 678                         printf(" LSHA, ");
 679                         break;
 680                 case RSHA:
 681                         printf(" RSHA, ");
 682                         break;
 683                 case LCTRA:
 684                         printf("LCTRA, ");
 685                         break;
 686                 case RCTRA:
 687                         printf("RCTRA, ");
 688                         break;
 689                 case LALTA:
 690                         printf("LALTA, ");
 691                         break;
 692                 case RALTA:
 693                         printf("RALTA, ");
 694                         break;
 695                 case HALT:
 696                         printf(" HALT, ");
 697                         break;
 698                 case PDWN:
 699                         printf(" PDWN, ");
 700                         break;
 701                 case PASTE:
 702                         printf("PASTE, ");
 703                         break;
 704                 default:
 705                         if (value >= F_FN && value <= L_FN)
 706                                 printf(" F(%2d),", value - F_FN + 1);
 707                         else if (value >= F_SCR && value <= L_SCR)
 708                                 printf(" S(%2d),", value - F_SCR + 1);
 709                         else if (value >= F_ACC && value <= L_ACC)
 710                                 printf(" %-4s, ", acc_names_u[value - F_ACC]);
 711                         else
 712                                 printf(" 0x%02X, ", value);
 713                         break;
 714                 }
 715         } else if (value == '\'') {
 716                 printf(" '\\'', ");
 717         } else if (value == '\\') {
 718                 printf(" '\\\\', ");
 719         } else if (isascii(value) && isprint(value)) {
 720                 printf("  '%c', ", value);
 721         } else {
 722                 printf(" 0x%02X, ", value);
 723         }
 724 }
 725
 726 static void
 727 dump_key_definition(char *name, keymap_t *keymap)
 728 {
 729         int     i, j;
 730
 731         printf("static keymap_t keymap_%s = { 0x%02x, {\n",
 732                name, (unsigned)keymap->n_keys);
 733         printf(
 734 "/*                                                         alt\n"
 735 " * scan                       cntrl          alt    alt   cntrl\n"
 736 " * code  base   shift  cntrl  shift   alt   shift  cntrl  shift    spcl flgs\n"
 737 " * ---------------------------------------------------------------------------\n"
 738 " */\n");
 739         for (i = 0; i < keymap->n_keys; i++) {
 740                 printf("/*%02x*/{{", i);
 741                 for (j = 0; j < NUM_STATES; j++) {
 742                         if (keymap->key[i].spcl & (0x80 >> j))
 743                                 dump_entry(keymap->key[i].map[j] | SPECIAL);
 744                         else
 745                                 dump_entry(keymap->key[i].map[j]);
 746                 }
 747                 printf("}, 0x%02X,0x%02X },\n",
 748                        (unsigned)keymap->key[i].spcl,
 749                        (unsigned)keymap->key[i].flgs);
 750         }
 751         printf("} };\n\n");
 752 }
 753
 754 static void
 755 dump_accent_definition(char *name, accentmap_t *accentmap)
 756 {
 757         int i, j;
 758         int c;
 759
 760         printf("static accentmap_t accentmap_%s = { %d",
 761                 name, accentmap->n_accs);
 762         if (accentmap->n_accs <= 0) {
 763                 printf(" };\n\n");
 764                 return;
 765         }
 766         printf(", {\n");
 767         for (i = 0; i < NUM_DEADKEYS; i++) {
 768                 printf("    /* %s=%d */\n    {", acc_names[i], i);
 769                 c = accentmap->acc[i].accchar;
 770                 if (c == '\'')
 771                         printf(" '\\'', {");
 772                 else if (c == '\\')
 773                         printf(" '\\\\', {");
 774                 else if (isascii(c) && isprint(c))
 775                         printf("  '%c', {", c);
 776                 else if (c == 0) {
 777                         printf(" 0x00 }, \n");
 778                         continue;
 779                 } else
 780                         printf(" 0x%02x, {", c);
 781                 for (j = 0; j < NUM_ACCENTCHARS; j++) {
 782                         c = accentmap->acc[i].map[j][0];
 783                         if (c == 0)
 784                                 break;
 785                         if ((j > 0) && ((j % 4) == 0))
 786                                 printf("\n\t     ");
 787                         if (isascii(c) && isprint(c))
 788                                 printf(" {  '%c',", c);
 789                         else
 790                                 printf(" { 0x%02x,", c);
 791                         printf("0x%02x },", accentmap->acc[i].map[j][1]);
 792                 }
 793                 printf(" }, },\n");
 794         }
 795         printf("} };\n\n");
 796 }
 797
 798 static void
 799 add_keymap_path(const char *path)
 800 {
 801         struct pathent* pe;
 802         size_t len;
 803
 804         len = strlen(path);
 805         if ((pe = malloc(sizeof(*pe))) == NULL ||
 806             (pe->path = malloc(len + 2)) == NULL)
 807                 err(1, "malloc");
 808         memcpy(pe->path, path, len);
 809         if (len > 0 && path[len - 1] != '/')
 810                 pe->path[len++] = '/';
 811         pe->path[len] = '\0';
 812         STAILQ_INSERT_TAIL(&pathlist, pe, next);
 813 }
 814
 815 #ifdef OPIO_DEADKEYMAP
 816 static void
 817 to_old_accentmap(accentmap_t *from, oaccentmap_t *to)
 818 {
 819         int i, j;
 820
 821         to->n_accs = from->n_accs;
 822         for (i = 0; i < NUM_DEADKEYS; i++) {
 823                 for (j = 0; j < NUM_ACCENTCHARS; j++) {
 824                         to->acc[i].map[j][0] = from->acc[i].map[j][0];
 825                         to->acc[i].map[j][1] = from->acc[i].map[j][1];
 826                         to->acc[i].accchar = from->acc[i].accchar;
 827                 }
 828         }
 829 }
 830 #endif /* OPIO_DEADKEYMAP */
 831
 832 static void
 833 load_keymap(char *opt, int dumponly)
 834 {
 835         keymap_t keymap;
 836         accentmap_t accentmap;
 837 #ifdef OPIO_DEADKEYMAP
 838         oaccentmap_t oaccentmap;
 839 #endif /* OPIO_DEADKEYMAP */
 840         struct pathent *pe;
 841         FILE    *file;
 842         int     j;
 843         char    *name, *cp;
 844         char    blank[] = "", keymap_path[] = KEYMAP_PATH;
 845         char    vt_keymap_path[] = VT_KEYMAP_PATH, dotkbd[] = ".kbd";
 846         char    *postfix[] = {blank, dotkbd, NULL};
 847
 848         if (!paths_configured) {
 849                 cp = getenv("KEYMAP_PATH");
 850                 if (cp != NULL)
 851                         add_keymap_path(cp);
 852                 add_keymap_path("");
 853 #ifndef BOOTSTRAP_KBDCONTROL
 854                 if (is_vt4())
 855                         add_keymap_path(vt_keymap_path);
 856                 else
 857                         add_keymap_path(keymap_path);
 858 #endif
 859                 paths_configured = 1;
 860         }
 861
 862         file = NULL;
 863         STAILQ_FOREACH(pe, &pathlist, next) {
 864                 for (j=0; postfix[j] && file == NULL; j++) {
 865                         name = mkfullname(pe->path, opt, postfix[j]);
 866                         file = fopen(name, "r");
 867                         if (file != NULL)
 868                                 break;
 869                 }
 870         }
 871         if (file == NULL) {
 872                 warn("keymap file \"%s\" not found", opt);
 873                 return;
 874         }
 875         memset(&keymap, 0, sizeof(keymap));
 876         memset(&accentmap, 0, sizeof(accentmap));
 877         token = -1;
 878         while (1) {
 879                 if (get_definition_line(file, &keymap, &accentmap) < 0)
 880                         break;
 881         }
 882         if (dumponly) {
 883                 /* fix up the filename to make it a valid C identifier */
 884                 for (cp = opt; *cp; cp++)
 885                         if (!isalpha(*cp) && !isdigit(*cp)) *cp = '_';
 886                 printf("/*\n"
 887                        " * Automatically generated from %s.\n"
 888                        " * DO NOT EDIT!\n"
 889                        " */\n", name);
 890                 dump_key_definition(opt, &keymap);
 891                 dump_accent_definition(opt, &accentmap);
 892                 return;
 893         }
 894 #ifndef BOOTSTRAP_KBDCONTROL
 895         if ((keymap.n_keys > 0) && (ioctl(0, PIO_KEYMAP, &keymap) < 0)) {
 896                 warn("setting keymap");
 897                 fclose(file);
 898                 return;
 899         }
 900         if ((accentmap.n_accs > 0)
 901             && (ioctl(0, PIO_DEADKEYMAP, &accentmap) < 0)) {
 902 #ifdef OPIO_DEADKEYMAP
 903                 to_old_accentmap(&accentmap, &oaccentmap);
 904                 if (ioctl(0, OPIO_DEADKEYMAP, &oaccentmap) < 0)
 905 #endif /* OGIO_DEADKEYMAP */
 906                 {
 907                         warn("setting accentmap");
 908                         fclose(file);
 909                         return;
 910                 }
 911         }
 912 #endif
 913 }
 914
 915 #ifdef OPIO_DEADKEYMAP
 916 static void
 917 to_new_accentmap(oaccentmap_t *from, accentmap_t *to)
 918 {
 919         int i, j;
 920
 921         to->n_accs = from->n_accs;
 922         for (i = 0; i < NUM_DEADKEYS; i++) {
 923                 for (j = 0; j < NUM_ACCENTCHARS; j++) {
 924                         to->acc[i].map[j][0] = from->acc[i].map[j][0];
 925                         to->acc[i].map[j][1] = from->acc[i].map[j][1];
 926                         to->acc[i].accchar = from->acc[i].accchar;
 927                 }
 928         }
 929 }
 930 #endif /* OPIO_DEADKEYMAP */
 931
 932 #ifndef BOOTSTRAP_KBDCONTROL
 933 static void
 934 print_keymap(void)
 935 {
 936         keymap_t keymap;
 937         accentmap_t accentmap;
 938 #ifdef OGIO_DEADKEYMAP
 939         oaccentmap_t oaccentmap;
 940 #endif /* OPIO_DEADKEYMAP */
 941         int i;
 942
 943         if (ioctl(0, GIO_KEYMAP, &keymap) < 0)
 944                 err(1, "getting keymap");
 945         if (ioctl(0, GIO_DEADKEYMAP, &accentmap) < 0) {
 946 #ifdef OGIO_DEADKEYMAP
 947                 if (ioctl(0, OGIO_DEADKEYMAP, &oaccentmap) == 0)
 948                         to_new_accentmap(&oaccentmap, &accentmap);
 949                 else
 950 #endif /* OGIO_DEADKEYMAP */
 951                         memset(&accentmap, 0, sizeof(accentmap));
 952         }
 953         printf(
 954 "#                                                         alt\n"
 955 "# scan                       cntrl          alt    alt   cntrl lock\n"
 956 "# code  base   shift  cntrl  shift  alt    shift  cntrl  shift state\n"
 957 "# ------------------------------------------------------------------\n"
 958         );
 959         for (i=0; i<keymap.n_keys; i++)
 960                 print_key_definition_line(stdout, i, &keymap.key[i]);
 961
 962         printf("\n");
 963         for (i = 0; i < NUM_DEADKEYS; i++)
 964                 print_accent_definition_line(stdout, i, &accentmap.acc[i]);
 965
 966 }
 967
 968 static void
 969 load_default_functionkeys(void)
 970 {
 971         fkeyarg_t fkey;
 972         int i;
 973
 974         for (i=0; i<NUM_FKEYS; i++) {
 975                 fkey.keynum = i;
 976                 strcpy(fkey.keydef, fkey_table[i]);
 977                 fkey.flen = strlen(fkey_table[i]);
 978                 if (ioctl(0, SETFKEY, &fkey) < 0)
 979                         warn("setting function key");
 980         }
 981 }
 982
 983 static void
 984 set_functionkey(char *keynumstr, char *string)
 985 {
 986         fkeyarg_t fkey;
 987
 988         if (!strcmp(keynumstr, "load") && !strcmp(string, "default")) {
 989                 load_default_functionkeys();
 990                 return;
 991         }
 992         fkey.keynum = atoi(keynumstr);
 993         if (fkey.keynum < 1 || fkey.keynum > NUM_FKEYS) {
 994                 warnx("function key number must be between 1 and %d",
 995                         NUM_FKEYS);
 996                 return;
 997         }
 998         if ((fkey.flen = strlen(string)) > MAXFK) {
 999                 warnx("function key string too long (%d > %d)",
1000                         fkey.flen, MAXFK);
1001                 return;
1002         }
1003         strncpy(fkey.keydef, string, MAXFK);
1004         fkey.keynum -= 1;
1005         if (ioctl(0, SETFKEY, &fkey) < 0)
1006                 warn("setting function key");
1007 }
1008
1009 static void
1010 set_bell_values(char *opt)
1011 {
1012         int bell, duration, pitch;
1013
1014         bell = 0;
1015         duration = 0;
1016         pitch = 0;
1017         if (!strncmp(opt, "quiet.", 6)) {
1018                 bell = CONS_QUIET_BELL;
1019                 opt += 6;
1020         }
1021         if (!strcmp(opt, "visual"))
1022                 bell |= CONS_VISUAL_BELL;
1023         else if (!strcmp(opt, "normal"))
1024                 duration = 5, pitch = 800;
1025         else if (!strcmp(opt, "off"))
1026                 duration = 0, pitch = 0;
1027         else {
1028                 char            *v1;
1029
1030                 bell = 0;
1031                 duration = strtol(opt, &v1, 0);
1032                 if ((duration < 0) || (*v1 != '.'))
1033                         goto badopt;
1034                 opt = ++v1;
1035                 pitch = strtol(opt, &v1, 0);
1036                 if ((pitch < 0) || (*opt == '\0') || (*v1 != '\0')) {
1037 badopt:
1038                         warnx("argument to -b must be duration.pitch or [quiet.]visual|normal|off");
1039                         return;
1040                 }
1041                 if (pitch != 0)
1042                         pitch = 1193182 / pitch;        /* in Hz */
1043                 duration /= 10; /* in 10 m sec */
1044         }
1045
1046         ioctl(0, CONS_BELLTYPE, &bell);
1047         if (duration > 0 && pitch > 0)
1048                 fprintf(stderr, "\e[=%d;%dB", pitch, duration);
1049 }
1050
1051 static void
1052 set_keyrates(char *opt)
1053 {
1054         int arg[2];
1055         int repeat;
1056         int delay;
1057         int r, d;
1058
1059         if (!strcmp(opt, "slow")) {
1060                 delay = 1000;
1061                 repeat = 504;
1062                 d = 3;
1063                 r = 31;
1064         } else if (!strcmp(opt, "normal")) {
1065                 delay = 500;
1066                 repeat = 126;
1067                 d = 1;
1068                 r = 15;
1069         } else if (!strcmp(opt, "fast")) {
1070                 delay = 0;
1071                 repeat = 0;
1072                 d = 0;
1073                 r = 0;
1074         } else {
1075                 int             n;
1076                 char            *v1;
1077
1078                 delay = strtol(opt, &v1, 0);
1079                 if ((delay < 0) || (*v1 != '.'))
1080                         goto badopt;
1081                 opt = ++v1;
1082                 repeat = strtol(opt, &v1, 0);
1083                 if ((repeat < 0) || (*opt == '\0') || (*v1 != '\0')) {
1084 badopt:
1085                         warnx("argument to -r must be delay.repeat or slow|normal|fast");
1086                         return;
1087                 }
1088                 for (n = 0; n < ndelays - 1; n++)
1089                         if (delay <= kbdelays[n])
1090                                 break;
1091                 d = n;
1092                 for (n = 0; n < nrepeats - 1; n++)
1093                         if (repeat <= kbrates[n])
1094                                 break;
1095                 r = n;
1096         }
1097
1098         arg[0] = delay;
1099         arg[1] = repeat;
1100         if (ioctl(0, KDSETREPEAT, arg)) {
1101                 warn("fallback, setting keyboard rate via legacy interface (KDSETRAD), will be removed soon");
1102                 if (ioctl(0, KDSETRAD, (d << 5) | r))
1103                         warn("setting keyboard rate");
1104         }
1105 }
1106
1107 static const char *
1108 get_kbd_type_name(int type)
1109 {
1110         static struct {
1111                 int type;
1112                 const char *name;
1113         } name_table[] = {
1114                 { KB_84,        "AT 84" },
1115                 { KB_101,       "AT 101/102" },
1116                 { KB_OTHER,     "generic" },
1117         };
1118         unsigned int i;
1119
1120         for (i = 0; i < sizeof(name_table)/sizeof(name_table[0]); ++i) {
1121                 if (type == name_table[i].type)
1122                         return name_table[i].name;
1123         }
1124         return "unknown";
1125 }
1126
1127 static void
1128 show_kbd_info(void)
1129 {
1130         keyboard_info_t info;
1131
1132         if (ioctl(0, KDGKBINFO, &info) == -1) {
1133                 warn("unable to obtain keyboard information");
1134                 return;
1135         }
1136         printf("kbd%d:\n", info.kb_index);
1137         printf("    %.*s%d, type:%s (%d)\n",
1138                 (int)sizeof(info.kb_name), info.kb_name, info.kb_unit,
1139                 get_kbd_type_name(info.kb_type), info.kb_type);
1140 }
1141
1142 static void
1143 set_keyboard(char *device)
1144 {
1145         keyboard_info_t info;
1146         int fd;
1147
1148         fd = open(device, O_RDONLY);
1149         if (fd < 0) {
1150                 warn("cannot open %s", device);
1151                 return;
1152         }
1153         if (ioctl(fd, KDGKBINFO, &info) == -1) {
1154                 warn("unable to obtain keyboard information");
1155                 close(fd);
1156                 return;
1157         }
1158         /*
1159          * The keyboard device driver won't release the keyboard by
1160          * the following ioctl, but it automatically will, when the device
1161          * is closed.  So, we don't check error here.
1162          */
1163         ioctl(fd, CONS_RELKBD, 0);
1164         close(fd);
1165 #if 1
1166         printf("kbd%d\n", info.kb_index);
1167         printf("    %.*s%d, type:%s (%d)\n",
1168                 (int)sizeof(info.kb_name), info.kb_name, info.kb_unit,
1169                 get_kbd_type_name(info.kb_type), info.kb_type);
1170 #endif
1171
1172         if (ioctl(0, CONS_SETKBD, info.kb_index) == -1)
1173                 warn("unable to set keyboard");
1174 }
1175
1176 static void
1177 release_keyboard(void)
1178 {
1179         keyboard_info_t info;
1180
1181         /*
1182          * If stdin is not associated with a keyboard, the following ioctl
1183          * will fail.
1184          */
1185         if (ioctl(0, KDGKBINFO, &info) == -1) {
1186                 warn("unable to obtain keyboard information");
1187                 return;
1188         }
1189 #if 1
1190         printf("kbd%d\n", info.kb_index);
1191         printf("    %.*s%d, type:%s (%d)\n",
1192                 (int)sizeof(info.kb_name), info.kb_name, info.kb_unit,
1193                 get_kbd_type_name(info.kb_type), info.kb_type);
1194 #endif
1195         if (ioctl(0, CONS_RELKBD, 0) == -1)
1196                 warn("unable to release the keyboard");
1197 }
1198
1199 static void
1200 mux_keyboard(u_int op, char *kbd)
1201 {
1202         keyboard_info_t info;
1203         char            *unit, *ep;
1204
1205         /*
1206          * If stdin is not associated with a keyboard, the following ioctl
1207          * will fail.
1208          */
1209         if (ioctl(0, KDGKBINFO, &info) == -1) {
1210                 warn("unable to obtain keyboard information");
1211                 return;
1212         }
1213 #if 1
1214         printf("kbd%d\n", info.kb_index);
1215         printf("    %.*s%d, type:%s (%d)\n",
1216                 (int)sizeof(info.kb_name), info.kb_name, info.kb_unit,
1217                 get_kbd_type_name(info.kb_type), info.kb_type);
1218 #endif
1219         /*
1220          * split kbd into name and unit. find the right most part of the
1221          * kbd string that consist of only digits.
1222          */
1223
1224         memset(&info, 0, sizeof(info));
1225
1226         info.kb_unit = -1;
1227         ep = kbd - 1;
1228
1229         do {
1230                 unit = strpbrk(ep + 1, "0123456789");
1231                 if (unit != NULL) {
1232                         info.kb_unit = strtol(unit, &ep, 10);
1233                         if (*ep != '\0')
1234                                 info.kb_unit = -1;
1235                 }
1236         } while (unit != NULL && info.kb_unit == -1);
1237
1238         if (info.kb_unit == -1) {
1239                 warnx("unable to find keyboard driver unit in '%s'", kbd);
1240                 return;
1241         }
1242
1243         if (unit == kbd) {
1244                 warnx("unable to find keyboard driver name in '%s'", kbd);
1245                 return;
1246         }
1247         if (unit - kbd >= (int) sizeof(info.kb_name)) {
1248                 warnx("keyboard name '%s' is too long", kbd);
1249                 return;
1250         }
1251
1252         strncpy(info.kb_name, kbd, unit - kbd);
1253
1254         /*
1255          * If stdin is not associated with a kbdmux(4) keyboard, the following
1256          * ioctl will fail.
1257          */
1258
1259         if (ioctl(0, op, &info) == -1)
1260                 warn("unable to (un)mux the keyboard");
1261 }
1262 #endif
1263
1264 static void
1265 usage(void)
1266 {
1267 #ifdef BOOTSTRAP_KBDCONTROL
1268         fprintf(stderr, "%s\n",
1269 "usage: kbdcontrol [-L mapfile] [-P path]");
1270 #else
1271         fprintf(stderr, "%s\n%s\n%s\n",
1272 "usage: kbdcontrol [-dFKix] [-A name] [-a name] [-b duration.pitch | [quiet.]belltype]",
1273 "                  [-r delay.repeat | speed] [-l mapfile] [-f # string]",
1274 "                  [-k device] [-L mapfile] [-P path]");
1275 #endif
1276         exit(1);
1277 }
1278
1279
1280 int
1281 main(int argc, char **argv)
1282 {
1283 #ifdef BOOTSTRAP_KBDCONTROL
1284         const char      *optstring = "L:P:";
1285 #else
1286         const char      *optstring = "A:a:b:df:iKk:Fl:L:P:r:x";
1287 #endif
1288         int             opt;
1289
1290         /* Collect any -P arguments, regardless of where they appear. */
1291         while ((opt = getopt(argc, argv, optstring)) != -1) {
1292                 if (opt == 'P')
1293                         add_keymap_path(optarg);
1294                 if (opt == '?')
1295                         usage();
1296         }
1297
1298         optind = optreset = 1;
1299         while ((opt = getopt(argc, argv, optstring)) != -1)
1300                 switch(opt) {
1301 #ifndef BOOTSTRAP_KBDCONTROL
1302                 case 'A':
1303                 case 'a':
1304                         mux_keyboard((opt == 'A')? KBRELKBD : KBADDKBD, optarg);
1305                         break;
1306                 case 'b':
1307                         set_bell_values(optarg);
1308                         break;
1309                 case 'd':
1310                         print_keymap();
1311                         break;
1312                 case 'l':
1313                         load_keymap(optarg, 0);
1314                         break;
1315 #endif
1316                 case 'L':
1317                         load_keymap(optarg, 1);
1318                         break;
1319                 case 'P':
1320                         break;
1321 #ifndef BOOTSTRAP_KBDCONTROL
1322                 case 'f':
1323                         set_functionkey(optarg,
1324                             nextarg(argc, argv, &optind, 'f'));
1325                         break;
1326                 case 'F':
1327                         load_default_functionkeys();
1328                         break;
1329                 case 'i':
1330                         show_kbd_info();
1331                         break;
1332                 case 'K':
1333                         release_keyboard();
1334                         break;
1335                 case 'k':
1336                         set_keyboard(optarg);
1337                         break;
1338                 case 'r':
1339                         set_keyrates(optarg);
1340                         break;
1341                 case 'x':
1342                         hex = 1;
1343                         break;
1344 #endif
1345                 default:
1346                         usage();
1347                 }
1348         if ((optind != argc) || (argc == 1))
1349                 usage();
1350         exit(0);
1351 }