1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22
23 /*
24 * Copyright (c) 1988 by Sun Microsystems, Inc.
25 */
26
27 #include <sys/types.h>
28 #include <ctype.h>
29 #include <stdio.h>
30 #include <fcntl.h>
31 #include <sys/kbd.h>
32 #include <sys/kbio.h>
33 #include <errno.h>
34
35 typedef enum {
36 SM_INVALID, /* this shift mask is invalid for this keyboard */
37 SM_NORMAL, /* "normal", valid shift mask */
38 SM_NUMLOCK, /* "Num Lock" shift mask */
39 SM_UP /* "Up" shift mask */
40 } smtype_t;
41
42 typedef struct {
43 char *sm_name;
44 int sm_mask;
45 smtype_t sm_type;
46 } smentry_t;
47
48
49 smentry_t shiftmasks[] = {
50 { "base", 0, SM_NORMAL },
51 { "shift", SHIFTMASK, SM_NORMAL },
52 { "caps", CAPSMASK, SM_NORMAL },
53 { "ctrl", CTRLMASK, SM_NORMAL },
54 { "altg", ALTGRAPHMASK, SM_NORMAL },
55 { "numl", NUMLOCKMASK, SM_NUMLOCK },
56 { "up", UPMASK, SM_UP },
57 };
58
59 #define NSHIFTS (sizeof (shiftmasks) / sizeof (shiftmasks[0]))
60
61 static void printentry(struct kiockeymap *kio);
62 static void printchar(int character, int delim);
63
64 /*ARGSUSED*/
65 int
66 main(int argc, char **argv)
67 {
68 register int kbdfd;
69 register int keystation;
70 register int shift;
71 int ktype;
72 struct kiockeymap keyentry[NSHIFTS];
73 register int allsame;
74
75 if ((kbdfd = open("/dev/kbd", O_WRONLY)) < 0) {
76 perror("dumpkeys: /dev/kbd");
77 return (1);
78 }
79 if (ioctl(kbdfd, KIOCTYPE, &ktype) < 0) {
80 perror("dumpkeys: ioctl(KIOCTYPE)");
81 return (1);
82 }
83 /* if no keyboard detected, or ascii terminal, exit silently */
84 if (ktype == KB_ASCII || ktype < 0)
85 exit(0);
86
87 /*
88 * See which shift masks are valid for this keyboard.
89 * We do that by trying to get the entry for keystation 0 and that
90 * shift mask; if the "ioctl" fails, we assume it's because the shift
91 * mask is invalid.
92 */
93 for (shift = 0; shift < NSHIFTS; shift++) {
94 keyentry[shift].kio_tablemask =
95 shiftmasks[shift].sm_mask;
96 keyentry[shift].kio_station = 0;
97 if (ioctl(kbdfd, KIOCGKEY, &keyentry[shift]) < 0)
98 shiftmasks[shift].sm_type = SM_INVALID;
99 }
100
101 /*
102 * Loop until we get an EINVAL, so we don't have to know
103 * how big the table might be.
104 */
105 for (keystation = 0; ; keystation++) {
106 for (shift = 0; shift < NSHIFTS; shift++) {
107 if (shiftmasks[shift].sm_type != SM_INVALID) {
108 keyentry[shift].kio_tablemask =
109 shiftmasks[shift].sm_mask;
110 keyentry[shift].kio_station = keystation;
111 if (ioctl(kbdfd, KIOCGKEY,
112 &keyentry[shift]) < 0) {
113 if (errno == EINVAL)
114 return (0);
115 perror("dumpkeys: KIOCGKEY");
116 return (1);
117 }
118 }
119 }
120
121 (void) printf("key %d\t", keystation);
122
123 /*
124 * See if all the "normal" entries (all but the Num Lock and Up
125 * entries) are the same.
126 */
127 allsame = 1;
128 for (shift = 1; shift < NSHIFTS; shift++) {
129 if (shiftmasks[shift].sm_type == SM_NORMAL) {
130 if (keyentry[0].kio_entry
131 != keyentry[shift].kio_entry) {
132 allsame = 0;
133 break;
134 }
135 }
136 }
137
138 if (allsame) {
139 /*
140 * All of the "normal" entries are the same; just print
141 * "all".
142 */
143 (void) printf(" all ");
144 printentry(&keyentry[0]);
145 } else {
146 /*
147 * The normal entries aren't all the same; print them
148 * individually.
149 */
150 for (shift = 0; shift < NSHIFTS; shift++) {
151 if (shiftmasks[shift].sm_type == SM_NORMAL) {
152 (void) printf(" %s ",
153 shiftmasks[shift].sm_name);
154 printentry(&keyentry[shift]);
155 }
156 }
157 }
158 if (allsame && keyentry[0].kio_entry == HOLE) {
159 /*
160 * This key is a "hole"; if either the Num Lock or Up
161 * entry isn't a "hole", print it.
162 */
163 for (shift = 0; shift < NSHIFTS; shift++) {
164 switch (shiftmasks[shift].sm_type) {
165
166 case SM_NUMLOCK:
167 case SM_UP:
168 if (keyentry[shift].kio_entry
169 != HOLE) {
170 (void) printf(" %s ",
171 shiftmasks[shift].sm_name);
172 printentry(&keyentry[shift]);
173 }
174 break;
175 }
176 }
177 } else {
178 /*
179 * This entry isn't a "hole"; if the Num Lock entry
180 * isn't NONL (i.e, if Num Lock actually does
181 * something) print it, and if the Up entry isn't NOP
182 * (i.e., if up transitions on this key actually do
183 * something) print it.
184 */
185 for (shift = 0; shift < NSHIFTS; shift++) {
186 switch (shiftmasks[shift].sm_type) {
187
188 case SM_NUMLOCK:
189 if (keyentry[shift].kio_entry
190 != NONL) {
191 (void) printf(" %s ",
192 shiftmasks[shift].sm_name);
193 printentry(&keyentry[shift]);
194 }
195 break;
196
197 case SM_UP:
198 if (keyentry[shift].kio_entry
199 != NOP) {
200 (void) printf(" %s ",
201 shiftmasks[shift].sm_name);
202 printentry(&keyentry[shift]);
203 }
204 break;
205 }
206 }
207 }
208 (void) printf("\n");
209 }
210 }
211
212 static char *shiftkeys[] = {
213 "capslock",
214 "shiftlock",
215 "leftshift",
216 "rightshift",
217 "leftctrl",
218 "rightctrl",
219 "meta", /* not used */
220 "top", /* not used */
221 "cmd", /* reserved */
222 "altgraph",
223 "alt",
224 "numlock",
225 };
226
227 #define NSHIFTKEYS (sizeof (shiftkeys) / sizeof (shiftkeys[0]))
228
229 static char *buckybits[] = {
230 "metabit",
231 "systembit",
232 };
233
234 #define NBUCKYBITS (sizeof (buckybits) / sizeof (buckybits[0]))
235
236 static char *funnies[] = {
237 "nop",
238 "oops",
239 "hole",
240 "", /* not used */
241 "", /* not used */
242 "", /* not used */
243 "reset",
244 "error",
245 "idle",
246 "compose",
247 "nonl",
248 };
249
250 #define NFUNNIES (sizeof (funnies) / sizeof (funnies[0]))
251
252 static char *fa_class[] = {
253 "fa_umlaut",
254 "fa_cflex",
255 "fa_tilde",
256 "fa_cedilla",
257 "fa_acute",
258 "fa_grave",
259 "fa_macron",
260 "fa_breve",
261 "fa_dot",
262 "fa_slash",
263 "fa_ring",
264 "fa_apostrophe",
265 "fa_dacute",
266 "fa_ogonek",
267 "fa_caron"
268 };
269
270 #define NFA_CLASS (sizeof (fa_class) / sizeof (fa_class[0]))
271
272 typedef struct {
273 char *string;
274 char *name;
275 } builtin_string_t;
276
277 builtin_string_t builtin_strings[] = {
278 { "\033[H", "homearrow" },
279 { "\033[A", "uparrow" },
280 { "\033[B", "downarrow" },
281 { "\033[D", "leftarrow" },
282 { "\033[C", "rightarrow" },
283 };
284
285 #define NBUILTIN_STRINGS (sizeof (builtin_strings) / \
286 sizeof (builtin_strings[0]))
287
288 static char *fkeysets[] = {
289 "lf",
290 "rf",
291 "tf",
292 "bf",
293 };
294
295 #define NFKEYSETS (sizeof (fkeysets) / sizeof (fkeysets[0]))
296
297 static char *padkeys[] = {
298 "padequal",
299 "padslash",
300 "padstar",
301 "padminus",
302 "padsep",
303 "pad7",
304 "pad8",
305 "pad9",
306 "padplus",
307 "pad4",
308 "pad5",
309 "pad6",
310 "pad1",
311 "pad2",
312 "pad3",
313 "pad0",
314 "paddot",
315 "padenter",
316 };
317
318 #define NPADKEYS (sizeof (padkeys) / sizeof (padkeys[0]))
319
320 static void
321 printentry(struct kiockeymap *kio)
322 {
323 int entry = (kio->kio_entry & 0x1F);
324 int fkeyset;
325 int i;
326 int c;
327
328 switch (KEYFLAGS(kio->kio_entry)) {
329
330 case 0x0:
331 if (kio->kio_entry == '"')
332 (void) printf("'\"'"); /* special case */
333 else if (kio->kio_entry == ' ')
334 (void) printf("' '"); /* special case */
335 else
336 printchar((int)kio->kio_entry, '\'');
337 break;
338
339 case SHIFTKEYS:
340 if (entry < NSHIFTKEYS)
341 (void) printf("shiftkeys+%s", shiftkeys[entry]);
342 else
343 (void) printf("%#4x", kio->kio_entry);
344 break;
345
346 case BUCKYBITS:
347 if (entry < NBUCKYBITS)
348 (void) printf("buckybits+%s", buckybits[entry]);
349 else
350 (void) printf("%#4x", kio->kio_entry);
351 break;
352
353 case FUNNY:
354 if (entry < NFUNNIES)
355 (void) printf("%s", funnies[entry]);
356 else
357 (void) printf("%#4x", kio->kio_entry);
358 break;
359
360 case FA_CLASS:
361 if (entry < NFA_CLASS)
362 (void) printf("%s", fa_class[entry]);
363 else
364 (void) printf("%#4x", kio->kio_entry);
365 break;
366
367 case STRING:
368 if (entry < NBUILTIN_STRINGS && strncmp(kio->kio_string,
369 builtin_strings[entry].string, KTAB_STRLEN) == 0)
370 (void) printf("string+%s", builtin_strings[entry].name);
371 else {
372 (void) printf("\"");
373 for (i = 0;
374 i < KTAB_STRLEN && (c = kio->kio_string[i]) != '\0';
375 i++)
376 printchar(c, '"');
377 (void) printf("\"");
378 }
379 break;
380
381 case FUNCKEYS:
382 fkeyset = (int)(kio->kio_entry & 0xF0) >> 4;
383 if (fkeyset < NFKEYSETS)
384 (void) printf("%s(%d)", fkeysets[fkeyset],
385 (entry & 0x0F) + 1);
386 else
387 (void) printf("%#4x", kio->kio_entry);
388 break;
389
390 case PADKEYS:
391 if (entry < NPADKEYS)
392 (void) printf("%s", padkeys[entry]);
393 else
394 (void) printf("%#4x", kio->kio_entry);
395 break;
396
397 default:
398 (void) printf("%#4x", kio->kio_entry);
399 break;
400 }
401 }
402
403 static void
404 printchar(int character, int delim)
405 {
406 switch (character) {
407
408 case '\n':
409 (void) printf("'\\n'");
410 break;
411
412 case '\t':
413 (void) printf("'\\t'");
414 break;
415
416 case '\b':
417 (void) printf("'\\b'");
418 break;
419
420 case '\r':
421 (void) printf("'\\r'");
422 break;
423
424 case '\v':
425 (void) printf("'\\v'");
426 break;
427
428 case '\\':
429 (void) printf("'\\\\'");
430 break;
431
432 default:
433 if (isprint(character)) {
434 if (character == delim)
435 (void) printf("'\\'");
436 (void) printf("%c", character);
437 } else {
438 if (character < 040)
439 (void) printf("^%c", character + 0100);
440 else if (character <= 0xff)
441 (void) printf("'\\%.3o'", character);
442 else
443 (void) printf("%#4x", character);
444 }
445 break;
446 }
447 }