]> git.proxmox.com Git - spiceterm.git/blob - spiceterm.c
projects / spiceterm.git / blob
? search:


49612da0ba49ddaae98d57e96ca95749d0ea789a
[spiceterm.git] / 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
45 #include "spiceterm.h"
46
47 #include <glib.h>
48 #include <spice.h>
49 #include <spice/enums.h>
50 #include <spice/macros.h>
51 #include <spice/qxl_dev.h>
52
53 #include <gdk/gdkkeysyms.h>
54
55 #include "event_loop.h"
56 #include "translations.h"
57
58 static int debug = 0;
59
60 #define DPRINTF(x, format, ...) { \
61 if (x <= debug) { \
62 printf("%s: " format "\n" , __FUNCTION__, ## __VA_ARGS__); \
63 } \
64 }
65
66 #define TERM "xterm"
67
68 #define TERMIDCODE "[?1;2c" // vt100 ID
69
70 #define CHECK_ARGC(argc,argv,i) if (i >= argc-1) { \
71 fprintf(stderr, "ERROR: not enough arguments for: %s\n", argv[i]); \
72 print_usage(NULL); \
73 exit(1); \
74 }
75
76 /* these colours are from linux kernel drivers/char/vt.c */
77
78 unsigned char color_table[] = { 0, 4, 2, 6, 1, 5, 3, 7,
79 8,12,10,14, 9,13,11,15 };
80
81
82 static void spiceterm_resize(spiceTerm *vt, uint32_t width, uint32_t height);
83
84 static void vdagent_grab_clipboard(spiceTerm *vt, uint8_t selection);
85 static void vdagent_request_clipboard(spiceTerm *vt, uint8_t selection);
86
87 static void
88 print_usage(const char *msg)
89 {
90 if (msg) { fprintf(stderr, "ERROR: %s\n", msg); }
91 fprintf(stderr, "USAGE: spiceterm [spiceopts] [-c command [args]]\n");
92 }
93
94 static void
95 draw_char_at(spiceTerm *vt, int x, int y, gunichar2 ch, TextAttributes attrib)
96 {
97 if (x < 0 || y < 0 || x >= vt->width || y >= vt->height) {
98 return;
99 }
100
101 spice_screen_draw_char(vt->screen, x, y, ch, attrib);
102 }
103
104 static void
105 spiceterm_update_xy(spiceTerm *vt, int x, int y)
106 {
107 if (x < 0 || y < 0 || x >= vt->width || y >= vt->height) { return; }
108
109 int y1 = (vt->y_base + y) % vt->total_height;
110 int y2 = y1 - vt->y_displ;
111 if (y2 < 0) {
112 y2 += vt->total_height;
113 }
114 if (y2 < vt->height) {
115 TextCell *c = &vt->cells[y1 * vt->width + x];
116 draw_char_at(vt, x, y2, c->ch, c->attrib);
117 }
118 }
119
120 static void
121 spiceterm_clear_xy(spiceTerm *vt, int x, int y)
122 {
123 if (x < 0 || y < 0 || x >= vt->width || y >= vt->height) { return; }
124
125 int y1 = (vt->y_base + y) % vt->total_height;
126 int y2 = y1 - vt->y_displ;
127 if (y2 < 0) {
128 y2 += vt->total_height;
129 }
130 if (y2 < vt->height) {
131 TextCell *c = &vt->cells[y1 * vt->width + x];
132 c->ch = ' ';
133 c->attrib = vt->default_attrib;
134 c->attrib.fgcol = vt->cur_attrib.fgcol;
135 c->attrib.bgcol = vt->cur_attrib.bgcol;
136
137 draw_char_at(vt, x, y, c->ch, c->attrib);
138 }
139 }
140
141 void
142 spiceterm_toggle_marked_cell(spiceTerm *vt, int pos)
143 {
144 int x = (pos%vt->width);
145 int y = (pos/vt->width);
146
147 if (x < 0 || y < 0 || x >= vt->width || y >= vt->height) { return; }
148
149 int y1 = (vt->y_displ + y) % vt->total_height;
150
151 TextCell *c = &vt->cells[y1 * vt->width + x];
152 c->attrib.selected = c->attrib.selected ? 0 : 1;
153
154 if (y < vt->height) {
155 draw_char_at(vt, x, y, c->ch, c->attrib);
156 }
157 }
158
159 static void
160 spiceterm_show_cursor(spiceTerm *vt, int show)
161 {
162 int x = vt->cx;
163 if (x >= vt->width) {
164 x = vt->width - 1;
165 }
166
167 int y1 = (vt->y_base + vt->cy) % vt->total_height;
168 int y = y1 - vt->y_displ;
169 if (y < 0) {
170 y += vt->total_height;
171 }
172
173 if (y < vt->height) {
174
175 TextCell *c = &vt->cells[y1 * vt->width + x];
176
177 if (show) {
178 TextAttributes attrib = vt->default_attrib;
179 attrib.invers = !(attrib.invers); /* invert fg and bg */
180 draw_char_at(vt, x, y, c->ch, attrib);
181 } else {
182 draw_char_at(vt, x, y, c->ch, c->attrib);
183 }
184 }
185 }
186
187 static void
188 spiceterm_refresh(spiceTerm *vt)
189 {
190 int x, y, y1;
191
192 y1 = vt->y_displ;
193 for(y = 0; y < vt->height; y++) {
194 TextCell *c = vt->cells + y1 * vt->width;
195 for(x = 0; x < vt->width; x++) {
196 draw_char_at(vt, x, y, c->ch, c->attrib);
197 c++;
198 }
199 if (++y1 == vt->total_height)
200 y1 = 0;
201 }
202
203 spiceterm_show_cursor(vt, 1);
204 }
205
206 static void
207 spiceterm_clear_screen(spiceTerm *vt)
208 {
209 int x, y;
210
211 for (y = 0; y <= vt->height; y++) {
212 int y1 = (vt->y_base + y) % vt->total_height;
213 TextCell *c = &vt->cells[y1 * vt->width];
214 for (x = 0; x < vt->width; x++) {
215 c->ch = ' ';
216 c->attrib = vt->default_attrib;
217 c->attrib.fgcol = vt->cur_attrib.fgcol;
218 c->attrib.bgcol = vt->cur_attrib.bgcol;
219
220 c++;
221 }
222 }
223
224 spice_screen_clear(vt->screen, 0, 0, vt->screen->primary_width,
225 vt->screen->primary_height);
226 }
227
228 void
229 spiceterm_unselect_all(spiceTerm *vt)
230 {
231 int x, y, y1;
232
233 y1 = vt->y_displ;
234 for(y = 0; y < vt->total_height; y++) {
235 TextCell *c = vt->cells + y1 * vt->width;
236 for(x = 0; x < vt->width; x++) {
237 if (c->attrib.selected) {
238 c->attrib.selected = 0;
239 if (y < vt->height) {
240 draw_char_at(vt, x, y, c->ch, c->attrib);
241 }
242 }
243 c++;
244 }
245 if (++y1 == vt->total_height)
246 y1 = 0;
247 }
248 }
249
250 static void
251 spiceterm_scroll_down(spiceTerm *vt, int top, int bottom, int lines)
252 {
253 if ((top + lines) >= bottom) {
254 lines = bottom - top -1;
255 }
256
257 if (top < 0 || bottom > vt->height || top >= bottom || lines < 1) {
258 return;
259 }
260
261 int i;
262 for(i = bottom - top - lines - 1; i >= 0; i--) {
263 int src = ((vt->y_base + top + i) % vt->total_height)*vt->width;
264 int dst = ((vt->y_base + top + lines + i) % vt->total_height)*vt->width;
265
266 memmove(vt->cells + dst, vt->cells + src, vt->width*sizeof(TextCell));
267 }
268
269 for (i = 0; i < lines; i++) {
270 int j;
271 TextCell *c = vt->cells + ((vt->y_base + top + i) % vt->total_height)*vt->width;
272 for(j = 0; j < vt->width; j++) {
273 c->attrib = vt->default_attrib;
274 c->ch = ' ';
275 c++;
276 }
277 }
278
279 int h = lines * 16;
280 int y0 = top*16;
281 int y1 = y0 + h;
282 int y2 = bottom*16;
283
284 spice_screen_scroll(vt->screen, 0, y1, vt->screen->primary_width, y2, 0, y0);
285 spice_screen_clear(vt->screen, 0, y0, vt->screen->primary_width, y1);
286 }
287
288 static void
289 spiceterm_scroll_up(spiceTerm *vt, int top, int bottom, int lines, int moveattr)
290 {
291 if ((top + lines) >= bottom) {
292 lines = bottom - top - 1;
293 }
294
295 if (top < 0 || bottom > vt->height || top >= bottom || lines < 1) {
296 return;
297 }
298
299
300 int h = lines * 16;
301 int y0 = top*16;
302 int y1 = (top + lines)*16;
303 int y2 = bottom*16;
304
305 spice_screen_scroll(vt->screen, 0, y0, vt->screen->primary_width, y2 -h, 0, y1);
306 spice_screen_clear(vt->screen, 0, y2 -h, vt->screen->primary_width, y2);
307
308 if (!moveattr) {
309 return;
310 }
311
312 // move attributes
313
314 int i;
315 for(i = 0; i < (bottom - top - lines); i++) {
316 int dst = ((vt->y_base + top + i) % vt->total_height)*vt->width;
317 int src = ((vt->y_base + top + lines + i) % vt->total_height)*vt->width;
318
319 memmove(vt->cells + dst, vt->cells + src, vt->width*sizeof(TextCell));
320 }
321
322 for (i = 1; i <= lines; i++) {
323 int j;
324 TextCell *c = vt->cells + ((vt->y_base + bottom - i) % vt->total_height)*vt->width;
325 for(j = 0; j < vt->width; j++) {
326 c->attrib = vt->default_attrib;
327 c->ch = ' ';
328 c++;
329 }
330 }
331 }
332
333 static void
334 spiceterm_virtual_scroll(spiceTerm *vt, int lines)
335 {
336 if (vt->altbuf || lines == 0) return;
337
338 if (lines < 0) {
339 lines = -lines;
340 int i = vt->scroll_height;
341 if (i > vt->total_height - vt->height)
342 i = vt->total_height - vt->height;
343 int y1 = vt->y_base - i;
344 if (y1 < 0)
345 y1 += vt->total_height;
346 for(i = 0; i < lines; i++) {
347 if (vt->y_displ == y1) break;
348 if (--vt->y_displ < 0) {
349 vt->y_displ = vt->total_height - 1;
350 }
351 }
352 } else {
353 int i;
354 for(i = 0; i < lines; i++) {
355 if (vt->y_displ == vt->y_base) break;
356 if (++vt->y_displ == vt->total_height) {
357 vt->y_displ = 0;
358 }
359 }
360 }
361
362 spiceterm_refresh(vt);
363 }
364
365 static void
366 spiceterm_respond_esc(spiceTerm *vt, const char *esc)
367 {
368 int len = strlen(esc);
369 int i;
370
371 if (vt->ibuf_count < (IBUFSIZE - 1 - len)) {
372 vt->ibuf[vt->ibuf_count++] = 27;
373 for (i = 0; i < len; i++) {
374 vt->ibuf[vt->ibuf_count++] = esc[i];
375 }
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 /* fixme:
1287 void
1288 spiceterm_set_xcut_text(char* str, int len, struct _rfbClientRec* cl)
1289 {
1290 spiceTerm *vt =(spiceTerm *)cl->screen->screenData;
1291
1292 // seems str is Latin-1 encoded
1293 if (vt->selection) free (vt->selection);
1294 vt->selection = (gunichar2 *)malloc (len*sizeof (gunichar2));
1295 int i;
1296 for (i = 0; i < len; i++) {
1297 vt->selection[i] = str[i] & 0xff;
1298 }
1299 vt->selection_len = len;
1300 }
1301 */
1302
1303 static void
1304 spiceterm_update_watch_mask(spiceTerm *vt, gboolean writable)
1305 {
1306 g_assert(vt != NULL);
1307
1308 int mask = SPICE_WATCH_EVENT_READ;
1309
1310 if (writable) {
1311 mask |= SPICE_WATCH_EVENT_WRITE;
1312 }
1313
1314 vt->screen->core->watch_update_mask(vt->screen->mwatch, mask);
1315 }
1316
1317 static void
1318 mouse_report(spiceTerm *vt, int butt, int mrx, int mry)
1319 {
1320 char buf[8];
1321
1322 sprintf(buf, "[M%c%c%c", (char)(' ' + butt), (char)('!' + mrx),
1323 (char)('!' + mry));
1324
1325 spiceterm_respond_esc(vt, buf);
1326
1327 spiceterm_update_watch_mask(vt, TRUE);
1328 }
1329
1330 static void
1331 spiceterm_respond_unichar2(spiceTerm *vt, gunichar2 uc)
1332 {
1333 if (vt->utf8) {
1334 gchar buf[10];
1335 gint len = g_unichar_to_utf8(uc, buf);
1336
1337 if (len > 0) {
1338 if ((vt->ibuf_count + len) < IBUFSIZE) {
1339 int i;
1340 for (i = 0; i < len; i++) {
1341 vt->ibuf[vt->ibuf_count++] = buf[i];
1342 }
1343 } else {
1344 fprintf(stderr, "warning: input buffer overflow\n");
1345 }
1346 }
1347 } else {
1348 if ((vt->ibuf_count + 1) < IBUFSIZE) {
1349 vt->ibuf[vt->ibuf_count++] = (char)uc;
1350 } else {
1351 fprintf(stderr, "warning: input buffer overflow\n");
1352 }
1353 }
1354 }
1355
1356 static void
1357 spiceterm_push_keysym(spiceTerm *vt, uint32_t keySym, uint32_t flags)
1358 {
1359 static int control = 0;
1360 static int shift = 0;
1361 char *esc = NULL;
1362
1363 gunichar2 uc = 0;
1364
1365 DPRINTF(1, "flags=%d keySym=%08x", flags, keySym);
1366
1367 if (flags & SPICE_KEYBOARD_FLAG_DOWN) {
1368 if (keySym == GDK_KEY_Shift_L || keySym == GDK_KEY_Shift_R) {
1369 shift = 1;
1370 } if (keySym == GDK_KEY_Control_L || keySym == GDK_KEY_Control_R) {
1371 control = 1;
1372 } else if (vt->ibuf_count < (IBUFSIZE - 32)) {
1373
1374 if (control) {
1375 if(keySym >= 'a' && keySym <= 'z')
1376 uc = keySym - 'a' + 1;
1377 else if (keySym >= 'A' && keySym <= 'Z')
1378 uc = keySym - 'A' + 1;
1379 else
1380 uc = 0;
1381
1382 } else {
1383 switch (keySym) {
1384 case GDK_KEY_Escape:
1385 uc = 27; break;
1386 case GDK_KEY_Return:
1387 uc = '\r'; break;
1388 case GDK_KEY_BackSpace:
1389 uc = 8; break;
1390 case GDK_KEY_Tab:
1391 uc = '\t'; break;
1392 case GDK_KEY_Delete: /* kdch1 */
1393 case GDK_KEY_KP_Delete:
1394 esc = "[3~";break;
1395 case GDK_KEY_Home: /* khome */
1396 case GDK_KEY_KP_Home:
1397 esc = "OH";break;
1398 case GDK_KEY_End:
1399 case GDK_KEY_KP_End: /* kend */
1400 esc = "OF";break;
1401 case GDK_KEY_Insert: /* kich1 */
1402 case GDK_KEY_KP_Insert:
1403 esc = "[2~";break;
1404 case GDK_KEY_Up:
1405 case GDK_KEY_KP_Up: /* kcuu1 */
1406 esc = "OA";break;
1407 case GDK_KEY_Down: /* kcud1 */
1408 case GDK_KEY_KP_Down:
1409 esc = "OB";break;
1410 case GDK_KEY_Right:
1411 case GDK_KEY_KP_Right: /* kcuf1 */
1412 esc = "OC";break;
1413 case GDK_KEY_Left:
1414 case GDK_KEY_KP_Left: /* kcub1 */
1415 esc = "OD";break;
1416 case GDK_KEY_Page_Up:
1417 if (shift) {
1418 spiceterm_virtual_scroll (vt, -vt->height/2);
1419 goto ret;
1420 }
1421 esc = "[5~";break;
1422 case GDK_KEY_Page_Down:
1423 if (shift) {
1424 spiceterm_virtual_scroll (vt, vt->height/2);
1425 goto ret;
1426 }
1427 esc = "[6~";break;
1428 case GDK_KEY_F1:
1429 esc = "OP";break;
1430 case GDK_KEY_F2:
1431 esc = "OQ";break;
1432 case GDK_KEY_F3:
1433 esc = "OR";break;
1434 case GDK_KEY_F4:
1435 esc = "OS";break;
1436 case GDK_KEY_F5:
1437 esc = "[15~";break;
1438 case GDK_KEY_F6:
1439 esc = "[17~";break;
1440 case GDK_KEY_F7:
1441 esc = "[18~";break;
1442 case GDK_KEY_F8:
1443 esc = "[19~";break;
1444 case GDK_KEY_F9:
1445 esc = "[20~";break;
1446 case GDK_KEY_F10:
1447 esc = "[21~";break;
1448 case GDK_KEY_F11:
1449 esc = "[23~";break;
1450 case GDK_KEY_F12:
1451 esc = "[24~";break;
1452 default:
1453 if (keySym < 0x100) {
1454 uc = keySym;
1455 }
1456 break;
1457 }
1458 }
1459
1460 DPRINTF(1, "escape=%s unicode=%08x\n", esc, uc);
1461
1462 if (vt->y_displ != vt->y_base) {
1463 vt->y_displ = vt->y_base;
1464 spiceterm_refresh(vt);
1465 }
1466
1467 if (esc) {
1468 spiceterm_respond_esc(vt, esc);
1469 } else if (uc > 0) {
1470 spiceterm_respond_unichar2(vt, uc);
1471 }
1472 }
1473 }
1474
1475 ret:
1476
1477 if (flags & SPICE_KEYBOARD_FLAG_UP) {
1478 if (keySym == GDK_KEY_Shift_L || keySym == GDK_KEY_Shift_R) {
1479 shift = 0;
1480 } else if (keySym == GDK_KEY_Control_L || keySym == GDK_KEY_Control_R) {
1481 control = 0;
1482 }
1483 }
1484
1485 spiceterm_update_watch_mask(vt, TRUE);
1486 }
1487
1488 static uint8_t
1489 my_kbd_get_leds(SpiceKbdInstance *sin)
1490 {
1491 return 0;
1492 }
1493
1494 static void
1495 my_kbd_push_key(SpiceKbdInstance *sin, uint8_t frag)
1496 {
1497 // spiceTerm *vt = SPICE_CONTAINEROF(sin, spiceTerm, keyboard_sin);
1498
1499 /* we no not need this */
1500
1501 return;
1502 }
1503
1504 static void
1505 my_kbd_push_x11_keysym(SpiceKbdInstance *sin, uint32_t keysym, uint32_t flags)
1506 {
1507 spiceTerm *vt = SPICE_CONTAINEROF(sin, spiceTerm, keyboard_sin);
1508
1509 spiceterm_push_keysym(vt, keysym, flags);
1510
1511 return;
1512 }
1513
1514 static SpiceKbdInterface my_keyboard_sif = {
1515 .base.type = SPICE_INTERFACE_KEYBOARD,
1516 .base.description = "spiceterm keyboard device",
1517 .base.major_version = SPICE_INTERFACE_KEYBOARD_MAJOR,
1518 .base.minor_version = SPICE_INTERFACE_KEYBOARD_MINOR,
1519 .push_scan_freg = my_kbd_push_key,
1520 .get_leds = my_kbd_get_leds,
1521 .push_x11_keysym = my_kbd_push_x11_keysym,
1522 };
1523
1524
1525 /* vdagent interface - to get mouse/clipboarde support */
1526
1527 #define VDAGENT_WBUF_SIZE (1024*50)
1528 static unsigned char vdagent_write_buffer[VDAGENT_WBUF_SIZE];
1529 static int vdagent_write_buffer_pos = 0;
1530 static int agent_owns_clipboard[256] = { 0, };
1531
1532 static void
1533 spiceterm_clear_selection(spiceTerm *vt)
1534 {
1535 DPRINTF(1, "mark_active = %d", vt->mark_active);
1536
1537 vt->mark_active = 0;
1538 if (vt->selection) free (vt->selection);
1539 vt->selection = NULL;
1540
1541 spiceterm_unselect_all(vt);
1542 }
1543
1544 static void
1545 spiceterm_motion_event(spiceTerm *vt, uint32_t x, uint32_t y, uint32_t buttons)
1546 {
1547 DPRINTF(1, "mask=%08x x=%d y=%d", buttons, x ,y);
1548
1549 static int last_mask = 0;
1550 static int sel_start_pos = 0;
1551 static int sel_end_pos = 0;
1552 static int button2_released = 1;
1553
1554 int i;
1555 int cx = x/8;
1556 int cy = y/16;
1557
1558 if (cx < 0) cx = 0;
1559 if (cx >= vt->width) cx = vt->width - 1;
1560 if (cy < 0) cy = 0;
1561 if (cy >= vt->height) cy = vt->height - 1;
1562
1563 if (vt->report_mouse && buttons != last_mask) {
1564 last_mask = buttons;
1565 if (buttons & 2) {
1566 mouse_report(vt, 0, cx, cy);
1567 }
1568 if (buttons & 4) {
1569 mouse_report (vt, 1, cx, cy);
1570 }
1571 if (buttons & 8) {
1572 mouse_report(vt, 2, cx, cy);
1573 }
1574 if(!buttons) {
1575 mouse_report(vt, 3, cx, cy);
1576 }
1577 }
1578
1579 if (buttons & 4) {
1580
1581 if(button2_released) {
1582
1583 if (agent_owns_clipboard[VD_AGENT_CLIPBOARD_SELECTION_PRIMARY]) {
1584 if (vt->selection) {
1585 int i;
1586 for(i = 0; i < vt->selection_len; i++) {
1587 spiceterm_respond_unichar2(vt, vt->selection[i]);
1588 }
1589 spiceterm_update_watch_mask(vt, TRUE);
1590 if (vt->y_displ != vt->y_base) {
1591 vt->y_displ = vt->y_base;
1592 spiceterm_refresh(vt);
1593 }
1594 }
1595 } else {
1596 vdagent_request_clipboard(vt, VD_AGENT_CLIPBOARD_SELECTION_PRIMARY);
1597 }
1598 }
1599
1600 button2_released = 0;
1601 } else {
1602 button2_released = 1;
1603 }
1604
1605 if (buttons & 2) {
1606 int pos = cy*vt->width + cx;
1607
1608 // code borrowed from libvncserver (VNCconsole.c)
1609
1610 if (!vt->mark_active) {
1611
1612 spiceterm_unselect_all(vt);
1613
1614 vt->mark_active = 1;
1615 sel_start_pos = sel_end_pos = pos;
1616 spiceterm_toggle_marked_cell(vt, pos);
1617
1618 } else {
1619
1620 if (pos != sel_end_pos) {
1621 if (pos > sel_end_pos) {
1622 cx = sel_end_pos; cy=pos;
1623 } else {
1624 cx=pos; cy=sel_end_pos;
1625 }
1626
1627 if (cx < sel_start_pos) {
1628 if (cy < sel_start_pos) cy--;
1629 } else {
1630 cx++;
1631 }
1632
1633 while (cx <= cy) {
1634 spiceterm_toggle_marked_cell(vt, cx);
1635 cx++;
1636 }
1637
1638 sel_end_pos = pos;
1639 }
1640 }
1641
1642 } else if (vt->mark_active) {
1643 vt->mark_active = 0;
1644
1645 if (sel_start_pos > sel_end_pos) {
1646 int tmp = sel_start_pos - 1;
1647 sel_start_pos = sel_end_pos;
1648 sel_end_pos = tmp;
1649 }
1650
1651 int len = sel_end_pos - sel_start_pos + 1;
1652
1653 if (vt->selection) free (vt->selection);
1654 vt->selection = (gunichar2 *)malloc (len*sizeof(gunichar2));
1655 vt->selection_len = len;
1656
1657 for (i = 0; i < len; i++) {
1658 int pos = sel_start_pos + i;
1659 int x = pos % vt->width;
1660 int y1 = ((pos / vt->width) + vt->y_displ) % vt->total_height;
1661 TextCell *c = &vt->cells[y1*vt->width + x];
1662 vt->selection[i] = c->ch;
1663 c++;
1664 }
1665
1666 DPRINTF(1, "selection length = %d", vt->selection_len);
1667
1668 vdagent_grab_clipboard(vt, VD_AGENT_CLIPBOARD_SELECTION_PRIMARY);
1669 }
1670 }
1671
1672 static void
1673 vdagent_reply(spiceTerm *vt, uint32_t type, uint32_t error)
1674 {
1675 uint32_t size;
1676
1677 size = sizeof(VDAgentReply);
1678
1679 int msg_size = sizeof(VDIChunkHeader) + sizeof(VDAgentMessage) + size;
1680 g_assert((vdagent_write_buffer_pos + msg_size) < VDAGENT_WBUF_SIZE);
1681
1682 unsigned char *buf = vdagent_write_buffer + vdagent_write_buffer_pos;
1683 vdagent_write_buffer_pos += msg_size;
1684
1685 memset(buf, 0, msg_size);
1686
1687 VDIChunkHeader *hdr = (VDIChunkHeader *)buf;
1688 VDAgentMessage *msg = (VDAgentMessage *)&hdr[1];
1689 VDAgentReply *reply = (VDAgentReply *)&msg[1];
1690 reply->type = type;
1691 reply->error = error;
1692
1693 hdr->port = VDP_CLIENT_PORT;
1694 hdr->size = sizeof(VDAgentMessage) + size;
1695
1696 msg->protocol = VD_AGENT_PROTOCOL;
1697 msg->type = VD_AGENT_REPLY;
1698 msg->opaque = 0;
1699 msg->size = size;
1700
1701 spice_server_char_device_wakeup(&vt->vdagent_sin);
1702 }
1703
1704 static void
1705 dump_message(unsigned char *buf, int size)
1706 {
1707 int i;
1708
1709 for (i = 0; i < size; i++) {
1710 printf("%d %02X\n", i, buf[i]);
1711 }
1712
1713 // exit(0);
1714 }
1715
1716 static void vdagent_send_capabilities(spiceTerm *vt, uint32_t request)
1717 {
1718 VDAgentAnnounceCapabilities *caps;
1719 uint32_t size;
1720
1721 size = sizeof(*caps) + VD_AGENT_CAPS_BYTES;
1722 caps = calloc(1, size);
1723 g_assert(caps != NULL);
1724
1725 caps->request = request;
1726 VD_AGENT_SET_CAPABILITY(caps->caps, VD_AGENT_CAP_MOUSE_STATE);
1727 VD_AGENT_SET_CAPABILITY(caps->caps, VD_AGENT_CAP_MONITORS_CONFIG);
1728 VD_AGENT_SET_CAPABILITY(caps->caps, VD_AGENT_CAP_REPLY);
1729 VD_AGENT_SET_CAPABILITY(caps->caps, VD_AGENT_CAP_CLIPBOARD_BY_DEMAND);
1730 VD_AGENT_SET_CAPABILITY(caps->caps, VD_AGENT_CAP_CLIPBOARD_SELECTION);
1731 VD_AGENT_SET_CAPABILITY(caps->caps, VD_AGENT_CAP_SPARSE_MONITORS_CONFIG);
1732 VD_AGENT_SET_CAPABILITY(caps->caps, VD_AGENT_CAP_GUEST_LINEEND_LF);
1733
1734 int msg_size = sizeof(VDIChunkHeader) + sizeof(VDAgentMessage) + size;
1735 g_assert((vdagent_write_buffer_pos + msg_size) < VDAGENT_WBUF_SIZE);
1736
1737 unsigned char *buf = vdagent_write_buffer + vdagent_write_buffer_pos;
1738 vdagent_write_buffer_pos += msg_size;
1739
1740 VDIChunkHeader *hdr = (VDIChunkHeader *)buf;
1741 VDAgentMessage *msg = (VDAgentMessage *)&hdr[1];
1742
1743 hdr->port = VDP_CLIENT_PORT;
1744 hdr->size = sizeof(VDAgentMessage) + size;
1745 msg->protocol = VD_AGENT_PROTOCOL;
1746 msg->type = VD_AGENT_ANNOUNCE_CAPABILITIES;
1747 msg->opaque = 0;
1748 msg->size = size;
1749
1750 memcpy(buf + sizeof(VDIChunkHeader) + sizeof(VDAgentMessage), (uint8_t *)caps, size);
1751
1752 if (0) dump_message(buf, msg_size);
1753
1754 spice_server_char_device_wakeup(&vt->vdagent_sin);
1755
1756 free(caps);
1757 }
1758
1759 static void vdagent_grab_clipboard(spiceTerm *vt, uint8_t selection)
1760 {
1761 uint32_t size;
1762
1763 agent_owns_clipboard[selection] = 1;
1764
1765 size = 8;
1766
1767 int msg_size = sizeof(VDIChunkHeader) + sizeof(VDAgentMessage) + size;
1768 g_assert((vdagent_write_buffer_pos + msg_size) < VDAGENT_WBUF_SIZE);
1769
1770 unsigned char *buf = vdagent_write_buffer + vdagent_write_buffer_pos;
1771 vdagent_write_buffer_pos += msg_size;
1772
1773 memset(buf, 0, msg_size);
1774
1775 VDIChunkHeader *hdr = (VDIChunkHeader *)buf;
1776 VDAgentMessage *msg = (VDAgentMessage *)&hdr[1];
1777 uint8_t *grab = (uint8_t *)&msg[1];
1778 *((uint8_t *)grab) = selection;
1779 *((uint32_t *)(grab + 4)) = VD_AGENT_CLIPBOARD_UTF8_TEXT;
1780
1781 hdr->port = VDP_CLIENT_PORT;
1782 hdr->size = sizeof(VDAgentMessage) + size;
1783
1784 msg->protocol = VD_AGENT_PROTOCOL;
1785 msg->type = VD_AGENT_CLIPBOARD_GRAB;
1786 msg->opaque = 0;
1787 msg->size = size;
1788
1789 if (0) dump_message(buf, msg_size);
1790
1791 spice_server_char_device_wakeup(&vt->vdagent_sin);
1792 }
1793
1794 static void vdagent_request_clipboard(spiceTerm *vt, uint8_t selection)
1795 {
1796 uint32_t size;
1797
1798 size = 4 + sizeof(VDAgentClipboardRequest);
1799
1800 int msg_size = sizeof(VDIChunkHeader) + sizeof(VDAgentMessage) + size;
1801 g_assert((vdagent_write_buffer_pos + msg_size) < VDAGENT_WBUF_SIZE);
1802
1803 unsigned char *buf = vdagent_write_buffer + vdagent_write_buffer_pos;
1804 vdagent_write_buffer_pos += msg_size;
1805
1806 memset(buf, 0, msg_size);
1807
1808 VDIChunkHeader *hdr = (VDIChunkHeader *)buf;
1809 VDAgentMessage *msg = (VDAgentMessage *)&hdr[1];
1810 uint8_t *data = (uint8_t *)&msg[1];
1811 *((uint32_t *)data) = 0;
1812 data[0] = selection;
1813 ((uint32_t *)data)[1] = VD_AGENT_CLIPBOARD_UTF8_TEXT;
1814
1815 hdr->port = VDP_CLIENT_PORT;
1816 hdr->size = sizeof(VDAgentMessage) + size;
1817
1818 msg->protocol = VD_AGENT_PROTOCOL;
1819 msg->type = VD_AGENT_CLIPBOARD_REQUEST;
1820 msg->opaque = 0;
1821 msg->size = size;
1822
1823 if (0) dump_message(buf, msg_size);
1824
1825 spice_server_char_device_wakeup(&vt->vdagent_sin);
1826 }
1827
1828 static void vdagent_send_clipboard(spiceTerm *vt, uint8_t selection)
1829 {
1830 uint32_t size;
1831
1832 if (selection != VD_AGENT_CLIPBOARD_SELECTION_PRIMARY) {
1833 fprintf(stderr, "clipboard select %d is not supported\n", selection);
1834 return;
1835 }
1836
1837 gchar *sel_data;
1838 glong sel_len;
1839 if (vt->utf8) {
1840 sel_data = g_utf16_to_utf8(vt->selection, vt->selection_len, NULL, &sel_len, NULL);
1841 } else {
1842 sel_len = vt->selection_len;
1843 sel_data = g_malloc(sel_len);
1844 int i;
1845 for (i = 0; i < sel_len; i++) { sel_data[i] = (char)vt->selection[i]; }
1846 sel_data[sel_len] = 0;
1847 }
1848
1849 size = 8 + sel_len;
1850
1851 int msg_size = sizeof(VDIChunkHeader) + sizeof(VDAgentMessage) + size;
1852 g_assert((vdagent_write_buffer_pos + msg_size) < VDAGENT_WBUF_SIZE);
1853
1854 unsigned char *buf = vdagent_write_buffer + vdagent_write_buffer_pos;
1855 vdagent_write_buffer_pos += msg_size;
1856
1857 memset(buf, 0, msg_size);
1858
1859 VDIChunkHeader *hdr = (VDIChunkHeader *)buf;
1860 VDAgentMessage *msg = (VDAgentMessage *)&hdr[1];
1861 uint8_t *data = (uint8_t *)&msg[1];
1862 *((uint8_t *)data) = selection;
1863 data += 4;
1864 *((uint32_t *)data) = VD_AGENT_CLIPBOARD_UTF8_TEXT;
1865 data += 4;
1866
1867 memcpy(data, sel_data, sel_len);
1868 g_free(sel_data);
1869
1870 hdr->port = VDP_CLIENT_PORT;
1871 hdr->size = sizeof(VDAgentMessage) + size;
1872
1873 msg->protocol = VD_AGENT_PROTOCOL;
1874 msg->type = VD_AGENT_CLIPBOARD;
1875 msg->opaque = 0;
1876 msg->size = size;
1877
1878 spice_server_char_device_wakeup(&vt->vdagent_sin);
1879 }
1880
1881 static int
1882 vmc_write(SpiceCharDeviceInstance *sin, const uint8_t *buf, int len)
1883 {
1884 spiceTerm *vt = SPICE_CONTAINEROF(sin, spiceTerm, vdagent_sin);
1885
1886 VDIChunkHeader *hdr = (VDIChunkHeader *)buf;
1887 VDAgentMessage *msg = (VDAgentMessage *)&hdr[1];
1888
1889 //g_assert(hdr->port == VDP_SERVER_PORT);
1890 g_assert(msg->protocol == VD_AGENT_PROTOCOL);
1891
1892 DPRINTF(1, "%d %d %d %d", len, hdr->port, msg->protocol, msg->type);
1893
1894 switch (msg->type) {
1895 case VD_AGENT_MOUSE_STATE: {
1896 VDAgentMouseState *info = (VDAgentMouseState *)&msg[1];
1897 spiceterm_motion_event(vt, info->x, info->y, info->buttons);
1898 break;
1899 }
1900 case VD_AGENT_ANNOUNCE_CAPABILITIES: {
1901 VDAgentAnnounceCapabilities *caps = (VDAgentAnnounceCapabilities *)&msg[1];
1902 DPRINTF(1, "VD_AGENT_ANNOUNCE_CAPABILITIES %d", caps->request);
1903 int i;
1904
1905 int caps_size = VD_AGENT_CAPS_SIZE_FROM_MSG_SIZE(hdr->size);
1906 for (i = 0; i < VD_AGENT_END_CAP; i++) {
1907 DPRINTF(1, "CAPABILITIES %d %d", i, VD_AGENT_HAS_CAPABILITY(caps->caps, caps_size, i));
1908 }
1909
1910 vdagent_send_capabilities(vt, 0);
1911 break;
1912 }
1913 case VD_AGENT_CLIPBOARD_GRAB: {
1914 VDAgentClipboardGrab *grab = (VDAgentClipboardGrab *)&msg[1];
1915 uint8_t selection = *((uint8_t *)grab);
1916 DPRINTF(1, "VD_AGENT_CLIPBOARD_GRAB %d", selection);
1917 agent_owns_clipboard[selection] = 0;
1918 spiceterm_clear_selection(vt);
1919 break;
1920 }
1921 case VD_AGENT_CLIPBOARD_REQUEST: {
1922 uint8_t *req = (uint8_t *)&msg[1];
1923 uint8_t selection = *((uint8_t *)req);
1924 uint32_t type = *((uint32_t *)(req + 4));
1925
1926 DPRINTF(1, "VD_AGENT_CLIPBOARD_REQUEST %d %d", selection, type);
1927
1928 vdagent_send_clipboard(vt, selection);
1929
1930 break;
1931 }
1932 case VD_AGENT_CLIPBOARD: {
1933 uint8_t *data = (uint8_t *)&msg[1];
1934 uint8_t selection = data[0];
1935 uint32_t type = *(uint32_t *)(data + 4);
1936 int size = msg->size - 8;
1937 DPRINTF(1, "VD_AGENT_CLIPBOARD %d %d %d", selection, type, size);
1938
1939 if (type == VD_AGENT_CLIPBOARD_UTF8_TEXT) {
1940 int i;
1941 for (i = 0; i < size; i++) {
1942 if ((vt->ibuf_count + 1) < IBUFSIZE) {
1943 vt->ibuf[vt->ibuf_count++] = *(char *)(data + 8 + i);
1944 } else {
1945 fprintf(stderr, "warning: input buffer overflow\n");
1946 }
1947 }
1948 spiceterm_update_watch_mask(vt, TRUE);
1949 }
1950 break;
1951 }
1952 case VD_AGENT_CLIPBOARD_RELEASE: {
1953 uint8_t *data = (uint8_t *)&msg[1];
1954 uint8_t selection = data[0];
1955
1956 DPRINTF(0, "VD_AGENT_CLIPBOARD_RELEASE %d", selection);
1957
1958 break;
1959 }
1960 case VD_AGENT_MONITORS_CONFIG: {
1961 VDAgentMonitorsConfig *list = (VDAgentMonitorsConfig *)&msg[1];
1962 g_assert(list->num_of_monitors > 0);
1963 DPRINTF(0, "VD_AGENT_MONITORS_CONFIG %d %d %d", list->num_of_monitors,
1964 list->monitors[0].width, list->monitors[0].height);
1965
1966 spiceterm_resize(vt, list->monitors[0].width, list->monitors[0].height);
1967
1968 vdagent_reply(vt, VD_AGENT_MONITORS_CONFIG, VD_AGENT_SUCCESS);
1969 break;
1970 }
1971 default:
1972 DPRINTF(0, "got uknown vdagent message type %d\n", msg->type);
1973 }
1974
1975 return len;
1976 }
1977
1978 static int
1979 vmc_read(SpiceCharDeviceInstance *sin, uint8_t *buf, int len)
1980 {
1981 DPRINTF(1, "%d %d", len, vdagent_write_buffer_pos);
1982 g_assert(len >= 8);
1983
1984 if (!vdagent_write_buffer_pos) {
1985 return 0;
1986 }
1987
1988 int size = (len >= vdagent_write_buffer_pos) ? vdagent_write_buffer_pos : len;
1989 memcpy(buf, vdagent_write_buffer, size);
1990 if (size < vdagent_write_buffer_pos) {
1991 memmove(vdagent_write_buffer, vdagent_write_buffer + size,
1992 vdagent_write_buffer_pos - size);
1993 }
1994 vdagent_write_buffer_pos -= size;
1995
1996 DPRINTF(1, "RET %d %d", size, vdagent_write_buffer_pos);
1997 return size;
1998 }
1999
2000 static void
2001 vmc_state(SpiceCharDeviceInstance *sin, int connected)
2002 {
2003 /* IGNORE */
2004 }
2005
2006 static SpiceCharDeviceInterface my_vdagent_sif = {
2007 .base.type = SPICE_INTERFACE_CHAR_DEVICE,
2008 .base.description = "spice virtual channel char device",
2009 .base.major_version = SPICE_INTERFACE_CHAR_DEVICE_MAJOR,
2010 .base.minor_version = SPICE_INTERFACE_CHAR_DEVICE_MINOR,
2011 .state = vmc_state,
2012 .write = vmc_write,
2013 .read = vmc_read,
2014 };
2015
2016 static void
2017 init_spiceterm(spiceTerm *vt, uint32_t width, uint32_t height)
2018 {
2019 int i;
2020
2021 g_assert(vt != NULL);
2022 g_assert(vt->screen != NULL);
2023
2024 vt->width = width / 8;
2025 vt->height = height / 16;
2026
2027 vt->total_height = vt->height * 20;
2028 vt->scroll_height = 0;
2029 vt->y_base = 0;
2030 vt->y_displ = 0;
2031
2032 vt->region_top = 0;
2033 vt->region_bottom = vt->height;
2034
2035 vt->g0enc = LAT1_MAP;
2036 vt->g1enc = GRAF_MAP;
2037 vt->cur_enc = vt->g0enc;
2038 vt->charset = 0;
2039
2040 /* default text attributes */
2041 vt->default_attrib.bold = 0;
2042 vt->default_attrib.uline = 0;
2043 vt->default_attrib.blink = 0;
2044 vt->default_attrib.invers = 0;
2045 vt->default_attrib.unvisible = 0;
2046 vt->default_attrib.fgcol = 7;
2047 vt->default_attrib.bgcol = 0;
2048
2049 vt->cur_attrib = vt->default_attrib;
2050
2051 if (vt->cells) {
2052 vt->cx = 0;
2053 vt->cy = 0;
2054 vt->cx_saved = 0;
2055 vt->cy_saved = 0;
2056 g_free(vt->cells);
2057 }
2058
2059 vt->cells = (TextCell *)calloc (sizeof (TextCell), vt->width*vt->total_height);
2060
2061 for (i = 0; i < vt->width*vt->total_height; i++) {
2062 vt->cells[i].ch = ' ';
2063 vt->cells[i].attrib = vt->default_attrib;
2064 }
2065
2066 if (vt->altcells) {
2067 g_free(vt->altcells);
2068 }
2069
2070 vt->altcells = (TextCell *)calloc (sizeof (TextCell), vt->width*vt->height);
2071 }
2072
2073 static void
2074 spiceterm_resize(spiceTerm *vt, uint32_t width, uint32_t height)
2075 {
2076 width = (width/8)*8;
2077 height = (height/16)*16;
2078
2079 if (vt->screen->width == width && vt->screen->height == height) {
2080 return;
2081 }
2082
2083 DPRINTF(0, "width=%u height=%u", width, height);
2084
2085 spice_screen_resize(vt->screen, width, height);
2086
2087 init_spiceterm(vt, width, height);
2088
2089 struct winsize dimensions;
2090 dimensions.ws_col = vt->width;
2091 dimensions.ws_row = vt->height;
2092
2093 ioctl(vt->pty, TIOCSWINSZ, &dimensions);
2094 }
2095
2096 static spiceTerm *
2097 create_spiceterm(int argc, char** argv, uint32_t maxx, uint32_t maxy, guint timeout)
2098 {
2099 SpiceCoreInterface *core = basic_event_loop_init();
2100 SpiceScreen *spice_screen = spice_screen_new(core, maxx, maxy, timeout);
2101
2102 //spice_server_set_image_compression(server, SPICE_IMAGE_COMPRESS_OFF);
2103
2104 spice_screen->image_cache = g_hash_table_new(g_int_hash, g_int_equal);
2105
2106 spiceTerm *vt = (spiceTerm *)calloc (sizeof(spiceTerm), 1);
2107
2108 vt->keyboard_sin.base.sif = &my_keyboard_sif.base;
2109 spice_server_add_interface(spice_screen->server, &vt->keyboard_sin.base);
2110
2111 vt->vdagent_sin.base.sif = &my_vdagent_sif.base;
2112 vt->vdagent_sin.subtype = "vdagent";
2113 spice_server_add_interface(spice_screen->server, &vt->vdagent_sin.base);
2114 vt->screen = spice_screen;
2115
2116 init_spiceterm(vt, maxx, maxy);
2117
2118 return vt;
2119 }
2120
2121 static gboolean
2122 master_error_callback(GIOChannel *channel, GIOCondition condition,
2123 gpointer data)
2124 {
2125 //spiceTerm *vt = (spiceTerm *)data;
2126
2127 DPRINTF(1, "condition %d", condition);
2128
2129 exit(0);
2130
2131 return FALSE;
2132 }
2133
2134 static void
2135 master_watch(int master, int event, void *opaque)
2136 {
2137 spiceTerm *vt = (spiceTerm *)opaque;
2138 int c;
2139
2140 // fixme: if (!vt->mark_active) {
2141
2142 if (event == SPICE_WATCH_EVENT_READ) {
2143 char buffer[1024];
2144 while ((c = read(master, buffer, 1024)) == -1) {
2145 if (errno != EAGAIN) break;
2146 }
2147 if (c == -1) {
2148 perror("master pipe read error"); // fixme
2149 }
2150 spiceterm_puts (vt, buffer, c);
2151 } else {
2152 if (vt->ibuf_count > 0) {
2153 DPRINTF(1, "write input %x %d", vt->ibuf[0], vt->ibuf_count);
2154 if ((c = write (master, vt->ibuf, vt->ibuf_count)) >= 0) {
2155 if (c == vt->ibuf_count) {
2156 vt->ibuf_count = 0;
2157 } else if (c > 0) {
2158 // not all data written
2159 memmove(vt->ibuf, vt->ibuf + c, vt->ibuf_count - c);
2160 vt->ibuf_count -= c;
2161 } else {
2162 // nothing written -ignore and try later
2163 }
2164 } else {
2165 perror("master pipe write error");
2166 }
2167 }
2168 if (vt->ibuf_count == 0) {
2169 spiceterm_update_watch_mask(vt, FALSE);
2170 }
2171 }
2172 }
2173
2174 int
2175 main (int argc, char** argv)
2176 {
2177 int i;
2178 char **cmdargv = NULL;
2179 char *command = "/bin/bash"; // execute normal shell as default
2180 int pid;
2181 int master;
2182 char ptyname[1024];
2183 struct winsize dimensions;
2184
2185 g_thread_init(NULL);
2186
2187 for (i = 1; i < argc; i++) {
2188 if (!strcmp (argv[i], "-c")) {
2189 command = argv[i+1];
2190 cmdargv = &argv[i+1];
2191 argc = i;
2192 argv[i] = NULL;
2193 break;
2194 }
2195 }
2196
2197 if (0) print_usage(NULL); // fixme:
2198
2199 spiceTerm *vt = create_spiceterm (argc, argv, 744, 400, 10);
2200
2201 setlocale(LC_ALL, ""); // set from environment
2202
2203 char *ctype = setlocale (LC_CTYPE, NULL); // query LC_CTYPE
2204
2205 // fixme: ist there a standard way to detect utf8 mode ?
2206 if (strcasestr (ctype, ".utf-8")||strcasestr (ctype, ".utf8")) {
2207 vt->utf8 = 1;
2208 }
2209
2210 dimensions.ws_col = vt->width;
2211 dimensions.ws_row = vt->height;
2212
2213 setenv("TERM", TERM, 1);
2214
2215 DPRINTF(1, "execute %s", command);
2216
2217 pid = forkpty (&master, ptyname, NULL, &dimensions);
2218 if(!pid) {
2219
2220 // install default signal handlers
2221 signal (SIGQUIT, SIG_DFL);
2222 signal (SIGTERM, SIG_DFL);
2223 signal (SIGINT, SIG_DFL);
2224
2225 if (cmdargv) {
2226 execvp (command, cmdargv);
2227 } else {
2228 execlp (command, command, NULL);
2229 }
2230 perror ("Error: exec failed\n");
2231 exit (-1); // should not be reached
2232 } else if (pid == -1) {
2233 perror ("Error: fork failed\n");
2234 exit (-1);
2235 }
2236
2237 vt->pty = master;
2238
2239 /* watch for errors - we need to use glib directly because spice
2240 * does not have SPICE_WATCH_EVENT for this */
2241 GIOChannel *channel = g_io_channel_unix_new(master);
2242 g_io_channel_set_flags(channel, G_IO_FLAG_NONBLOCK, NULL);
2243 g_io_channel_set_encoding(channel, NULL, NULL);
2244 g_io_add_watch(channel, G_IO_ERR|G_IO_HUP, master_error_callback, vt);
2245
2246 vt->screen->mwatch = vt->screen->core->watch_add(
2247 master, SPICE_WATCH_EVENT_READ /* |SPICE_WATCH_EVENT_WRITE */,
2248 master_watch, vt);
2249
2250 basic_event_loop_mainloop();
2251
2252 kill (pid, 9);
2253 int status;
2254 waitpid(pid, &status, 0);
2255
2256 exit (0);
2257 }
SPICE terminal emulator