xref: /illumos-gate/usr/src/cmd/loadkeys/dumpkeys.c (revision 8a2b682e57a046b828f37bcde1776f131ef4629f) 
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 }
448