spiceterm.c

   1 /*
   2
   3      Copyright (C) 2013 Proxmox Server Solutions GmbH
   4
   5      Copyright: spiceterm is under GNU GPL, the GNU General Public License.
   6
   7      This program is free software; you can redistribute it and/or modify
   8      it under the terms of the GNU General Public License as published by
   9      the Free Software Foundation; version 2 dated June, 1991.
  10
  11      This program is distributed in the hope that it will be useful,
  12      but WITHOUT ANY WARRANTY; without even the implied warranty of
  13      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14      GNU General Public License for more details.
  15
  16      You should have received a copy of the GNU General Public License
  17      along with this program; if not, write to the Free Software
  18      Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  19      02111-1307, USA.
  20
  21      Author: Dietmar Maurer <dietmar@proxmox.com>
  22
  23      Note: most of the code here is copied from vncterm (which is
  24      also written by me).
  25
  26 */
  27
  28 #define _GNU_SOURCE
  29
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <unistd.h>
  33 #include <sys/types.h>
  34 #include <sys/socket.h>
  35 #include <arpa/inet.h>
  36 #include <netdb.h>
  37 #include <pty.h>  /* for openpty and forkpty */
  38 #include <string.h>
  39 #include <errno.h>
  40 #include <sys/ioctl.h>
  41 #include <sys/wait.h>
  42 #include <signal.h>
  43 #include <locale.h>
  44 #include <getopt.h>
  45
  46 #include "spiceterm.h"
  47
  48 #include <glib.h>
  49 #include <spice.h>
  50 #include <spice/enums.h>
  51 #include <spice/macros.h>
  52 #include <spice/qxl_dev.h>
  53
  54 #include <gdk/gdkkeysyms.h>
  55
  56 #include "event_loop.h"
  57 #include "translations.h"
  58
  59 static int debug = 0;
  60
  61 #define DPRINTF(x, format, ...) { \
  62     if (x <= debug) { \
  63         printf("%s: " format "\n" , __FUNCTION__, ## __VA_ARGS__); \
  64     } \
  65 }
  66
  67 #define TERM "xterm"
  68
  69 #define TERMIDCODE "[?1;2c" // vt100 ID
  70
  71 /* these colours are from linux kernel drivers/char/vt.c */
  72
  73 unsigned char color_table[] = { 0, 4, 2, 6, 1, 5, 3, 7,
  74                                 8,12,10,14, 9,13,11,15 };
  75
  76 static void
  77 draw_char_at(spiceTerm *vt, int x, int y, gunichar2 ch, TextAttributes attrib)
  78 {
  79     if (x < 0 || y < 0 || x >= vt->width || y >= vt->height) {
  80         return;
  81     }
  82
  83     spice_screen_draw_char(vt->screen, x, y, ch, attrib);
  84 }
  85
  86 static void
  87 spiceterm_update_xy(spiceTerm *vt, int x, int y)
  88 {
  89     if (x < 0 || y < 0 || x >= vt->width || y >= vt->height) { return; }
  90
  91     int y1 = (vt->y_base + y) % vt->total_height;
  92     int y2 = y1 - vt->y_displ;
  93     if (y2 < 0) {
  94         y2 += vt->total_height;
  95     }
  96     if (y2 < vt->height) {
  97         TextCell *c = &vt->cells[y1 * vt->width + x];
  98         draw_char_at(vt, x, y2, c->ch, c->attrib);
  99     }
 100 }
 101
 102 static void
 103 spiceterm_clear_xy(spiceTerm *vt, int x, int y)
 104 {
 105     if (x < 0 || y < 0 || x >= vt->width || y >= vt->height) { return; }
 106
 107     int y1 = (vt->y_base + y) % vt->total_height;
 108     int y2 = y1 - vt->y_displ;
 109     if (y2 < 0) {
 110         y2 += vt->total_height;
 111     }
 112     if (y2 < vt->height) {
 113         TextCell *c = &vt->cells[y1 * vt->width + x];
 114         c->ch = ' ';
 115         c->attrib = vt->default_attrib;
 116         c->attrib.fgcol = vt->cur_attrib.fgcol;
 117         c->attrib.bgcol = vt->cur_attrib.bgcol;
 118
 119         draw_char_at(vt, x, y, c->ch, c->attrib);
 120     }
 121 }
 122
 123 void
 124 spiceterm_toggle_marked_cell(spiceTerm *vt, int pos)
 125 {
 126     int x = (pos%vt->width);
 127     int y = (pos/vt->width);
 128
 129     if (x < 0 || y < 0 || x >= vt->width || y >= vt->height) { return; }
 130
 131     int y1 = (vt->y_displ + y) % vt->total_height;
 132
 133     TextCell *c = &vt->cells[y1 * vt->width + x];
 134     c->attrib.selected =  c->attrib.selected ? 0 : 1;
 135
 136     if (y < vt->height) {
 137         draw_char_at(vt, x, y, c->ch, c->attrib);
 138     }
 139 }
 140
 141 static void
 142 spiceterm_show_cursor(spiceTerm *vt, int show)
 143 {
 144     int x = vt->cx;
 145     if (x >= vt->width) {
 146         x = vt->width - 1;
 147     }
 148
 149     int y1 = (vt->y_base + vt->cy) % vt->total_height;
 150     int y = y1 - vt->y_displ;
 151     if (y < 0) {
 152         y += vt->total_height;
 153     }
 154
 155     if (y < vt->height) {
 156
 157         TextCell *c = &vt->cells[y1 * vt->width + x];
 158
 159         if (show) {
 160             TextAttributes attrib = vt->default_attrib;
 161             attrib.invers = !(attrib.invers); /* invert fg and bg */
 162             draw_char_at(vt, x, y, c->ch, attrib);
 163         } else {
 164             draw_char_at(vt, x, y, c->ch, c->attrib);
 165         }
 166     }
 167 }
 168
 169 void
 170 spiceterm_refresh(spiceTerm *vt)
 171 {
 172     int x, y, y1;
 173
 174     y1 = vt->y_displ;
 175     for(y = 0; y < vt->height; y++) {
 176         TextCell *c = vt->cells + y1 * vt->width;
 177         for(x = 0; x < vt->width; x++) {
 178             draw_char_at(vt, x, y, c->ch, c->attrib);
 179             c++;
 180         }
 181         if (++y1 == vt->total_height)
 182             y1 = 0;
 183     }
 184
 185     spiceterm_show_cursor(vt, 1);
 186 }
 187
 188 static void
 189 spiceterm_clear_screen(spiceTerm *vt)
 190 {
 191     int x, y;
 192
 193     for (y = 0; y <= vt->height; y++) {
 194         int y1 = (vt->y_base + y) % vt->total_height;
 195         TextCell *c = &vt->cells[y1 * vt->width];
 196         for (x = 0; x < vt->width; x++) {
 197             c->ch = ' ';
 198             c->attrib = vt->default_attrib;
 199             c->attrib.fgcol = vt->cur_attrib.fgcol;
 200             c->attrib.bgcol = vt->cur_attrib.bgcol;
 201
 202             c++;
 203         }
 204     }
 205
 206     spice_screen_clear(vt->screen, 0, 0, vt->screen->primary_width,
 207                        vt->screen->primary_height);
 208 }
 209
 210 void
 211 spiceterm_unselect_all(spiceTerm *vt)
 212 {
 213     int x, y, y1;
 214
 215     y1 = vt->y_displ;
 216     for(y = 0; y < vt->total_height; y++) {
 217         TextCell *c = vt->cells + y1 * vt->width;
 218         for(x = 0; x < vt->width; x++) {
 219            if (c->attrib.selected) {
 220                c->attrib.selected = 0;
 221                if (y < vt->height) {
 222                    draw_char_at(vt, x, y, c->ch, c->attrib);
 223                }
 224            }
 225            c++;
 226         }
 227         if (++y1 == vt->total_height)
 228             y1 = 0;
 229     }
 230 }
 231
 232 static void
 233 spiceterm_scroll_down(spiceTerm *vt, int top, int bottom, int lines)
 234 {
 235     if ((top + lines) >= bottom) {
 236         lines = bottom - top -1;
 237     }
 238
 239     if (top < 0 || bottom > vt->height || top >= bottom || lines < 1) {
 240         return;
 241     }
 242
 243     int i;
 244     for(i = bottom - top - lines - 1; i >= 0; i--) {
 245         int src = ((vt->y_base + top + i) % vt->total_height)*vt->width;
 246         int dst = ((vt->y_base + top + lines + i) % vt->total_height)*vt->width;
 247
 248         memmove(vt->cells + dst, vt->cells + src, vt->width*sizeof(TextCell));
 249     }
 250
 251     for (i = 0; i < lines; i++) {
 252         int j;
 253         TextCell *c = vt->cells + ((vt->y_base + top + i) % vt->total_height)*vt->width;
 254         for(j = 0; j < vt->width; j++) {
 255             c->attrib = vt->default_attrib;
 256             c->ch = ' ';
 257             c++;
 258         }
 259     }
 260
 261     int h = lines * 16;
 262     int y0 = top*16;
 263     int y1 = y0 + h;
 264     int y2 = bottom*16;
 265
 266     spice_screen_scroll(vt->screen, 0, y1, vt->screen->primary_width, y2, 0, y0);
 267     spice_screen_clear(vt->screen, 0, y0, vt->screen->primary_width, y1);
 268 }
 269
 270 static void
 271 spiceterm_scroll_up(spiceTerm *vt, int top, int bottom, int lines, int moveattr)
 272 {
 273     if ((top + lines) >= bottom) {
 274         lines = bottom - top - 1;
 275     }
 276
 277     if (top < 0 || bottom > vt->height || top >= bottom || lines < 1) {
 278         return;
 279     }
 280
 281
 282     int h = lines * 16;
 283     int y0 = top*16;
 284     int y1 = (top + lines)*16;
 285     int y2 = bottom*16;
 286
 287     spice_screen_scroll(vt->screen, 0, y0, vt->screen->primary_width, y2 -h, 0, y1);
 288     spice_screen_clear(vt->screen, 0, y2 -h, vt->screen->primary_width, y2);
 289
 290     if (!moveattr) {
 291         return;
 292     }
 293
 294     // move attributes
 295
 296     int i;
 297     for(i = 0; i < (bottom - top - lines); i++) {
 298         int dst = ((vt->y_base + top + i) % vt->total_height)*vt->width;
 299         int src = ((vt->y_base + top + lines + i) % vt->total_height)*vt->width;
 300
 301         memmove(vt->cells + dst, vt->cells + src, vt->width*sizeof(TextCell));
 302     }
 303
 304     for (i = 1; i <= lines; i++) {
 305         int j;
 306         TextCell *c = vt->cells + ((vt->y_base + bottom - i) % vt->total_height)*vt->width;
 307         for(j = 0; j < vt->width; j++) {
 308             c->attrib = vt->default_attrib;
 309             c->ch = ' ';
 310             c++;
 311         }
 312     }
 313 }
 314
 315 void
 316 spiceterm_virtual_scroll(spiceTerm *vt, int lines)
 317 {
 318     if (vt->altbuf || lines == 0) return;
 319
 320     if (lines < 0) {
 321         lines = -lines;
 322         int i = vt->scroll_height;
 323         if (i > vt->total_height - vt->height)
 324             i = vt->total_height - vt->height;
 325         int y1 = vt->y_base - i;
 326         if (y1 < 0)
 327             y1 += vt->total_height;
 328         for(i = 0; i < lines; i++) {
 329             if (vt->y_displ == y1) break;
 330             if (--vt->y_displ < 0) {
 331                 vt->y_displ = vt->total_height - 1;
 332             }
 333         }
 334     } else {
 335         int i;
 336         for(i = 0; i < lines; i++) {
 337             if (vt->y_displ == vt->y_base) break;
 338             if (++vt->y_displ == vt->total_height) {
 339                 vt->y_displ = 0;
 340             }
 341         }
 342     }
 343
 344     spiceterm_refresh(vt);
 345 }
 346
 347 void
 348 spiceterm_respond_esc(spiceTerm *vt, const char *esc)
 349 {
 350     int len = strlen(esc);
 351     int i;
 352
 353     if (vt->ibuf_count < (IBUFSIZE - 1 - len)) {
 354         vt->ibuf[vt->ibuf_count++] = 27;
 355         for (i = 0; i < len; i++) {
 356             vt->ibuf[vt->ibuf_count++] = esc[i];
 357         }
 358     } else {
 359         fprintf(stderr, "input buffer oferflow\n");
 360         return;
 361     }
 362 }
 363
 364 void
 365 spiceterm_respond_data(spiceTerm *vt, int len, uint8_t *data)
 366 {
 367     int i;
 368
 369     if (vt->ibuf_count < (IBUFSIZE - len)) {
 370         for (i = 0; i < len; i++) {
 371             vt->ibuf[vt->ibuf_count++] = data[i];
 372         }
 373     } else {
 374         fprintf(stderr, "input buffer oferflow\n");
 375         return;
 376     }
 377 }
 378
 379 static void
 380 spiceterm_put_lf(spiceTerm *vt)
 381 {
 382     if (vt->cy + 1 == vt->region_bottom) {
 383
 384         if (vt->altbuf || vt->region_top != 0 || vt->region_bottom != vt->height) {
 385             spiceterm_scroll_up(vt, vt->region_top, vt->region_bottom, 1, 1);
 386             return;
 387         }
 388
 389         if (vt->y_displ == vt->y_base) {
 390             spiceterm_scroll_up(vt, vt->region_top, vt->region_bottom, 1, 0);
 391         }
 392
 393         if (vt->y_displ == vt->y_base) {
 394             if (++vt->y_displ == vt->total_height) {
 395                 vt->y_displ = 0;
 396             }
 397         }
 398
 399         if (++vt->y_base == vt->total_height) {
 400             vt->y_base = 0;
 401         }
 402
 403         if (vt->scroll_height < vt->total_height) {
 404             vt->scroll_height++;
 405         }
 406
 407         int y1 = (vt->y_base + vt->height - 1) % vt->total_height;
 408         TextCell *c = &vt->cells[y1 * vt->width];
 409         int x;
 410         for (x = 0; x < vt->width; x++) {
 411             c->ch = ' ';
 412             c->attrib = vt->default_attrib;
 413             c++;
 414         }
 415
 416         // fprintf (stderr, "BASE: %d DISPLAY %d\n", vt->y_base, vt->y_displ);
 417
 418     } else if (vt->cy < vt->height - 1) {
 419         vt->cy += 1;
 420     }
 421 }
 422
 423 static void
 424 spiceterm_csi_m(spiceTerm *vt)
 425 {
 426     int i;
 427
 428     for (i = 0; i < vt->esc_count; i++) {
 429         switch (vt->esc_buf[i]) {
 430         case 0: /* reset all console attributes to default */
 431             vt->cur_attrib = vt->default_attrib;
 432             break;
 433         case 1:
 434             vt->cur_attrib.bold = 1;
 435             break;
 436         case 4:
 437             vt->cur_attrib.uline = 1;
 438             break;
 439         case 5:
 440             vt->cur_attrib.blink = 1;
 441             break;
 442         case 7:
 443             vt->cur_attrib.invers = 1;
 444             break;
 445         case 8:
 446             vt->cur_attrib.unvisible = 1;
 447             break;
 448         case 10:
 449             vt->cur_enc = LAT1_MAP;
 450             // fixme: dispaly controls = 0 ?
 451             // fixme: toggle meta = 0 ?
 452             break;
 453         case 11:
 454             vt->cur_enc = IBMPC_MAP;
 455             // fixme: dispaly controls = 1 ?
 456             // fixme: toggle meta = 0 ?
 457             break;
 458         case 12:
 459             vt->cur_enc = IBMPC_MAP;
 460             // fixme: dispaly controls = 1 ?
 461             // fixme: toggle meta = 1 ?
 462             break;
 463         case 22:
 464             vt->cur_attrib.bold = 0;
 465             break;
 466         case 24:
 467             vt->cur_attrib.uline = 0;
 468             break;
 469         case 25:
 470             vt->cur_attrib.blink = 0;
 471             break;
 472         case 27:
 473             vt->cur_attrib.invers = 0;
 474             break;
 475         case 28:
 476             vt->cur_attrib.unvisible = 0;
 477             break;
 478         case 30:
 479         case 31:
 480         case 32:
 481         case 33:
 482         case 34:
 483         case 35:
 484         case 36:
 485         case 37:
 486             /* set foreground color */
 487             vt->cur_attrib.fgcol = color_table [vt->esc_buf[i] - 30];
 488             break;
 489         case 38:
 490             /* reset color to default, enable underline */
 491             vt->cur_attrib.fgcol = vt->default_attrib.fgcol;
 492             vt->cur_attrib.uline = 1;
 493             break;
 494         case 39:
 495             /* reset color to default, disable underline */
 496             vt->cur_attrib.fgcol = vt->default_attrib.fgcol;
 497             vt->cur_attrib.uline = 0;
 498             break;
 499         case 40:
 500         case 41:
 501         case 42:
 502         case 43:
 503         case 44:
 504         case 45:
 505         case 46:
 506         case 47:
 507             /* set background color */
 508             vt->cur_attrib.bgcol = color_table [vt->esc_buf[i] - 40];
 509             break;
 510         case 49:
 511             /* reset background color */
 512             vt->cur_attrib.bgcol = vt->default_attrib.bgcol;
 513             break;
 514         default:
 515             fprintf(stderr, "unhandled ESC[%d m code\n",vt->esc_buf[i]);
 516             //fixme: implement
 517         }
 518     }
 519 }
 520
 521 static void
 522 spiceterm_save_cursor(spiceTerm *vt)
 523 {
 524     vt->cx_saved = vt->cx;
 525     vt->cy_saved = vt->cy;
 526     vt->cur_attrib_saved = vt->cur_attrib;
 527     vt->charset_saved = vt->charset;
 528     vt->g0enc_saved = vt->g0enc;
 529     vt->g1enc_saved = vt->g1enc;
 530     vt->cur_enc_saved = vt->cur_enc;
 531 }
 532
 533 static void
 534 spiceterm_restore_cursor(spiceTerm *vt)
 535 {
 536     vt->cx = vt->cx_saved;
 537     vt->cy = vt->cy_saved;
 538     vt->cur_attrib = vt->cur_attrib_saved;
 539     vt->charset = vt->charset_saved;
 540     vt->g0enc = vt->g0enc_saved;
 541     vt->g1enc = vt->g1enc_saved;
 542     vt->cur_enc = vt->cur_enc_saved;
 543 }
 544
 545 static void
 546 spiceterm_set_alternate_buffer(spiceTerm *vt, int on_off)
 547 {
 548     int x, y;
 549
 550     vt->y_displ = vt->y_base;
 551
 552     if (on_off) {
 553
 554         if (vt->altbuf) return;
 555
 556         vt->altbuf = 1;
 557
 558         /* alternate buffer & cursor */
 559
 560         spiceterm_save_cursor(vt);
 561         /* save screen to altcels */
 562         for (y = 0; y < vt->height; y++) {
 563             int y1 = (vt->y_base + y) % vt->total_height;
 564             for (x = 0; x < vt->width; x++) {
 565                 vt->altcells[y*vt->width + x] = vt->cells[y1*vt->width + x];
 566             }
 567         }
 568
 569         /* clear screen */
 570         for (y = 0; y <= vt->height; y++) {
 571             for (x = 0; x < vt->width; x++) {
 572                 //     spiceterm_clear_xy(vt, x, y);
 573             }
 574         }
 575
 576     } else {
 577
 578         if (vt->altbuf == 0) return;
 579
 580         vt->altbuf = 0;
 581
 582         /* restore saved data */
 583         for (y = 0; y < vt->height; y++) {
 584             int y1 = (vt->y_base + y) % vt->total_height;
 585             for (x = 0; x < vt->width; x++) {
 586                 vt->cells[y1*vt->width + x] = vt->altcells[y*vt->width + x];
 587             }
 588         }
 589
 590         spiceterm_restore_cursor(vt);
 591     }
 592
 593     spiceterm_refresh(vt);
 594 }
 595
 596 static void
 597 spiceterm_set_mode(spiceTerm *vt, int on_off)
 598 {
 599     int i;
 600
 601     for (i = 0; i <= vt->esc_count; i++) {
 602         if (vt->esc_ques) {          /* DEC private modes set/reset */
 603             switch(vt->esc_buf[i]) {
 604             case 10:                   /* X11 mouse reporting on/off */
 605             case 1000:                 /* SET_VT200_MOUSE */
 606             case 1002:                 /* xterm SET_BTN_EVENT_MOUSE */
 607                 vt->report_mouse = on_off;
 608                 break;
 609             case 1049:          /* start/end special app mode (smcup/rmcup) */
 610                 spiceterm_set_alternate_buffer (vt, on_off);
 611                 break;
 612             case 25:                    /* Cursor on/off */
 613             case 9:                     /* X10 mouse reporting on/off */
 614             case 6:                     /* Origin relative/absolute */
 615             case 1:                     /* Cursor keys in appl mode*/
 616             case 5:                     /* Inverted screen on/off */
 617             case 7:                     /* Autowrap on/off */
 618             case 8:                     /* Autorepeat on/off */
 619                 break;
 620              }
 621         } else { /* ANSI modes set/reset */
 622             //g_assert_not_reached();
 623
 624             /* fixme: implement me */
 625         }
 626     }
 627 }
 628
 629 static void
 630 spiceterm_gotoxy(spiceTerm *vt, int x, int y)
 631 {
 632     /* verify all boundaries */
 633
 634     if (x < 0) {
 635         x = 0;
 636     }
 637
 638     if (x >= vt->width) {
 639         x = vt->width - 1;
 640     }
 641
 642     vt->cx = x;
 643
 644     if (y < 0) {
 645         y = 0;
 646     }
 647
 648     if (y >= vt->height) {
 649         y = vt->height - 1;
 650     }
 651
 652     vt->cy = y;
 653 }
 654
 655 static void
 656 debug_print_escape_buffer(spiceTerm *vt, const char *func, const char *prefix,
 657                           const char *qes, gunichar2 ch)
 658 {
 659     if (debug >=1 ) {
 660         if (vt->esc_count == 0) {
 661             printf("%s:%s ESC[%s%c\n", func, prefix, qes, ch);
 662         } else if (vt->esc_count == 1) {
 663             printf("%s:%s ESC[%s%d%c\n", func, prefix, qes, vt->esc_buf[0], ch);
 664         } else {
 665             int i;
 666             printf("%s:%s ESC[%s%d", func, prefix, qes, vt->esc_buf[0]);
 667             for (i = 1; i < vt->esc_count; i++) {
 668                 printf(";%d",  vt->esc_buf[i]);
 669             }
 670             printf("%c\n", ch);
 671         }
 672     }
 673 }
 674
 675 enum { ESnormal, ESesc, ESsquare, ESgetpars, ESgotpars, ESfunckey,
 676        EShash, ESsetG0, ESsetG1, ESpercent, ESignore, ESnonstd,
 677        ESpalette, ESidquery, ESosc1, ESosc2};
 678
 679 static void
 680 spiceterm_putchar(spiceTerm *vt, gunichar2 ch)
 681 {
 682     int x, y, i, c;
 683
 684     if (debug && !vt->tty_state) {
 685         DPRINTF(1, "CHAR:%2d: %4x '%c' (cur_enc %d) %d %d",
 686                 vt->tty_state, ch, ch, vt->cur_enc, vt->cx, vt->cy);
 687     }
 688
 689     switch(vt->tty_state) {
 690     case ESesc:
 691         vt->tty_state = ESnormal;
 692         switch (ch) {
 693         case '[':
 694             vt->tty_state = ESsquare;
 695             break;
 696         case ']':
 697             vt->tty_state = ESnonstd;
 698             break;
 699         case '%':
 700             vt->tty_state = ESpercent;
 701             break;
 702         case '7':
 703             spiceterm_save_cursor(vt);
 704             break;
 705         case '8':
 706             spiceterm_restore_cursor(vt);
 707             break;
 708         case '(':
 709             vt->tty_state = ESsetG0; // SET G0
 710             break;
 711         case ')':
 712             vt->tty_state = ESsetG1; // SET G1
 713             break;
 714         case 'M':
 715             /* cursor up (ri) */
 716             if (vt->cy == vt->region_top)
 717                 spiceterm_scroll_down(vt, vt->region_top, vt->region_bottom, 1);
 718             else if (vt->cy > 0) {
 719                 vt->cy--;
 720             }
 721             break;
 722         case '>':
 723             /* numeric keypad  - ignored */
 724             break;
 725         case '=':
 726             /* appl. keypad - ignored */
 727             break;
 728         default:
 729             DPRINTF(1, "got unhandled ESC%c  %d", ch, ch);
 730             break;
 731         }
 732         break;
 733     case ESnonstd: /* Operating System Controls */
 734         vt->tty_state = ESnormal;
 735
 736         switch (ch) {
 737         case 'P':   /* palette escape sequence */
 738             for(i = 0; i < MAX_ESC_PARAMS; i++) {
 739                 vt->esc_buf[i] = 0;
 740             }
 741
 742             vt->esc_count = 0;
 743             vt->tty_state = ESpalette;
 744             break;
 745         case 'R':   /* reset palette */
 746             // fixme: reset_palette(vc);
 747             break;
 748         case '0':
 749         case '1':
 750         case '2':
 751         case '4':
 752             vt->osc_cmd = ch;
 753             vt->osc_textbuf[0] = 0;
 754             vt->tty_state = ESosc1;
 755             break;
 756         default:
 757             DPRINTF(1, "got unhandled OSC %c", ch);
 758             vt->tty_state = ESnormal;
 759             break;
 760         }
 761         break;
 762     case ESosc1:
 763         vt->tty_state = ESnormal;
 764         if (ch == ';') {
 765             vt->tty_state = ESosc2;
 766         } else {
 767             DPRINTF(1, "got illegal OSC sequence");
 768         }
 769         break;
 770     case ESosc2:
 771         if (ch != 0x9c && ch != 7) {
 772             int i = 0;
 773             while (vt->osc_textbuf[i]) i++;
 774             vt->osc_textbuf[i++] = ch;
 775             vt->osc_textbuf[i] = 0;
 776         } else {
 777             DPRINTF(1, "OSC:%c:%s", vt->osc_cmd, vt->osc_textbuf);
 778             vt->tty_state = ESnormal;
 779         }
 780         break;
 781     case ESpalette:
 782         if ((ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'F')
 783             || (ch >= 'a' && ch <= 'f')) {
 784             vt->esc_buf[vt->esc_count++] = (ch > '9' ? (ch & 0xDF) - 'A' + 10 : ch - '0');
 785             if (vt->esc_count == 7) {
 786                 // fixme: this does not work - please test
 787                 /*
 788                   rfbColourMap *cmap =&vt->screen->colourMap;
 789
 790                   int i = color_table[vt->esc_buf[0]] * 3, j = 1;
 791                   cmap->data.bytes[i] = 16 * vt->esc_buf[j++];
 792                   cmap->data.bytes[i++] += vt->esc_buf[j++];
 793                   cmap->data.bytes[i] = 16 * vt->esc_buf[j++];
 794                   cmap->data.bytes[i++] += vt->esc_buf[j++];
 795                   cmap->data.bytes[i] = 16 * vt->esc_buf[j++];
 796                   cmap->data.bytes[i] += vt->esc_buf[j];
 797                 */
 798                 //set_palette(vc); ?
 799
 800                 vt->tty_state = ESnormal;
 801             }
 802         } else
 803             vt->tty_state = ESnormal;
 804         break;
 805     case ESsquare:
 806         for(i = 0; i < MAX_ESC_PARAMS; i++) {
 807             vt->esc_buf[i] = 0;
 808         }
 809
 810         vt->esc_count = 0;
 811         vt->esc_has_par = 0;
 812         vt->tty_state = ESgetpars;
 813
 814         if (ch == '>') {
 815             vt->tty_state = ESidquery;
 816             break;
 817         }
 818
 819         if ((vt->esc_ques = (ch == '?'))) {
 820             break;
 821         }
 822     case ESgetpars:
 823         if (ch >= '0' && ch <= '9') {
 824             vt->esc_has_par = 1;
 825             if (vt->esc_count < MAX_ESC_PARAMS) {
 826                 vt->esc_buf[vt->esc_count] = vt->esc_buf[vt->esc_count] * 10 + ch - '0';
 827             }
 828             break;
 829         } else if (ch == ';') {
 830             vt->esc_count++;
 831             break;
 832         } else {
 833             if (vt->esc_has_par) {
 834                 vt->esc_count++;
 835             }
 836             vt->tty_state = ESgotpars;
 837         }
 838     case ESgotpars:
 839
 840         vt->tty_state = ESnormal;
 841
 842         char *qes = vt->esc_ques ? "?" : "";
 843
 844         if (debug) {
 845             debug_print_escape_buffer(vt, __func__, "", qes, ch);
 846         }
 847
 848         switch (ch) {
 849         case 'h':
 850             spiceterm_set_mode(vt, 1);
 851             break;
 852         case 'l':
 853             spiceterm_set_mode(vt, 0);
 854             break;
 855         case 'm':
 856             if (!vt->esc_count) {
 857                 vt->esc_count++; // default parameter 0
 858             }
 859             spiceterm_csi_m(vt);
 860             break;
 861         case 'n':
 862             /* report cursor position */
 863             /* TODO: send ESC[row;colR */
 864             break;
 865         case 'A':
 866             /* move cursor up */
 867             if (vt->esc_buf[0] == 0) {
 868                 vt->esc_buf[0] = 1;
 869             }
 870             vt->cy -= vt->esc_buf[0];
 871             if (vt->cy < 0) {
 872                 vt->cy = 0;
 873             }
 874             break;
 875         case 'B':
 876         case 'e':
 877             /* move cursor down */
 878             if (vt->esc_buf[0] == 0) {
 879                 vt->esc_buf[0] = 1;
 880             }
 881             vt->cy += vt->esc_buf[0];
 882             if (vt->cy >= vt->height) {
 883                 vt->cy = vt->height - 1;
 884             }
 885             break;
 886         case 'C':
 887         case 'a':
 888             /* move cursor right */
 889             if (vt->esc_buf[0] == 0) {
 890                 vt->esc_buf[0] = 1;
 891             }
 892             vt->cx += vt->esc_buf[0];
 893             if (vt->cx >= vt->width) {
 894                 vt->cx = vt->width - 1;
 895             }
 896             break;
 897         case 'D':
 898             /* move cursor left */
 899             if (vt->esc_buf[0] == 0) {
 900                 vt->esc_buf[0] = 1;
 901             }
 902             vt->cx -= vt->esc_buf[0];
 903             if (vt->cx < 0) {
 904                 vt->cx = 0;
 905             }
 906             break;
 907         case 'G':
 908         case '`':
 909             /* move cursor to column */
 910             spiceterm_gotoxy(vt, vt->esc_buf[0] - 1, vt->cy);
 911             break;
 912         case 'd':
 913             /* move cursor to row */
 914             spiceterm_gotoxy(vt, vt->cx , vt->esc_buf[0] - 1);
 915             break;
 916         case 'f':
 917         case 'H':
 918             /* move cursor to row, column */
 919             spiceterm_gotoxy(vt, vt->esc_buf[1] - 1,  vt->esc_buf[0] - 1);
 920             break;
 921         case 'J':
 922             switch (vt->esc_buf[0]) {
 923             case 0:
 924                 /* clear to end of screen */
 925                 for (y = vt->cy; y < vt->height; y++) {
 926                     for (x = 0; x < vt->width; x++) {
 927                         if (y == vt->cy && x < vt->cx) {
 928                             continue;
 929                         }
 930                         spiceterm_clear_xy (vt, x, y);
 931                     }
 932                 }
 933                 break;
 934             case 1:
 935                 /* clear from beginning of screen */
 936                 for (y = 0; y <= vt->cy; y++) {
 937                     for (x = 0; x < vt->width; x++) {
 938                         if (y == vt->cy && x > vt->cx) {
 939                             break;
 940                         }
 941                         spiceterm_clear_xy(vt, x, y);
 942                     }
 943                 }
 944                 break;
 945             case 2:
 946                 /* clear entire screen */
 947                 spiceterm_clear_screen(vt);
 948                 break;
 949             }
 950             break;
 951         case 'K':
 952             switch (vt->esc_buf[0]) {
 953             case 0:
 954                 /* clear to eol */
 955                 for(x = vt->cx; x < vt->width; x++) {
 956                     spiceterm_clear_xy(vt, x, vt->cy);
 957                 }
 958                 break;
 959             case 1:
 960                 /* clear from beginning of line */
 961                 for (x = 0; x <= vt->cx; x++) {
 962                     spiceterm_clear_xy(vt, x, vt->cy);
 963                 }
 964                 break;
 965             case 2:
 966                 /* clear entire line */
 967                 for(x = 0; x < vt->width; x++) {
 968                     spiceterm_clear_xy(vt, x, vt->cy);
 969                 }
 970                 break;
 971             }
 972             break;
 973         case 'L':
 974             /* insert line */
 975             c = vt->esc_buf[0];
 976
 977             if (c > vt->height - vt->cy)
 978                 c = vt->height - vt->cy;
 979             else if (!c)
 980                 c = 1;
 981
 982             spiceterm_scroll_down(vt, vt->cy, vt->region_bottom, c);
 983             break;
 984         case 'M':
 985             /* delete line */
 986             c = vt->esc_buf[0];
 987
 988             if (c > vt->height - vt->cy)
 989                 c = vt->height - vt->cy;
 990             else if (!c)
 991                 c = 1;
 992
 993             spiceterm_scroll_up(vt, vt->cy, vt->region_bottom, c, 1);
 994             break;
 995         case 'T':
 996             /* scroll down */
 997             c = vt->esc_buf[0];
 998             if (!c) c = 1;
 999             spiceterm_scroll_down(vt, vt->region_top, vt->region_bottom, c);
1000             break;
1001         case 'S':
1002             /* scroll up */
1003             c = vt->esc_buf[0];
1004             if (!c) c = 1;
1005             spiceterm_scroll_up(vt, vt->region_top, vt->region_bottom, c, 1);
1006             break;
1007         case 'P':
1008             /* delete c character */
1009             c = vt->esc_buf[0];
1010
1011             if (c > vt->width - vt->cx)
1012                 c = vt->width - vt->cx;
1013             else if (!c)
1014                 c = 1;
1015
1016             for (x = vt->cx; x < vt->width - c; x++) {
1017                 int y1 = (vt->y_base + vt->cy) % vt->total_height;
1018                 TextCell *dst = &vt->cells[y1 * vt->width + x];
1019                 TextCell *src = dst + c;
1020                 *dst = *src;
1021                 spiceterm_update_xy(vt, x + c, vt->cy);
1022                 src->ch = ' ';
1023                 src->attrib = vt->default_attrib;
1024                 spiceterm_update_xy(vt, x, vt->cy);
1025             }
1026             break;
1027         case 's':
1028             /* save cursor position */
1029             spiceterm_save_cursor(vt);
1030             break;
1031         case 'u':
1032             /* restore cursor position */
1033             spiceterm_restore_cursor(vt);
1034             break;
1035         case 'X':
1036             /* erase c characters */
1037             c = vt->esc_buf[0];
1038             if (!c) c = 1;
1039
1040             if (c > (vt->width - vt->cx)) c = vt->width - vt->cx;
1041
1042             for(i = 0; i < c; i++) {
1043                 spiceterm_clear_xy(vt, vt->cx + i, vt->cy);
1044             }
1045             break;
1046         case '@':
1047             /* insert c character */
1048             c = vt->esc_buf[0];
1049             if (c > (vt->width - vt->cx)) {
1050                 c = vt->width - vt->cx;
1051             }
1052             if (!c) c = 1;
1053
1054             for (x = vt->width - c; x >= vt->cx; x--) {
1055                 int y1 = (vt->y_base + vt->cy) % vt->total_height;
1056                 TextCell *src = &vt->cells[y1 * vt->width + x];
1057                 TextCell *dst = src + c;
1058                 *dst = *src;
1059                 spiceterm_update_xy (vt, x + c, vt->cy);
1060                 src->ch = ' ';
1061                 src->attrib = vt->cur_attrib;
1062                 spiceterm_update_xy(vt, x, vt->cy);
1063             }
1064
1065             break;
1066         case 'r':
1067             /* set region */
1068             if (!vt->esc_buf[0])
1069                 vt->esc_buf[0]++;
1070             if (!vt->esc_buf[1])
1071                 vt->esc_buf[1] = vt->height;
1072             /* Minimum allowed region is 2 lines */
1073             if (vt->esc_buf[0] < vt->esc_buf[1] &&
1074                 vt->esc_buf[1] <= vt->height) {
1075                 vt->region_top = vt->esc_buf[0] - 1;
1076                 vt->region_bottom = vt->esc_buf[1];
1077                 vt->cx = 0;
1078                 vt->cy = vt->region_top;
1079                 DPRINTF(1, "set region %d %d", vt->region_top, vt->region_bottom);
1080             }
1081
1082             break;
1083         default:
1084             if (debug) {
1085                 debug_print_escape_buffer(vt, __func__, " unhandled escape", qes, ch);
1086             }
1087             break;
1088         }
1089         vt->esc_ques = 0;
1090         break;
1091     case ESsetG0: // Set G0
1092         vt->tty_state = ESnormal;
1093
1094         if (ch == '0')
1095             vt->g0enc = GRAF_MAP;
1096         else if (ch == 'B')
1097             vt->g0enc = LAT1_MAP;
1098         else if (ch == 'U')
1099             vt->g0enc = IBMPC_MAP;
1100         else if (ch == 'K')
1101             vt->g0enc = USER_MAP;
1102
1103         if (vt->charset == 0)
1104             vt->cur_enc = vt->g0enc;
1105
1106         break;
1107     case ESsetG1: // Set G1
1108         vt->tty_state = ESnormal;
1109
1110         if (ch == '0')
1111             vt->g1enc = GRAF_MAP;
1112         else if (ch == 'B')
1113             vt->g1enc = LAT1_MAP;
1114         else if (ch == 'U')
1115             vt->g1enc = IBMPC_MAP;
1116         else if (ch == 'K')
1117             vt->g1enc = USER_MAP;
1118
1119         if (vt->charset == 1)
1120             vt->cur_enc = vt->g1enc;
1121
1122         break;
1123     case ESidquery: // vt100 query id
1124         vt->tty_state = ESnormal;
1125
1126         if (ch == 'c') {
1127             DPRINTF(1, "ESC[>c   Query term ID");
1128             spiceterm_respond_esc(vt, TERMIDCODE);
1129          }
1130         break;
1131     case ESpercent:
1132         vt->tty_state = ESnormal;
1133         switch (ch) {
1134         case '@':  /* defined in ISO 2022 */
1135             vt->utf8 = 0;
1136             break;
1137         case 'G':  /* prelim official escape code */
1138         case '8':  /* retained for compatibility */
1139             vt->utf8 = 1;
1140             break;
1141         }
1142         break;
1143     default: // ESnormal
1144         vt->tty_state = ESnormal;
1145
1146         switch(ch) {
1147         case 0:
1148             break;
1149         case 7:  /* alert aka. bell */
1150             // fixme:
1151             //rfbSendBell(vt->screen);
1152             break;
1153         case 8:  /* backspace */
1154             if (vt->cx > 0)
1155                 vt->cx--;
1156             break;
1157         case 9:  /* tabspace */
1158             if (vt->cx + (8 - (vt->cx % 8)) > vt->width) {
1159                 vt->cx = 0;
1160                 spiceterm_put_lf(vt);
1161             } else {
1162                 vt->cx = vt->cx + (8 - (vt->cx % 8));
1163             }
1164             break;
1165         case 10:  /* LF,*/
1166         case 11:  /* VT */
1167         case 12:  /* FF */
1168             spiceterm_put_lf(vt);
1169             break;
1170         case 13:  /* carriage return */
1171             vt->cx = 0;
1172             break;
1173         case 14:
1174             /* SI (shift in), select character set 1 */
1175             vt->charset = 1;
1176             vt->cur_enc = vt->g1enc;
1177             /* fixme: display controls = 1 */
1178             break;
1179         case 15:
1180             /* SO (shift out), select character set 0 */
1181             vt->charset = 0;
1182             vt->cur_enc = vt->g0enc;
1183             /* fixme: display controls = 0 */
1184             break;
1185         case 27:    /* esc */
1186             vt->tty_state = ESesc;
1187             break;
1188         case 127: /* delete */
1189             /* ignore */
1190             break;
1191         case 128+27:    /* csi */
1192             vt->tty_state = ESsquare;
1193             break;
1194         default:
1195             if (vt->cx >= vt->width) {
1196                 /* line wrap */
1197                 vt->cx = 0;
1198                 spiceterm_put_lf(vt);
1199             }
1200
1201             int y1 = (vt->y_base + vt->cy) % vt->total_height;
1202             TextCell *c = &vt->cells[y1*vt->width + vt->cx];
1203             c->attrib = vt->cur_attrib;
1204             c->ch = ch;
1205             spiceterm_update_xy(vt, vt->cx, vt->cy);
1206             vt->cx++;
1207             break;
1208         }
1209         break;
1210     }
1211 }
1212
1213 static int
1214 spiceterm_puts(spiceTerm *vt, const char *buf, int len)
1215 {
1216     gunichar2 tc;
1217
1218     spiceterm_show_cursor(vt, 0);
1219
1220     while (len) {
1221         unsigned char c = *buf;
1222         len--;
1223         buf++;
1224
1225         if (vt->tty_state != ESnormal) {
1226             // never translate escape sequence
1227             tc = c;
1228         } else if (vt->utf8 && !vt->cur_enc) {
1229
1230             if(c & 0x80) { // utf8 multi-byte sequence
1231
1232                 if (vt->utf_count > 0 && (c & 0xc0) == 0x80) {
1233                     // inside UTF8 sequence
1234                     vt->utf_char = (vt->utf_char << 6) | (c & 0x3f);
1235                     vt->utf_count--;
1236                     if (vt->utf_count == 0) {
1237                         tc = vt->utf_char;
1238                     } else {
1239                         continue;
1240                     }
1241                 } else {
1242                     //  first char of a UTF8 sequence
1243                     if ((c & 0xe0) == 0xc0) {
1244                         vt->utf_count = 1;
1245                         vt->utf_char = (c & 0x1f);
1246                     } else if ((c & 0xf0) == 0xe0) {
1247                         vt->utf_count = 2;
1248                         vt->utf_char = (c & 0x0f);
1249                     } else if ((c & 0xf8) == 0xf0) {
1250                         vt->utf_count = 3;
1251                         vt->utf_char = (c & 0x07);
1252                     } else if ((c & 0xfc) == 0xf8) {
1253                         vt->utf_count = 4;
1254                         vt->utf_char = (c & 0x03);
1255                     } else if ((c & 0xfe) == 0xfc) {
1256                         vt->utf_count = 5;
1257                         vt->utf_char = (c & 0x01);
1258                     } else
1259                         vt->utf_count = 0;
1260
1261                     continue;
1262                 }
1263             } else {
1264                 // utf8 single byte
1265                 tc = c;
1266                 vt->utf_count = 0;
1267             }
1268
1269         } else {
1270             // never translate controls
1271             if (c >= 32 && c != 127 && c != (128+27)) {
1272                 tc = translations[vt->cur_enc][c & 0x0ff];
1273             } else {
1274                 tc = c;
1275             }
1276         }
1277
1278         spiceterm_putchar(vt, tc);
1279     }
1280
1281     spiceterm_show_cursor(vt, 1);
1282
1283     return len;
1284 }
1285
1286 void
1287 spiceterm_update_watch_mask(spiceTerm *vt, gboolean writable)
1288 {
1289     g_assert(vt != NULL);
1290
1291     int mask = SPICE_WATCH_EVENT_READ;
1292
1293     if (writable) {
1294         mask |= SPICE_WATCH_EVENT_WRITE;
1295     }
1296
1297     vt->screen->core->watch_update_mask(vt->screen->mwatch, mask);
1298 }
1299
1300 static void
1301 mouse_report(spiceTerm *vt, int butt, int mrx, int mry)
1302 {
1303     char buf[8];
1304
1305     sprintf(buf, "[M%c%c%c", (char)(' ' + butt), (char)('!' + mrx),
1306              (char)('!' + mry));
1307
1308     spiceterm_respond_esc(vt, buf);
1309
1310     spiceterm_update_watch_mask(vt, TRUE);
1311 }
1312
1313 static void
1314 spiceterm_respond_unichar2(spiceTerm *vt, gunichar2 uc)
1315 {
1316     if (vt->utf8) {
1317         gchar buf[10];
1318         gint len = g_unichar_to_utf8(uc, buf);
1319
1320         if (len > 0) {
1321             spiceterm_respond_data(vt, len, (uint8_t *)buf);
1322         }
1323     } else {
1324         uint8_t buf[1] = { (uint8_t)uc };
1325         spiceterm_respond_data(vt, 1, buf);
1326     }
1327 }
1328
1329 void
1330 spiceterm_clear_selection(spiceTerm *vt)
1331 {
1332     DPRINTF(1, "mark_active = %d", vt->mark_active);
1333
1334     vt->mark_active = 0;
1335     if (vt->selection) free (vt->selection);
1336     vt->selection = NULL;
1337
1338     spiceterm_unselect_all(vt);
1339 }
1340
1341 void
1342 spiceterm_motion_event(spiceTerm *vt, uint32_t x, uint32_t y, uint32_t buttons)
1343 {
1344     DPRINTF(1, "mask=%08x x=%d y=%d", buttons, x ,y);
1345
1346     static int last_mask = 0;
1347     static int sel_start_pos = 0;
1348     static int sel_end_pos = 0;
1349     static int button2_released = 1;
1350
1351     int i;
1352     int cx = x/8;
1353     int cy = y/16;
1354
1355     if (cx < 0) cx = 0;
1356     if (cx >= vt->width) cx = vt->width - 1;
1357     if (cy < 0) cy = 0;
1358     if (cy >= vt->height) cy = vt->height - 1;
1359
1360     if (vt->report_mouse && buttons != last_mask) {
1361         last_mask = buttons;
1362         if (buttons & 2) {
1363             mouse_report(vt, 0, cx, cy);
1364         }
1365         if (buttons & 4) {
1366             mouse_report (vt, 1, cx, cy);
1367         }
1368         if (buttons & 8) {
1369             mouse_report(vt, 2, cx, cy);
1370         }
1371         if(!buttons) {
1372             mouse_report(vt, 3, cx, cy);
1373         }
1374     }
1375
1376     if (buttons & 4) {
1377
1378         if(button2_released) {
1379
1380             if (vdagent_owns_clipboard(vt)) {
1381                 if (vt->selection) {
1382                     int i;
1383                     for(i = 0; i < vt->selection_len; i++) {
1384                         spiceterm_respond_unichar2(vt, vt->selection[i]);
1385                     }
1386                     spiceterm_update_watch_mask(vt, TRUE);
1387                     if (vt->y_displ != vt->y_base) {
1388                         vt->y_displ = vt->y_base;
1389                         spiceterm_refresh(vt);
1390                     }
1391                 }
1392             } else {
1393                 vdagent_request_clipboard(vt);
1394             }
1395         }
1396
1397         button2_released = 0;
1398     } else {
1399         button2_released = 1;
1400     }
1401
1402     if (buttons & 2) {
1403         int pos = cy*vt->width + cx;
1404
1405         // code borrowed from libvncserver (VNCconsole.c)
1406
1407         if (!vt->mark_active) {
1408
1409             spiceterm_unselect_all(vt);
1410
1411             vt->mark_active = 1;
1412             sel_start_pos = sel_end_pos = pos;
1413             spiceterm_toggle_marked_cell(vt, pos);
1414
1415         } else {
1416
1417             if (pos != sel_end_pos) {
1418                 if (pos > sel_end_pos) {
1419                     cx = sel_end_pos; cy=pos;
1420                 } else {
1421                     cx=pos; cy=sel_end_pos;
1422                 }
1423
1424                 if (cx < sel_start_pos) {
1425                     if (cy < sel_start_pos) cy--;
1426                 } else {
1427                     cx++;
1428                 }
1429
1430                 while (cx <= cy) {
1431                     spiceterm_toggle_marked_cell(vt, cx);
1432                     cx++;
1433                 }
1434
1435                 sel_end_pos = pos;
1436             }
1437         }
1438
1439     } else if (vt->mark_active) {
1440         vt->mark_active = 0;
1441
1442         if (sel_start_pos > sel_end_pos) {
1443             int tmp = sel_start_pos - 1;
1444             sel_start_pos = sel_end_pos;
1445             sel_end_pos = tmp;
1446         }
1447
1448         int len = sel_end_pos - sel_start_pos + 1;
1449
1450         if (vt->selection) free (vt->selection);
1451         vt->selection = (gunichar2 *)malloc (len*sizeof(gunichar2));
1452         vt->selection_len = len;
1453
1454         for (i = 0; i < len; i++) {
1455             int pos = sel_start_pos + i;
1456             int x = pos % vt->width;
1457             int y1 = ((pos / vt->width) + vt->y_displ) % vt->total_height;
1458             TextCell *c = &vt->cells[y1*vt->width + x];
1459             vt->selection[i] = c->ch;
1460             c++;
1461         }
1462
1463         DPRINTF(1, "selection length = %d", vt->selection_len);
1464
1465         vdagent_grab_clipboard(vt);
1466     }
1467 }
1468
1469 void
1470 init_spiceterm(spiceTerm *vt, uint32_t width, uint32_t height)
1471 {
1472     int i;
1473
1474     g_assert(vt != NULL);
1475     g_assert(vt->screen != NULL);
1476
1477     vt->width = width / 8;
1478     vt->height = height / 16;
1479
1480     vt->total_height = vt->height * 20;
1481     vt->scroll_height = 0;
1482     vt->y_base =  0;
1483     vt->y_displ =  0;
1484
1485     vt->region_top = 0;
1486     vt->region_bottom = vt->height;
1487
1488     vt->g0enc = LAT1_MAP;
1489     vt->g1enc = GRAF_MAP;
1490     vt->cur_enc = vt->g0enc;
1491     vt->charset = 0;
1492
1493     /* default text attributes */
1494     vt->default_attrib.bold = 0;
1495     vt->default_attrib.uline = 0;
1496     vt->default_attrib.blink = 0;
1497     vt->default_attrib.invers = 0;
1498     vt->default_attrib.unvisible = 0;
1499     vt->default_attrib.fgcol = 7;
1500     vt->default_attrib.bgcol = 0;
1501
1502     vt->cur_attrib = vt->default_attrib;
1503
1504     if (vt->cells) {
1505         vt->cx = 0;
1506         vt->cy = 0;
1507         vt->cx_saved = 0;
1508         vt->cy_saved = 0;
1509         g_free(vt->cells);
1510     }
1511
1512     vt->cells = (TextCell *)calloc (sizeof (TextCell), vt->width*vt->total_height);
1513
1514     for (i = 0; i < vt->width*vt->total_height; i++) {
1515         vt->cells[i].ch = ' ';
1516         vt->cells[i].attrib = vt->default_attrib;
1517     }
1518
1519     if (vt->altcells) {
1520         g_free(vt->altcells);
1521     }
1522
1523     vt->altcells = (TextCell *)calloc (sizeof (TextCell), vt->width*vt->height);
1524 }
1525
1526 void
1527 spiceterm_resize(spiceTerm *vt, uint32_t width, uint32_t height)
1528 {
1529     width = (width/8)*8;
1530     height = (height/16)*16;
1531
1532     if (vt->screen->width == width && vt->screen->height == height) {
1533         return;
1534     }
1535
1536     DPRINTF(0, "width=%u height=%u", width, height);
1537
1538     spice_screen_resize(vt->screen, width, height);
1539
1540     init_spiceterm(vt, width, height);
1541
1542     struct winsize dimensions;
1543     dimensions.ws_col = vt->width;
1544     dimensions.ws_row = vt->height;
1545
1546     ioctl(vt->pty, TIOCSWINSZ, &dimensions);
1547 }
1548
1549 static gboolean
1550 master_error_callback(GIOChannel *channel, GIOCondition condition,
1551                       gpointer data)
1552 {
1553     //spiceTerm *vt = (spiceTerm *)data;
1554
1555     DPRINTF(1, "condition %d", condition);
1556
1557     exit(0);
1558
1559     return FALSE;
1560 }
1561
1562 static void
1563 master_watch(int master, int event, void *opaque)
1564 {
1565     spiceTerm *vt = (spiceTerm *)opaque;
1566     int c;
1567
1568     // fixme: if (!vt->mark_active) {
1569
1570     if (event == SPICE_WATCH_EVENT_READ) {
1571         char buffer[1024];
1572         while ((c = read(master, buffer, 1024)) == -1) {
1573             if (errno != EAGAIN) break;
1574         }
1575         if (c == -1) {
1576             perror("master pipe read error"); // fixme
1577         }
1578         spiceterm_puts (vt, buffer, c);
1579     } else {
1580         if (vt->ibuf_count > 0) {
1581             DPRINTF(1, "write input %x %d", vt->ibuf[0], vt->ibuf_count);
1582             if ((c = write (master, vt->ibuf, vt->ibuf_count)) >= 0) {
1583                 if (c == vt->ibuf_count) {
1584                     vt->ibuf_count = 0;
1585                 } else if (c > 0) {
1586                     // not all data written
1587                     memmove(vt->ibuf, vt->ibuf + c, vt->ibuf_count - c);
1588                     vt->ibuf_count -= c;
1589                 } else {
1590                     // nothing written -ignore and try later
1591                 }
1592             } else {
1593                 perror("master pipe write error");
1594             }
1595         }
1596         if (vt->ibuf_count == 0) {
1597             spiceterm_update_watch_mask(vt, FALSE);
1598         }
1599     }
1600 }
1601
1602 static void
1603 spiceterm_print_usage(const char *msg)
1604 {
1605     if (msg) {
1606         fprintf(stderr, "ERROR: %s\n", msg);
1607     }
1608     fprintf(stderr, "USAGE: spiceterm [OPTIONS] [-- command [args]]\n");
1609     fprintf(stderr, "  --timeout <seconds>  Wait this time before aborting (default is 10 seconds)\n");
1610     fprintf(stderr, "  --authpath <path>    Authentication path  (PVE AUTH)\n");
1611     fprintf(stderr, "  --permission <perm>  Required permissions (PVE AUTH)\n");
1612     fprintf(stderr, "  --port <port>        Bind to port <port>\n");
1613     fprintf(stderr, "  --addr <addr>        Bind to address <addr>\n");
1614     fprintf(stderr, "  --sasl               Enable SASL based authentication\n");
1615     fprintf(stderr, "  --noauth             Disable authentication\n");
1616 }
1617
1618 int
1619 main (int argc, char** argv)
1620 {
1621     int c;
1622     char **cmdargv = NULL;
1623     char *command = "/bin/bash"; // execute normal shell as default
1624     int pid;
1625     int master;
1626     char ptyname[1024];
1627     struct winsize dimensions;
1628     SpiceTermOptions opts = {
1629         .timeout = 10,
1630         .port = 5900,
1631         .addr = NULL,
1632         .noauth = FALSE,
1633         .sasl = FALSE,
1634     };
1635
1636     g_thread_init(NULL);
1637
1638     static struct option long_options[] = {
1639         { "timeout", required_argument, 0,  't' },
1640         { "authpath", required_argument, 0, 'A' },
1641         { "permissions", required_argument, 0, 'P' },
1642         { "port", required_argument, 0, 'p' },
1643         { "addr", required_argument, 0, 'a' },
1644         { "noauth", no_argument, 0, 'n' },
1645         { "sasl", no_argument, 0, 's' },
1646         { NULL, 0, 0, 0 },
1647     };
1648
1649     while ((c = getopt_long(argc, argv, "nst:a:p:P:", long_options, NULL)) != -1) {
1650
1651         switch (c) {
1652         case 'n':
1653             opts.noauth = TRUE;
1654             break;
1655         case 's':
1656             opts.sasl = TRUE;
1657             break;
1658         case 'A':
1659             pve_auth_set_path(optarg);
1660             break;
1661         case 'P':
1662             pve_auth_set_permissions(optarg);
1663             break;
1664         case 'p':
1665             opts.port = atoi(optarg);
1666             break;
1667          case 'a':
1668             opts.addr = optarg;
1669             break;
1670         case 't':
1671             opts.timeout = atoi(optarg);
1672             break;
1673         case '?':
1674             spiceterm_print_usage(NULL);
1675             exit(-1);
1676             break;
1677         default:
1678             spiceterm_print_usage("getopt returned unknown character code");
1679             exit(-1);
1680         }
1681     }
1682
1683     if (optind < argc) {
1684         command = argv[optind+1];
1685         cmdargv = &argv[optind+1];
1686     }
1687
1688     spiceTerm *vt = spiceterm_create(744, 400, &opts);
1689
1690     setlocale(LC_ALL, ""); // set from environment
1691
1692     char *ctype = setlocale (LC_CTYPE, NULL); // query LC_CTYPE
1693
1694     // fixme: ist there a standard way to detect utf8 mode ?
1695     if (strcasestr (ctype, ".utf-8")||strcasestr (ctype, ".utf8")) {
1696         vt->utf8 = 1;
1697     }
1698
1699     dimensions.ws_col = vt->width;
1700     dimensions.ws_row = vt->height;
1701
1702     setenv("TERM", TERM, 1);
1703
1704     DPRINTF(1, "execute %s", command);
1705
1706     pid = forkpty (&master, ptyname, NULL, &dimensions);
1707     if(!pid) {
1708
1709         // install default signal handlers
1710         signal (SIGQUIT, SIG_DFL);
1711         signal (SIGTERM, SIG_DFL);
1712         signal (SIGINT, SIG_DFL);
1713
1714         if (cmdargv) {
1715             execvp (command, cmdargv);
1716         } else {
1717             execlp (command, command, NULL);
1718         }
1719         perror ("Error: exec failed\n");
1720         exit (-1); // should not be reached
1721     } else if (pid == -1) {
1722         perror ("Error: fork failed\n");
1723         exit (-1);
1724     }
1725
1726     vt->pty = master;
1727
1728     /* watch for errors - we need to use glib directly because spice
1729      * does not have SPICE_WATCH_EVENT for this */
1730     GIOChannel *channel = g_io_channel_unix_new(master);
1731     g_io_channel_set_flags(channel, G_IO_FLAG_NONBLOCK, NULL);
1732     g_io_channel_set_encoding(channel, NULL, NULL);
1733     g_io_add_watch(channel, G_IO_ERR|G_IO_HUP, master_error_callback, vt);
1734
1735     vt->screen->mwatch = vt->screen->core->watch_add(
1736         master, SPICE_WATCH_EVENT_READ /* |SPICE_WATCH_EVENT_WRITE */,
1737         master_watch, vt);
1738
1739     basic_event_loop_mainloop();
1740
1741     kill (pid, 9);
1742     int status;
1743     waitpid(pid, &status, 0);
1744
1745     exit (0);
1746 }