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