Logo Search packages:      
Sourcecode: freebsd-utils version File versions

kbdcontrol.c

/*-
 * 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: src/usr.sbin/kbdcontrol/kbdcontrol.c,v 1.51.6.1 2008/11/25 02:59:29 kensmith Exp $");

#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 "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

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 "
      };

char acc_names[15][5] = {
      "dgra", "dacu", "dcir", "dtil", "dmac", "dbre", "ddot",
      "duml", "dsla", "drin", "dced", "dapo", "ddac", "dogo", 
      "dcar",
      };

char acc_names_u[15][5] = {
      "DGRA", "DACU", "DCIR", "DTIL", "DMAC", "DBRE", "DDOT",
      "DUML", "DSLA", "DRIN", "DCED", "DAPO", "DDAC", "DOGO", 
      "DCAR",
      };

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 */ ""      , ""      , ""      , ""      ,
      };

const int   delays[]  = {250, 500, 750, 1000};
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};
const int   ndelays = (sizeof(delays) / sizeof(int));
const int   nrepeats = (sizeof(repeats) / sizeof(int));
int         hex = 0;
int         number;
char        letter;
int         token;

void        dump_accent_definition(char *name, accentmap_t *accentmap);
void        dump_entry(int value);
void        dump_key_definition(char *name, keymap_t *keymap);
int         get_accent_definition_line(accentmap_t *);
int         get_entry(void);
int         get_key_definition_line(keymap_t *);
void        load_keymap(char *opt, int dumponly);
void        load_default_functionkeys(void);
char *            nextarg(int ac, char **av, int *indp, int oc);
char *            mkfullname(const char *s1, const char *s2, const char *s3);
void        print_accent_definition_line(FILE *fp, int accent,
                  struct acc_t *key);
void        print_entry(FILE *fp, int value);
void        print_key_definition_line(FILE *fp, int scancode,
                  struct keyent_t *key);
void        print_keymap(void);
void        release_keyboard(void);
void        mux_keyboard(u_int op, char *kbd);
void        set_bell_values(char *opt);
void        set_functionkey(char *keynumstr, char *string);
void        set_keyboard(char *device);
void        set_keyrates(char *opt);
void        show_kbd_info(void);
void        usage(void) __dead2;

char *
nextarg(int ac, char **av, int *indp, int oc)
{
      if (*indp < ac)
            return(av[(*indp)++]);
      warnx("option requires two arguments -- %c", oc);
      usage();
}


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);
}


int
get_entry(void)
{
      switch ((token = yylex())) {
      case TNOP:
            return NOP | 0x100;
      case TLSH:
            return LSH | 0x100;
      case TRSH:
            return RSH | 0x100;
      case TCLK:
            return CLK | 0x100;
      case TNLK:
            return NLK | 0x100;
      case TSLK:
            return SLK | 0x100;
      case TBTAB:
            return BTAB | 0x100;
      case TLALT:
            return LALT | 0x100;
      case TLCTR:
            return LCTR | 0x100;
      case TNEXT:
            return NEXT | 0x100;
      case TPREV:
            return PREV | 0x100;
      case TRCTR:
            return RCTR | 0x100;
      case TRALT:
            return RALT | 0x100;
      case TALK:
            return ALK | 0x100;
      case TASH:
            return ASH | 0x100;
      case TMETA:
            return META | 0x100;
      case TRBT:
            return RBT | 0x100;
      case TDBG:
            return DBG | 0x100;
      case TSUSP:
            return SUSP | 0x100;
      case TSPSC:
            return SPSC | 0x100;
      case TPANIC:
            return PNC | 0x100;
      case TLSHA:
            return LSHA | 0x100;
      case TRSHA:
            return RSHA | 0x100;
      case TLCTRA:
            return LCTRA | 0x100;
      case TRCTRA:
            return RCTRA | 0x100;
      case TLALTA:
            return LALTA | 0x100;
      case TRALTA:
            return RALTA | 0x100;
      case THALT:
            return HALT | 0x100;
      case TPDWN:
            return PDWN | 0x100;
      case TPASTE:
            return PASTE | 0x100;
      case TACC:
            if (ACC(number) > L_ACC)
                  return -1;
            return ACC(number) | 0x100;
      case TFUNC:
            if (F(number) > L_FN)
                  return -1;
            return F(number) | 0x100;
      case TSCRN:
            if (S(number) > L_SCR)
                  return -1;
            return S(number) | 0x100;
      case TLET:
            return (unsigned char)letter;
      case TNUM:
            if (number < 0 || number > 255)
                  return -1;
            return number;
      default:
            return -1;
      }
}

