1 /*-
2 * Copyright (c) 1994-1996 Søren Schmidt
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer,
10 * in this position and unchanged.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * 3. The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
28 * $FreeBSD: src/usr.sbin/vidcontrol/vidcontrol.c,v 1.32.2.7 2002/09/15 22:31:50 dd Exp $
29 */
30
31 #include <machine/console.h>
32
33 #include <sys/consio.h>
34 #include <sys/errno.h>
35 #include <sys/types.h>
36 #include <sys/stat.h>
37
38 #include <ctype.h>
39 #include <err.h>
40 #include <limits.h>
41 #include <stdio.h>
42 #include <stdlib.h>
43 #include <string.h>
44 #include <unistd.h>
45
46 #include "path.h"
47 #include "decode.h"
48
49
50 #define DATASIZE(x) ((x).w * (x).h * 256 / 8)
51
52 #define DUMP_RAW 0
53 #define DUMP_TXT 1
54
55 #define DUMP_FMT_REV 1
56
57
58 char legal_colors[16][16] = {
59 "black", "blue", "green", "cyan",
60 "red", "magenta", "brown", "white",
61 "grey", "lightblue", "lightgreen", "lightcyan",
62 "lightred", "lightmagenta", "yellow", "lightwhite"
63 };
64
65 struct {
66 int active_vty;
67 vid_info_t console_info;
68 unsigned char screen_map[256];
69 int video_mode_number;
70 struct video_info video_mode_info;
71 } cur_info;
72
73 int hex = 0;
74 int number;
75 int g_cols;
76 int g_rows;
77 int font_height;
78 int colors_changed;
79 int video_mode_changed;
80 int normal_fore_color, normal_back_color;
81 int revers_fore_color, revers_back_color;
82 char letter;
83 struct vid_info info;
84 struct video_info new_mode_info;
85
86
87 /*
88 * Initialize revert data.
89 *
90 * NOTE: the following parameters are not yet saved/restored:
91 *
92 * screen saver timeout
93 * cursor type
94 * mouse character and mouse show/hide state
95 * vty switching on/off state
96 * history buffer size
97 * history contents
98 * font maps
99 */
100
101 static void
init(void)102 init(void)
103 {
104 if (ioctl(0, VT_GETACTIVE, &cur_info.active_vty) == -1)
105 errc(1, errno, "getting active vty");
106
107 cur_info.console_info.size = sizeof(cur_info.console_info);
108
109 if (ioctl(0, CONS_GETINFO, &cur_info.console_info) == -1)
110 errc(1, errno, "getting console information");
111
112 if (ioctl(0, GIO_SCRNMAP, &cur_info.screen_map) == -1)
113 errc(1, errno, "getting screen map");
114
115 if (ioctl(0, CONS_GET, &cur_info.video_mode_number) == -1)
116 errc(1, errno, "getting video mode number");
117
118 cur_info.video_mode_info.vi_mode = cur_info.video_mode_number;
119
120 if (ioctl(0, CONS_MODEINFO, &cur_info.video_mode_info) == -1)
121 errc(1, errno, "getting video mode parameters");
122
123 normal_fore_color = cur_info.console_info.mv_norm.fore;
124 normal_back_color = cur_info.console_info.mv_norm.back;
125 revers_fore_color = cur_info.console_info.mv_rev.fore;
126 revers_back_color = cur_info.console_info.mv_rev.back;
127 }
128
129
130 /*
131 * If something goes wrong along the way we call revert() to go back to the
132 * console state we came from (which is assumed to be working).
133 *
134 * NOTE: please also read the comments of init().
135 */
136
137 static void
revert(void)138 revert(void)
139 {
140 int size[3];
141
142 ioctl(0, VT_ACTIVATE, (caddr_t) (long) cur_info.active_vty);
143
144 fprintf(stderr, "[=%dA", cur_info.console_info.mv_ovscan);
145 fprintf(stderr, "[=%dF", cur_info.console_info.mv_norm.fore);
146 fprintf(stderr, "[=%dG", cur_info.console_info.mv_norm.back);
147 fprintf(stderr, "[=%dH", cur_info.console_info.mv_rev.fore);
148 fprintf(stderr, "[=%dI", cur_info.console_info.mv_rev.back);
149
150 ioctl(0, PIO_SCRNMAP, &cur_info.screen_map);
151 ioctl(0, CONS_SET, &cur_info.video_mode_number);
152
153 if (cur_info.video_mode_info.vi_flags & V_INFO_GRAPHICS) {
154 size[0] = cur_info.video_mode_info.vi_width / 8;
155 size[1] = cur_info.video_mode_info.vi_height /
156 cur_info.console_info.font_size;
157 size[2] = cur_info.console_info.font_size;
158
159 ioctl(0, KDRASTER, size);
160 }
161 }
162
163
164 /*
165 * Print a short usage string describing all options, then exit.
166 */
167
168 static void
usage(void)169 usage(void)
170 {
171 fprintf(stderr,
172 "usage: vidcontrol [-CdLPpx] [-b color] [-c appearance]"
173 " [-f [size] file]\n"
174 " [-g geometry] [-h size] [-i adapter | mode]"
175 " [-l screen_map]\n"
176 " [-M char] [-m on | off] [-r foreground"
177 " background]\n"
178 " [-S on | off] [-s number] [-t N | off]"
179 " [mode]\n"
180 " [foreground [background]] [show]\n");
181
182 exit(1);
183 }
184
185
186 /*
187 * Retrieve the next argument from the command line (for options that require
188 * more than one argument).
189 */
190
191 static char *
nextarg(int ac,char ** av,int * indp,int oc,int strict)192 nextarg(int ac, char **av, int *indp, int oc, int strict)
193 {
194 if (*indp < ac)
195 return(av[(*indp)++]);
196
197 if (strict != 0) {
198 revert();
199 errx(1, "option requires two arguments -- %c", oc);
200 }
201
202 return(NULL);
203 }
204
205
206 /*
207 * Guess which file to open. Try to open each combination of a specified set
208 * of file name components.
209 */
210
211 static FILE *
openguess(const char * a[],const char * b[],const char * c[],const char * d[],char ** name)212 openguess(const char *a[], const char *b[], const char *c[], const char *d[], char **name)
213 {
214 FILE *f;
215 int i, j, k, l;
216
217 for (i = 0; a[i] != NULL; i++) {
218 for (j = 0; b[j] != NULL; j++) {
219 for (k = 0; c[k] != NULL; k++) {
220 for (l = 0; d[l] != NULL; l++) {
221 asprintf(name, "%s%s%s%s",
222 a[i], b[j], c[k], d[l]);
223
224 f = fopen(*name, "r");
225
226 if (f != NULL)
227 return (f);
228
229 free(*name);
230 }
231 }
232 }
233 }
234
235 return (NULL);
236 }
237
238
239 /*
240 * Load a screenmap from a file and set it.
241 */
242
243 static void
load_scrnmap(char * filename)244 load_scrnmap(char *filename)
245 {
246 FILE *fd;
247 int size;
248 char *name;
249 scrmap_t scrnmap;
250 const char *a[] = {"", SCRNMAP_PATH, NULL};
251 const char *b[] = {filename, NULL};
252 const char *c[] = {"", ".scm", NULL};
253 const char *d[] = {"", NULL};
254
255 fd = openguess(a, b, c, d, &name);
256
257 if (fd == NULL) {
258 revert();
259 errx(1, "screenmap file not found");
260 }
261
262 size = sizeof(scrnmap);
263
264 if (decode(fd, (char *)&scrnmap, size) != size) {
265 rewind(fd);
266
267 if (fread(&scrnmap, 1, size, fd) != (size_t)size) {
268 fclose(fd);
269 revert();
270 errx(1, "bad screenmap file");
271 }
272 }
273
274 if (ioctl(0, PIO_SCRNMAP, &scrnmap) == -1) {
275 revert();
276 errc(1, errno, "loading screenmap");
277 }
278
279 fclose(fd);
280 }
281
282
283 /*
284 * Set the default screenmap.
285 */
286
287 static void
load_default_scrnmap(void)288 load_default_scrnmap(void)
289 {
290 scrmap_t scrnmap;
291 int i;
292
293 for (i = 0; i < 256; i++)
294 *((char*)&scrnmap + i) = i;
295
296 if (ioctl(0, PIO_SCRNMAP, &scrnmap) == -1) {
297 revert();
298 errc(1, errno, "loading default screenmap");
299 }
300 }
301
302
303 /*
304 * Print the current screenmap to stdout.
305 */
306
307 static void
print_scrnmap(void)308 print_scrnmap(void)
309 {
310 unsigned char map[256];
311 size_t i;
312
313 if (ioctl(0, GIO_SCRNMAP, &map) == -1) {
314 revert();
315 errc(1, errno, "getting screenmap");
316 }
317
318 for (i=0; i<sizeof(map); i++) {
319 if (i > 0 && i % 16 == 0)
320 fprintf(stdout, "\n");
321
322 if (hex != 0)
323 fprintf(stdout, " %02x", map[i]);
324 else
325 fprintf(stdout, " %03d", map[i]);
326 }
327
328 fprintf(stdout, "\n");
329 }
330
331
332 /*
333 * Determine a file's size.
334 */
335
336 static int
fsize(FILE * file)337 fsize(FILE *file)
338 {
339 struct stat sb;
340
341 if (fstat(fileno(file), &sb) == 0)
342 return sb.st_size;
343 else
344 return -1;
345 }
346
347
348 /*
349 * Load a font from file and set it.
350 */
351
352 static void
load_font(char * type,char * filename)353 load_font(char *type, char *filename)
354 {
355 FILE *fd;
356 int h, i, size, w;
357 unsigned long io = 0; /* silence stupid gcc(1) in the Wall mode */
358 char *name, *fontmap, size_sufx[6];
359 const char *a[] = {"", FONT_PATH, NULL};
360 const char *b[] = {filename, NULL};
361 const char *c[] = {"", size_sufx, NULL};
362 const char *d[] = {"", ".fnt", NULL};
363 vid_info_t vinfo;
364
365 struct sizeinfo {
366 int w;
367 int h;
368 unsigned long io;
369 } sizes[] = {{8, 16, PIO_FONT8x16},
370 {8, 14, PIO_FONT8x14},
371 {8, 8, PIO_FONT8x8},
372 {0, 0, 0}};
373
374 vinfo.size = sizeof(vinfo);
375
376 if (ioctl(0, CONS_GETINFO, &vinfo) == -1) {
377 revert();
378 errc(1, errno, "obtaining current video mode parameters");
379 }
380
381 snprintf(size_sufx, sizeof(size_sufx), "-8x%hu", vinfo.font_size);
382
383 fd = openguess(a, b, c, d, &name);
384
385 if (fd == NULL) {
386 revert();
387 errx(1, "%s: can't load font file", filename);
388 }
389
390 if (type != NULL) {
391 size = 0;
392 if (sscanf(type, "%dx%d", &w, &h) == 2) {
393 for (i = 0; sizes[i].w != 0; i++) {
394 if (sizes[i].w == w && sizes[i].h == h) {
395 size = DATASIZE(sizes[i]);
396 io = sizes[i].io;
397 font_height = sizes[i].h;
398 }
399 }
400 }
401 if (size == 0) {
402 fclose(fd);
403 revert();
404 errx(1, "%s: bad font size specification", type);
405 }
406 } else {
407 /* Apply heuristics */
408
409 int j;
410 int dsize[2];
411
412 size = DATASIZE(sizes[0]);
413 fontmap = (char*) malloc(size);
414 dsize[0] = decode(fd, fontmap, size);
415 dsize[1] = fsize(fd);
416 free(fontmap);
417
418 size = 0;
419 for (j = 0; j < 2; j++) {
420 for (i = 0; sizes[i].w != 0; i++) {
421 if (DATASIZE(sizes[i]) == dsize[j]) {
422 size = dsize[j];
423 io = sizes[i].io;
424 font_height = sizes[i].h;
425 j = 2; /* XXX */
426 break;
427 }
428 }
429 }
430
431 if (size == 0) {
432 fclose(fd);
433 revert();
434 errx(1, "%s: can't guess font size", filename);
435 }
436
437 rewind(fd);
438 }
439
440 fontmap = (char*) malloc(size);
441
442 if (decode(fd, fontmap, size) != size) {
443 rewind(fd);
444 if (fsize(fd) != size ||
445 fread(fontmap, 1, size, fd) != (size_t)size) {
446 fclose(fd);
447 free(fontmap);
448 revert();
449 errx(1, "%s: bad font file", filename);
450 }
451 }
452
453 if (ioctl(0, io, fontmap) == -1) {
454 revert();
455 errc(1, errno, "loading font");
456 }
457
458 fclose(fd);
459 free(fontmap);
460 }
461
462
463 /*
464 * Set the timeout for the screensaver.
465 */
466
467 static void
set_screensaver_timeout(char * arg)468 set_screensaver_timeout(char *arg)
469 {
470 int nsec;
471
472 if (!strcmp(arg, "off")) {
473 nsec = 0;
474 } else {
475 nsec = atoi(arg);
476
477 if ((*arg == '\0') || (nsec < 1)) {
478 revert();
479 errx(1, "argument must be a positive number");
480 }
481 }
482
483 if (ioctl(0, CONS_BLANKTIME, &nsec) == -1) {
484 revert();
485 errc(1, errno, "setting screensaver period");
486 }
487 }
488
489
490 /*
491 * Set the cursor's shape/type.
492 */
493
494 static void
set_cursor_type(char * appearance)495 set_cursor_type(char *appearance)
496 {
497 int type;
498
499 if (!strcmp(appearance, "normal"))
500 type = 0;
501 else if (!strcmp(appearance, "blink"))
502 type = 1;
503 else if (!strcmp(appearance, "destructive"))
504 type = 3;
505 else {
506 revert();
507 errx(1, "argument to -c must be normal, blink or destructive");
508 }
509
510 if (ioctl(0, CONS_CURSORTYPE, &type) == -1) {
511 revert();
512 errc(1, errno, "setting cursor type");
513 }
514 }
515
516
517 /*
518 * Set the video mode.
519 */
520
521 static void
video_mode(int argc,char ** argv,int * mode_index)522 video_mode(int argc, char **argv, int *mode_index)
523 {
524 static struct {
525 const char *name;
526 unsigned long mode_num;
527 } modes[] = {{ "80x25", M_VGA_C80x25 },
528 { "80x30", M_VGA_C80x30 },
529 { "80x43", M_ENH_C80x43 },
530 { "80x50", M_VGA_C80x50 },
531 { "80x60", M_VGA_C80x60 },
532 { "VGA_40x25", M_VGA_C40x25 },
533 { "VGA_80x25", M_VGA_C80x25 },
534 { "VGA_80x30", M_VGA_C80x30 },
535 { "VGA_80x50", M_VGA_C80x50 },
536 { "VGA_80x60", M_VGA_C80x60 },
537 #ifdef SW_VGA_C90x25
538 { "VGA_90x25", M_VGA_C90x25 },
539 { "VGA_90x30", M_VGA_C90x30 },
540 { "VGA_90x43", M_VGA_C90x43 },
541 { "VGA_90x50", M_VGA_C90x50 },
542 { "VGA_90x60", M_VGA_C90x60 },
543 #endif
544 { "VGA_320x200", M_CG320 },
545 { "EGA_80x25", M_ENH_C80x25 },
546 { "EGA_80x43", M_ENH_C80x43 },
547 { NULL, 0 },
548 };
549
550 int new_mode_num = 0;
551 int size[3];
552 int i;
553
554 /*
555 * Parse the video mode argument...
556 */
557
558 if (*mode_index < argc) {
559 if (!strncmp(argv[*mode_index], "MODE_", 5)) {
560 if (!isdigit(argv[*mode_index][5]))
561 errx(1, "invalid video mode number");
562
563 new_mode_num = atoi(&argv[*mode_index][5]);
564 } else {
565 for (i = 0; modes[i].name != NULL; ++i) {
566 if (!strcmp(argv[*mode_index], modes[i].name)) {
567 new_mode_num = modes[i].mode_num;
568 break;
569 }
570 }
571
572 if (modes[i].name == NULL)
573 errx(1, "invalid video mode name");
574 }
575
576 /*
577 * Collect enough information about the new video mode...
578 */
579
580 new_mode_info.vi_mode = new_mode_num;
581
582 if (ioctl(0, CONS_MODEINFO, &new_mode_info) == -1) {
583 revert();
584 errc(1, errno, "obtaining new video mode parameters");
585 }
586
587 /*
588 * Try setting the new mode.
589 */
590
591 if (ioctl(0, CONS_SET, &new_mode_num) == -1) {
592 revert();
593 errc(1, errno, "setting video mode");
594 }
595
596 /*
597 * For raster modes it's not enough to just set the mode.
598 * We also need to explicitly set the raster mode.
599 */
600
601 if (new_mode_info.vi_flags & V_INFO_GRAPHICS) {
602 /* font size */
603
604 if (font_height == 0)
605 font_height = cur_info.console_info.font_size;
606
607 size[2] = font_height;
608
609 /* adjust columns */
610
611 if ((g_cols * 8 > new_mode_info.vi_width) ||
612 (g_cols <= 0)) {
613 size[0] = new_mode_info.vi_width / 8;
614 } else {
615 size[0] = g_cols;
616 }
617
618 /* adjust rows */
619
620 if ((g_rows * font_height > new_mode_info.vi_height) ||
621 (g_rows <= 0)) {
622 size[1] = new_mode_info.vi_height /
623 font_height;
624 } else {
625 size[1] = g_rows;
626 }
627
628 /* set raster mode */
629
630 if (ioctl(0, KDRASTER, size)) {
631 revert();
632 errc(1, errno, "activating raster display");
633 }
634 }
635
636 video_mode_changed = 1;
637
638 (*mode_index)++;
639 }
640 }
641
642
643 /*
644 * Return the number for a specified color name.
645 */
646
647 static int
get_color_number(char * color)648 get_color_number(char *color)
649 {
650 int i;
651
652 for (i=0; i<16; i++) {
653 if (!strcmp(color, legal_colors[i]))
654 return i;
655 }
656 return -1;
657 }
658
659
660 /*
661 * Get normal text and background colors.
662 */
663
664 static void
get_normal_colors(int argc,char ** argv,int * color_index)665 get_normal_colors(int argc, char **argv, int *color_index)
666 {
667 int color;
668
669 if (*color_index < argc &&
670 (color = get_color_number(argv[*color_index])) != -1) {
671 (*color_index)++;
672 normal_fore_color = color;
673 colors_changed = 1;
674
675 if (*color_index < argc &&
676 (color = get_color_number(argv[*color_index])) != -1) {
677 (*color_index)++;
678 normal_back_color = color;
679 }
680 }
681 }
682
683
684 /*
685 * Get reverse text and background colors.
686 */
687
688 static void
get_reverse_colors(int argc,char ** argv,int * color_index)689 get_reverse_colors(int argc, char **argv, int *color_index)
690 {
691 int color;
692
693 if ((color = get_color_number(argv[*(color_index)-1])) != -1) {
694 revers_fore_color = color;
695 colors_changed = 1;
696
697 if (*color_index < argc &&
698 (color = get_color_number(argv[*color_index])) != -1) {
699 (*color_index)++;
700 revers_back_color = color;
701 }
702 }
703 }
704
705
706 /*
707 * Set normal and reverse foreground and background colors.
708 */
709
710 static void
set_colors(void)711 set_colors(void)
712 {
713 fprintf(stderr, "[=%dF", normal_fore_color);
714 fprintf(stderr, "[=%dG", normal_back_color);
715 fprintf(stderr, "[=%dH", revers_fore_color);
716 fprintf(stderr, "[=%dI", revers_back_color);
717 }
718
719
720 /*
721 * Switch to virtual terminal #arg.
722 */
723
724 static void
set_console(char * arg)725 set_console(char *arg)
726 {
727 int n;
728
729 if(!arg || strspn(arg,"0123456789") != strlen(arg)) {
730 revert();
731 errx(1, "bad console number");
732 }
733
734 n = atoi(arg);
735
736 if (n < 1 || n > 16) {
737 revert();
738 errx(1, "console number out of range");
739 } else if (ioctl(0, VT_ACTIVATE, (caddr_t) (long) n) == -1) {
740 revert();
741 errc(1, errno, "switching vty");
742 }
743 }
744
745
746 /*
747 * Sets the border color.
748 */
749
750 static void
set_border_color(char * arg)751 set_border_color(char *arg)
752 {
753 int color;
754
755 if ((color = get_color_number(arg)) != -1)
756 fprintf(stderr, "[=%dA", color);
757 else
758 usage();
759 }
760
761
762 static void
set_mouse_char(char * arg)763 set_mouse_char(char *arg)
764 {
765 struct mouse_info mouse;
766 long l;
767
768 l = strtol(arg, NULL, 0);
769
770 if ((l < 0) || (l > UCHAR_MAX)) {
771 revert();
772 errx(1, "argument to -M must be 0 through %d", UCHAR_MAX);
773 }
774
775 mouse.operation = MOUSE_MOUSECHAR;
776 mouse.u.mouse_char = (int)l;
777
778 if (ioctl(0, CONS_MOUSECTL, &mouse) == -1) {
779 revert();
780 errc(1, errno, "setting mouse character");
781 }
782 }
783
784
785 /*
786 * Show/hide the mouse.
787 */
788
789 static void
set_mouse(char * arg)790 set_mouse(char *arg)
791 {
792 struct mouse_info mouse;
793
794 if (!strcmp(arg, "on")) {
795 mouse.operation = MOUSE_SHOW;
796 } else if (!strcmp(arg, "off")) {
797 mouse.operation = MOUSE_HIDE;
798 } else {
799 revert();
800 errx(1, "argument to -m must be either on or off");
801 }
802 ioctl(0, CONS_MOUSECTL, &mouse);
803 }
804
805
806 static void
set_lockswitch(char * arg)807 set_lockswitch(char *arg)
808 {
809 int data;
810
811 if (!strcmp(arg, "off")) {
812 data = 0x01;
813 } else if (!strcmp(arg, "on")) {
814 data = 0x02;
815 } else {
816 revert();
817 errx(1, "argument to -S must be either on or off");
818 }
819
820 if (ioctl(0, VT_LOCKSWITCH, &data) == -1) {
821 revert();
822 errc(1, errno, "turning %s vty switching",
823 data == 0x01 ? "off" : "on");
824 }
825 }
826
827
828 /*
829 * Return the adapter name for a specified type.
830 */
831
832 static const char *
adapter_name(int type)833 adapter_name(int type)
834 {
835 static struct {
836 int type;
837 const char *name;
838 } names[] = {{ KD_MONO, "MDA" },
839 { KD_HERCULES, "Hercules" },
840 { KD_CGA, "CGA" },
841 { KD_EGA, "EGA" },
842 { KD_VGA, "VGA" },
843 { KD_TGA, "TGA" },
844 { -1, "Unknown" },
845 };
846
847 int i;
848
849 for (i = 0; names[i].type != -1; ++i) {
850 if (names[i].type == type)
851 break;
852 }
853
854 return names[i].name;
855 }
856
857
858 /*
859 * Show graphics adapter information.
860 */
861
862 static void
show_adapter_info(void)863 show_adapter_info(void)
864 {
865 struct video_adapter_info ad;
866
867 ad.va_index = 0;
868
869 if (ioctl(0, CONS_ADPINFO, &ad) == -1) {
870 revert();
871 errc(1, errno, "obtaining adapter information");
872 }
873
874 printf("fb%d:\n", ad.va_index);
875 printf(" %.*s%d, type:%s (%d), flags:0x%x\n",
876 (int)sizeof(ad.va_name), ad.va_name, ad.va_unit,
877 adapter_name(ad.va_type), ad.va_type, ad.va_flags);
878 printf(" initial mode:%d, current mode:%d, BIOS mode:%d\n",
879 ad.va_initial_mode, ad.va_mode, ad.va_initial_bios_mode);
880 printf(" frame buffer window:0x%x, buffer size:0x%zx\n",
881 ad.va_window, ad.va_buffer_size);
882 printf(" window size:0x%zx, origin:0x%x\n",
883 ad.va_window_size, ad.va_window_orig);
884 printf(" display start address (%d, %d), scan line width:%d\n",
885 ad.va_disp_start.x, ad.va_disp_start.y, ad.va_line_width);
886 printf(" reserved:0x%x\n", ad.va_unused0);
887 }
888
889
890 /*
891 * Show video mode information.
892 */
893
894 static void
show_mode_info(void)895 show_mode_info(void)
896 {
897 struct video_info vinfo;
898 char buf[80];
899 int mode;
900 int c;
901
902 printf(" mode# flags type size "
903 "font window linear buffer\n");
904 printf("---------------------------------------"
905 "---------------------------------------\n");
906
907 for (mode = 0; mode <= M_MCA_MODE; ++mode) {
908 vinfo.vi_mode = mode;
909
910 if (ioctl(0, CONS_MODEINFO, &vinfo))
911 continue;
912 if (vinfo.vi_mode != mode)
913 continue;
914
915 printf("%3d (0x%03x)", mode, mode);
916 printf(" 0x%08x", vinfo.vi_flags);
917
918 if (vinfo.vi_flags & V_INFO_GRAPHICS) {
919 c = 'G';
920
921 snprintf(buf, sizeof(buf), "%dx%dx%d %d",
922 vinfo.vi_width, vinfo.vi_height,
923 vinfo.vi_depth, vinfo.vi_planes);
924 } else {
925 c = 'T';
926
927 snprintf(buf, sizeof(buf), "%dx%d",
928 vinfo.vi_width, vinfo.vi_height);
929 }
930
931 printf(" %c %-15s", c, buf);
932 snprintf(buf, sizeof(buf), "%dx%d",
933 vinfo.vi_cwidth, vinfo.vi_cheight);
934 printf(" %-5s", buf);
935 printf(" 0x%05x %2dk %2dk",
936 vinfo.vi_window, (int)vinfo.vi_window_size / 1024,
937 (int)vinfo.vi_window_gran/1024);
938 printf(" 0x%08x %dk\n",
939 vinfo.vi_buffer, (int)vinfo.vi_buffer_size / 1024);
940 }
941 }
942
943
944 static void
show_info(char * arg)945 show_info(char *arg)
946 {
947 if (!strcmp(arg, "adapter")) {
948 show_adapter_info();
949 } else if (!strcmp(arg, "mode")) {
950 show_mode_info();
951 } else {
952 revert();
953 errx(1, "argument to -i must be either adapter or mode");
954 }
955 }
956
957
958 static void
test_frame(void)959 test_frame(void)
960 {
961 int i;
962
963 fprintf(stdout, "[=0G\n\n");
964
965 for (i = 0; i < 8; i++) {
966 fprintf(stdout, "[=15F[=0G %2d [=%dF%-16s"
967 "[=15F[=0G %2d [=%dF%-16s "
968 "[=15F %2d [=%dGBACKGROUND[=0G\n",
969 i, i, legal_colors[i], i+8, i+8,
970 legal_colors[i+8], i, i);
971 }
972
973 fprintf(stdout, "[=%dF[=%dG[=%dH[=%dI\n",
974 info.mv_norm.fore, info.mv_norm.back,
975 info.mv_rev.fore, info.mv_rev.back);
976 }
977
978
979 /*
980 * Snapshot the video memory of that terminal, using the CONS_SCRSHOT
981 * ioctl, and writes the results to stdout either in the special
982 * binary format (see manual page for details), or in the plain
983 * text format.
984 */
985
986 static void
dump_screen(int mode)987 dump_screen(int mode)
988 {
989 scrshot_t shot;
990 vid_info_t vinfo;
991
992 vinfo.size = sizeof(vinfo);
993
994 if (ioctl(0, CONS_GETINFO, &vinfo) == -1) {
995 revert();
996 errc(1, errno, "obtaining current video mode parameters");
997 }
998
999 shot.buf = alloca(vinfo.mv_csz * vinfo.mv_rsz * sizeof(u_int16_t));
1000
1001 if (shot.buf == NULL) {
1002 revert();
1003 errx(1, "failed to allocate memory for dump");
1004 }
1005
1006 shot.xsize = vinfo.mv_csz;
1007 shot.ysize = vinfo.mv_rsz;
1008
1009 if (ioctl(0, CONS_SCRSHOT, &shot) == -1) {
1010 revert();
1011 errc(1, errno, "dumping screen");
1012 }
1013
1014 if (mode == DUMP_RAW) {
1015 printf("SCRSHOT_%c%c%c%c", DUMP_FMT_REV, 2,
1016 shot.xsize, shot.ysize);
1017
1018 fflush(stdout);
1019
1020 write(STDOUT_FILENO, shot.buf,
1021 shot.xsize * shot.ysize * sizeof(u_int16_t));
1022 } else {
1023 char *line;
1024 int x, y;
1025 u_int16_t ch;
1026
1027 line = alloca(shot.xsize + 1);
1028
1029 if (line == NULL) {
1030 revert();
1031 errx(1, "failed to allocate memory for line buffer");
1032 }
1033
1034 for (y = 0; y < shot.ysize; y++) {
1035 for (x = 0; x < shot.xsize; x++) {
1036 ch = shot.buf[x + (y * shot.xsize)];
1037 ch &= 0xff;
1038
1039 if (isprint(ch) == 0)
1040 ch = ' ';
1041
1042 line[x] = (char)ch;
1043 }
1044
1045 /* Trim trailing spaces */
1046
1047 do {
1048 line[x--] = '\0';
1049 } while (line[x] == ' ' && x != 0);
1050
1051 puts(line);
1052 }
1053
1054 fflush(stdout);
1055 }
1056 }
1057
1058
1059 /*
1060 * Set the console history buffer size.
1061 */
1062
1063 static void
set_history(char * opt)1064 set_history(char *opt)
1065 {
1066 int size;
1067
1068 size = atoi(opt);
1069
1070 if ((*opt == '\0') || size < 0) {
1071 revert();
1072 errx(1, "argument must be a positive number");
1073 }
1074
1075 if (ioctl(0, CONS_HISTORY, &size) == -1) {
1076 revert();
1077 errc(1, errno, "setting history buffer size");
1078 }
1079 }
1080
1081
1082 /*
1083 * Clear the console history buffer.
1084 */
1085
1086 static void
clear_history(void)1087 clear_history(void)
1088 {
1089 if (ioctl(0, CONS_CLRHIST) == -1) {
1090 revert();
1091 errc(1, errno, "clearing history buffer");
1092 }
1093 }
1094
1095
1096 int
main(int argc,char ** argv)1097 main(int argc, char **argv)
1098 {
1099 char *font, *type;
1100 int opt;
1101
1102 if (argc == 1)
1103 usage();
1104
1105 init();
1106
1107 info.size = sizeof(info);
1108
1109 if (ioctl(0, CONS_GETINFO, &info) == -1)
1110 err(1, "must be on a virtual console");
1111
1112 while((opt = getopt(argc, argv, "b:Cc:df:g:h:i:l:LM:m:pPr:S:s:t:x")) != -1) {
1113 switch(opt) {
1114 case 'b':
1115 set_border_color(optarg);
1116 break;
1117 case 'C':
1118 clear_history();
1119 break;
1120 case 'c':
1121 set_cursor_type(optarg);
1122 break;
1123 case 'd':
1124 print_scrnmap();
1125 break;
1126 case 'f':
1127 type = optarg;
1128 font = nextarg(argc, argv, &optind, 'f', 0);
1129
1130 if (font == NULL) {
1131 type = NULL;
1132 font = optarg;
1133 }
1134
1135 load_font(type, font);
1136 break;
1137 case 'g':
1138 if (sscanf(optarg, "%dx%d", &g_cols, &g_rows) != 2) {
1139 revert();
1140 warnx("incorrect geometry: %s", optarg);
1141 usage();
1142 }
1143 break;
1144 case 'h':
1145 set_history(optarg);
1146 break;
1147 case 'i':
1148 show_info(optarg);
1149 break;
1150 case 'l':
1151 load_scrnmap(optarg);
1152 break;
1153 case 'L':
1154 load_default_scrnmap();
1155 break;
1156 case 'M':
1157 set_mouse_char(optarg);
1158 break;
1159 case 'm':
1160 set_mouse(optarg);
1161 break;
1162 case 'p':
1163 dump_screen(DUMP_RAW);
1164 break;
1165 case 'P':
1166 dump_screen(DUMP_TXT);
1167 break;
1168 case 'r':
1169 get_reverse_colors(argc, argv, &optind);
1170 break;
1171 case 'S':
1172 set_lockswitch(optarg);
1173 break;
1174 case 's':
1175 set_console(optarg);
1176 break;
1177 case 't':
1178 set_screensaver_timeout(optarg);
1179 break;
1180 case 'x':
1181 hex = 1;
1182 break;
1183 default:
1184 usage();
1185 }
1186 }
1187
1188 if (optind < argc && !strcmp(argv[optind], "show")) {
1189 test_frame();
1190 optind++;
1191 }
1192
1193 video_mode(argc, argv, &optind);
1194
1195 get_normal_colors(argc, argv, &optind);
1196
1197 if (colors_changed || video_mode_changed) {
1198 if (!(new_mode_info.vi_flags & V_INFO_GRAPHICS)) {
1199 if ((normal_back_color < 8) && (revers_back_color < 8)) {
1200 set_colors();
1201 } else {
1202 revert();
1203 errx(1, "bg color for text modes must be < 8");
1204 }
1205 } else {
1206 set_colors();
1207 }
1208 }
1209
1210 if ((optind != argc) || (argc == 1))
1211 usage();
1212
1213 return 0;
1214 }
1215