7551d83c35
Mainly focus on files that use BSD 2-Clause license, however the tool I was using misidentified many licenses so this was mostly a manual - error prone - task. The Software Package Data Exchange (SPDX) group provides a specification to make it easier for automated tools to detect and summarize well known opensource licenses. We are gradually adopting the specification, noting that the tags are considered only advisory and do not, in any way, superceed or replace the license texts. No functional change intended.
1275 lines
28 KiB
C
1275 lines
28 KiB
C
/*-
|
||
* SPDX-License-Identifier: BSD-2-Clause-FreeBSD
|
||
*
|
||
* 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 <sys/cdefs.h>
|
||
__FBSDID("$FreeBSD$");
|
||
|
||
#include <ctype.h>
|
||
#include <err.h>
|
||
#include <stdio.h>
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
#include <unistd.h>
|
||
#include <fcntl.h>
|
||
#include <sys/kbio.h>
|
||
#include <sys/consio.h>
|
||
#include <sys/queue.h>
|
||
#include <sys/sysctl.h>
|
||
#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 *file, keymap_t *keymap, accentmap_t *accentmap)
|
||
{
|
||
int c;
|
||
|
||
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; i<NUM_STATES; i++) {
|
||
if ((def = get_entry()) == -1)
|
||
return -1;
|
||
if (def & SPECIAL)
|
||
map->key[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; i<NUM_STATES; i++) {
|
||
if (key->spcl & (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;
|
||
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 *postfix[] = {blank, dotkbd, NULL};
|
||
|
||
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;
|
||
}
|
||
|
||
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 (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(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(file);
|
||
return;
|
||
}
|
||
if ((accentmap.n_accs > 0)
|
||
&& (ioctl(0, PIO_DEADKEYMAP, &accentmap) < 0)) {
|
||
warn("setting accentmap");
|
||
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<keymap.n_keys; i++)
|
||
print_key_definition_line(stdout, i, &keymap.key[i]);
|
||
|
||
printf("\n");
|
||
for (i = 0; i < NUM_DEADKEYS; i++)
|
||
print_accent_definition_line(stdout, i, &accentmap.acc[i]);
|
||
|
||
}
|
||
|
||
static void
|
||
load_default_functionkeys(void)
|
||
{
|
||
fkeyarg_t fkey;
|
||
int i;
|
||
|
||
for (i=0; i<NUM_FKEYS; i++) {
|
||
fkey.keynum = i;
|
||
strcpy(fkey.keydef, fkey_table[i]);
|
||
fkey.flen = strlen(fkey_table[i]);
|
||
if (ioctl(0, SETFKEY, &fkey) < 0)
|
||
warn("setting function key");
|
||
}
|
||
}
|
||
|
||
static void
|
||
set_functionkey(char *keynumstr, char *string)
|
||
{
|
||
fkeyarg_t fkey;
|
||
|
||
if (!strcmp(keynumstr, "load") && !strcmp(string, "default")) {
|
||
load_default_functionkeys();
|
||
return;
|
||
}
|
||
fkey.keynum = atoi(keynumstr);
|
||
if (fkey.keynum < 1 || fkey.keynum > 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] [-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;
|
||
|
||
/* 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);
|
||
}
|