static int
get_definition_line(FILE *fd, keymap_t *keymap, accentmap_t *accentmap)
{
      int c;

      yyin = fd;

      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;
}

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 & 0x100)
                  map->key[scancode].spcl |= (0x80 >> i);
            map->key[scancode].map[i] = def & 0xFF;
      }
      /* get lock state key def */
      if ((token = yylex()) != TFLAG)
            return -1;
      map->key[scancode].flgs = number;
      token = yylex();
      return (scancode + 1);
}

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);
}

void
print_entry(FILE *fp, int value)
{
      int val = value & 0xFF;

      switch (value) {
      case NOP | 0x100:
            fprintf(fp, " nop   ");
            break;
      case LSH | 0x100:
            fprintf(fp, " lshift");
            break;
      case RSH | 0x100:
            fprintf(fp, " rshift");
            break;
      case CLK | 0x100:
            fprintf(fp, " clock ");
            break;
      case NLK | 0x100:
            fprintf(fp, " nlock ");
            break;
      case SLK | 0x100:
            fprintf(fp, " slock ");
            break;
      case BTAB | 0x100:
            fprintf(fp, " btab  ");
            break;
      case LALT | 0x100:
            fprintf(fp, " lalt  ");
            break;
      case LCTR | 0x100:
            fprintf(fp, " lctrl ");
            break;
      case NEXT | 0x100:
            fprintf(fp, " nscr  ");
            break;
      case PREV | 0x100:
            fprintf(fp, " pscr  ");
            break;
      case RCTR | 0x100:
            fprintf(fp, " rctrl ");
            break;
      case RALT | 0x100:
            fprintf(fp, " ralt  ");
            break;
      case ALK | 0x100:
            fprintf(fp, " alock ");
            break;
      case ASH | 0x100:
            fprintf(fp, " ashift");
            break;
      case META | 0x100:
            fprintf(fp, " meta  ");
            break;
      case RBT | 0x100:
            fprintf(fp, " boot  ");
            break;
      case DBG | 0x100:
            fprintf(fp, " debug ");
            break;
      case SUSP | 0x100:
            fprintf(fp, " susp  ");
            break;
      case SPSC | 0x100:
            fprintf(fp, " saver ");
            break;
      case PNC | 0x100:
            fprintf(fp, " panic ");
            break;
      case LSHA | 0x100:
            fprintf(fp, " lshifta");
            break;
      case RSHA | 0x100:
            fprintf(fp, " rshifta");
            break;
      case LCTRA | 0x100:
            fprintf(fp, " lctrla");
            break;
      case RCTRA | 0x100:
            fprintf(fp, " rctrla");
            break;
      case LALTA | 0x100:
            fprintf(fp, " lalta ");
            break;
      case RALTA | 0x100:
            fprintf(fp, " ralta ");
            break;
      case HALT | 0x100:
            fprintf(fp, " halt  ");
            break;
      case PDWN | 0x100:
            fprintf(fp, " pdwn  ");
            break;
      case PASTE | 0x100:
            fprintf(fp, " paste ");
            break;
      default:
            if (value & 0x100) {
                  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);
            }
      }
}

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] | 0x100);
            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;
      }
}

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");
}

void
dump_entry(int value)
{
      if (value & 0x100) {
            value &= 0x00ff;
            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);
      }
}

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] | 0x100);
                  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");
}

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");
}

void
load_keymap(char *opt, int dumponly)
{
      keymap_t keymap;
      accentmap_t accentmap;
      FILE  *fd;
      int   i, j;
      char  *name, *cp;
      char  blank[] = "", keymap_path[] = KEYMAP_PATH, dotkbd[] = ".kbd";
      char  *prefix[]  = {blank, blank, keymap_path, NULL};
      char  *postfix[] = {blank, dotkbd, NULL};

      cp = getenv("KEYMAP_PATH");
      if (cp != NULL)
            asprintf(&(prefix[0]), "%s/", cp);

      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");
            }
      }
      if (fd == 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)
                  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);
            return;
      }
      if ((accentmap.n_accs > 0) 
            && (ioctl(0, PIO_DEADKEYMAP, &accentmap) < 0)) {
            warn("setting accentmap");
            fclose(fd);
            return;
      }
}

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]);

}

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");
      }
}

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");
}

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);
}

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";
}

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);
}

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");
}

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");
}

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");
}

void
usage()
{
      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]");
      exit(1);
}


int
main(int argc, char **argv)
{
      int         opt;

      while((opt = getopt(argc, argv, "A:a:b:df:iKk:Fl:L:r:x")) != -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 '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);
}

Generated by  Doxygen 1.6.0   Back to index