miscutils/conspy.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * A text-mode VNC like program for Linux virtual terminals.
   4  *
   5  * pascal.bellard@ads-lu.com
   6  *
   7  * Based on Russell Stuart's conspy.c
   8  *   http://ace-host.stuart.id.au/russell/files/conspy.c
   9  *
  10  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  11  */
  12
  13 //applet:IF_CONSPY(APPLET(conspy, BB_DIR_BIN, BB_SUID_DROP))
  14
  15 //kbuild:lib-$(CONFIG_CONSPY) += conspy.o
  16
  17 //config:config CONSPY
  18 //config:       bool "conspy"
  19 //config:       default n
  20 //config:       select PLATFORM_LINUX
  21 //config:       help
  22 //config:         A text-mode VNC like program for Linux virtual terminals.
  23 //config:         example:  conspy NUM      shared access to console num
  24 //config:         or        conspy -nd NUM  screenshot of console num
  25 //config:         or        conspy -cs NUM  poor man's GNU screen like
  26
  27 //usage:#define conspy_trivial_usage
  28 //usage:        "[-vcsndf] [-x COL] [-y LINE] [CONSOLE_NO]"
  29 //usage:#define conspy_full_usage "\n\n"
  30 //usage:     "A text-mode VNC like program for Linux virtual consoles."
  31 //usage:     "\nTo exit, quickly press ESC 3 times."
  32 //usage:     "\n"
  33 //usage:     "\nOptions:"
  34 //usage:     "\n        -v      Don't send keystrokes to the console"
  35 //usage:     "\n        -c      Create missing devices in /dev"
  36 //usage:     "\n        -s      Open a SHELL session"
  37 //usage:     "\n        -n      Black & white"
  38 //usage:     "\n        -d      Dump console to stdout"
  39 //usage:     "\n        -f      Follow cursor"
  40 //usage:     "\n        -x COL  Starting column"
  41 //usage:     "\n        -y LINE Starting line"
  42
  43 #include "libbb.h"
  44 #include <sys/kd.h>
  45
  46
  47 #define ESC "\033"
  48
  49 struct screen_info {
  50         unsigned char lines, cols, cursor_x, cursor_y;
  51 };
  52
  53 #define CHAR(x) (*(uint8_t*)(x))
  54 #define ATTR(x) (((uint8_t*)(x))[1])
  55 #define NEXT(x) ((x) += 2)
  56 #define DATA(x) (*(uint16_t*)(x))
  57
  58 struct globals {
  59         char* data;
  60         int size;
  61         int x, y;
  62         int kbd_fd;
  63         int ioerror_count;
  64         int key_count;
  65         int escape_count;
  66         int nokeys;
  67         int current;
  68         int first_line_offset;
  69         int last_attr;
  70         // cached local tty parameters
  71         unsigned width;
  72         unsigned height;
  73         unsigned col;
  74         unsigned line;
  75         smallint curoff; // unknown:0 cursor on:-1 cursor off:1
  76         char attrbuf[sizeof(ESC"[0;1;5;30;40m")];
  77         // remote console
  78         struct screen_info remote;
  79         // saved local tty terminfo
  80         struct termios term_orig;
  81         char vcsa_name[sizeof("/dev/vcsaNN")];
  82 };
  83
  84 #define G (*ptr_to_globals)
  85 #define INIT_G() do { \
  86         SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
  87         G.attrbuf[0] = '\033'; \
  88         G.attrbuf[1] = '['; \
  89         G.width = G.height = UINT_MAX; \
  90         G.last_attr--; \
  91 } while (0)
  92
  93 enum {
  94         FLAG_v,  // view only
  95         FLAG_c,  // create device if need
  96         FLAG_s,  // session
  97         FLAG_n,  // no colors
  98         FLAG_d,  // dump screen
  99         FLAG_f,  // follow cursor
 100 };
 101 #define FLAG(x) (1 << FLAG_##x)
 102 #define BW (option_mask32 & FLAG(n))
 103
 104 static void clrscr(void)
 105 {
 106         // Home, clear till end of screen
 107         fputs(ESC"[1;1H" ESC"[J", stdout);
 108         G.col = G.line = 0;
 109 }
 110
 111 static void set_cursor(int state)
 112 {
 113         if (G.curoff != state) {
 114                 G.curoff = state;
 115                 fputs(ESC"[?25", stdout);
 116                 bb_putchar("h?l"[1 + state]);
 117         }
 118 }
 119
 120 static void gotoxy(int col, int line)
 121 {
 122         if (G.col != col || G.line != line) {
 123                 G.col = col;
 124                 G.line = line;
 125                 printf(ESC"[%u;%uH", line + 1, col + 1);
 126         }
 127 }
 128
 129 static void cleanup(int code)
 130 {
 131         set_cursor(-1); // cursor on
 132         tcsetattr(G.kbd_fd, TCSANOW, &G.term_orig);
 133         if (ENABLE_FEATURE_CLEAN_UP) {
 134                 close(G.kbd_fd);
 135         }
 136         // Reset attributes
 137         if (!BW)
 138                 fputs(ESC"[0m", stdout);
 139         bb_putchar('\n');
 140         if (code > 1)
 141                 kill_myself_with_sig(code);
 142         exit(code);
 143 }
 144
 145 static void screen_read_close(void)
 146 {
 147         unsigned i, j;
 148         int vcsa_fd;
 149         char *data;
 150
 151         // Close & re-open vcsa in case they have swapped virtual consoles
 152         vcsa_fd = xopen(G.vcsa_name, O_RDONLY);
 153         xread(vcsa_fd, &G.remote, 4);
 154         i = G.remote.cols * 2;
 155         G.first_line_offset = G.y * i;
 156         i *= G.remote.lines;
 157         if (G.data == NULL) {
 158                 G.size = i;
 159                 G.data = xzalloc(2 * i);
 160         }
 161         else if (G.size != i) {
 162                 cleanup(1);
 163         }
 164         data = G.data + G.current;
 165         xread(vcsa_fd, data, G.size);
 166         close(vcsa_fd);
 167         for (i = 0; i < G.remote.lines; i++) {
 168                 for (j = 0; j < G.remote.cols; j++, NEXT(data)) {
 169                         unsigned x = j - G.x; // if will catch j < G.x too
 170                         unsigned y = i - G.y; // if will catch i < G.y too
 171
 172                         if (CHAR(data) < ' ')
 173                                 CHAR(data) = ' ';
 174                         if (y >= G.height || x >= G.width)
 175                                 DATA(data) = 0;
 176                 }
 177         }
 178 }
 179
 180 static void screen_char(char *data)
 181 {
 182         if (!BW) {
 183                 uint8_t attr = ATTR(data);
 184                 //uint8_t attr = ATTR(data) >> 1; // for framebuffer console
 185                 uint8_t attr_diff = G.last_attr ^ attr;
 186
 187                 if (attr_diff) {
 188 // Attribute layout for VGA compatible text videobuffer:
 189 // blinking text
 190 // |red bkgd
 191 // ||green bkgd
 192 // |||blue bkgd
 193 // vvvv
 194 // 00000000 <- lsb bit on the right
 195 //     bold text / text 8th bit
 196 //      red text
 197 //       green text
 198 //        blue text
 199 // TODO: apparently framebuffer-based console uses different layout
 200 // (bug? attempt to get 8th text bit in better position?)
 201 // red bkgd
 202 // |green bkgd
 203 // ||blue bkgd
 204 // vvv
 205 // 00000000 <- lsb bit on the right
 206 //    bold text
 207 //     red text
 208 //      green text
 209 //       blue text
 210 //        text 8th bit
 211                         // converting RGB color bit triad to BGR:
 212                         static const char color[8] = "04261537";
 213                         const uint8_t fg_mask = 0x07, bold_mask  = 0x08;
 214                         const uint8_t bg_mask = 0x70, blink_mask = 0x80;
 215                         char *ptr;
 216
 217                         ptr = G.attrbuf + 2; // skip "ESC ["
 218
 219                         // (G.last_attr & ~attr) has 1 only where
 220                         // G.last_attr has 1 but attr has 0.
 221                         // Here we check whether we have transition
 222                         // bold->non-bold or blink->non-blink:
 223                         if (G.last_attr < 0  // initial value
 224                          || ((G.last_attr & ~attr) & (bold_mask | blink_mask)) != 0
 225                         ) {
 226                                 *ptr++ = '0'; // "reset all attrs"
 227                                 *ptr++ = ';';
 228                                 // must set fg & bg, maybe need to set bold or blink:
 229                                 attr_diff = attr | ~(bold_mask | blink_mask);
 230                         }
 231                         G.last_attr = attr;
 232                         if (attr_diff & bold_mask) {
 233                                 *ptr++ = '1';
 234                                 *ptr++ = ';';
 235                         }
 236                         if (attr_diff & blink_mask) {
 237                                 *ptr++ = '5';
 238                                 *ptr++ = ';';
 239                         }
 240                         if (attr_diff & fg_mask) {
 241                                 *ptr++ = '3';
 242                                 *ptr++ = color[attr & fg_mask];
 243                                 *ptr++ = ';';
 244                         }
 245                         if (attr_diff & bg_mask) {
 246                                 *ptr++ = '4';
 247                                 *ptr++ = color[(attr & bg_mask) >> 4];
 248                                 *ptr++ = ';';
 249                         }
 250                         if (ptr != G.attrbuf + 2) {
 251                                 ptr[-1] = 'm';
 252                                 *ptr = '\0';
 253                                 fputs(G.attrbuf, stdout);
 254                         }
 255                 }
 256         }
 257         putchar(CHAR(data));
 258         G.col++;
 259 }
 260
 261 static void screen_dump(void)
 262 {
 263         int linefeed_cnt;
 264         int line, col;
 265         int linecnt = G.remote.lines - G.y;
 266         char *data = G.data + G.current + G.first_line_offset;
 267
 268         linefeed_cnt = 0;
 269         for (line = 0; line < linecnt && line < G.height; line++) {
 270                 int space_cnt = 0;
 271                 for (col = 0; col < G.remote.cols; col++, NEXT(data)) {
 272                         unsigned tty_col = col - G.x; // if will catch col < G.x too
 273
 274                         if (tty_col >= G.width)
 275                                 continue;
 276                         space_cnt++;
 277                         if (BW && CHAR(data) == ' ')
 278                                 continue;
 279                         while (linefeed_cnt != 0) {
 280                                 //bb_putchar('\r'); - tty driver does it for us
 281                                 bb_putchar('\n');
 282                                 linefeed_cnt--;
 283                         }
 284                         while (--space_cnt)
 285                                 bb_putchar(' ');
 286                         screen_char(data);
 287                 }
 288                 linefeed_cnt++;
 289         }
 290 }
 291
 292 static void curmove(void)
 293 {
 294         unsigned cx = G.remote.cursor_x - G.x;
 295         unsigned cy = G.remote.cursor_y - G.y;
 296         int cursor = 1;
 297
 298         if (cx < G.width && cy < G.height) {
 299                 gotoxy(cx, cy);
 300                 cursor = -1;
 301         }
 302         set_cursor(cursor);
 303 }
 304
 305 static void create_cdev_if_doesnt_exist(const char* name, dev_t dev)
 306 {
 307         int fd = open(name, O_RDONLY);
 308         if (fd != -1)
 309                 close(fd);
 310         else if (errno == ENOENT)
 311                 mknod(name, S_IFCHR | 0660, dev);
 312 }
 313
 314 static NOINLINE void start_shell_in_child(const char* tty_name)
 315 {
 316         int pid = xvfork();
 317         if (pid == 0) {
 318                 struct termios termchild;
 319                 const char *shell = get_shell_name();
 320
 321                 signal(SIGHUP, SIG_IGN);
 322                 // set tty as a controlling tty
 323                 setsid();
 324                 // make tty to be input, output, error
 325                 close(0);
 326                 xopen(tty_name, O_RDWR); // uses fd 0
 327                 xdup2(0, 1);
 328                 xdup2(0, 2);
 329                 ioctl(0, TIOCSCTTY, 1);
 330                 tcsetpgrp(0, getpid());
 331                 tcgetattr(0, &termchild);
 332                 termchild.c_lflag |= ECHO;
 333                 termchild.c_oflag |= ONLCR | XTABS;
 334                 termchild.c_iflag |= ICRNL;
 335                 termchild.c_iflag &= ~IXOFF;
 336                 tcsetattr_stdin_TCSANOW(&termchild);
 337                 execl(shell, shell, "-i", (char *) NULL);
 338                 bb_simple_perror_msg_and_die(shell);
 339         }
 340 }
 341
 342 int conspy_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 343 int conspy_main(int argc UNUSED_PARAM, char **argv)
 344 {
 345         char tty_name[sizeof("/dev/ttyNN")];
 346 #define keybuf bb_common_bufsiz1
 347         struct termios termbuf;
 348         unsigned opts;
 349         unsigned ttynum;
 350         int poll_timeout_ms;
 351 #if ENABLE_LONG_OPTS
 352         static const char getopt_longopts[] ALIGN1 =
 353                 "viewonly\0"     No_argument "v"
 354                 "createdevice\0" No_argument "c"
 355                 "session\0"      No_argument "s"
 356                 "nocolors\0"     No_argument "n"
 357                 "dump\0"         No_argument "d"
 358                 "follow\0"       No_argument "f"
 359                 ;
 360
 361         applet_long_options = getopt_longopts;
 362 #endif
 363         INIT_G();
 364         strcpy(G.vcsa_name, "/dev/vcsa");
 365
 366         opt_complementary = "x+:y+"; // numeric params
 367         opts = getopt32(argv, "vcsndfx:y:", &G.x, &G.y);
 368         argv += optind;
 369         ttynum = 0;
 370         if (argv[0]) {
 371                 ttynum = xatou_range(argv[0], 0, 63);
 372                 sprintf(G.vcsa_name + sizeof("/dev/vcsa")-1, "%u", ttynum);
 373         }
 374         sprintf(tty_name, "%s%u", "/dev/tty", ttynum);
 375         if (opts & FLAG(c)) {
 376                 if ((opts & (FLAG(s)|FLAG(v))) != FLAG(v))
 377                         create_cdev_if_doesnt_exist(tty_name, makedev(4, ttynum));
 378                 create_cdev_if_doesnt_exist(G.vcsa_name, makedev(7, 128 + ttynum));
 379         }
 380         if ((opts & FLAG(s)) && ttynum) {
 381                 start_shell_in_child(tty_name);
 382         }
 383
 384         screen_read_close();
 385         if (opts & FLAG(d)) {
 386                 screen_dump();
 387                 bb_putchar('\n');
 388                 return 0;
 389         }
 390
 391         bb_signals(BB_FATAL_SIGS, cleanup);
 392
 393         // All characters must be passed through to us unaltered
 394         G.kbd_fd = xopen(CURRENT_TTY, O_RDONLY);
 395         tcgetattr(G.kbd_fd, &G.term_orig);
 396         termbuf = G.term_orig;
 397         termbuf.c_iflag &= ~(BRKINT|INLCR|ICRNL|IXON|IXOFF|IUCLC|IXANY|IMAXBEL);
 398         //termbuf.c_oflag &= ~(OPOST); - no, we still want \n -> \r\n
 399         termbuf.c_lflag &= ~(ISIG|ICANON|ECHO);
 400         termbuf.c_cc[VMIN] = 1;
 401         termbuf.c_cc[VTIME] = 0;
 402         tcsetattr(G.kbd_fd, TCSANOW, &termbuf);
 403
 404         poll_timeout_ms = 250;
 405         while (1) {
 406                 struct pollfd pfd;
 407                 int bytes_read;
 408                 int i, j;
 409                 char *data, *old;
 410
 411                 // in the first loop G.width = G.height = 0: refresh
 412                 i = G.width;
 413                 j = G.height;
 414                 get_terminal_width_height(G.kbd_fd, &G.width, &G.height);
 415                 if (option_mask32 & FLAG(f)) {
 416                         int nx = G.remote.cursor_x - G.width + 1;
 417                         int ny = G.remote.cursor_y - G.height + 1;
 418
 419                         if (G.remote.cursor_x < G.x) {
 420                                 G.x = G.remote.cursor_x;
 421                                 i = 0; // force refresh
 422                         }
 423                         if (nx > G.x) {
 424                                 G.x = nx;
 425                                 i = 0; // force refresh
 426                         }
 427                         if (G.remote.cursor_y < G.y) {
 428                                 G.y = G.remote.cursor_y;
 429                                 i = 0; // force refresh
 430                         }
 431                         if (ny > G.y) {
 432                                 G.y = ny;
 433                                 i = 0; // force refresh
 434                         }
 435                 }
 436
 437                 // Scan console data and redraw our tty where needed
 438                 old = G.data + G.current;
 439                 G.current = G.size - G.current;
 440                 data = G.data + G.current;
 441                 screen_read_close();
 442                 if (i != G.width || j != G.height) {
 443                         clrscr();
 444                         screen_dump();
 445                 } else {
 446                         // For each remote line
 447                         old += G.first_line_offset;
 448                         data += G.first_line_offset;
 449                         for (i = G.y; i < G.remote.lines; i++) {
 450                                 char *first = NULL; // first char which needs updating
 451                                 char *last = last;  // last char which needs updating
 452                                 unsigned iy = i - G.y;
 453
 454                                 if (iy >= G.height)
 455                                         break;
 456                                 for (j = 0; j < G.remote.cols; j++, NEXT(old), NEXT(data)) {
 457                                         unsigned jx = j - G.x; // if will catch j >= G.x too
 458
 459                                         if (jx < G.width && DATA(data) != DATA(old)) {
 460                                                 last = data;
 461                                                 if (!first) {
 462                                                         first = data;
 463                                                         gotoxy(jx, iy);
 464                                                 }
 465                                         }
 466                                 }
 467                                 if (first) {
 468                                         // Rewrite updated data on the local screen
 469                                         for (; first <= last; NEXT(first))
 470                                                 screen_char(first);
 471                                 }
 472                         }
 473                 }
 474                 curmove();
 475
 476                 // Wait for local user keypresses
 477                 fflush_all();
 478                 pfd.fd = G.kbd_fd;
 479                 pfd.events = POLLIN;
 480                 bytes_read = 0;
 481                 switch (poll(&pfd, 1, poll_timeout_ms)) {
 482                         char *k;
 483                 case -1:
 484                         if (errno != EINTR)
 485                                 cleanup(1);
 486                         break;
 487                 case 0:
 488                         if (++G.nokeys >= 4)
 489                                 G.nokeys = G.escape_count = 0;
 490                         break;
 491                 default:
 492                         // Read the keys pressed
 493                         k = keybuf + G.key_count;
 494                         bytes_read = read(G.kbd_fd, k, sizeof(keybuf) - G.key_count);
 495                         if (bytes_read < 0)
 496                                 cleanup(1);
 497
 498                         // Do exit processing
 499                         for (i = 0; i < bytes_read; i++) {
 500                                 if (k[i] != '\033')
 501                                         G.escape_count = 0;
 502                                 else if (++G.escape_count >= 3)
 503                                         cleanup(0);
 504                         }
 505                 }
 506                 poll_timeout_ms = 250;
 507
 508                 // Insert all keys pressed into the virtual console's input
 509                 // buffer.  Don't do this if the virtual console is in scan
 510                 // code mode - giving ASCII characters to a program expecting
 511                 // scan codes will confuse it.
 512                 if (!(option_mask32 & FLAG(v)) && G.escape_count == 0) {
 513                         int handle, result;
 514                         long kbd_mode;
 515
 516                         G.key_count += bytes_read;
 517                         handle = xopen(tty_name, O_WRONLY);
 518                         result = ioctl(handle, KDGKBMODE, &kbd_mode);
 519                         if (result >= 0) {
 520                                 char *p = keybuf;
 521
 522                                 if (kbd_mode != K_XLATE && kbd_mode != K_UNICODE) {
 523                                         G.key_count = 0; // scan code mode
 524                                 }
 525                                 for (; G.key_count != 0; p++, G.key_count--) {
 526                                         result = ioctl(handle, TIOCSTI, p);
 527                                         if (result < 0) {
 528                                                 memmove(keybuf, p, G.key_count);
 529                                                 break;
 530                                         }
 531                                         // If there is an application on console which reacts
 532                                         // to keypresses, we need to make our first sleep
 533                                         // shorter to quickly redraw whatever it printed there.
 534                                         poll_timeout_ms = 20;
 535                                 }
 536                         }
 537                         // Close & re-open tty in case they have
 538                         // swapped virtual consoles
 539                         close(handle);
 540
 541                         // We sometimes get spurious IO errors on the TTY
 542                         // as programs close and re-open it
 543                         if (result >= 0)
 544                                 G.ioerror_count = 0;
 545                         else if (errno != EIO || ++G.ioerror_count > 4)
 546                                 cleanup(1);
 547                 }
 548         } /* while (1) */
 549 }