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:       depends on 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                 char *shell = getenv("SHELL");
 320
 321                 if (!shell)
 322                         shell = (char *) DEFAULT_SHELL;
 323                 signal(SIGHUP, SIG_IGN);
 324                 // set tty as a controlling tty
 325                 setsid();
 326                 // make tty to be input, output, error
 327                 close(0);
 328                 xopen(tty_name, O_RDWR); // uses fd 0
 329                 xdup2(0, 1);
 330                 xdup2(0, 2);
 331                 ioctl(0, TIOCSCTTY, 1);
 332                 tcsetpgrp(0, getpid());
 333                 tcgetattr(0, &termchild);
 334                 termchild.c_lflag |= ECHO;
 335                 termchild.c_oflag |= ONLCR | XTABS;
 336                 termchild.c_iflag |= ICRNL;
 337                 termchild.c_iflag &= ~IXOFF;
 338                 tcsetattr_stdin_TCSANOW(&termchild);
 339                 execl(shell, shell, "-i", (char *) NULL);
 340                 bb_simple_perror_msg_and_die(shell);
 341         }
 342 }
 343
 344 int conspy_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 345 int conspy_main(int argc UNUSED_PARAM, char **argv)
 346 {
 347         char tty_name[sizeof("/dev/ttyNN")];
 348 #define keybuf bb_common_bufsiz1
 349         struct termios termbuf;
 350         unsigned opts;
 351         unsigned ttynum;
 352         int poll_timeout_ms;
 353 #if ENABLE_LONG_OPTS
 354         static const char getopt_longopts[] ALIGN1 =
 355                 "viewonly\0"     No_argument "v"
 356                 "createdevice\0" No_argument "c"
 357                 "session\0"      No_argument "s"
 358                 "nocolors\0"     No_argument "n"
 359                 "dump\0"         No_argument "d"
 360                 "follow\0"       No_argument "f"
 361                 ;
 362
 363         applet_long_options = getopt_longopts;
 364 #endif
 365         INIT_G();
 366         strcpy(G.vcsa_name, "/dev/vcsa");
 367
 368         opt_complementary = "x+:y+"; // numeric params
 369         opts = getopt32(argv, "vcsndfx:y:", &G.x, &G.y);
 370         argv += optind;
 371         ttynum = 0;
 372         if (argv[0]) {
 373                 ttynum = xatou_range(argv[0], 0, 63);
 374                 sprintf(G.vcsa_name + sizeof("/dev/vcsa")-1, "%u", ttynum);
 375         }
 376         sprintf(tty_name, "%s%u", "/dev/tty", ttynum);
 377         if (opts & FLAG(c)) {
 378                 if ((opts & (FLAG(s)|FLAG(v))) != FLAG(v))
 379                         create_cdev_if_doesnt_exist(tty_name, makedev(4, ttynum));
 380                 create_cdev_if_doesnt_exist(G.vcsa_name, makedev(7, 128 + ttynum));
 381         }
 382         if ((opts & FLAG(s)) && ttynum) {
 383                 start_shell_in_child(tty_name);
 384         }
 385
 386         screen_read_close();
 387         if (opts & FLAG(d)) {
 388                 screen_dump();
 389                 bb_putchar('\n');
 390                 return 0;
 391         }
 392
 393         bb_signals(BB_FATAL_SIGS, cleanup);
 394
 395         // All characters must be passed through to us unaltered
 396         G.kbd_fd = xopen(CURRENT_TTY, O_RDONLY);
 397         tcgetattr(G.kbd_fd, &G.term_orig);
 398         termbuf = G.term_orig;
 399         termbuf.c_iflag &= ~(BRKINT|INLCR|ICRNL|IXON|IXOFF|IUCLC|IXANY|IMAXBEL);
 400         //termbuf.c_oflag &= ~(OPOST); - no, we still want \n -> \r\n
 401         termbuf.c_lflag &= ~(ISIG|ICANON|ECHO);
 402         termbuf.c_cc[VMIN] = 1;
 403         termbuf.c_cc[VTIME] = 0;
 404         tcsetattr(G.kbd_fd, TCSANOW, &termbuf);
 405
 406         poll_timeout_ms = 250;
 407         while (1) {
 408                 struct pollfd pfd;
 409                 int bytes_read;
 410                 int i, j;
 411                 char *data, *old;
 412
 413                 // in the first loop G.width = G.height = 0: refresh
 414                 i = G.width;
 415                 j = G.height;
 416                 get_terminal_width_height(G.kbd_fd, &G.width, &G.height);
 417                 if (option_mask32 & FLAG(f)) {
 418                         int nx = G.remote.cursor_x - G.width + 1;
 419                         int ny = G.remote.cursor_y - G.height + 1;
 420
 421                         if (G.remote.cursor_x < G.x) {
 422                                 G.x = G.remote.cursor_x;
 423                                 i = 0; // force refresh
 424                         }
 425                         if (nx > G.x) {
 426                                 G.x = nx;
 427                                 i = 0; // force refresh
 428                         }
 429                         if (G.remote.cursor_y < G.y) {
 430                                 G.y = G.remote.cursor_y;
 431                                 i = 0; // force refresh
 432                         }
 433                         if (ny > G.y) {
 434                                 G.y = ny;
 435                                 i = 0; // force refresh
 436                         }
 437                 }
 438
 439                 // Scan console data and redraw our tty where needed
 440                 old = G.data + G.current;
 441                 G.current = G.size - G.current;
 442                 data = G.data + G.current;
 443                 screen_read_close();
 444                 if (i != G.width || j != G.height) {
 445                         clrscr();
 446                         screen_dump();
 447                 } else {
 448                         // For each remote line
 449                         old += G.first_line_offset;
 450                         data += G.first_line_offset;
 451                         for (i = G.y; i < G.remote.lines; i++) {
 452                                 char *first = NULL; // first char which needs updating
 453                                 char *last = last;  // last char which needs updating
 454                                 unsigned iy = i - G.y;
 455
 456                                 if (iy >= G.height)
 457                                         break;
 458                                 for (j = 0; j < G.remote.cols; j++, NEXT(old), NEXT(data)) {
 459                                         unsigned jx = j - G.x; // if will catch j >= G.x too
 460
 461                                         if (jx < G.width && DATA(data) != DATA(old)) {
 462                                                 last = data;
 463                                                 if (!first) {
 464                                                         first = data;
 465                                                         gotoxy(jx, iy);
 466                                                 }
 467                                         }
 468                                 }
 469                                 if (first) {
 470                                         // Rewrite updated data on the local screen
 471                                         for (; first <= last; NEXT(first))
 472                                                 screen_char(first);
 473                                 }
 474                         }
 475                 }
 476                 curmove();
 477
 478                 // Wait for local user keypresses
 479                 fflush_all();
 480                 pfd.fd = G.kbd_fd;
 481                 pfd.events = POLLIN;
 482                 bytes_read = 0;
 483                 switch (poll(&pfd, 1, poll_timeout_ms)) {
 484                         char *k;
 485                 case -1:
 486                         if (errno != EINTR)
 487                                 cleanup(1);
 488                         break;
 489                 case 0:
 490                         if (++G.nokeys >= 4)
 491                                 G.nokeys = G.escape_count = 0;
 492                         break;
 493                 default:
 494                         // Read the keys pressed
 495                         k = keybuf + G.key_count;
 496                         bytes_read = read(G.kbd_fd, k, sizeof(keybuf) - G.key_count);
 497                         if (bytes_read < 0)
 498                                 cleanup(1);
 499
 500                         // Do exit processing
 501                         for (i = 0; i < bytes_read; i++) {
 502                                 if (k[i] != '\033')
 503                                         G.escape_count = 0;
 504                                 else if (++G.escape_count >= 3)
 505                                         cleanup(0);
 506                         }
 507                 }
 508                 poll_timeout_ms = 250;
 509
 510                 // Insert all keys pressed into the virtual console's input
 511                 // buffer.  Don't do this if the virtual console is in scan
 512                 // code mode - giving ASCII characters to a program expecting
 513                 // scan codes will confuse it.
 514                 if (!(option_mask32 & FLAG(v)) && G.escape_count == 0) {
 515                         int handle, result;
 516                         long kbd_mode;
 517
 518                         G.key_count += bytes_read;
 519                         handle = xopen(tty_name, O_WRONLY);
 520                         result = ioctl(handle, KDGKBMODE, &kbd_mode);
 521                         if (result >= 0) {
 522                                 char *p = keybuf;
 523
 524                                 if (kbd_mode != K_XLATE && kbd_mode != K_UNICODE) {
 525                                         G.key_count = 0; // scan code mode
 526                                 }
 527                                 for (; G.key_count != 0; p++, G.key_count--) {
 528                                         result = ioctl(handle, TIOCSTI, p);
 529                                         if (result < 0) {
 530                                                 memmove(keybuf, p, G.key_count);
 531                                                 break;
 532                                         }
 533                                         // If there is an application on console which reacts
 534                                         // to keypresses, we need to make our first sleep
 535                                         // shorter to quickly redraw whatever it printed there.
 536                                         poll_timeout_ms = 20;
 537                                 }
 538                         }
 539                         // Close & re-open tty in case they have
 540                         // swapped virtual consoles
 541                         close(handle);
 542
 543                         // We sometimes get spurious IO errors on the TTY
 544                         // as programs close and re-open it
 545                         if (result >= 0)
 546                                 G.ioerror_count = 0;
 547                         else if (errno != EIO || ++G.ioerror_count > 4)
 548                                 cleanup(1);
 549                 }
 550         } /* while (1) */
 551 }