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