1 /* ovirt viewer console application
2 * Copyright (C) 2008 Red Hat Inc.
3 * Written by Richard W.M. Jones <rjones@redhat.com>
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
28 #include <gdk/gdkkeysyms.h>
29 #include <vncdisplay.h>
35 #ifdef HAVE_NETINET_IN_H
36 #include <netinet/in.h>
39 #include <arpa/inet.h>
41 #ifdef HAVE_SYS_SOCKET_H
42 #include <sys/socket.h>
55 /*#define HTTPS "https"*/
62 /* Usually /etc/pki/tls/certs/ca-bundle.crt unless overridden during
63 * configure or on the command line.
65 const char *cainfo = CAINFO;
66 gboolean check_cert = FALSE; // do we want this enabled by default ?
67 // would require a CA by default (self-signed wont work)
68 // (don't set to true, change var/flag to no_check_cert)
70 /* The WUI thread has updated the vm list. Here in the main thread
71 * we keep our own copy of the vmlist.
73 static GSList *vmlist = NULL;
75 /* internal.h shared constructs */
77 struct vm* vm_in_focus;
78 int ovirt_server_vnc_port = 5900;
80 /* Private functions. */
81 static void start_ui (void);
82 static GtkWidget *menu_item_new (int which_menu);
83 static void refresh_menu_vm_list (GtkWidget *, gpointer);
84 static void connect_to_wui_on_enter (GtkWidget *, gpointer);
85 static void connect_to_wui (GtkWidget *, gpointer);
86 static void send_key_to_vm (GtkWidget *widget, gpointer _keyComboDef);
87 static void login_to_wui_on_enter (GtkWidget *, gpointer);
88 static void login_to_wui (GtkWidget *, gpointer);
89 static gboolean delete_event (GtkWidget *widget, GdkEvent *event, gpointer data);
90 static void destroy (GtkWidget *widget, gpointer data);
91 static void clear_connectmenu (void);
92 static void help_about (GtkWidget *menu);
93 static void viewer_shutdown (GtkWidget *src, void *dummy, GtkWidget *vnc);
95 static void viewer_quit (GtkWidget *src, GtkWidget *vnc);
97 static void viewer_connected (GtkWidget *vnc);
98 static void viewer_initialized (GtkWidget *vnc, GtkWidget *data);
99 static void viewer_disconnected (GtkWidget *vnc);
100 static void viewer_credential (GtkWidget *vnc, GValueArray *credList);
101 static int viewer_open_vnc_socket (const char *vnchost, int vncport);
102 static void add_vm_to_connectmenu (gpointer _vm, gpointer data);
104 /* For any widgets accessed from multiple functions. */
105 static GtkWidget *window;
106 static GtkWidget *connectitem;
107 static GtkWidget *connectmenu;
108 static GtkWidget *no_connections;
109 static GtkWidget *refresh_vmlist;
110 static GtkWidget *refresh_vmlist_separator;
111 static GtkWidget *connection_area;
112 static GtkWidget *ca_hostname;
113 static GtkWidget *ca_button;
114 static GtkWidget *ca_error;
115 static GtkWidget *login_area;
116 static GtkWidget *la_username;
117 static GtkWidget *la_password;
118 static GtkWidget *la_button;
119 static GtkWidget *la_error;
120 static GtkWidget *notebook;
121 static GtkWidget *statusbar;
122 static guint statusbar_ctx;
123 static GdkCursor *busy_cursor;
137 const char *ungrabbed_text;
138 const char *grabbed_text;
141 static struct menuItem menuItems[] = {
142 { CONNECT_MENU, NULL, "_Connect", "Connect" },
143 { VIEW_MENU, NULL, "_View", "View" },
144 { SEND_KEY_MENU, NULL, "_Send Key", "Send Key" },
145 { WINDOW_MENU, NULL, "_Window", "Window" },
146 { HELP_MENU, NULL, "_Help", "Help" }
149 #define MAX_KEY_COMBO 3
151 guint keys[MAX_KEY_COMBO];
156 #define NUM_KEY_COMBOS 17
157 static struct keyComboDef keyCombos[] = {
158 { { GDK_Control_L, GDK_Alt_L, GDK_Delete }, 3, "Ctrl+Alt+Del"},
159 { { GDK_Control_L, GDK_Alt_L, GDK_BackSpace }, 3, "Ctrl+Alt+Backspace"},
161 { { GDK_Control_L, GDK_Alt_L, GDK_F1 }, 3, "Ctrl+Alt+F1"},
162 { { GDK_Control_L, GDK_Alt_L, GDK_F2 }, 3, "Ctrl+Alt+F2"},
163 { { GDK_Control_L, GDK_Alt_L, GDK_F3 }, 3, "Ctrl+Alt+F3"},
164 { { GDK_Control_L, GDK_Alt_L, GDK_F4 }, 3, "Ctrl+Alt+F4"},
165 { { GDK_Control_L, GDK_Alt_L, GDK_F5 }, 3, "Ctrl+Alt+F5"},
166 { { GDK_Control_L, GDK_Alt_L, GDK_F6 }, 3, "Ctrl+Alt+F6"},
167 { { GDK_Control_L, GDK_Alt_L, GDK_F7 }, 3, "Ctrl+Alt+F7"},
168 { { GDK_Control_L, GDK_Alt_L, GDK_F8 }, 3, "Ctrl+Alt+F8"},
169 { { GDK_Control_L, GDK_Alt_L, GDK_F5 }, 3, "Ctrl+Alt+F9"},
170 { { GDK_Control_L, GDK_Alt_L, GDK_F6 }, 3, "Ctrl+Alt+F10"},
171 { { GDK_Control_L, GDK_Alt_L, GDK_F7 }, 3, "Ctrl+Alt+F11"},
172 { { GDK_Control_L, GDK_Alt_L, GDK_F8 }, 3, "Ctrl+Alt+F12"},
174 { { GDK_Print }, 1, "PrintScreen"},
178 static const char *title = "oVirt Viewer";
182 static const char *title_vm =
183 "oVirt Viewer: (ctrl+alt to grab/release mouse) ";
185 /* Gtk widget styles. Avoid installation hassles by keeping this
186 * inside the binary. It can still be overridden by the user (who
189 static const char *styles =
190 "style \"ovirt-viewer-yellow-box\"\n"
192 " bg[NORMAL] = shade (1.5, \"yellow\")\n"
194 "widget \"*.ovirt-viewer-connection-area\" style \"ovirt-viewer-yellow-box\"\n"
197 /* Command-line arguments. */
198 static int print_version = 0;
200 static const char *help_msg =
201 "Use '" PACKAGE " --help' to see a list of available command line options";
203 static const GOptionEntry options[] = {
204 { "port", 'p', 0, G_OPTION_ARG_INT, &ovirt_server_vnc_port,
205 "set port which to connect to server via vnc", NULL },
206 { "cainfo", 0, 0, G_OPTION_ARG_STRING, &cainfo,
207 "set the path of the CA certificate bundle", NULL },
208 { "check-certificate", 0, 0, G_OPTION_ARG_NONE, &check_cert,
209 "check the SSL certificate of the server", NULL },
210 { "debug", 'd', 0, G_OPTION_ARG_NONE, &debug,
211 "turn on debugging messages", NULL },
212 { "verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose,
213 "turn on verbose messages", NULL },
214 { "version", 'V', 0, G_OPTION_ARG_NONE, &print_version,
215 "display version and exit", NULL },
216 { NULL, 0, 0, G_OPTION_ARG_NONE, NULL, NULL, NULL }
220 main (int argc, char *argv[])
222 GOptionContext *context;
223 GError *error = NULL;
225 /* Initialize GLib threads before anything else.
227 * There is one main thread, which is used for all Gtk interactions
228 * and to keep the UI responsive, and one WUI thread. The WUI
229 * thread is used to connect to the WUI, log in, and maintain the list
230 * of virtual machines. The WUI thread is the only thread allowed
231 * to use the CURL library.
233 * The main thread sends instructions to the WUI thread (like "connect",
234 * "disconnect", etc.) using a simple message-passing protocol and
237 * The WUI thread keeps the UI updated by adding idle events which are
238 * processed in the main thread - see:
239 * http://mail.gnome.org/archives/gtk-app-devel-list/2007-March/msg00232.html
241 * A tunnel thread is also started to locally listen for vnc packets
242 * and make them proxyable, adding the vm name, before forwarding onto
245 * Note that under Win32 you must confine all Gtk/Gdk interactions
246 * to a single thread - see:
247 * http://developer.gimp.org/api/2.0/gdk/gdk-Threads.html
249 if (!g_thread_supported ()) {
250 g_thread_init (NULL);
255 fprintf (stderr, "GLib threads not supported or not working.");
259 gtk_init (&argc, &argv);
261 /* Parse command-line options. */
262 context = g_option_context_new ("oVirt viewer");
263 g_option_context_add_main_entries (context, options, NULL);
264 g_option_context_add_group (context, gtk_get_option_group (TRUE));
265 g_option_context_add_group (context, vnc_display_get_option_group ());
266 g_option_context_parse (context, &argc, &argv, &error);
269 g_print ("%s\n%s\n", error->message, help_msg);
270 g_error_free (error);
275 printf ("%s %s\n", PACKAGE, VERSION);
282 DEBUG ("entering the Gtk main loop");
292 /* Create the viewer window, menus. */
302 GtkWidget *sendkeymenu;
303 GtkWidget *sendkeymenuitem;
316 DEBUG ("creating viewer windows and menus");
319 gtk_rc_parse_string (styles);
321 /* Busy cursor, used by main_busy() function.
322 * XXX This cursor is crap - how can we use the Bluecurve/theme cursor?
324 busy_cursor = gdk_cursor_new (GDK_WATCH);
327 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
328 gtk_window_set_default_size (GTK_WINDOW (window), 800, 600);
329 gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
330 gtk_window_set_title (GTK_WINDOW (window), title);
332 g_signal_connect (G_OBJECT (window), "delete_event",
333 G_CALLBACK (delete_event), NULL);
334 g_signal_connect (G_OBJECT (window), "destroy",
335 G_CALLBACK (destroy), NULL);
337 /* VBox for layout within the window. */
338 vbox = gtk_vbox_new (FALSE, 0);
341 menubar = gtk_menu_bar_new ();
342 connectitem = menu_item_new (CONNECT_MENU);
343 connectmenu = gtk_menu_new ();
344 gtk_menu_item_set_submenu (GTK_MENU_ITEM (connectitem), connectmenu);
346 no_connections = gtk_menu_item_new_with_label ("Not connected");
347 gtk_menu_append (GTK_MENU (connectmenu), no_connections);
348 gtk_widget_set_sensitive (no_connections, FALSE);
350 /* This is not added to the menu yet, but will be when we are
354 gtk_menu_item_new_with_label ("Refresh list of virtual machines");
355 g_object_ref (refresh_vmlist);
356 refresh_vmlist_separator = gtk_separator_menu_item_new ();
357 g_object_ref (refresh_vmlist_separator);
359 g_signal_connect (G_OBJECT (refresh_vmlist), "activate",
360 G_CALLBACK (refresh_menu_vm_list), NULL);
363 screenshot = gtk_menu_item_new_with_mnemonic ("_Screenshot");
364 gtk_menu_append (GTK_MENU (filemenu), screenshot);
365 g_signal_connect (screenshot, "activate",
366 GTK_SIGNAL_FUNC (take_screenshot), NULL);
369 view = menu_item_new (VIEW_MENU);
370 viewmenu = gtk_menu_new ();
371 gtk_menu_item_set_submenu (GTK_MENU_ITEM (view), viewmenu);
373 sendkey = menu_item_new (SEND_KEY_MENU);
374 sendkeymenu = gtk_menu_new ();
375 gtk_menu_item_set_submenu (GTK_MENU_ITEM (sendkey), sendkeymenu);
377 for(i = 0; i < NUM_KEY_COMBOS; ++i){
378 sendkeymenuitem = gtk_menu_item_new_with_label (keyCombos[i].label);
379 gtk_menu_append (GTK_MENU (sendkeymenu), sendkeymenuitem);
380 g_signal_connect (G_OBJECT (sendkeymenuitem), "activate",
381 G_CALLBACK (send_key_to_vm), &(keyCombos[i]));
384 wind = menu_item_new (WINDOW_MENU);
385 windmenu = gtk_menu_new ();
386 gtk_menu_item_set_submenu (GTK_MENU_ITEM (wind), windmenu);
388 help = menu_item_new (HELP_MENU);
389 helpmenu = gtk_menu_new ();
390 gtk_menu_item_set_submenu (GTK_MENU_ITEM (help), helpmenu);
392 about = gtk_image_menu_item_new_from_stock(GTK_STOCK_ABOUT, NULL);
393 gtk_menu_append(GTK_MENU(helpmenu), about);
394 g_signal_connect(about, "activate", GTK_SIGNAL_FUNC (help_about), NULL);
396 gtk_menu_bar_append (GTK_MENU_BAR (menubar), connectitem);
397 gtk_menu_bar_append (GTK_MENU_BAR (menubar), view);
398 gtk_menu_bar_append (GTK_MENU_BAR (menubar), sendkey);
399 gtk_menu_bar_append (GTK_MENU_BAR (menubar), wind);
400 gtk_menu_bar_append (GTK_MENU_BAR (menubar), help);
402 /* For login dialogs, etc., usually invisible. */
403 connection_area = gtk_event_box_new ();
404 ca_vbox = gtk_vbox_new (FALSE, 0);
405 ca_label = gtk_label_new ("Give the name of the oVirt management server:");
406 ca_hbox = gtk_hbox_new (FALSE, 0);
407 ca_hostname = gtk_entry_new ();
408 gtk_entry_set_width_chars (GTK_ENTRY (ca_hostname), 24);
409 ca_button = gtk_button_new_with_label ("Connect");
410 ca_error = gtk_label_new (NULL);
411 gtk_box_pack_start (GTK_BOX (ca_hbox), ca_hostname, FALSE, FALSE, 0);
412 gtk_box_pack_start (GTK_BOX (ca_hbox), ca_button, FALSE, FALSE, 0);
413 gtk_box_pack_start (GTK_BOX (ca_vbox), ca_label, FALSE, FALSE, 4);
414 gtk_box_pack_start (GTK_BOX (ca_vbox), ca_hbox, TRUE, FALSE, 4);
415 gtk_box_pack_start (GTK_BOX (ca_vbox), ca_error, TRUE, FALSE, 4);
416 gtk_container_add (GTK_CONTAINER (connection_area), ca_vbox);
418 gtk_widget_set_name (connection_area, "ovirt-viewer-connection-area");
420 g_signal_connect (G_OBJECT (ca_hostname), "key-release-event",
421 G_CALLBACK (connect_to_wui_on_enter), NULL);
422 g_signal_connect (G_OBJECT (ca_button), "clicked",
423 G_CALLBACK (connect_to_wui), NULL);
425 login_area = gtk_event_box_new ();
426 la_vbox = gtk_vbox_new (FALSE, 0);
427 la_hbox = gtk_hbox_new (FALSE, 0);
428 la_label = gtk_label_new ("Username / password:");
429 la_username = gtk_entry_new ();
430 gtk_entry_set_width_chars (GTK_ENTRY (la_username), 12);
431 la_password = gtk_entry_new ();
432 gtk_entry_set_width_chars (GTK_ENTRY (la_password), 12);
433 gtk_entry_set_visibility (GTK_ENTRY (la_password), FALSE);
434 la_button = gtk_button_new_with_label ("Login");
435 la_error = gtk_label_new (NULL);
436 gtk_container_add (GTK_CONTAINER (la_hbox), la_username);
437 gtk_container_add (GTK_CONTAINER (la_hbox), la_password);
438 gtk_container_add (GTK_CONTAINER (la_hbox), la_button);
439 gtk_box_pack_start (GTK_BOX (la_vbox), la_label, TRUE, FALSE, 4);
440 gtk_box_pack_start (GTK_BOX (la_vbox), la_hbox, TRUE, FALSE, 4);
441 gtk_box_pack_start (GTK_BOX (la_vbox), la_error, TRUE, FALSE, 4);
442 gtk_container_add (GTK_CONTAINER (login_area), la_vbox);
444 gtk_widget_set_name (login_area, "ovirt-viewer-login-area");
446 g_signal_connect (G_OBJECT (la_username), "key-release-event",
447 G_CALLBACK (login_to_wui_on_enter), NULL);
448 g_signal_connect (G_OBJECT (la_password), "key-release-event",
449 G_CALLBACK (login_to_wui_on_enter), NULL);
450 g_signal_connect (G_OBJECT (la_button), "clicked",
451 G_CALLBACK (login_to_wui), NULL);
453 /* Tabbed notebook. */
454 notebook = gtk_notebook_new ();
455 /*gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_LEFT);*/
456 gtk_notebook_set_show_tabs (GTK_NOTEBOOK (notebook), TRUE);
457 gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook), TRUE);
460 statusbar = gtk_statusbar_new ();
461 statusbar_ctx = gtk_statusbar_get_context_id (GTK_STATUSBAR (statusbar),
463 gtk_statusbar_push (GTK_STATUSBAR (statusbar), statusbar_ctx, "");
466 gtk_container_add (GTK_CONTAINER (window), vbox);
467 gtk_container_add_with_properties (GTK_CONTAINER (vbox), menubar,
468 "expand", FALSE, NULL);
469 gtk_container_add_with_properties (GTK_CONTAINER (vbox), connection_area,
470 "expand", FALSE, "fill", TRUE, NULL);
471 gtk_container_add_with_properties (GTK_CONTAINER (vbox), login_area,
472 "expand", FALSE, "fill", TRUE, NULL);
473 gtk_container_add_with_properties (GTK_CONTAINER (vbox), notebook,
474 "expand", TRUE, NULL);
475 gtk_container_add_with_properties (GTK_CONTAINER (vbox), statusbar,
476 "expand", FALSE, NULL);
479 gtk_widget_show_all (window);
481 if (wui_thread_is_connected ())
482 gtk_widget_hide (connection_area);
483 if (!wui_thread_is_connected () || wui_thread_is_logged_in ())
484 gtk_widget_hide (login_area);
488 menu_item_new (int which_menu)
494 text = menuItems[which_menu].ungrabbed_text;
496 widget = gtk_menu_item_new ();
497 label = g_object_new (GTK_TYPE_ACCEL_LABEL, NULL);
498 gtk_label_set_text_with_mnemonic (GTK_LABEL (label), text);
499 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
501 gtk_container_add (GTK_CONTAINER (widget), label);
502 gtk_accel_label_set_accel_widget (GTK_ACCEL_LABEL (label), widget);
503 gtk_widget_show (label);
505 menuItems[which_menu].label = label;
511 delete_event (GtkWidget *widget, GdkEvent *event, gpointer data)
513 DEBUG ("delete_event");
518 destroy (GtkWidget *widget, gpointer data)
525 help_about (GtkWidget *menu)
528 const char *authors[] = {
529 "Richard W.M. Jones <rjones@redhat.com>",
530 "Daniel P. Berrange <berrange@redhat.com>",
531 "Mohammed Morsi <mmorsi@redhat.com>",
535 about = gtk_about_dialog_new();
537 gtk_about_dialog_set_name(GTK_ABOUT_DIALOG(about), "oVirt Viewer");
538 gtk_about_dialog_set_version(GTK_ABOUT_DIALOG(about), VERSION);
539 gtk_about_dialog_set_website(GTK_ABOUT_DIALOG(about), "http://ovirt.org/");
540 gtk_about_dialog_set_website_label(GTK_ABOUT_DIALOG(about), "oVirt website");
541 gtk_about_dialog_set_authors(GTK_ABOUT_DIALOG(about), authors);
542 gtk_about_dialog_set_license(GTK_ABOUT_DIALOG(about),
543 "This program is free software; you can redistribute it and/or modify\n" \
544 "it under the terms of the GNU General Public License as published by\n" \
545 "the Free Software Foundation; either version 2 of the License, or\n" \
546 "(at your option) any later version.\n" \
548 "This program is distributed in the hope that it will be useful,\n" \
549 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n" \
550 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n" \
551 "GNU General Public License for more details.\n" \
553 "You should have received a copy of the GNU General Public License\n" \
554 "along with this program; if not, write to the Free Software\n" \
555 "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\n");
557 gtk_dialog_run(GTK_DIALOG(about));
558 gtk_widget_destroy(about);
562 refresh_menu_vm_list(GtkWidget *widget, gpointer data)
564 wui_thread_send_refresh_vm_list();
568 connect_to_wui_on_enter (GtkWidget *widget, gpointer data)
570 // if key released was not 'enter' key
571 if(((GdkEventKey *)data)->type == GDK_KEY_RELEASE && (((GdkEventKey *)data)->keyval & 0xFF) != 13 ) return;
573 connect_to_wui(widget, data);
577 connect_to_wui (GtkWidget *widget, gpointer data)
582 hostname = gtk_entry_get_text (GTK_ENTRY (ca_hostname));
583 if (STREQ (hostname, "")) return;
585 /* https:// + hostname + /ovirt + \0 */
586 len = 8 + strlen (hostname) + 6 + 1;
587 uri = g_alloca (len);
588 snprintf (uri, len, HTTPS "://%s/ovirt", hostname);
590 wui_thread_send_connect (uri);
595 login_to_wui_on_enter (GtkWidget *widget, gpointer data)
597 // if key released was not 'enter' key
598 if(((GdkEventKey *)data)->type == GDK_KEY_RELEASE && (((GdkEventKey *)data)->keyval & 0xFF) != 13 ) return;
600 login_to_wui(widget, data);
604 login_to_wui (GtkWidget *widget, gpointer data)
606 const char *username, *password;
608 username = gtk_entry_get_text (GTK_ENTRY (la_username));
609 if (STREQ (username, "")) return;
610 password = gtk_entry_get_text (GTK_ENTRY (la_password));
612 wui_thread_send_login (username, password);
615 /* Connect to a virtual machine. This callback is called from the
616 * connect menu. It searches the notebook of gtk-vnc widgets to see
617 * if we have already connected to this machine, and if not it
618 * makes a new connection.
621 connect_to_vm (GtkWidget *widget, gpointer _vm)
623 struct vm *vm = (struct vm *) _vm;
624 int n = gtk_notebook_get_n_pages (GTK_NOTEBOOK (notebook));
625 int i, uuidlen, len, fd;
629 char new_title[97]; // 47 chars for title + 50 for vm name
631 DEBUG ("searching tabs for uuid %s", vm->uuid);
633 uuidlen = strlen (vm->uuid);
635 /* Search the tabs for this UUID, and if found, switch to it and return. */
636 for (i = 0; i < n; ++i) {
637 child = gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook), i);
638 label = gtk_notebook_get_tab_label_text (GTK_NOTEBOOK (notebook), child);
639 len = strlen (label);
640 if (len >= uuidlen &&
641 STREQ (label + len - uuidlen, vm->uuid)) {
642 DEBUG ("found on tab %d", i);
643 gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), i);
648 DEBUG ("not found, creating new tab");
650 // before we open vnc connection, make sure vm is running
651 gboolean vm_running = main_vmlist_has_running_vm(vm);
654 main_status_error (g_strdup ("VM not running"));
658 // FIXME on notebook tab switch, change vm_in_focus
661 /* This VM isn't in the notebook already, so create a new console. */
662 DEBUG ("connecting to local tunnel on port %i", tunnel_port);
663 fd = viewer_open_vnc_socket("127.0.0.1", tunnel_port);
664 if (fd == -1) return; /* We've already given an error. */
666 child = vnc_display_new ();
667 if (! vnc_display_open_fd (VNC_DISPLAY (child), fd)) {
668 main_status_error (g_strdup ("internal error in Gtk-VNC widget"));
672 main_status_error(g_strdup(""));
674 for(i = 0; i < 47; ++i) new_title[i] = title_vm[i];
675 for(i = 0; i < 50; ++i){
676 if(vm->description[i] == '\0') break;
677 new_title[47 + i] = vm->description[i];
679 new_title[i < 50 ? i+47 : 96] = '\0';
680 gtk_window_set_title (GTK_WINDOW (window), new_title);
683 gtk_signal_connect(GTK_OBJECT(child), "vnc-pointer-grab",
684 GTK_SIGNAL_FUNC(viewer_grab), window);
685 gtk_signal_connect(GTK_OBJECT(child), "vnc-pointer-ungrab",
686 GTK_SIGNAL_FUNC(viewer_ungrab), window);
689 gtk_signal_connect(GTK_OBJECT(child), "delete-event",
690 GTK_SIGNAL_FUNC(viewer_shutdown), child);
692 gtk_signal_connect(GTK_OBJECT(child), "vnc-connected",
693 GTK_SIGNAL_FUNC(viewer_connected), NULL);
694 gtk_signal_connect(GTK_OBJECT(child), "vnc-initialized",
695 GTK_SIGNAL_FUNC(viewer_initialized), NULL);
696 gtk_signal_connect(GTK_OBJECT(child), "vnc-disconnected",
697 GTK_SIGNAL_FUNC(viewer_disconnected), NULL);
699 g_signal_connect(GTK_OBJECT(child), "vnc-auth-credential",
700 GTK_SIGNAL_FUNC(viewer_credential), NULL);
702 /* NB. We have to do this before adding it to the notebook. */
703 gtk_widget_show (child);
705 /* Choose a tab label, which MUST end with the uuid string, since
706 * we use the tab label to store uuid.
708 len = strlen (vm->description) + 1 + strlen (vm->uuid) + 1;
709 label2 = g_alloca (len);
710 snprintf (label2, len, "%s %s", vm->description, vm->uuid);
712 i = gtk_notebook_append_page (GTK_NOTEBOOK (notebook), child, NULL);
713 gtk_notebook_set_tab_label_text (GTK_NOTEBOOK (notebook), child, label2);
714 gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), i);
716 DEBUG ("finished creating new tab");
719 /* Send key to a virtual machine. This callback is called from the
720 * send key menu. If finds vm in focus, and sends specified key to it
723 send_key_to_vm (GtkWidget *widget, gpointer _keyComboDef)
726 struct keyComboDef* key_combo = (struct keyComboDef*) _keyComboDef;
727 int c = gtk_notebook_get_current_page (GTK_NOTEBOOK (notebook));
733 viewer = gtk_notebook_get_nth_page(GTK_NOTEBOOK (notebook), c);
735 DEBUG ("sending keys to vm");
736 vnc_display_send_keys(VNC_DISPLAY(viewer),
744 static void viewer_grab(GtkWidget *vnc, GtkWidget *window)
748 viewer_set_title(VNC_DISPLAY(vnc), window, TRUE);
750 for (i = 0 ; i < LAST_MENU; i++) {
751 gtk_label_set_text_with_mnemonic(GTK_LABEL(menuItems[i].label), menuItems[i].grabbed_text);
755 static void viewer_ungrab(GtkWidget *vnc, GtkWidget *window)
759 viewer_set_title(VNC_DISPLAY(vnc), window, FALSE);
761 for (i = 0 ; i < LAST_MENU; i++) {
762 gtk_label_set_text_with_mnemonic(GTK_LABEL(menuItems[i].label), menuItems[i].ungrabbed_text);
768 viewer_shutdown (GtkWidget *src, void *dummy, GtkWidget *vnc)
770 vnc_display_close (VNC_DISPLAY(vnc));
772 /* Just close the notebook tab for now. XXX */
773 gtk_notebook_remove_page (GTK_NOTEBOOK (notebook),
774 gtk_notebook_page_num (GTK_NOTEBOOK (notebook),
780 viewer_quit (GtkWidget *src, GtkWidget *vnc)
782 viewer_shutdown (src, NULL, vnc);
787 viewer_connected (GtkWidget *vnc)
789 DEBUG ("Connected to server");
793 viewer_initialized (GtkWidget *vnc, GtkWidget *data)
795 DEBUG ("Connection initialized");
799 viewer_disconnected (GtkWidget *vnc)
801 DEBUG ("Disconnected from server");
805 viewer_credential (GtkWidget *vnc, GValueArray *credList)
807 GtkWidget *dialog = NULL;
809 unsigned int i, prompt = 0;
812 DEBUG ("Got credential request for %d credential(s)",
815 data = g_new0(const char *, credList->n_values);
817 for (i = 0 ; i < credList->n_values ; i++) {
818 GValue *cred = g_value_array_get_nth(credList, i);
819 switch (g_value_get_enum(cred)) {
820 case VNC_DISPLAY_CREDENTIAL_USERNAME:
821 case VNC_DISPLAY_CREDENTIAL_PASSWORD:
824 case VNC_DISPLAY_CREDENTIAL_CLIENTNAME:
832 GtkWidget **label, **entry, *box, *vbox;
834 dialog = gtk_dialog_new_with_buttons("Authentication required",
842 gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
844 box = gtk_table_new(credList->n_values, 2, FALSE);
845 label = g_new(GtkWidget *, prompt);
846 entry = g_new(GtkWidget *, prompt);
848 for (i = 0, row =0 ; i < credList->n_values ; i++) {
849 GValue *cred = g_value_array_get_nth(credList, i);
850 switch (g_value_get_enum(cred)) {
851 case VNC_DISPLAY_CREDENTIAL_USERNAME:
852 label[row] = gtk_label_new("Username:");
854 case VNC_DISPLAY_CREDENTIAL_PASSWORD:
855 label[row] = gtk_label_new("Password:");
860 entry[row] = gtk_entry_new();
861 if (g_value_get_enum(cred) == VNC_DISPLAY_CREDENTIAL_PASSWORD)
862 gtk_entry_set_visibility(GTK_ENTRY(entry[row]), FALSE);
864 gtk_table_attach(GTK_TABLE(box), label[i], 0, 1, row, row+1, GTK_SHRINK, GTK_SHRINK, 3, 3);
865 gtk_table_attach(GTK_TABLE(box), entry[i], 1, 2, row, row+1, GTK_SHRINK, GTK_SHRINK, 3, 3);
869 vbox = gtk_bin_get_child(GTK_BIN(dialog));
870 gtk_container_add(GTK_CONTAINER(vbox), box);
872 gtk_widget_show_all(dialog);
873 response = gtk_dialog_run(GTK_DIALOG(dialog));
874 gtk_widget_hide(GTK_WIDGET(dialog));
876 if (response == GTK_RESPONSE_OK) {
877 for (i = 0, row = 0 ; i < credList->n_values ; i++) {
878 GValue *cred = g_value_array_get_nth(credList, i);
879 switch (g_value_get_enum(cred)) {
880 case VNC_DISPLAY_CREDENTIAL_USERNAME:
881 case VNC_DISPLAY_CREDENTIAL_PASSWORD:
882 data[i] = gtk_entry_get_text(GTK_ENTRY(entry[row]));
889 for (i = 0 ; i < credList->n_values ; i++) {
890 GValue *cred = g_value_array_get_nth(credList, i);
892 if (vnc_display_set_credential(VNC_DISPLAY(vnc),
893 g_value_get_enum(cred),
895 DEBUG("Failed to set credential type %d",
896 g_value_get_enum(cred));
897 vnc_display_close(VNC_DISPLAY(vnc));
900 DEBUG("Unsupported credential type %d",
901 g_value_get_enum(cred));
902 vnc_display_close(VNC_DISPLAY(vnc));
908 gtk_widget_destroy(GTK_WIDGET(dialog));
911 #if defined(HAVE_SOCKET) && defined(HAVE_CONNECT) && defined(HAVE_HTONS)
914 viewer_open_vnc_socket(const char* vnchost, int vncport)
916 int result, socketfd;
918 struct addrinfo* vnc_addr;
920 sprintf(port, "%d", vncport);
922 result = getaddrinfo(vnchost, port, NULL, &vnc_addr);
923 if(result != 0 || vnc_addr == NULL)
926 // just use first found, ignoring rest
927 socketfd = socket(vnc_addr->ai_family,
928 vnc_addr->ai_socktype,
929 vnc_addr->ai_protocol);
931 if(connect(socketfd, vnc_addr->ai_addr, vnc_addr->ai_addrlen) <0)
934 freeaddrinfo(vnc_addr);
939 #endif /* defined(HAVE_SOCKET) && defined(HAVE_CONNECT) && defined(HAVE_HTONS) */
941 /* Remove all menu items from the Connect menu. */
943 remove_menu_item (GtkWidget *menu_item, gpointer data)
945 gtk_container_remove (GTK_CONTAINER (connectmenu), menu_item);
949 clear_connectmenu (void)
951 DEBUG ("clear Connect menu");
952 gtk_container_foreach (GTK_CONTAINER (connectmenu), remove_menu_item, NULL);
955 /* The WUI thread has changed its state to connected. */
957 main_connected (gpointer data)
960 ASSERT_IS_MAIN_THREAD ();
962 gtk_label_set_text (GTK_LABEL (ca_error), NULL);
964 gtk_widget_hide (connection_area);
965 if (!wui_thread_is_logged_in ())
966 gtk_widget_show (login_area);
970 /* The WUI thread has changed its state to disconnected. */
972 main_disconnected (gpointer data)
974 DEBUG ("disconnected");
975 ASSERT_IS_MAIN_THREAD ();
977 gtk_widget_show (connection_area);
978 gtk_widget_hide (login_area);
980 clear_connectmenu ();
981 gtk_menu_append (GTK_MENU (connectmenu), no_connections);
982 gtk_widget_show_all (connectmenu);
987 /* The WUI thread has changed its state to logged in. */
989 main_logged_in (gpointer data)
992 ASSERT_IS_MAIN_THREAD ();
994 gtk_widget_hide (login_area);
998 /* The WUI thread has changed its state to logged out. */
1000 main_logged_out (gpointer data)
1002 DEBUG ("logged out");
1003 ASSERT_IS_MAIN_THREAD ();
1005 if (wui_thread_is_connected ())
1006 gtk_widget_show (login_area);
1010 /* The WUI thread has changed its state to busy. */
1012 main_busy (gpointer data)
1014 GdkWindow *gdk_window;
1017 ASSERT_IS_MAIN_THREAD ();
1019 gdk_window = gtk_widget_get_window (window);
1021 gdk_window_set_cursor (gdk_window, busy_cursor);
1028 /* The WUI thread has changed its state to idle. */
1030 main_idle (gpointer data)
1032 GdkWindow *gdk_window;
1035 ASSERT_IS_MAIN_THREAD ();
1037 gdk_window = gtk_widget_get_window (window);
1039 gdk_window_set_cursor (gdk_window, NULL);
1046 /* The WUI thread had a connection error. This function must
1050 main_connection_error (gpointer _str)
1052 char *str = (char *) _str;
1054 DEBUG ("connection error: %s", str);
1055 ASSERT_IS_MAIN_THREAD ();
1057 gtk_label_set_text (GTK_LABEL (ca_error), str);
1063 /* The WUI thread had a login error. This function must
1067 main_login_error (gpointer _str)
1069 char *str = (char *) _str;
1071 DEBUG ("login error: %s", str);
1072 ASSERT_IS_MAIN_THREAD ();
1074 gtk_label_set_text (GTK_LABEL (la_error), str);
1080 /* The WUI thread reports a general status error. This function
1081 * must free the string.
1084 main_status_error (gpointer _str)
1086 char *str = (char *) _str;
1088 DEBUG ("status error: %s", str);
1089 ASSERT_IS_MAIN_THREAD ();
1091 gtk_statusbar_pop (GTK_STATUSBAR (statusbar), statusbar_ctx);
1092 gtk_statusbar_push (GTK_STATUSBAR (statusbar), statusbar_ctx, str);
1099 main_vmlist_updated (gpointer data)
1103 DEBUG ("vmlist updated");
1104 ASSERT_IS_MAIN_THREAD ();
1106 /* Get the new vmlist. */
1107 if (wui_thread_get_vmlist (&new_vmlist)) {
1108 /* Free the previous vmlist. This invalidates all the vm pointers
1109 * contained in the Connect menu callbacks, but we're going to
1110 * delete those callbacks and create news ones in a moment anyway ...
1112 free_vmlist (vmlist);
1114 vmlist = new_vmlist;
1116 clear_connectmenu ();
1118 gtk_menu_append (GTK_MENU (connectmenu), refresh_vmlist);
1120 if (vmlist != NULL) {
1121 gtk_menu_append (GTK_MENU (connectmenu), refresh_vmlist_separator);
1122 g_slist_foreach (vmlist, add_vm_to_connectmenu, NULL);
1125 /* Grrrr Gtk is stupid. */
1126 gtk_widget_show_all (connectmenu);
1133 add_vm_to_connectmenu (gpointer _vm, gpointer data)
1135 struct vm *vm = (struct vm *) _vm;
1138 // TODO only present running vms ?
1139 // if(vm->state == "running")
1141 DEBUG ("adding %s to Connect menu", vm->description);
1143 item = gtk_menu_item_new_with_label (vm->description);
1144 gtk_menu_append (GTK_MENU (connectmenu), item);
1146 g_signal_connect (G_OBJECT (item), "activate",
1147 G_CALLBACK (connect_to_vm), vm);