usr.sbin/vidcontrol/vidcontrol.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-3-Clause
   3  *
   4  * Copyright (c) 1994-1996 Søren Schmidt
   5  * All rights reserved.
   6  *
   7  * Portions of this software are based in part on the work of
   8  * Sascha Wildner <saw@online.de> contributed to The DragonFly Project
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer,
  15  *    in this position and unchanged.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  * 3. The name of the author may not be used to endorse or promote products
  20  *    derived from this software without specific prior written permission
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  23  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  24  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  25  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  27  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  31  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  *
  33  * $DragonFly: src/usr.sbin/vidcontrol/vidcontrol.c,v 1.10 2005/03/02 06:08:29 joerg Exp $
  34  */
  35
  36 #ifndef lint
  37 static const char rcsid[] =
  38   "$FreeBSD$";
  39 #endif /* not lint */
  40
  41 #include <ctype.h>
  42 #include <err.h>
  43 #include <limits.h>
  44 #include <stdio.h>
  45 #include <stdlib.h>
  46 #include <string.h>
  47 #include <unistd.h>
  48 #include <sys/fbio.h>
  49 #include <sys/consio.h>
  50 #include <sys/endian.h>
  51 #include <sys/errno.h>
  52 #include <sys/param.h>
  53 #include <sys/types.h>
  54 #include <sys/stat.h>
  55 #include <sys/sysctl.h>
  56 #include "path.h"
  57 #include "decode.h"
  58
  59
  60 #define DATASIZE(x)     ((x).w * (x).h * 256 / 8)
  61
  62 /* Screen dump modes */
  63 #define DUMP_FMT_RAW    1
  64 #define DUMP_FMT_TXT    2
  65 /* Screen dump options */
  66 #define DUMP_FBF        0
  67 #define DUMP_ALL        1
  68 /* Screen dump file format revision */
  69 #define DUMP_FMT_REV    1
  70
  71 static const char *legal_colors[16] = {
  72         "black", "blue", "green", "cyan",
  73         "red", "magenta", "brown", "white",
  74         "grey", "lightblue", "lightgreen", "lightcyan",
  75         "lightred", "lightmagenta", "yellow", "lightwhite"
  76 };
  77
  78 static struct {
  79         int                     active_vty;
  80         vid_info_t              console_info;
  81         unsigned char           screen_map[256];
  82         int                     video_mode_number;
  83         struct video_info       video_mode_info;
  84 } cur_info;
  85
  86 struct vt4font_header {
  87         uint8_t         magic[8];
  88         uint8_t         width;
  89         uint8_t         height;
  90         uint16_t        pad;
  91         uint32_t        glyph_count;
  92         uint32_t        map_count[4];
  93 } __packed;
  94
  95 static int      hex = 0;
  96 static int      vesa_cols;
  97 static int      vesa_rows;
  98 static int      font_height;
  99 static int      vt4_mode = 0;
 100 static int      video_mode_changed;
 101 static struct   video_info new_mode_info;
 102
 103
 104 /*
 105  * Initialize revert data.
 106  *
 107  * NOTE: the following parameters are not yet saved/restored:
 108  *
 109  *   screen saver timeout
 110  *   cursor type
 111  *   mouse character and mouse show/hide state
 112  *   vty switching on/off state
 113  *   history buffer size
 114  *   history contents
 115  *   font maps
 116  */
 117
 118 static void
 119 init(void)
 120 {
 121         if (ioctl(0, VT_GETACTIVE, &cur_info.active_vty) == -1)
 122                 err(1, "getting active vty");
 123
 124         cur_info.console_info.size = sizeof(cur_info.console_info);
 125         if (ioctl(0, CONS_GETINFO, &cur_info.console_info) == -1)
 126                 err(1, "getting console information");
 127
 128         /* vt(4) use unicode, so no screen mapping required. */
 129         if (vt4_mode == 0 &&
 130             ioctl(0, GIO_SCRNMAP, &cur_info.screen_map) == -1)
 131                 err(1, "getting screen map");
 132
 133         if (ioctl(0, CONS_GET, &cur_info.video_mode_number) == -1)
 134                 err(1, "getting video mode number");
 135
 136         cur_info.video_mode_info.vi_mode = cur_info.video_mode_number;
 137
 138         if (ioctl(0, CONS_MODEINFO, &cur_info.video_mode_info) == -1)
 139                 err(1, "getting video mode parameters");
 140 }
 141
 142
 143 /*
 144  * If something goes wrong along the way we call revert() to go back to the
 145  * console state we came from (which is assumed to be working).
 146  *
 147  * NOTE: please also read the comments of init().
 148  */
 149
 150 static void
 151 revert(void)
 152 {
 153         int save_errno, size[3];
 154
 155         save_errno = errno;
 156
 157         ioctl(0, VT_ACTIVATE, cur_info.active_vty);
 158
 159         ioctl(0, KDSBORDER, cur_info.console_info.mv_ovscan);
 160         fprintf(stderr, "\033[=%dH", cur_info.console_info.mv_rev.fore);
 161         fprintf(stderr, "\033[=%dI", cur_info.console_info.mv_rev.back);
 162
 163         if (vt4_mode == 0)
 164                 ioctl(0, PIO_SCRNMAP, &cur_info.screen_map);
 165
 166         if (video_mode_changed) {
 167                 if (cur_info.video_mode_number >= M_VESA_BASE)
 168                         ioctl(0,
 169                             _IO('V', cur_info.video_mode_number - M_VESA_BASE),
 170                             NULL);
 171                 else
 172                         ioctl(0, _IO('S', cur_info.video_mode_number), NULL);
 173                 if (cur_info.video_mode_info.vi_flags & V_INFO_GRAPHICS) {
 174                         size[0] = cur_info.console_info.mv_csz;
 175                         size[1] = cur_info.console_info.mv_rsz;
 176                         size[2] = cur_info.console_info.font_size;
 177                         ioctl(0, KDRASTER, size);
 178                 }
 179         }
 180
 181         /* Restore some colors last since mode setting forgets some. */
 182         fprintf(stderr, "\033[=%dF", cur_info.console_info.mv_norm.fore);
 183         fprintf(stderr, "\033[=%dG", cur_info.console_info.mv_norm.back);
 184
 185         errno = save_errno;
 186 }
 187
 188
 189 /*
 190  * Print a short usage string describing all options, then exit.
 191  */
 192
 193 static void
 194 usage(void)
 195 {
 196         if (vt4_mode)
 197                 fprintf(stderr, "%s\n%s\n%s\n%s\n%s\n%s\n",
 198 "usage: vidcontrol [-CHPpx] [-b color] [-c appearance] [-f [[size] file]]",
 199 "                  [-g geometry] [-h size] [-i active | adapter | mode]",
 200 "                  [-M char] [-m on | off]",
 201 "                  [-r foreground background] [-S on | off] [-s number]",
 202 "                  [-T xterm | cons25] [-t N | off] [mode]",
 203 "                  [foreground [background]] [show]");
 204         else
 205                 fprintf(stderr, "%s\n%s\n%s\n%s\n%s\n%s\n",
 206 "usage: vidcontrol [-CdHLPpx] [-b color] [-c appearance] [-E emulator]",
 207 "                  [-f [[size] file]] [-g geometry] [-h size]",
 208 "                  [-i active | adapter | mode] [-l screen_map] [-M char]",
 209 "                  [-m on | off] [-r foreground background] [-S on | off]",
 210 "                  [-s number] [-T xterm | cons25] [-t N | off] [mode]",
 211 "                  [foreground [background]] [show]");
 212         exit(1);
 213 }
 214
 215 /* Detect presence of vt(4). */
 216 static int
 217 is_vt4(void)
 218 {
 219         char vty_name[4] = "";
 220         size_t len = sizeof(vty_name);
 221
 222         if (sysctlbyname("kern.vty", vty_name, &len, NULL, 0) != 0)
 223                 return (0);
 224         return (strcmp(vty_name, "vt") == 0);
 225 }
 226
 227 /*
 228  * Retrieve the next argument from the command line (for options that require
 229  * more than one argument).
 230  */
 231
 232 static char *
 233 nextarg(int ac, char **av, int *indp, int oc, int strict)
 234 {
 235         if (*indp < ac)
 236                 return(av[(*indp)++]);
 237
 238         if (strict != 0) {
 239                 revert();
 240                 errx(1, "option requires two arguments -- %c", oc);
 241         }
 242
 243         return(NULL);
 244 }
 245
 246
 247 /*
 248  * Guess which file to open. Try to open each combination of a specified set
 249  * of file name components.
 250  */
 251
 252 static FILE *
 253 openguess(const char *a[], const char *b[], const char *c[], const char *d[], char **name)
 254 {
 255         FILE *f;
 256         int i, j, k, l;
 257
 258         for (i = 0; a[i] != NULL; i++) {
 259                 for (j = 0; b[j] != NULL; j++) {
 260                         for (k = 0; c[k] != NULL; k++) {
 261                                 for (l = 0; d[l] != NULL; l++) {
 262                                         asprintf(name, "%s%s%s%s",
 263                                                  a[i], b[j], c[k], d[l]);
 264
 265                                         f = fopen(*name, "r");
 266
 267                                         if (f != NULL)
 268                                                 return (f);
 269
 270                                         free(*name);
 271                                 }
 272                         }
 273                 }
 274         }
 275         return (NULL);
 276 }
 277
 278
 279 /*
 280  * Load a screenmap from a file and set it.
 281  */
 282
 283 static void
 284 load_scrnmap(const char *filename)
 285 {
 286         FILE *fd;
 287         int size;
 288         char *name;
 289         scrmap_t scrnmap;
 290         const char *a[] = {"", SCRNMAP_PATH, NULL};
 291         const char *b[] = {filename, NULL};
 292         const char *c[] = {"", ".scm", NULL};
 293         const char *d[] = {"", NULL};
 294
 295         fd = openguess(a, b, c, d, &name);
 296
 297         if (fd == NULL) {
 298                 revert();
 299                 errx(1, "screenmap file not found");
 300         }
 301
 302         size = sizeof(scrnmap);
 303
 304         if (decode(fd, (char *)&scrnmap, size) != size) {
 305                 rewind(fd);
 306
 307                 if (fread(&scrnmap, 1, size, fd) != (size_t)size) {
 308                         fclose(fd);
 309                         revert();
 310                         errx(1, "bad screenmap file");
 311                 }
 312         }
 313
 314         if (ioctl(0, PIO_SCRNMAP, &scrnmap) == -1) {
 315                 revert();
 316                 err(1, "loading screenmap");
 317         }
 318
 319         fclose(fd);
 320 }
 321
 322
 323 /*
 324  * Set the default screenmap.
 325  */
 326
 327 static void
 328 load_default_scrnmap(void)
 329 {
 330         scrmap_t scrnmap;
 331         int i;
 332
 333         for (i=0; i<256; i++)
 334                 *((char*)&scrnmap + i) = i;
 335
 336         if (ioctl(0, PIO_SCRNMAP, &scrnmap) == -1) {
 337                 revert();
 338                 err(1, "loading default screenmap");
 339         }
 340 }
 341
 342
 343 /*
 344  * Print the current screenmap to stdout.
 345  */
 346
 347 static void
 348 print_scrnmap(void)
 349 {
 350         unsigned char map[256];
 351         size_t i;
 352
 353         if (ioctl(0, GIO_SCRNMAP, &map) == -1) {
 354                 revert();
 355                 err(1, "getting screenmap");
 356         }
 357         for (i=0; i<sizeof(map); i++) {
 358                 if (i != 0 && i % 16 == 0)
 359                         fprintf(stdout, "\n");
 360
 361                 if (hex != 0)
 362                         fprintf(stdout, " %02x", map[i]);
 363                 else
 364                         fprintf(stdout, " %03d", map[i]);
 365         }
 366         fprintf(stdout, "\n");
 367
 368 }
 369
 370
 371 /*
 372  * Determine a file's size.
 373  */
 374
 375 static int
 376 fsize(FILE *file)
 377 {
 378         struct stat sb;
 379
 380         if (fstat(fileno(file), &sb) == 0)
 381                 return sb.st_size;
 382         else
 383                 return -1;
 384 }
 385
 386 static vfnt_map_t *
 387 load_vt4mappingtable(unsigned int nmappings, FILE *f)
 388 {
 389         vfnt_map_t *t;
 390         unsigned int i;
 391
 392         if (nmappings == 0)
 393                 return (NULL);
 394
 395         if ((t = calloc(nmappings, sizeof(*t))) == NULL) {
 396                 warn("calloc");
 397                 return (NULL);
 398         }
 399
 400         if (fread(t, sizeof *t * nmappings, 1, f) != 1) {
 401                 warn("read mappings");
 402                 free(t);
 403                 return (NULL);
 404         }
 405
 406         for (i = 0; i < nmappings; i++) {
 407                 t[i].src = be32toh(t[i].src);
 408                 t[i].dst = be16toh(t[i].dst);
 409                 t[i].len = be16toh(t[i].len);
 410         }
 411
 412         return (t);
 413 }
 414
 415 /*
 416  * Set the default vt font.
 417  */
 418
 419 static void
 420 load_default_vt4font(void)
 421 {
 422         if (ioctl(0, PIO_VFONT_DEFAULT) == -1) {
 423                 revert();
 424                 err(1, "loading default vt font");
 425         }
 426 }
 427
 428 static void
 429 load_vt4font(FILE *f)
 430 {
 431         struct vt4font_header fh;
 432         static vfnt_t vfnt;
 433         size_t glyphsize;
 434         unsigned int i;
 435
 436         if (fread(&fh, sizeof fh, 1, f) != 1) {
 437                 warn("read file_header");
 438                 return;
 439         }
 440
 441         if (memcmp(fh.magic, "VFNT0002", 8) != 0) {
 442                 warnx("bad magic in font file\n");
 443                 return;
 444         }
 445
 446         for (i = 0; i < VFNT_MAPS; i++)
 447                 vfnt.map_count[i] = be32toh(fh.map_count[i]);
 448         vfnt.glyph_count = be32toh(fh.glyph_count);
 449         vfnt.width = fh.width;
 450         vfnt.height = fh.height;
 451
 452         glyphsize = howmany(vfnt.width, 8) * vfnt.height * vfnt.glyph_count;
 453         if ((vfnt.glyphs = malloc(glyphsize)) == NULL) {
 454                 warn("malloc");
 455                 return;
 456         }
 457
 458         if (fread(vfnt.glyphs, glyphsize, 1, f) != 1) {
 459                 warn("read glyphs");
 460                 free(vfnt.glyphs);
 461                 return;
 462         }
 463
 464         for (i = 0; i < VFNT_MAPS; i++)
 465                 vfnt.map[i] = load_vt4mappingtable(vfnt.map_count[i], f);
 466
 467         if (ioctl(STDIN_FILENO, PIO_VFONT, &vfnt) == -1)
 468                 warn("PIO_VFONT");
 469
 470         for (i = 0; i < VFNT_MAPS; i++)
 471                 free(vfnt.map[i]);
 472         free(vfnt.glyphs);
 473 }
 474
 475 /*
 476  * Load a font from file and set it.
 477  */
 478
 479 static void
 480 load_font(const char *type, const char *filename)
 481 {
 482         FILE    *fd;
 483         int     h, i, size, w;
 484         unsigned long io = 0;   /* silence stupid gcc(1) in the Wall mode */
 485         char    *name, *fontmap, size_sufx[6];
 486         const char      *a[] = {"", FONT_PATH, NULL};
 487         const char      *vt4a[] = {"", VT_FONT_PATH, NULL};
 488         const char      *b[] = {filename, NULL};
 489         const char      *c[] = {"", size_sufx, NULL};
 490         const char      *d[] = {"", ".fnt", NULL};
 491         vid_info_t info;
 492
 493         struct sizeinfo {
 494                 int w;
 495                 int h;
 496                 unsigned long io;
 497         } sizes[] = {{8, 16, PIO_FONT8x16},
 498                      {8, 14, PIO_FONT8x14},
 499                      {8,  8,  PIO_FONT8x8},
 500                      {0,  0,            0}};
 501
 502         if (vt4_mode) {
 503                 size_sufx[0] = '\0';
 504         } else {
 505                 info.size = sizeof(info);
 506                 if (ioctl(0, CONS_GETINFO, &info) == -1) {
 507                         revert();
 508                         err(1, "getting console information");
 509                 }
 510
 511                 snprintf(size_sufx, sizeof(size_sufx), "-8x%d", info.font_size);
 512         }
 513         fd = openguess((vt4_mode == 0) ? a : vt4a, b, c, d, &name);
 514
 515         if (fd == NULL) {
 516                 revert();
 517                 errx(1, "%s: can't load font file", filename);
 518         }
 519
 520         if (vt4_mode) {
 521                 load_vt4font(fd);
 522                 fclose(fd);
 523                 return;
 524         }
 525
 526         if (type != NULL) {
 527                 size = 0;
 528                 if (sscanf(type, "%dx%d", &w, &h) == 2) {
 529                         for (i = 0; sizes[i].w != 0; i++) {
 530                                 if (sizes[i].w == w && sizes[i].h == h) {
 531                                         size = DATASIZE(sizes[i]);
 532                                         io = sizes[i].io;
 533                                         font_height = sizes[i].h;
 534                                 }
 535                         }
 536                 }
 537                 if (size == 0) {
 538                         fclose(fd);
 539                         revert();
 540                         errx(1, "%s: bad font size specification", type);
 541                 }
 542         } else {
 543                 /* Apply heuristics */
 544
 545                 int j;
 546                 int dsize[2];
 547
 548                 size = DATASIZE(sizes[0]);
 549                 fontmap = (char*) malloc(size);
 550                 dsize[0] = decode(fd, fontmap, size);
 551                 dsize[1] = fsize(fd);
 552                 free(fontmap);
 553
 554                 size = 0;
 555                 for (j = 0; j < 2; j++) {
 556                         for (i = 0; sizes[i].w != 0; i++) {
 557                                 if (DATASIZE(sizes[i]) == dsize[j]) {
 558                                         size = dsize[j];
 559                                         io = sizes[i].io;
 560                                         font_height = sizes[i].h;
 561                                         j = 2;  /* XXX */
 562                                         break;
 563                                 }
 564                         }
 565                 }
 566
 567                 if (size == 0) {
 568                         fclose(fd);
 569                         revert();
 570                         errx(1, "%s: can't guess font size", filename);
 571                 }
 572
 573                 rewind(fd);
 574         }
 575
 576         fontmap = (char*) malloc(size);
 577
 578         if (decode(fd, fontmap, size) != size) {
 579                 rewind(fd);
 580                 if (fsize(fd) != size ||
 581                     fread(fontmap, 1, size, fd) != (size_t)size) {
 582                         fclose(fd);
 583                         free(fontmap);
 584                         revert();
 585                         errx(1, "%s: bad font file", filename);
 586                 }
 587         }
 588
 589         if (ioctl(0, io, fontmap) == -1) {
 590                 revert();
 591                 err(1, "loading font");
 592         }
 593
 594         fclose(fd);
 595         free(fontmap);
 596 }
 597
 598
 599 /*
 600  * Set the timeout for the screensaver.
 601  */
 602
 603 static void
 604 set_screensaver_timeout(char *arg)
 605 {
 606         int nsec;
 607
 608         if (!strcmp(arg, "off")) {
 609                 nsec = 0;
 610         } else {
 611                 nsec = atoi(arg);
 612
 613                 if ((*arg == '\0') || (nsec < 1)) {
 614                         revert();
 615                         errx(1, "argument must be a positive number");
 616                 }
 617         }
 618
 619         if (ioctl(0, CONS_BLANKTIME, &nsec) == -1) {
 620                 revert();
 621                 err(1, "setting screensaver period");
 622         }
 623 }
 624
 625 static void
 626 parse_cursor_params(char *param, struct cshape *shape)
 627 {
 628         char *dupparam, *word;
 629         int type;
 630
 631         param = dupparam = strdup(param);
 632         type = shape->shape[0];
 633         while ((word = strsep(&param, ",")) != NULL) {
 634                 if (strcmp(word, "normal") == 0)
 635                         type = 0;
 636                 else if (strcmp(word, "destructive") == 0)
 637                         type = CONS_BLINK_CURSOR | CONS_CHAR_CURSOR;
 638                 else if (strcmp(word, "blink") == 0)
 639                         type |= CONS_BLINK_CURSOR;
 640                 else if (strcmp(word, "noblink") == 0)
 641                         type &= ~CONS_BLINK_CURSOR;
 642                 else if (strcmp(word, "block") == 0)
 643                         type &= ~CONS_CHAR_CURSOR;
 644                 else if (strcmp(word, "noblock") == 0)
 645                         type |= CONS_CHAR_CURSOR;
 646                 else if (strcmp(word, "hidden") == 0)
 647                         type |= CONS_HIDDEN_CURSOR;
 648                 else if (strcmp(word, "nohidden") == 0)
 649                         type &= ~CONS_HIDDEN_CURSOR;
 650                 else if (strncmp(word, "base=", 5) == 0)
 651                         shape->shape[1] = strtol(word + 5, NULL, 0);
 652                 else if (strncmp(word, "height=", 7) == 0)
 653                         shape->shape[2] = strtol(word + 7, NULL, 0);
 654                 else if (strcmp(word, "charcolors") == 0)
 655                         type |= CONS_CHARCURSOR_COLORS;
 656                 else if (strcmp(word, "mousecolors") == 0)
 657                         type |= CONS_MOUSECURSOR_COLORS;
 658                 else if (strcmp(word, "default") == 0)
 659                         type |= CONS_DEFAULT_CURSOR;
 660                 else if (strcmp(word, "shapeonly") == 0)
 661                         type |= CONS_SHAPEONLY_CURSOR;
 662                 else if (strcmp(word, "local") == 0)
 663                         type |= CONS_LOCAL_CURSOR;
 664                 else if (strcmp(word, "reset") == 0)
 665                         type |= CONS_RESET_CURSOR;
 666                 else if (strcmp(word, "show") == 0)
 667                         printf("flags %#x, base %d, height %d\n",
 668                             type, shape->shape[1], shape->shape[2]);
 669                 else {
 670                         revert();
 671                         errx(1,
 672                             "invalid parameters for -c starting at '%s%s%s'",
 673                             word, param != NULL ? "," : "",
 674                             param != NULL ? param : "");
 675                 }
 676         }
 677         free(dupparam);
 678         shape->shape[0] = type;
 679 }
 680
 681
 682 /*
 683  * Set the cursor's shape/type.
 684  */
 685
 686 static void
 687 set_cursor_type(char *param)
 688 {
 689         struct cshape shape;
 690
 691         /* Dry run to determine color, default and local flags. */
 692         shape.shape[0] = 0;
 693         shape.shape[1] = -1;
 694         shape.shape[2] = -1;
 695         parse_cursor_params(param, &shape);
 696
 697         /* Get the relevant old setting. */
 698         if (ioctl(0, CONS_GETCURSORSHAPE, &shape) != 0) {
 699                 revert();
 700                 err(1, "ioctl(CONS_GETCURSORSHAPE)");
 701         }
 702
 703         parse_cursor_params(param, &shape);
 704         if (ioctl(0, CONS_SETCURSORSHAPE, &shape) != 0) {
 705                 revert();
 706                 err(1, "ioctl(CONS_SETCURSORSHAPE)");
 707         }
 708 }
 709
 710
 711 /*
 712  * Set the video mode.
 713  */
 714
 715 static void
 716 video_mode(int argc, char **argv, int *mode_index)
 717 {
 718         static struct {
 719                 const char *name;
 720                 unsigned long mode;
 721                 unsigned long mode_num;
 722         } modes[] = {
 723                 { "80x25",        SW_TEXT_80x25,   M_TEXT_80x25 },
 724                 { "80x30",        SW_TEXT_80x30,   M_TEXT_80x30 },
 725                 { "80x43",        SW_TEXT_80x43,   M_TEXT_80x43 },
 726                 { "80x50",        SW_TEXT_80x50,   M_TEXT_80x50 },
 727                 { "80x60",        SW_TEXT_80x60,   M_TEXT_80x60 },
 728                 { "132x25",       SW_TEXT_132x25,  M_TEXT_132x25 },
 729                 { "132x30",       SW_TEXT_132x30,  M_TEXT_132x30 },
 730                 { "132x43",       SW_TEXT_132x43,  M_TEXT_132x43 },
 731                 { "132x50",       SW_TEXT_132x50,  M_TEXT_132x50 },
 732                 { "132x60",       SW_TEXT_132x60,  M_TEXT_132x60 },
 733                 { "VGA_40x25",    SW_VGA_C40x25,   M_VGA_C40x25 },
 734                 { "VGA_80x25",    SW_VGA_C80x25,   M_VGA_C80x25 },
 735                 { "VGA_80x30",    SW_VGA_C80x30,   M_VGA_C80x30 },
 736                 { "VGA_80x50",    SW_VGA_C80x50,   M_VGA_C80x50 },
 737                 { "VGA_80x60",    SW_VGA_C80x60,   M_VGA_C80x60 },
 738 #ifdef SW_VGA_C90x25
 739                 { "VGA_90x25",    SW_VGA_C90x25,   M_VGA_C90x25 },
 740                 { "VGA_90x30",    SW_VGA_C90x30,   M_VGA_C90x30 },
 741                 { "VGA_90x43",    SW_VGA_C90x43,   M_VGA_C90x43 },
 742                 { "VGA_90x50",    SW_VGA_C90x50,   M_VGA_C90x50 },
 743                 { "VGA_90x60",    SW_VGA_C90x60,   M_VGA_C90x60 },
 744 #endif
 745                 { "VGA_320x200",        SW_VGA_CG320,   M_CG320 },
 746                 { "EGA_80x25",          SW_ENH_C80x25,  M_ENH_C80x25 },
 747                 { "EGA_80x43",          SW_ENH_C80x43,  M_ENH_C80x43 },
 748                 { "VESA_132x25",        SW_VESA_C132x25,M_VESA_C132x25 },
 749                 { "VESA_132x43",        SW_VESA_C132x43,M_VESA_C132x43 },
 750                 { "VESA_132x50",        SW_VESA_C132x50,M_VESA_C132x50 },
 751                 { "VESA_132x60",        SW_VESA_C132x60,M_VESA_C132x60 },
 752                 { "VESA_800x600",       SW_VESA_800x600,M_VESA_800x600 },
 753                 { NULL, 0, 0 },
 754         };
 755
 756         int new_mode_num = 0;
 757         unsigned long mode = 0;
 758         int cur_mode;
 759         int save_errno;
 760         int size[3];
 761         int i;
 762
 763         if (ioctl(0, CONS_GET, &cur_mode) < 0)
 764                 err(1, "cannot get the current video mode");
 765
 766         /*
 767          * Parse the video mode argument...
 768          */
 769
 770         if (*mode_index < argc) {
 771                 if (!strncmp(argv[*mode_index], "MODE_", 5)) {
 772                         if (!isdigit(argv[*mode_index][5]))
 773                                 errx(1, "invalid video mode number");
 774
 775                         new_mode_num = atoi(&argv[*mode_index][5]);
 776                 } else {
 777                         for (i = 0; modes[i].name != NULL; ++i) {
 778                                 if (!strcmp(argv[*mode_index], modes[i].name)) {
 779                                         mode = modes[i].mode;
 780                                         new_mode_num = modes[i].mode_num;
 781                                         break;
 782                                 }
 783                         }
 784
 785                         if (modes[i].name == NULL)
 786                                 return;
 787                         if (ioctl(0, mode, NULL) < 0) {
 788                                 revert();
 789                                 err(1, "cannot set videomode");
 790                         }
 791                         video_mode_changed = 1;
 792                 }
 793
 794                 /*
 795                  * Collect enough information about the new video mode...
 796                  */
 797
 798                 new_mode_info.vi_mode = new_mode_num;
 799
 800                 if (ioctl(0, CONS_MODEINFO, &new_mode_info) == -1) {
 801                         revert();
 802                         err(1, "obtaining new video mode parameters");
 803                 }
 804
 805                 if (mode == 0) {
 806                         if (new_mode_num >= M_VESA_BASE)
 807                                 mode = _IO('V', new_mode_num - M_VESA_BASE);
 808                         else
 809                                 mode = _IO('S', new_mode_num);
 810                 }
 811
 812                 /*
 813                  * Try setting the new mode.
 814                  */
 815
 816                 if (ioctl(0, mode, NULL) == -1) {
 817                         revert();
 818                         err(1, "setting video mode");
 819                 }
 820                 video_mode_changed = 1;
 821
 822                 /*
 823                  * For raster modes it's not enough to just set the mode.
 824                  * We also need to explicitly set the raster mode.
 825                  */
 826
 827                 if (new_mode_info.vi_flags & V_INFO_GRAPHICS) {
 828                         /* font size */
 829
 830                         if (font_height == 0)
 831                                 font_height = cur_info.console_info.font_size;
 832
 833                         size[2] = font_height;
 834
 835                         /* adjust columns */
 836
 837                         if ((vesa_cols * 8 > new_mode_info.vi_width) ||
 838                             (vesa_cols <= 0)) {
 839                                 size[0] = new_mode_info.vi_width / 8;
 840                         } else {
 841                                 size[0] = vesa_cols;
 842                         }
 843
 844                         /* adjust rows */
 845
 846                         if ((vesa_rows * font_height > new_mode_info.vi_height) ||
 847                             (vesa_rows <= 0)) {
 848                                 size[1] = new_mode_info.vi_height /
 849                                           font_height;
 850                         } else {
 851                                 size[1] = vesa_rows;
 852                         }
 853
 854                         /* set raster mode */
 855
 856                         if (ioctl(0, KDRASTER, size)) {
 857                                 save_errno = errno;
 858                                 if (cur_mode >= M_VESA_BASE)
 859                                         ioctl(0,
 860                                             _IO('V', cur_mode - M_VESA_BASE),
 861                                             NULL);
 862                                 else
 863                                         ioctl(0, _IO('S', cur_mode), NULL);
 864                                 revert();
 865                                 errno = save_errno;
 866                                 err(1, "cannot activate raster display");
 867                         }
 868                 }
 869
 870                 /* Recover from mode setting forgetting colors. */
 871                 fprintf(stderr, "\033[=%dF",
 872                     cur_info.console_info.mv_norm.fore);
 873                 fprintf(stderr, "\033[=%dG",
 874                     cur_info.console_info.mv_norm.back);
 875
 876                 (*mode_index)++;
 877         }
 878 }
 879
 880
 881 /*
 882  * Return the number for a specified color name.
 883  */
 884
 885 static int
 886 get_color_number(char *color)
 887 {
 888         int i;
 889
 890         for (i=0; i<16; i++) {
 891                 if (!strcmp(color, legal_colors[i]))
 892                         return i;
 893         }
 894         return -1;
 895 }
 896
 897
 898 /*
 899  * Set normal text and background colors.
 900  */
 901
 902 static void
 903 set_normal_colors(int argc, char **argv, int *_index)
 904 {
 905         int color;
 906
 907         if (*_index < argc && (color = get_color_number(argv[*_index])) != -1) {
 908                 (*_index)++;
 909                 fprintf(stderr, "\033[=%dF", color);
 910                 if (*_index < argc
 911                     && (color = get_color_number(argv[*_index])) != -1) {
 912                         (*_index)++;
 913                         fprintf(stderr, "\033[=%dG", color);
 914                 }
 915         }
 916 }
 917
 918
 919 /*
 920  * Set reverse text and background colors.
 921  */
 922
 923 static void
 924 set_reverse_colors(int argc, char **argv, int *_index)
 925 {
 926         int color;
 927
 928         if ((color = get_color_number(argv[*(_index)-1])) != -1) {
 929                 fprintf(stderr, "\033[=%dH", color);
 930                 if (*_index < argc
 931                     && (color = get_color_number(argv[*_index])) != -1) {
 932                         (*_index)++;
 933                         fprintf(stderr, "\033[=%dI", color);
 934                 }
 935         }
 936 }
 937
 938
 939 /*
 940  * Switch to virtual terminal #arg.
 941  */
 942
 943 static void
 944 set_console(char *arg)
 945 {
 946         int n;
 947
 948         if(!arg || strspn(arg,"0123456789") != strlen(arg)) {
 949                 revert();
 950                 errx(1, "bad console number");
 951         }
 952
 953         n = atoi(arg);
 954
 955         if (n < 1 || n > 16) {
 956                 revert();
 957                 errx(1, "console number out of range");
 958         } else if (ioctl(0, VT_ACTIVATE, n) == -1) {
 959                 revert();
 960                 err(1, "switching vty");
 961         }
 962 }
 963
 964
 965 /*
 966  * Sets the border color.
 967  */
 968
 969 static void
 970 set_border_color(char *arg)
 971 {
 972         int color;
 973
 974         color = get_color_number(arg);
 975         if (color == -1) {
 976                 revert();
 977                 errx(1, "invalid color '%s'", arg);
 978         }
 979         if (ioctl(0, KDSBORDER, color) != 0) {
 980                 revert();
 981                 err(1, "ioctl(KD_SBORDER)");
 982         }
 983 }
 984
 985 static void
 986 set_mouse_char(char *arg)
 987 {
 988         struct mouse_info mouse;
 989         long l;
 990
 991         l = strtol(arg, NULL, 0);
 992
 993         if ((l < 0) || (l > UCHAR_MAX - 3)) {
 994                 revert();
 995                 warnx("argument to -M must be 0 through %d", UCHAR_MAX - 3);
 996                 return;
 997         }
 998
 999         mouse.operation = MOUSE_MOUSECHAR;
1000         mouse.u.mouse_char = (int)l;
1001
1002         if (ioctl(0, CONS_MOUSECTL, &mouse) == -1) {
1003                 revert();
1004                 err(1, "setting mouse character");
1005         }
1006 }
1007
1008
1009 /*
1010  * Show/hide the mouse.
1011  */
1012
1013 static void
1014 set_mouse(char *arg)
1015 {
1016         struct mouse_info mouse;
1017
1018         if (!strcmp(arg, "on")) {
1019                 mouse.operation = MOUSE_SHOW;
1020         } else if (!strcmp(arg, "off")) {
1021                 mouse.operation = MOUSE_HIDE;
1022         } else {
1023                 revert();
1024                 errx(1, "argument to -m must be either on or off");
1025         }
1026
1027         if (ioctl(0, CONS_MOUSECTL, &mouse) == -1) {
1028                 revert();
1029                 err(1, "%sing the mouse",
1030                      mouse.operation == MOUSE_SHOW ? "show" : "hid");
1031         }
1032 }
1033
1034
1035 static void
1036 set_lockswitch(char *arg)
1037 {
1038         int data;
1039
1040         if (!strcmp(arg, "off")) {
1041                 data = 0x01;
1042         } else if (!strcmp(arg, "on")) {
1043                 data = 0x02;
1044         } else {
1045                 revert();
1046                 errx(1, "argument to -S must be either on or off");
1047         }
1048
1049         if (ioctl(0, VT_LOCKSWITCH, &data) == -1) {
1050                 revert();
1051                 err(1, "turning %s vty switching",
1052                      data == 0x01 ? "off" : "on");
1053         }
1054 }
1055
1056
1057 /*
1058  * Return the adapter name for a specified type.
1059  */
1060
1061 static const char
1062 *adapter_name(int type)
1063 {
1064     static struct {
1065         int type;
1066         const char *name;
1067     } names[] = {
1068         { KD_MONO,      "MDA" },
1069         { KD_HERCULES,  "Hercules" },
1070         { KD_CGA,       "CGA" },
1071         { KD_EGA,       "EGA" },
1072         { KD_VGA,       "VGA" },
1073         { KD_TGA,       "TGA" },
1074         { -1,           "Unknown" },
1075     };
1076
1077     int i;
1078
1079     for (i = 0; names[i].type != -1; ++i)
1080         if (names[i].type == type)
1081             break;
1082     return names[i].name;
1083 }
1084
1085
1086 /*
1087  * Show active VTY, ie current console number.
1088  */
1089
1090 static void
1091 show_active_info(void)
1092 {
1093
1094         printf("%d\n", cur_info.active_vty);
1095 }
1096
1097
1098 /*
1099  * Show graphics adapter information.
1100  */
1101
1102 static void
1103 show_adapter_info(void)
1104 {
1105         struct video_adapter_info ad;
1106
1107         ad.va_index = 0;
1108
1109         if (ioctl(0, CONS_ADPINFO, &ad) == -1) {
1110                 revert();
1111                 err(1, "obtaining adapter information");
1112         }
1113
1114         printf("fb%d:\n", ad.va_index);
1115         printf("    %.*s%d, type:%s%s (%d), flags:0x%x\n",
1116                (int)sizeof(ad.va_name), ad.va_name, ad.va_unit,
1117                (ad.va_flags & V_ADP_VESA) ? "VESA " : "",
1118                adapter_name(ad.va_type), ad.va_type, ad.va_flags);
1119         printf("    initial mode:%d, current mode:%d, BIOS mode:%d\n",
1120                ad.va_initial_mode, ad.va_mode, ad.va_initial_bios_mode);
1121         printf("    frame buffer window:0x%zx, buffer size:0x%zx\n",
1122                ad.va_window, ad.va_buffer_size);
1123         printf("    window size:0x%zx, origin:0x%x\n",
1124                ad.va_window_size, ad.va_window_orig);
1125         printf("    display start address (%d, %d), scan line width:%d\n",
1126                ad.va_disp_start.x, ad.va_disp_start.y, ad.va_line_width);
1127         printf("    reserved:0x%zx\n", ad.va_unused0);
1128 }
1129
1130
1131 /*
1132  * Show video mode information.
1133  */
1134
1135 static void
1136 show_mode_info(void)
1137 {
1138         char buf[80];
1139         struct video_info info;
1140         int c;
1141         int mm;
1142         int mode;
1143
1144         printf("    mode#     flags   type    size       "
1145                "font      window      linear buffer\n");
1146         printf("---------------------------------------"
1147                "---------------------------------------\n");
1148
1149         memset(&info, 0, sizeof(info));
1150         for (mode = 0; mode <= M_VESA_MODE_MAX; ++mode) {
1151                 info.vi_mode = mode;
1152                 if (ioctl(0, CONS_MODEINFO, &info))
1153                         continue;
1154                 if (info.vi_mode != mode)
1155                         continue;
1156                 if (info.vi_width == 0 && info.vi_height == 0 &&
1157                     info.vi_cwidth == 0 && info.vi_cheight == 0)
1158                         continue;
1159
1160                 printf("%3d (0x%03x)", mode, mode);
1161                 printf(" 0x%08x", info.vi_flags);
1162                 if (info.vi_flags & V_INFO_GRAPHICS) {
1163                         c = 'G';
1164
1165                         if (info.vi_mem_model == V_INFO_MM_PLANAR)
1166                                 snprintf(buf, sizeof(buf), "%dx%dx%d %d",
1167                                     info.vi_width, info.vi_height,
1168                                     info.vi_depth, info.vi_planes);
1169                         else {
1170                                 switch (info.vi_mem_model) {
1171                                 case V_INFO_MM_PACKED:
1172                                         mm = 'P';
1173                                         break;
1174                                 case V_INFO_MM_DIRECT:
1175                                         mm = 'D';
1176                                         break;
1177                                 case V_INFO_MM_CGA:
1178                                         mm = 'C';
1179                                         break;
1180                                 case V_INFO_MM_HGC:
1181                                         mm = 'H';
1182                                         break;
1183                                 case V_INFO_MM_VGAX:
1184                                         mm = 'V';
1185                                         break;
1186                                 default:
1187                                         mm = ' ';
1188                                         break;
1189                                 }
1190                                 snprintf(buf, sizeof(buf), "%dx%dx%d %c",
1191                                     info.vi_width, info.vi_height,
1192                                     info.vi_depth, mm);
1193                         }
1194                 } else {
1195                         c = 'T';
1196
1197                         snprintf(buf, sizeof(buf), "%dx%d",
1198                                  info.vi_width, info.vi_height);
1199                 }
1200
1201                 printf(" %c %-15s", c, buf);
1202                 snprintf(buf, sizeof(buf), "%dx%d",
1203                          info.vi_cwidth, info.vi_cheight);
1204                 printf(" %-5s", buf);
1205                 printf(" 0x%05zx %2dk %2dk",
1206                        info.vi_window, (int)info.vi_window_size/1024,
1207                        (int)info.vi_window_gran/1024);
1208                 printf(" 0x%08zx %dk\n",
1209                        info.vi_buffer, (int)info.vi_buffer_size/1024);
1210         }
1211 }
1212
1213
1214 static void
1215 show_info(char *arg)
1216 {
1217
1218         if (!strcmp(arg, "active")) {
1219                 show_active_info();
1220         } else if (!strcmp(arg, "adapter")) {
1221                 show_adapter_info();
1222         } else if (!strcmp(arg, "mode")) {
1223                 show_mode_info();
1224         } else {
1225                 revert();
1226                 errx(1, "argument to -i must be active, adapter, or mode");
1227         }
1228 }
1229
1230
1231 static void
1232 test_frame(void)
1233 {
1234         vid_info_t info;
1235         const char *bg, *sep;
1236         int i, fore;
1237
1238         info.size = sizeof(info);
1239         if (ioctl(0, CONS_GETINFO, &info) == -1)
1240                 err(1, "getting console information");
1241
1242         fore = 15;
1243         if (info.mv_csz < 80) {
1244                 bg = "BG";
1245                 sep = " ";
1246         } else {
1247                 bg = "BACKGROUND";
1248                 sep = "    ";
1249         }
1250
1251         fprintf(stdout, "\033[=0G\n\n");
1252         for (i=0; i<8; i++) {
1253                 fprintf(stdout,
1254                     "\033[=%dF\033[=0G%2d \033[=%dF%-7s%s"
1255                     "\033[=%dF\033[=0G%2d \033[=%dF%-12s%s"
1256                     "\033[=%dF%2d \033[=%dG%s\033[=0G%s"
1257                     "\033[=%dF%2d \033[=%dG%s\033[=0G\n",
1258                     fore, i, i, legal_colors[i], sep,
1259                     fore, i + 8, i + 8, legal_colors[i + 8], sep,
1260                     fore, i, i, bg, sep,
1261                     fore, i + 8, i + 8, bg);
1262         }
1263         fprintf(stdout, "\033[=%dF\033[=%dG\033[=%dH\033[=%dI\n",
1264                 info.mv_norm.fore, info.mv_norm.back,
1265                 info.mv_rev.fore, info.mv_rev.back);
1266 }
1267
1268
1269 /*
1270  * Snapshot the video memory of that terminal, using the CONS_SCRSHOT
1271  * ioctl, and writes the results to stdout either in the special
1272  * binary format (see manual page for details), or in the plain
1273  * text format.
1274  */
1275
1276 static void
1277 dump_screen(int mode, int opt)
1278 {
1279         scrshot_t shot;
1280         vid_info_t info;
1281
1282         info.size = sizeof(info);
1283         if (ioctl(0, CONS_GETINFO, &info) == -1) {
1284                 revert();
1285                 err(1, "getting console information");
1286         }
1287
1288         shot.x = shot.y = 0;
1289         shot.xsize = info.mv_csz;
1290         shot.ysize = info.mv_rsz;
1291         if (opt == DUMP_ALL)
1292                 shot.ysize += info.mv_hsz;
1293
1294         shot.buf = alloca(shot.xsize * shot.ysize * sizeof(u_int16_t));
1295         if (shot.buf == NULL) {
1296                 revert();
1297                 errx(1, "failed to allocate memory for dump");
1298         }
1299
1300         if (ioctl(0, CONS_SCRSHOT, &shot) == -1) {
1301                 revert();
1302                 err(1, "dumping screen");
1303         }
1304
1305         if (mode == DUMP_FMT_RAW) {
1306                 printf("SCRSHOT_%c%c%c%c", DUMP_FMT_REV, 2,
1307                        shot.xsize, shot.ysize);
1308
1309                 fflush(stdout);
1310
1311                 write(STDOUT_FILENO, shot.buf,
1312                       shot.xsize * shot.ysize * sizeof(u_int16_t));
1313         } else {
1314                 char *line;
1315                 int x, y;
1316                 u_int16_t ch;
1317
1318                 line = alloca(shot.xsize + 1);
1319
1320                 if (line == NULL) {
1321                         revert();
1322                         errx(1, "failed to allocate memory for line buffer");
1323                 }
1324
1325                 for (y = 0; y < shot.ysize; y++) {
1326                         for (x = 0; x < shot.xsize; x++) {
1327                                 ch = shot.buf[x + (y * shot.xsize)];
1328                                 ch &= 0xff;
1329
1330                                 if (isprint(ch) == 0)
1331                                         ch = ' ';
1332
1333                                 line[x] = (char)ch;
1334                         }
1335
1336                         /* Trim trailing spaces */
1337
1338                         do {
1339                                 line[x--] = '\0';
1340                         } while (line[x] == ' ' && x != 0);
1341
1342                         puts(line);
1343                 }
1344
1345                 fflush(stdout);
1346         }
1347 }
1348
1349
1350 /*
1351  * Set the console history buffer size.
1352  */
1353
1354 static void
1355 set_history(char *opt)
1356 {
1357         int size;
1358
1359         size = atoi(opt);
1360
1361         if ((*opt == '\0') || size < 0) {
1362                 revert();
1363                 errx(1, "argument must not be less than zero");
1364         }
1365
1366         if (ioctl(0, CONS_HISTORY, &size) == -1) {
1367                 revert();
1368                 err(1, "setting history buffer size");
1369         }
1370 }
1371
1372
1373 /*
1374  * Clear the console history buffer.
1375  */
1376
1377 static void
1378 clear_history(void)
1379 {
1380         if (ioctl(0, CONS_CLRHIST) == -1) {
1381                 revert();
1382                 err(1, "clearing history buffer");
1383         }
1384 }
1385
1386 static int
1387 get_terminal_emulator(int i, struct term_info *tip)
1388 {
1389         tip->ti_index = i;
1390         if (ioctl(0, CONS_GETTERM, tip) == 0)
1391                 return (1);
1392         strlcpy((char *)tip->ti_name, "unknown", sizeof(tip->ti_name));
1393         strlcpy((char *)tip->ti_desc, "unknown", sizeof(tip->ti_desc));
1394         return (0);
1395 }
1396
1397 static void
1398 get_terminal_emulators(void)
1399 {
1400         struct term_info ti;
1401         int i;
1402
1403         for (i = 0; i < 10; i++) {
1404                 if (get_terminal_emulator(i, &ti) == 0)
1405                         break;
1406                 printf("%d: %s (%s)%s\n", i, ti.ti_name, ti.ti_desc,
1407                     i == 0 ? " (active)" : "");
1408         }
1409 }
1410
1411 static void
1412 set_terminal_emulator(const char *name)
1413 {
1414         struct term_info old_ti, ti;
1415
1416         get_terminal_emulator(0, &old_ti);
1417         strlcpy((char *)ti.ti_name, name, sizeof(ti.ti_name));
1418         if (ioctl(0, CONS_SETTERM, &ti) != 0)
1419                 warn("SETTERM '%s'", name);
1420         get_terminal_emulator(0, &ti);
1421         printf("%s (%s) -> %s (%s)\n", old_ti.ti_name, old_ti.ti_desc,
1422             ti.ti_name, ti.ti_desc);
1423 }
1424
1425 static void
1426 set_terminal_mode(char *arg)
1427 {
1428
1429         if (strcmp(arg, "xterm") == 0)
1430                 fprintf(stderr, "\033[=T");
1431         else if (strcmp(arg, "cons25") == 0)
1432                 fprintf(stderr, "\033[=1T");
1433 }
1434
1435
1436 int
1437 main(int argc, char **argv)
1438 {
1439         char    *font, *type, *termmode;
1440         const char *opts;
1441         int     dumpmod, dumpopt, opt;
1442
1443         vt4_mode = is_vt4();
1444
1445         init();
1446
1447         dumpmod = 0;
1448         dumpopt = DUMP_FBF;
1449         termmode = NULL;
1450         if (vt4_mode)
1451                 opts = "b:Cc:fg:h:Hi:M:m:pPr:S:s:T:t:x";
1452         else
1453                 opts = "b:Cc:deE:fg:h:Hi:l:LM:m:pPr:S:s:T:t:x";
1454
1455         while ((opt = getopt(argc, argv, opts)) != -1)
1456                 switch(opt) {
1457                 case 'b':
1458                         set_border_color(optarg);
1459                         break;
1460                 case 'C':
1461                         clear_history();
1462                         break;
1463                 case 'c':
1464                         set_cursor_type(optarg);
1465                         break;
1466                 case 'd':
1467                         if (vt4_mode)
1468                                 break;
1469                         print_scrnmap();
1470                         break;
1471                 case 'E':
1472                         if (vt4_mode)
1473                                 break;
1474                         set_terminal_emulator(optarg);
1475                         break;
1476                 case 'e':
1477                         if (vt4_mode)
1478                                 break;
1479                         get_terminal_emulators();
1480                         break;
1481                 case 'f':
1482                         optarg = nextarg(argc, argv, &optind, 'f', 0);
1483                         if (optarg != NULL) {
1484                                 font = nextarg(argc, argv, &optind, 'f', 0);
1485
1486                                 if (font == NULL) {
1487                                         type = NULL;
1488                                         font = optarg;
1489                                 } else
1490                                         type = optarg;
1491
1492                                 load_font(type, font);
1493                         } else {
1494                                 if (!vt4_mode)
1495                                         usage(); /* Switch syscons to ROM? */
1496
1497                                 load_default_vt4font();
1498                         }
1499                         break;
1500                 case 'g':
1501                         if (sscanf(optarg, "%dx%d",
1502                             &vesa_cols, &vesa_rows) != 2) {
1503                                 revert();
1504                                 warnx("incorrect geometry: %s", optarg);
1505                                 usage();
1506                         }
1507                         break;
1508                 case 'h':
1509                         set_history(optarg);
1510                         break;
1511                 case 'H':
1512                         dumpopt = DUMP_ALL;
1513                         break;
1514                 case 'i':
1515                         show_info(optarg);
1516                         break;
1517                 case 'l':
1518                         if (vt4_mode)
1519                                 break;
1520                         load_scrnmap(optarg);
1521                         break;
1522                 case 'L':
1523                         if (vt4_mode)
1524                                 break;
1525                         load_default_scrnmap();
1526                         break;
1527                 case 'M':
1528                         set_mouse_char(optarg);
1529                         break;
1530                 case 'm':
1531                         set_mouse(optarg);
1532                         break;
1533                 case 'p':
1534                         dumpmod = DUMP_FMT_RAW;
1535                         break;
1536                 case 'P':
1537                         dumpmod = DUMP_FMT_TXT;
1538                         break;
1539                 case 'r':
1540                         set_reverse_colors(argc, argv, &optind);
1541                         break;
1542                 case 'S':
1543                         set_lockswitch(optarg);
1544                         break;
1545                 case 's':
1546                         set_console(optarg);
1547                         break;
1548                 case 'T':
1549                         if (strcmp(optarg, "xterm") != 0 &&
1550                             strcmp(optarg, "cons25") != 0)
1551                                 usage();
1552                         termmode = optarg;
1553                         break;
1554                 case 't':
1555                         set_screensaver_timeout(optarg);
1556                         break;
1557                 case 'x':
1558                         hex = 1;
1559                         break;
1560                 default:
1561                         usage();
1562                 }
1563
1564         if (dumpmod != 0)
1565                 dump_screen(dumpmod, dumpopt);
1566         video_mode(argc, argv, &optind);
1567         set_normal_colors(argc, argv, &optind);
1568
1569         if (optind < argc && !strcmp(argv[optind], "show")) {
1570                 test_frame();
1571                 optind++;
1572         }
1573
1574         if (termmode != NULL)
1575                 set_terminal_mode(termmode);
1576
1577         if ((optind != argc) || (argc == 1))
1578                 usage();
1579         return (0);
1580 }
1581