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