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