Index: head/usr.sbin/kbdcontrol/kbdcontrol.1 =================================================================== --- head/usr.sbin/kbdcontrol/kbdcontrol.1 (revision 296925) +++ head/usr.sbin/kbdcontrol/kbdcontrol.1 (revision 296926) @@ -1,291 +1,298 @@ .\" .\" kbdcontrol - a utility for manipulating the syscons or vt keyboard driver section .\" .\" Redistribution and use in source and binary forms, with or without .\" modification, are permitted provided that the following conditions .\" are met: .\" 1. Redistributions of source code must retain the above copyright .\" notice, this list of conditions and the following disclaimer. .\" 2. Redistributions in binary form must reproduce the above copyright .\" notice, this list of conditions and the following disclaimer in the .\" documentation and/or other materials provided with the distribution. .\" .\" @(#)kbdcontrol.1 .\" $FreeBSD$ .\" -.Dd January 29, 2008 +.Dd March 16, 2016 .Dt KBDCONTROL 1 .Os .Sh NAME .Nm kbdcontrol .Nd keyboard control and configuration utility .Sh SYNOPSIS .Nm .Op Fl dFKix .Op Fl A Ar name .Op Fl a Ar name .Oo .Fl b .Ar duration . Ns Ar pitch | Ar belltype .Oc .Oo .Fl r .Ar delay . Ns Ar repeat | Ar speed .Oc .Op Fl l Ar keymap_file .Op Fl f Ar # Ar string .Op Fl k Ar keyboard_device .Op Fl L Ar keymap_file +.Op Fl P Ar path .Sh DESCRIPTION The .Nm command is used to set various keyboard related options for the .Xr syscons 4 or .Xr vt 4 console driver and the keyboard drivers, such as key map, keyboard repeat and delay rates, bell characteristics etc. .Pp Keyboard options may be automatically configured at system boot time by setting variables in .Pa /etc/rc.conf . See .Sx Boot Time Configuration below. .Pp The following command line options are supported: .Bl -tag -width indent .It Fl A Ar name Detach the keyboard, specified by the keyboard device name, from the keyboard multiplexer. When using this option, the standard input of the .Nm process should be redirected from the keyboard multiplexer keyboard device (if the keyboard multiplexer is not the active keyboard) or .Pa /dev/console (if the keyboard multiplexer is the active keyboard and you are not working on the system console). .It Fl a Ar name Attach the keyboard, specified by the keyboard device name, to the keyboard multiplexer. When using this option, the standard input of the .Nm process should be redirected from the keyboard multiplexer keyboard device (if the keyboard multiplexer is not the active keyboard) or .Pa /dev/console (if the keyboard multiplexer is the active keyboard and you are not working on the system console). .It Fl b Xo .Ar duration . Ns Ar pitch | Ar belltype .Xc Set the bell duration in milliseconds and pitch in hertz. If a .Ar belltype argument is specified, it may be one of .Cm normal which sets sound parameters back to normal values, .Cm off which disables the bell entirely, or .Cm visual which sets the bell to visual mode, i.e., flashes the screen instead. If .Ar belltype is preceded by the word .Cm quiet. , the bell will not be rung when the ringing process is in the background vty. The .Cm visual bell, when chosen, applies to all vtys; other bell types can be set individually for each vty. .It Fl r Xo .Ar delay . Ns Ar repeat | Ar speed .Xc Set keyboard .Ar delay (250, 500, 750, 1000) and .Ar repeat (34, 38, 42, 46, 50, 55, 59, 63, 68, 76, 84, 92, 100, 110, 118, 126, 136, 152, 168, 184, 200, 220, 236, 252, 272, 304, 336, 368, 400, 440, 472, 504) rates, or if a .Ar speed argument is specified, it may be one of .Cm slow (1000.504), .Cm fast (250.34) or .Cm normal (500.126). .It Fl l Ar keymap_file Install keyboard map file from .Ar keymap_file . You may load the keyboard map file from a menu-driven command, .Xr kbdmap 1 . The format of keyboard map files is documented in the .Xr kbdmap 5 manual page. .It Fl d Dump the current keyboard map onto stdout. The output may be redirected to a file and can be loaded back to the kernel later by the .Fl l option above. .It Fl f Ar # Ar string Set function key number .Ar # to send .Ar string . Refer to the man page for the keyboard driver (e.g.\& .Xr atkbd 4 ) for available function keys and their numbers. .It Fl F Set function keys back to the standard definitions. .It Fl x Use hexadecimal numbers in keyboard map dump. .It Fl i Print brief information about the keyboard. .It Fl K Disconnect the keyboard from the console. You need to use the .Fl k option below to associate a keyboard with the console again. .It Fl k Ar keyboard_device Use the specified device as the console keyboard. When using this option, the standard input of the .Nm process should be redirected from .Pa /dev/console if you are not working on the system console (see the .Sx EXAMPLES section). .It Fl L Ar keymap_file Load keyboard map file from .Ar keymap_file and write the .Ft "struct keymap" compiled from it to stdout. This option is primarily intended for programmers and is probably of little use under normal circumstances. +.It Fl P Ar path +Search for the keymap file in +.Ar path . +The +.Fl P +option may be specified multiple times. .El .Sh ENVIRONMENT The environment variable .Ev KEYMAP_PATH can hold an alternative path to the keyboard map files. .Sh KEYBOARD CONFIGURATION .Ss Boot Time Configuration You may set variables in .Pa /etc/rc.conf or .Pa /etc/rc.conf.local in order to configure the keyboard at boot time. The following is the list of relevant variables. .Pp .Bl -tag -width foo_bar_var -compact .It Ar keymap Specifies a keyboard map file for the .Fl l option. .It Ar keyrate Sets the keyboard repeat rate for the .Fl r option. .It Ar keychange Lists function key strings for the .Fl f option. .El .Pp See .Xr rc.conf 5 for details. .Ss Driver Configuration The keyboard device driver may let you change default configuration options, such as the default keyboard map, so that you do not need to set up the options at boot time. See keyboard driver manuals (e.g.\& .Xr atkbd 4 , .Xr ukbd 4 ) for details. .Sh FILES .Bl -tag -width /usr/share/syscons/keymaps/foo_bar -compact .It Pa /usr/share/syscons/keymaps/* keyboard map files for syscons .It Pa /usr/share/vt/keymaps/* keyboard map files for vt .El .Sh EXAMPLES The following command will load the keyboard map file .Pa /usr/share/syscons/keymaps/ru.koi8-r.kbd . .Pp .Dl kbdcontrol -l /usr/share/syscons/keymaps/ru.koi8-r.kbd .Pp So long as the keyboard map file resides in .Pa /usr/share/syscons/keymaps (if using .Xr syscons 4 ) or .Pa /usr/share/vt/keymaps (if using .Xr vt 4 ) , you may abbreviate the file name as .Pa ru.koi8-r . Since .Xr vt 4 uses Unicode, the corresponding keyboard file names omit the encoding and typically are just a country code, e.g.\& .Pa ru . .Pp .Dl kbdcontrol -l ru.koi8-r .Pp The following command will make the function key 10 emit "telnet myhost". .Pp .Dl kbdcontrol -f 10 \&"telnet myhost\&" .Pp In order to get the visual effect for bell, but prevent the screen from flashing if the bell is to ring in the background screen, run the following command. .Pp .Dl kbdcontrol -b quiet.visual .Pp To change the default console keyboard to another keyboard, for example the first USB keyboard (see .Xr ukbd 4 ) , use the following command. .Pp .Dl kbdcontrol -k /dev/ukbd0 < /dev/console .Pp To switch back to the default keyboard, use this command. .Pp .Dl kbdcontrol -k /dev/kbd0 .Pp To allow using both the second USB keyboard and the first AT keyboard at the same time on console via the .Xr kbdmux 4 driver, use the following sequence of commands. .Bd -literal -offset indent kbdcontrol -K < /dev/console kbdcontrol -a atkbd0 < /dev/kbdmux0 kbdcontrol -a ukbd1 < /dev/kbdmux0 kbdcontrol -k /dev/kbdmux0 < /dev/console .Ed .Sh SEE ALSO .Xr kbdmap 1 , .Xr vidcontrol 1 , .Xr atkbd 4 , .Xr kbdmux 4 , .Xr keyboard 4 , .Xr screen 4 , .Xr syscons 4 , .Xr ukbd 4 , .Xr vt 4 , .Xr kbdmap 5 , .Xr rc.conf 5 .Sh AUTHORS .An S\(/oren Schmidt Aq Mt sos@FreeBSD.org .Sh BUGS Report when found. Index: head/usr.sbin/kbdcontrol/kbdcontrol.c =================================================================== --- head/usr.sbin/kbdcontrol/kbdcontrol.c (revision 296925) +++ head/usr.sbin/kbdcontrol/kbdcontrol.c (revision 296926) @@ -1,1229 +1,1272 @@ /*- * Copyright (c) 1994-1995 Søren Schmidt * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer, * in this position and unchanged. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. The name of the author may not be used to endorse or promote products * derived from this software without specific prior written permission * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include __FBSDID("$FreeBSD$"); #include #include #include #include #include #include #include #include #include +#include #include #include "path.h" #include "lex.h" /* * HALT, PDWN, and PASTE aren't defined in 4.x, but we need them to bridge * to 5.0-current so define them here as a stop gap transition measure. */ #ifndef HALT #define HALT 0xa1 /* halt machine */ #endif #ifndef PDWN #define PDWN 0xa2 /* halt machine and power down */ #endif #ifndef PASTE #define PASTE 0xa3 /* paste from cut-paste buffer */ #endif #define SPECIAL 0x80000000 static const char ctrl_names[32][4] = { "nul", "soh", "stx", "etx", "eot", "enq", "ack", "bel", "bs ", "ht ", "nl ", "vt ", "ff ", "cr ", "so ", "si ", "dle", "dc1", "dc2", "dc3", "dc4", "nak", "syn", "etb", "can", "em ", "sub", "esc", "fs ", "gs ", "rs ", "us " }; static const char acc_names[15][5] = { "dgra", "dacu", "dcir", "dtil", "dmac", "dbre", "ddot", "duml", "dsla", "drin", "dced", "dapo", "ddac", "dogo", "dcar", }; static const char acc_names_u[15][5] = { "DGRA", "DACU", "DCIR", "DTIL", "DMAC", "DBRE", "DDOT", "DUML", "DSLA", "DRIN", "DCED", "DAPO", "DDAC", "DOGO", "DCAR", }; static const char fkey_table[96][MAXFK] = { /* 01-04 */ "\033[M", "\033[N", "\033[O", "\033[P", /* 05-08 */ "\033[Q", "\033[R", "\033[S", "\033[T", /* 09-12 */ "\033[U", "\033[V", "\033[W", "\033[X", /* 13-16 */ "\033[Y", "\033[Z", "\033[a", "\033[b", /* 17-20 */ "\033[c", "\033[d", "\033[e", "\033[f", /* 21-24 */ "\033[g", "\033[h", "\033[i", "\033[j", /* 25-28 */ "\033[k", "\033[l", "\033[m", "\033[n", /* 29-32 */ "\033[o", "\033[p", "\033[q", "\033[r", /* 33-36 */ "\033[s", "\033[t", "\033[u", "\033[v", /* 37-40 */ "\033[w", "\033[x", "\033[y", "\033[z", /* 41-44 */ "\033[@", "\033[[", "\033[\\","\033[]", /* 45-48 */ "\033[^", "\033[_", "\033[`", "\033[{", /* 49-52 */ "\033[H", "\033[A", "\033[I", "-" , /* 53-56 */ "\033[D", "\033[E", "\033[C", "+" , /* 57-60 */ "\033[F", "\033[B", "\033[G", "\033[L", /* 61-64 */ "\177", "\033[J", "\033[~", "\033[}", /* 65-68 */ "" , "" , "" , "" , /* 69-72 */ "" , "" , "" , "" , /* 73-76 */ "" , "" , "" , "" , /* 77-80 */ "" , "" , "" , "" , /* 81-84 */ "" , "" , "" , "" , /* 85-88 */ "" , "" , "" , "" , /* 89-92 */ "" , "" , "" , "" , /* 93-96 */ "" , "" , "" , "" , }; static const int delays[] = {250, 500, 750, 1000}; static const int repeats[] = { 34, 38, 42, 46, 50, 55, 59, 63, 68, 76, 84, 92, 100, 110, 118, 126, 136, 152, 168, 184, 200, 220, 236, 252, 272, 304, 336, 368, 400, 440, 472, 504}; static const int ndelays = (sizeof(delays) / sizeof(int)); static const int nrepeats = (sizeof(repeats) / sizeof(int)); static int hex = 0; +static int paths_configured = 0; static int token; int number; char letter; +static void add_keymap_path(const char *path); static void dump_accent_definition(char *name, accentmap_t *accentmap); static void dump_entry(int value); static void dump_key_definition(char *name, keymap_t *keymap); static int get_accent_definition_line(accentmap_t *); static int get_entry(void); static int get_key_definition_line(keymap_t *); static void load_keymap(char *opt, int dumponly); static void load_default_functionkeys(void); static char * nextarg(int ac, char **av, int *indp, int oc); static char * mkfullname(const char *s1, const char *s2, const char *s3); static void print_accent_definition_line(FILE *fp, int accent, struct acc_t *key); static void print_entry(FILE *fp, int value); static void print_key_definition_line(FILE *fp, int scancode, struct keyent_t *key); static void print_keymap(void); static void release_keyboard(void); static void mux_keyboard(u_int op, char *kbd); static void set_bell_values(char *opt); static void set_functionkey(char *keynumstr, char *string); static void set_keyboard(char *device); static void set_keyrates(char *opt); static void show_kbd_info(void); static void usage(void) __dead2; +struct pathent { + STAILQ_ENTRY(pathent) next; + char *path; +}; +static STAILQ_HEAD(, pathent) pathlist = STAILQ_HEAD_INITIALIZER(pathlist); + /* Detect presence of vt(4). */ static int is_vt4(void) { char vty_name[4] = ""; size_t len = sizeof(vty_name); if (sysctlbyname("kern.vty", vty_name, &len, NULL, 0) != 0) return (0); return (strcmp(vty_name, "vt") == 0); } static char * nextarg(int ac, char **av, int *indp, int oc) { if (*indp < ac) return(av[(*indp)++]); warnx("option requires two arguments -- %c", oc); usage(); } static char * mkfullname(const char *s1, const char *s2, const char *s3) { static char *buf = NULL; static int bufl = 0; int f; f = strlen(s1) + strlen(s2) + strlen(s3) + 1; if (f > bufl) { if (buf) buf = (char *)realloc(buf, f); else buf = (char *)malloc(f); } if (!buf) { bufl = 0; return(NULL); } bufl = f; strcpy(buf, s1); strcat(buf, s2); strcat(buf, s3); return(buf); } static int get_entry(void) { switch ((token = yylex())) { case TNOP: return NOP | SPECIAL; case TLSH: return LSH | SPECIAL; case TRSH: return RSH | SPECIAL; case TCLK: return CLK | SPECIAL; case TNLK: return NLK | SPECIAL; case TSLK: return SLK | SPECIAL; case TBTAB: return BTAB | SPECIAL; case TLALT: return LALT | SPECIAL; case TLCTR: return LCTR | SPECIAL; case TNEXT: return NEXT | SPECIAL; case TPREV: return PREV | SPECIAL; case TRCTR: return RCTR | SPECIAL; case TRALT: return RALT | SPECIAL; case TALK: return ALK | SPECIAL; case TASH: return ASH | SPECIAL; case TMETA: return META | SPECIAL; case TRBT: return RBT | SPECIAL; case TDBG: return DBG | SPECIAL; case TSUSP: return SUSP | SPECIAL; case TSPSC: return SPSC | SPECIAL; case TPANIC: return PNC | SPECIAL; case TLSHA: return LSHA | SPECIAL; case TRSHA: return RSHA | SPECIAL; case TLCTRA: return LCTRA | SPECIAL; case TRCTRA: return RCTRA | SPECIAL; case TLALTA: return LALTA | SPECIAL; case TRALTA: return RALTA | SPECIAL; case THALT: return HALT | SPECIAL; case TPDWN: return PDWN | SPECIAL; case TPASTE: return PASTE | SPECIAL; case TACC: if (ACC(number) > L_ACC) return -1; return ACC(number) | SPECIAL; case TFUNC: if (F(number) > L_FN) return -1; return F(number) | SPECIAL; case TSCRN: if (S(number) > L_SCR) return -1; return S(number) | SPECIAL; case TLET: return (unsigned char)letter; case TNUM: if (number < 0x000000 || number > 0x10FFFF) return -1; return number; default: return -1; } } static int -get_definition_line(FILE *fd, keymap_t *keymap, accentmap_t *accentmap) +get_definition_line(FILE *file, keymap_t *keymap, accentmap_t *accentmap) { int c; - yyin = fd; + yyin = file; if (token < 0) token = yylex(); switch (token) { case TNUM: c = get_key_definition_line(keymap); if (c < 0) errx(1, "invalid key definition"); if (c > keymap->n_keys) keymap->n_keys = c; break; case TACC: c = get_accent_definition_line(accentmap); if (c < 0) errx(1, "invalid accent key definition"); if (c > accentmap->n_accs) accentmap->n_accs = c; break; case 0: /* EOF */ return -1; default: errx(1, "illegal definition line"); } return c; } static int get_key_definition_line(keymap_t *map) { int i, def, scancode; /* check scancode number */ if (number < 0 || number >= NUM_KEYS) return -1; scancode = number; /* get key definitions */ map->key[scancode].spcl = 0; for (i=0; ikey[scancode].spcl |= (0x80 >> i); map->key[scancode].map[i] = def & ~SPECIAL; } /* get lock state key def */ if ((token = yylex()) != TFLAG) return -1; map->key[scancode].flgs = number; token = yylex(); return (scancode + 1); } static int get_accent_definition_line(accentmap_t *map) { int accent; int c1, c2; int i; if (ACC(number) < F_ACC || ACC(number) > L_ACC) /* number out of range */ return -1; accent = number; if (map->acc[accent].accchar != 0) { /* this entry has already been defined before! */ errx(1, "duplicated accent key definition"); } switch ((token = yylex())) { case TLET: map->acc[accent].accchar = letter; break; case TNUM: map->acc[accent].accchar = number; break; default: return -1; } for (i = 0; (token = yylex()) == '(';) { switch ((token = yylex())) { case TLET: c1 = letter; break; case TNUM: c1 = number; break; default: return -1; } switch ((token = yylex())) { case TLET: c2 = letter; break; case TNUM: c2 = number; break; default: return -1; } if ((token = yylex()) != ')') return -1; if (i >= NUM_ACCENTCHARS) { warnx("too many accented characters, ignored"); continue; } map->acc[accent].map[i][0] = c1; map->acc[accent].map[i][1] = c2; ++i; } return (accent + 1); } static void print_entry(FILE *fp, int value) { int val = value & ~SPECIAL; switch (value) { case NOP | SPECIAL: fprintf(fp, " nop "); break; case LSH | SPECIAL: fprintf(fp, " lshift"); break; case RSH | SPECIAL: fprintf(fp, " rshift"); break; case CLK | SPECIAL: fprintf(fp, " clock "); break; case NLK | SPECIAL: fprintf(fp, " nlock "); break; case SLK | SPECIAL: fprintf(fp, " slock "); break; case BTAB | SPECIAL: fprintf(fp, " btab "); break; case LALT | SPECIAL: fprintf(fp, " lalt "); break; case LCTR | SPECIAL: fprintf(fp, " lctrl "); break; case NEXT | SPECIAL: fprintf(fp, " nscr "); break; case PREV | SPECIAL: fprintf(fp, " pscr "); break; case RCTR | SPECIAL: fprintf(fp, " rctrl "); break; case RALT | SPECIAL: fprintf(fp, " ralt "); break; case ALK | SPECIAL: fprintf(fp, " alock "); break; case ASH | SPECIAL: fprintf(fp, " ashift"); break; case META | SPECIAL: fprintf(fp, " meta "); break; case RBT | SPECIAL: fprintf(fp, " boot "); break; case DBG | SPECIAL: fprintf(fp, " debug "); break; case SUSP | SPECIAL: fprintf(fp, " susp "); break; case SPSC | SPECIAL: fprintf(fp, " saver "); break; case PNC | SPECIAL: fprintf(fp, " panic "); break; case LSHA | SPECIAL: fprintf(fp, " lshifta"); break; case RSHA | SPECIAL: fprintf(fp, " rshifta"); break; case LCTRA | SPECIAL: fprintf(fp, " lctrla"); break; case RCTRA | SPECIAL: fprintf(fp, " rctrla"); break; case LALTA | SPECIAL: fprintf(fp, " lalta "); break; case RALTA | SPECIAL: fprintf(fp, " ralta "); break; case HALT | SPECIAL: fprintf(fp, " halt "); break; case PDWN | SPECIAL: fprintf(fp, " pdwn "); break; case PASTE | SPECIAL: fprintf(fp, " paste "); break; default: if (value & SPECIAL) { if (val >= F_FN && val <= L_FN) fprintf(fp, " fkey%02d", val - F_FN + 1); else if (val >= F_SCR && val <= L_SCR) fprintf(fp, " scr%02d ", val - F_SCR + 1); else if (val >= F_ACC && val <= L_ACC) fprintf(fp, " %-6s", acc_names[val - F_ACC]); else if (hex) fprintf(fp, " 0x%02x ", val); else fprintf(fp, " %3d ", val); } else { if (val < ' ') fprintf(fp, " %s ", ctrl_names[val]); else if (val == 127) fprintf(fp, " del "); else if (isascii(val) && isprint(val)) fprintf(fp, " '%c' ", val); else if (hex) fprintf(fp, " 0x%02x ", val); else fprintf(fp, " %3d ", val); } } } static void print_key_definition_line(FILE *fp, int scancode, struct keyent_t *key) { int i; /* print scancode number */ if (hex) fprintf(fp, " 0x%02x ", scancode); else fprintf(fp, " %03d ", scancode); /* print key definitions */ for (i=0; ispcl & (0x80 >> i)) print_entry(fp, key->map[i] | SPECIAL); else print_entry(fp, key->map[i]); } /* print lock state key def */ switch (key->flgs) { case 0: fprintf(fp, " O\n"); break; case 1: fprintf(fp, " C\n"); break; case 2: fprintf(fp, " N\n"); break; case 3: fprintf(fp, " B\n"); break; } } static void print_accent_definition_line(FILE *fp, int accent, struct acc_t *key) { int c; int i; if (key->accchar == 0) return; /* print accent number */ fprintf(fp, " %-6s", acc_names[accent]); if (isascii(key->accchar) && isprint(key->accchar)) fprintf(fp, "'%c' ", key->accchar); else if (hex) fprintf(fp, "0x%02x ", key->accchar); else fprintf(fp, "%03d ", key->accchar); for (i = 0; i < NUM_ACCENTCHARS; ++i) { c = key->map[i][0]; if (c == 0) break; if ((i > 0) && ((i % 4) == 0)) fprintf(fp, "\n "); if (isascii(c) && isprint(c)) fprintf(fp, "( '%c' ", c); else if (hex) fprintf(fp, "(0x%02x ", c); else fprintf(fp, "( %03d ", c); c = key->map[i][1]; if (isascii(c) && isprint(c)) fprintf(fp, "'%c' ) ", c); else if (hex) fprintf(fp, "0x%02x) ", c); else fprintf(fp, "%03d ) ", c); } fprintf(fp, "\n"); } static void dump_entry(int value) { if (value & SPECIAL) { value &= ~SPECIAL; switch (value) { case NOP: printf(" NOP, "); break; case LSH: printf(" LSH, "); break; case RSH: printf(" RSH, "); break; case CLK: printf(" CLK, "); break; case NLK: printf(" NLK, "); break; case SLK: printf(" SLK, "); break; case BTAB: printf(" BTAB, "); break; case LALT: printf(" LALT, "); break; case LCTR: printf(" LCTR, "); break; case NEXT: printf(" NEXT, "); break; case PREV: printf(" PREV, "); break; case RCTR: printf(" RCTR, "); break; case RALT: printf(" RALT, "); break; case ALK: printf(" ALK, "); break; case ASH: printf(" ASH, "); break; case META: printf(" META, "); break; case RBT: printf(" RBT, "); break; case DBG: printf(" DBG, "); break; case SUSP: printf(" SUSP, "); break; case SPSC: printf(" SPSC, "); break; case PNC: printf(" PNC, "); break; case LSHA: printf(" LSHA, "); break; case RSHA: printf(" RSHA, "); break; case LCTRA: printf("LCTRA, "); break; case RCTRA: printf("RCTRA, "); break; case LALTA: printf("LALTA, "); break; case RALTA: printf("RALTA, "); break; case HALT: printf(" HALT, "); break; case PDWN: printf(" PDWN, "); break; case PASTE: printf("PASTE, "); break; default: if (value >= F_FN && value <= L_FN) printf(" F(%2d),", value - F_FN + 1); else if (value >= F_SCR && value <= L_SCR) printf(" S(%2d),", value - F_SCR + 1); else if (value >= F_ACC && value <= L_ACC) printf(" %-4s, ", acc_names_u[value - F_ACC]); else printf(" 0x%02X, ", value); break; } } else if (value == '\'') { printf(" '\\'', "); } else if (value == '\\') { printf(" '\\\\', "); } else if (isascii(value) && isprint(value)) { printf(" '%c', ", value); } else { printf(" 0x%02X, ", value); } } static void dump_key_definition(char *name, keymap_t *keymap) { int i, j; printf("static keymap_t keymap_%s = { 0x%02x, {\n", name, (unsigned)keymap->n_keys); printf( "/* alt\n" " * scan cntrl alt alt cntrl\n" " * code base shift cntrl shift alt shift cntrl shift spcl flgs\n" " * ---------------------------------------------------------------------------\n" " */\n"); for (i = 0; i < keymap->n_keys; i++) { printf("/*%02x*/{{", i); for (j = 0; j < NUM_STATES; j++) { if (keymap->key[i].spcl & (0x80 >> j)) dump_entry(keymap->key[i].map[j] | SPECIAL); else dump_entry(keymap->key[i].map[j]); } printf("}, 0x%02X,0x%02X },\n", (unsigned)keymap->key[i].spcl, (unsigned)keymap->key[i].flgs); } printf("} };\n\n"); } static void dump_accent_definition(char *name, accentmap_t *accentmap) { int i, j; int c; printf("static accentmap_t accentmap_%s = { %d", name, accentmap->n_accs); if (accentmap->n_accs <= 0) { printf(" };\n\n"); return; } printf(", {\n"); for (i = 0; i < NUM_DEADKEYS; i++) { printf(" /* %s=%d */\n {", acc_names[i], i); c = accentmap->acc[i].accchar; if (c == '\'') printf(" '\\'', {"); else if (c == '\\') printf(" '\\\\', {"); else if (isascii(c) && isprint(c)) printf(" '%c', {", c); else if (c == 0) { printf(" 0x00 }, \n"); continue; } else printf(" 0x%02x, {", c); for (j = 0; j < NUM_ACCENTCHARS; j++) { c = accentmap->acc[i].map[j][0]; if (c == 0) break; if ((j > 0) && ((j % 4) == 0)) printf("\n\t "); if (isascii(c) && isprint(c)) printf(" { '%c',", c); else printf(" { 0x%02x,", c); printf("0x%02x },", accentmap->acc[i].map[j][1]); } printf(" }, },\n"); } printf("} };\n\n"); } static void +add_keymap_path(const char *path) +{ + struct pathent* pe; + size_t len; + + len = strlen(path); + if ((pe = malloc(sizeof(*pe))) == NULL || + (pe->path = malloc(len + 2)) == NULL) + err(1, "malloc"); + memcpy(pe->path, path, len); + if (len > 0 && path[len - 1] != '/') + pe->path[len++] = '/'; + pe->path[len] = '\0'; + STAILQ_INSERT_TAIL(&pathlist, pe, next); +} + +static void load_keymap(char *opt, int dumponly) { keymap_t keymap; accentmap_t accentmap; - FILE *fd; - int i, j; + struct pathent *pe; + FILE *file; + int j; char *name, *cp; char blank[] = "", keymap_path[] = KEYMAP_PATH; char vt_keymap_path[] = VT_KEYMAP_PATH, dotkbd[] = ".kbd"; - char *prefix[] = {blank, blank, keymap_path, NULL}; char *postfix[] = {blank, dotkbd, NULL}; - if (is_vt4()) - prefix[2] = vt_keymap_path; - cp = getenv("KEYMAP_PATH"); - if (cp != NULL) - asprintf(&(prefix[0]), "%s/", cp); + if (!paths_configured) { + cp = getenv("KEYMAP_PATH"); + if (cp != NULL) + add_keymap_path(cp); + add_keymap_path(""); + if (is_vt4()) + add_keymap_path(vt_keymap_path); + else + add_keymap_path(keymap_path); + paths_configured = 1; + } - fd = NULL; - for (i=0; prefix[i] && fd == NULL; i++) { - for (j=0; postfix[j] && fd == NULL; j++) { - name = mkfullname(prefix[i], opt, postfix[j]); - fd = fopen(name, "r"); + file = NULL; + STAILQ_FOREACH(pe, &pathlist, next) { + for (j=0; postfix[j] && file == NULL; j++) { + name = mkfullname(pe->path, opt, postfix[j]); + file = fopen(name, "r"); + if (file != NULL) + break; } } - if (fd == NULL) { + if (file == NULL) { warn("keymap file \"%s\" not found", opt); return; } memset(&keymap, 0, sizeof(keymap)); memset(&accentmap, 0, sizeof(accentmap)); token = -1; while (1) { - if (get_definition_line(fd, &keymap, &accentmap) < 0) + if (get_definition_line(file, &keymap, &accentmap) < 0) break; } if (dumponly) { /* fix up the filename to make it a valid C identifier */ for (cp = opt; *cp; cp++) if (!isalpha(*cp) && !isdigit(*cp)) *cp = '_'; printf("/*\n" " * Automatically generated from %s.\n" " * DO NOT EDIT!\n" " */\n", name); dump_key_definition(opt, &keymap); dump_accent_definition(opt, &accentmap); return; } if ((keymap.n_keys > 0) && (ioctl(0, PIO_KEYMAP, &keymap) < 0)) { warn("setting keymap"); - fclose(fd); + fclose(file); return; } if ((accentmap.n_accs > 0) && (ioctl(0, PIO_DEADKEYMAP, &accentmap) < 0)) { warn("setting accentmap"); - fclose(fd); + fclose(file); return; } } static void print_keymap(void) { keymap_t keymap; accentmap_t accentmap; int i; if (ioctl(0, GIO_KEYMAP, &keymap) < 0) err(1, "getting keymap"); if (ioctl(0, GIO_DEADKEYMAP, &accentmap) < 0) memset(&accentmap, 0, sizeof(accentmap)); printf( "# alt\n" "# scan cntrl alt alt cntrl lock\n" "# code base shift cntrl shift alt shift cntrl shift state\n" "# ------------------------------------------------------------------\n" ); for (i=0; i NUM_FKEYS) { warnx("function key number must be between 1 and %d", NUM_FKEYS); return; } if ((fkey.flen = strlen(string)) > MAXFK) { warnx("function key string too long (%d > %d)", fkey.flen, MAXFK); return; } strncpy(fkey.keydef, string, MAXFK); fkey.keynum -= 1; if (ioctl(0, SETFKEY, &fkey) < 0) warn("setting function key"); } static void set_bell_values(char *opt) { int bell, duration, pitch; bell = 0; if (!strncmp(opt, "quiet.", 6)) { bell = CONS_QUIET_BELL; opt += 6; } if (!strcmp(opt, "visual")) bell |= CONS_VISUAL_BELL; else if (!strcmp(opt, "normal")) duration = 5, pitch = 800; else if (!strcmp(opt, "off")) duration = 0, pitch = 0; else { char *v1; bell = 0; duration = strtol(opt, &v1, 0); if ((duration < 0) || (*v1 != '.')) goto badopt; opt = ++v1; pitch = strtol(opt, &v1, 0); if ((pitch < 0) || (*opt == '\0') || (*v1 != '\0')) { badopt: warnx("argument to -b must be duration.pitch or [quiet.]visual|normal|off"); return; } if (pitch != 0) pitch = 1193182 / pitch; /* in Hz */ duration /= 10; /* in 10 m sec */ } ioctl(0, CONS_BELLTYPE, &bell); if (!(bell & CONS_VISUAL_BELL)) fprintf(stderr, "[=%d;%dB", pitch, duration); } static void set_keyrates(char *opt) { int arg[2]; int repeat; int delay; int r, d; if (!strcmp(opt, "slow")) { delay = 1000, repeat = 500; d = 3, r = 31; } else if (!strcmp(opt, "normal")) { delay = 500, repeat = 125; d = 1, r = 15; } else if (!strcmp(opt, "fast")) { delay = repeat = 0; d = r = 0; } else { int n; char *v1; delay = strtol(opt, &v1, 0); if ((delay < 0) || (*v1 != '.')) goto badopt; opt = ++v1; repeat = strtol(opt, &v1, 0); if ((repeat < 0) || (*opt == '\0') || (*v1 != '\0')) { badopt: warnx("argument to -r must be delay.repeat or slow|normal|fast"); return; } for (n = 0; n < ndelays - 1; n++) if (delay <= delays[n]) break; d = n; for (n = 0; n < nrepeats - 1; n++) if (repeat <= repeats[n]) break; r = n; } arg[0] = delay; arg[1] = repeat; if (ioctl(0, KDSETREPEAT, arg)) { if (ioctl(0, KDSETRAD, (d << 5) | r)) warn("setting keyboard rate"); } } static const char * get_kbd_type_name(int type) { static struct { int type; const char *name; } name_table[] = { { KB_84, "AT 84" }, { KB_101, "AT 101/102" }, { KB_OTHER, "generic" }, }; unsigned int i; for (i = 0; i < sizeof(name_table)/sizeof(name_table[0]); ++i) { if (type == name_table[i].type) return name_table[i].name; } return "unknown"; } static void show_kbd_info(void) { keyboard_info_t info; if (ioctl(0, KDGKBINFO, &info) == -1) { warn("unable to obtain keyboard information"); return; } printf("kbd%d:\n", info.kb_index); printf(" %.*s%d, type:%s (%d)\n", (int)sizeof(info.kb_name), info.kb_name, info.kb_unit, get_kbd_type_name(info.kb_type), info.kb_type); } static void set_keyboard(char *device) { keyboard_info_t info; int fd; fd = open(device, O_RDONLY); if (fd < 0) { warn("cannot open %s", device); return; } if (ioctl(fd, KDGKBINFO, &info) == -1) { warn("unable to obtain keyboard information"); close(fd); return; } /* * The keyboard device driver won't release the keyboard by * the following ioctl, but it automatically will, when the device * is closed. So, we don't check error here. */ ioctl(fd, CONS_RELKBD, 0); close(fd); #if 1 printf("kbd%d\n", info.kb_index); printf(" %.*s%d, type:%s (%d)\n", (int)sizeof(info.kb_name), info.kb_name, info.kb_unit, get_kbd_type_name(info.kb_type), info.kb_type); #endif if (ioctl(0, CONS_SETKBD, info.kb_index) == -1) warn("unable to set keyboard"); } static void release_keyboard(void) { keyboard_info_t info; /* * If stdin is not associated with a keyboard, the following ioctl * will fail. */ if (ioctl(0, KDGKBINFO, &info) == -1) { warn("unable to obtain keyboard information"); return; } #if 1 printf("kbd%d\n", info.kb_index); printf(" %.*s%d, type:%s (%d)\n", (int)sizeof(info.kb_name), info.kb_name, info.kb_unit, get_kbd_type_name(info.kb_type), info.kb_type); #endif if (ioctl(0, CONS_RELKBD, 0) == -1) warn("unable to release the keyboard"); } static void mux_keyboard(u_int op, char *kbd) { keyboard_info_t info; char *unit, *ep; /* * If stdin is not associated with a keyboard, the following ioctl * will fail. */ if (ioctl(0, KDGKBINFO, &info) == -1) { warn("unable to obtain keyboard information"); return; } #if 1 printf("kbd%d\n", info.kb_index); printf(" %.*s%d, type:%s (%d)\n", (int)sizeof(info.kb_name), info.kb_name, info.kb_unit, get_kbd_type_name(info.kb_type), info.kb_type); #endif /* * split kbd into name and unit. find the right most part of the * kbd string that consist of only digits. */ memset(&info, 0, sizeof(info)); info.kb_unit = -1; ep = kbd - 1; do { unit = strpbrk(ep + 1, "0123456789"); if (unit != NULL) { info.kb_unit = strtol(unit, &ep, 10); if (*ep != '\0') info.kb_unit = -1; } } while (unit != NULL && info.kb_unit == -1); if (info.kb_unit == -1) { warnx("unable to find keyboard driver unit in '%s'", kbd); return; } if (unit == kbd) { warnx("unable to find keyboard driver name in '%s'", kbd); return; } if (unit - kbd >= (int) sizeof(info.kb_name)) { warnx("keyboard name '%s' is too long", kbd); return; } strncpy(info.kb_name, kbd, unit - kbd); /* * If stdin is not associated with a kbdmux(4) keyboard, the following * ioctl will fail. */ if (ioctl(0, op, &info) == -1) warn("unable to (un)mux the keyboard"); } static void usage(void) { fprintf(stderr, "%s\n%s\n%s\n", "usage: kbdcontrol [-dFKix] [-A name] [-a name] [-b duration.pitch | [quiet.]belltype]", " [-r delay.repeat | speed] [-l mapfile] [-f # string]", -" [-k device] [-L mapfile]"); +" [-k device] [-L mapfile] [-P path]"); exit(1); } int main(int argc, char **argv) { + const char *optstring = "A:a:b:df:iKk:Fl:L:P:r:x"; int opt; - while((opt = getopt(argc, argv, "A:a:b:df:iKk:Fl:L:r:x")) != -1) + /* Collect any -P arguments, regardless of where they appear. */ + while ((opt = getopt(argc, argv, optstring)) != -1) + if (opt == 'P') + add_keymap_path(optarg); + + optind = optreset = 1; + while ((opt = getopt(argc, argv, optstring)) != -1) switch(opt) { case 'A': case 'a': mux_keyboard((opt == 'A')? KBRELKBD : KBADDKBD, optarg); break; case 'b': set_bell_values(optarg); break; case 'd': print_keymap(); break; case 'l': load_keymap(optarg, 0); break; case 'L': load_keymap(optarg, 1); + break; + case 'P': break; case 'f': set_functionkey(optarg, nextarg(argc, argv, &optind, 'f')); break; case 'F': load_default_functionkeys(); break; case 'i': show_kbd_info(); break; case 'K': release_keyboard(); break; case 'k': set_keyboard(optarg); break; case 'r': set_keyrates(optarg); break; case 'x': hex = 1; break; default: usage(); } if ((optind != argc) || (argc == 1)) usage(); exit(0); }