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
is_vt4(void)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 *
nextarg(int ac,char ** av,int * indp,int oc)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 *
mkfullname(const char * s1,const char * s2,const char * s3)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
get_entry(void)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
get_definition_line(FILE * file,keymap_t * keymap,accentmap_t * accentmap)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
get_key_definition_line(keymap_t * map)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
get_accent_definition_line(accentmap_t * map)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
print_entry(FILE * fp,int value)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
print_key_definition_line(FILE * fp,int scancode,struct keyent_t * key)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
print_accent_definition_line(FILE * fp,int accent,struct acc_t * key)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
dump_entry(int value)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
dump_key_definition(char * name,keymap_t * keymap)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
dump_accent_definition(char * name,accentmap_t * accentmap)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
add_keymap_path(const char * path)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
to_old_accentmap(accentmap_t * from,oaccentmap_t * to)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
load_keymap(char * opt,int dumponly)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
to_new_accentmap(oaccentmap_t * from,accentmap_t * to)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
print_keymap(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
load_default_functionkeys(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
set_functionkey(char * keynumstr,char * string)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
set_bell_values(char * opt)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 (!is_vt4()) {
1042 if (pitch != 0)
1043 pitch = 1193182 / pitch; /* in Hz */
1044 }
1045 duration /= 10; /* in 10 m sec */
1046 }
1047
1048 ioctl(0, CONS_BELLTYPE, &bell);
1049 if (duration > 0 && pitch > 0)
1050 fprintf(stderr, "\e[=%d;%dB", pitch, duration);
1051 }
1052
1053 static void
set_keyrates(char * opt)1054 set_keyrates(char *opt)
1055 {
1056 int arg[2];
1057 int repeat;
1058 int delay;
1059 int r, d;
1060
1061 if (!strcmp(opt, "slow")) {
1062 delay = 1000;
1063 repeat = 504;
1064 d = 3;
1065 r = 31;
1066 } else if (!strcmp(opt, "normal")) {
1067 delay = 500;
1068 repeat = 126;
1069 d = 1;
1070 r = 15;
1071 } else if (!strcmp(opt, "fast")) {
1072 delay = 0;
1073 repeat = 0;
1074 d = 0;
1075 r = 0;
1076 } else {
1077 int n;
1078 char *v1;
1079
1080 delay = strtol(opt, &v1, 0);
1081 if ((delay < 0) || (*v1 != '.'))
1082 goto badopt;
1083 opt = ++v1;
1084 repeat = strtol(opt, &v1, 0);
1085 if ((repeat < 0) || (*opt == '\0') || (*v1 != '\0')) {
1086 badopt:
1087 warnx("argument to -r must be delay.repeat or slow|normal|fast");
1088 return;
1089 }
1090 for (n = 0; n < ndelays - 1; n++)
1091 if (delay <= kbdelays[n])
1092 break;
1093 d = n;
1094 for (n = 0; n < nrepeats - 1; n++)
1095 if (repeat <= kbrates[n])
1096 break;
1097 r = n;
1098 }
1099
1100 arg[0] = delay;
1101 arg[1] = repeat;
1102 if (ioctl(0, KDSETREPEAT, arg)) {
1103 warn("fallback, setting keyboard rate via legacy interface (KDSETRAD), will be removed soon");
1104 if (ioctl(0, KDSETRAD, (d << 5) | r))
1105 warn("setting keyboard rate");
1106 }
1107 }
1108
1109 static const char *
get_kbd_type_name(int type)1110 get_kbd_type_name(int type)
1111 {
1112 static struct {
1113 int type;
1114 const char *name;
1115 } name_table[] = {
1116 { KB_84, "AT 84" },
1117 { KB_101, "AT 101/102" },
1118 { KB_OTHER, "generic" },
1119 };
1120 unsigned int i;
1121
1122 for (i = 0; i < nitems(name_table); ++i) {
1123 if (type == name_table[i].type)
1124 return name_table[i].name;
1125 }
1126 return "unknown";
1127 }
1128
1129 static void
show_kbd_info(void)1130 show_kbd_info(void)
1131 {
1132 keyboard_info_t info;
1133
1134 if (ioctl(0, KDGKBINFO, &info) == -1) {
1135 warn("unable to obtain keyboard information");
1136 return;
1137 }
1138 printf("kbd%d:\n", info.kb_index);
1139 printf(" %.*s%d, type:%s (%d)\n",
1140 (int)sizeof(info.kb_name), info.kb_name, info.kb_unit,
1141 get_kbd_type_name(info.kb_type), info.kb_type);
1142 }
1143
1144 static void
set_keyboard(char * device)1145 set_keyboard(char *device)
1146 {
1147 keyboard_info_t info;
1148 int fd;
1149
1150 fd = open(device, O_RDONLY);
1151 if (fd < 0) {
1152 warn("cannot open %s", device);
1153 return;
1154 }
1155 if (ioctl(fd, KDGKBINFO, &info) == -1) {
1156 warn("unable to obtain keyboard information");
1157 close(fd);
1158 return;
1159 }
1160 /*
1161 * The keyboard device driver won't release the keyboard by
1162 * the following ioctl, but it automatically will, when the device
1163 * is closed. So, we don't check error here.
1164 */
1165 ioctl(fd, CONS_RELKBD, 0);
1166 close(fd);
1167 #if 1
1168 printf("kbd%d\n", info.kb_index);
1169 printf(" %.*s%d, type:%s (%d)\n",
1170 (int)sizeof(info.kb_name), info.kb_name, info.kb_unit,
1171 get_kbd_type_name(info.kb_type), info.kb_type);
1172 #endif
1173
1174 if (ioctl(0, CONS_SETKBD, info.kb_index) == -1)
1175 warn("unable to set keyboard");
1176 }
1177
1178 static void
release_keyboard(void)1179 release_keyboard(void)
1180 {
1181 keyboard_info_t info;
1182
1183 /*
1184 * If stdin is not associated with a keyboard, the following ioctl
1185 * will fail.
1186 */
1187 if (ioctl(0, KDGKBINFO, &info) == -1) {
1188 warn("unable to obtain keyboard information");
1189 return;
1190 }
1191 #if 1
1192 printf("kbd%d\n", info.kb_index);
1193 printf(" %.*s%d, type:%s (%d)\n",
1194 (int)sizeof(info.kb_name), info.kb_name, info.kb_unit,
1195 get_kbd_type_name(info.kb_type), info.kb_type);
1196 #endif
1197 if (ioctl(0, CONS_RELKBD, 0) == -1)
1198 warn("unable to release the keyboard");
1199 }
1200
1201 static void
mux_keyboard(u_int op,char * kbd)1202 mux_keyboard(u_int op, char *kbd)
1203 {
1204 keyboard_info_t info;
1205 char *unit, *ep;
1206
1207 /*
1208 * If stdin is not associated with a keyboard, the following ioctl
1209 * will fail.
1210 */
1211 if (ioctl(0, KDGKBINFO, &info) == -1) {
1212 warn("unable to obtain keyboard information");
1213 return;
1214 }
1215 #if 1
1216 printf("kbd%d\n", info.kb_index);
1217 printf(" %.*s%d, type:%s (%d)\n",
1218 (int)sizeof(info.kb_name), info.kb_name, info.kb_unit,
1219 get_kbd_type_name(info.kb_type), info.kb_type);
1220 #endif
1221 /*
1222 * split kbd into name and unit. find the right most part of the
1223 * kbd string that consist of only digits.
1224 */
1225
1226 memset(&info, 0, sizeof(info));
1227
1228 info.kb_unit = -1;
1229 ep = kbd - 1;
1230
1231 do {
1232 unit = strpbrk(ep + 1, "0123456789");
1233 if (unit != NULL) {
1234 info.kb_unit = strtol(unit, &ep, 10);
1235 if (*ep != '\0')
1236 info.kb_unit = -1;
1237 }
1238 } while (unit != NULL && info.kb_unit == -1);
1239
1240 if (info.kb_unit == -1) {
1241 warnx("unable to find keyboard driver unit in '%s'", kbd);
1242 return;
1243 }
1244
1245 if (unit == kbd) {
1246 warnx("unable to find keyboard driver name in '%s'", kbd);
1247 return;
1248 }
1249 if (unit - kbd >= (int) sizeof(info.kb_name)) {
1250 warnx("keyboard name '%s' is too long", kbd);
1251 return;
1252 }
1253
1254 strncpy(info.kb_name, kbd, unit - kbd);
1255
1256 /*
1257 * If stdin is not associated with a kbdmux(4) keyboard, the following
1258 * ioctl will fail.
1259 */
1260
1261 if (ioctl(0, op, &info) == -1)
1262 warn("unable to (un)mux the keyboard");
1263 }
1264 #endif
1265
1266 static void
usage(void)1267 usage(void)
1268 {
1269 #ifdef BOOTSTRAP_KBDCONTROL
1270 fprintf(stderr, "%s\n",
1271 "usage: kbdcontrol [-L mapfile] [-P path]");
1272 #else
1273 fprintf(stderr, "%s\n%s\n%s\n",
1274 "usage: kbdcontrol [-dFKix] [-A name] [-a name] [-b duration.pitch | [quiet.]belltype]",
1275 " [-r delay.repeat | speed] [-l mapfile] [-f # string]",
1276 " [-k device] [-L mapfile] [-P path]");
1277 #endif
1278 exit(1);
1279 }
1280
1281
1282 int
main(int argc,char ** argv)1283 main(int argc, char **argv)
1284 {
1285 #ifdef BOOTSTRAP_KBDCONTROL
1286 const char *optstring = "L:P:";
1287 #else
1288 const char *optstring = "A:a:b:df:iKk:Fl:L:P:r:x";
1289 #endif
1290 int opt;
1291
1292 /* Collect any -P arguments, regardless of where they appear. */
1293 while ((opt = getopt(argc, argv, optstring)) != -1) {
1294 if (opt == 'P')
1295 add_keymap_path(optarg);
1296 if (opt == '?')
1297 usage();
1298 }
1299
1300 optind = optreset = 1;
1301 while ((opt = getopt(argc, argv, optstring)) != -1)
1302 switch(opt) {
1303 #ifndef BOOTSTRAP_KBDCONTROL
1304 case 'A':
1305 case 'a':
1306 mux_keyboard((opt == 'A')? KBRELKBD : KBADDKBD, optarg);
1307 break;
1308 case 'b':
1309 set_bell_values(optarg);
1310 break;
1311 case 'd':
1312 print_keymap();
1313 break;
1314 case 'l':
1315 load_keymap(optarg, 0);
1316 break;
1317 #endif
1318 case 'L':
1319 load_keymap(optarg, 1);
1320 break;
1321 case 'P':
1322 break;
1323 #ifndef BOOTSTRAP_KBDCONTROL
1324 case 'f':
1325 set_functionkey(optarg,
1326 nextarg(argc, argv, &optind, 'f'));
1327 break;
1328 case 'F':
1329 load_default_functionkeys();
1330 break;
1331 case 'i':
1332 show_kbd_info();
1333 break;
1334 case 'K':
1335 release_keyboard();
1336 break;
1337 case 'k':
1338 set_keyboard(optarg);
1339 break;
1340 case 'r':
1341 set_keyrates(optarg);
1342 break;
1343 case 'x':
1344 hex = 1;
1345 break;
1346 #endif
1347 default:
1348 usage();
1349 }
1350 if ((optind != argc) || (argc == 1))
1351 usage();
1352 exit(0);
1353 }
1354