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