/* ovirt viewer console application * Copyright (C) 2008 Red Hat Inc. * Written by Richard W.M. Jones * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include #include #include #include #include #include #include #include #ifdef HAVE_NETDB_H #include #endif #ifdef HAVE_NETINET_IN_H #include #endif #include #ifdef HAVE_SYS_SOCKET_H #include #endif #ifdef HAVE_SYS_UN_H #include #endif #ifdef HAVE_WINDOWS_H #include #endif #include "internal.h" /*#define HTTPS "https"*/ #define HTTPS "http" gboolean debug = 0; gboolean verbose = 0; /* Usually /etc/pki/tls/certs/ca-bundle.crt unless overridden during * configure or on the command line. */ const char *cainfo = CAINFO; gboolean check_cert = FALSE; // do we want this enabled by default ? // would require a CA by default (self-signed wont work) // (don't set to true, change var/flag to no_check_cert) /* The WUI thread has updated the vm list. Here in the main thread * we keep our own copy of the vmlist. */ static GSList *vmlist = NULL; /* internal.h shared constructs */ const char* hostname; struct vm* vm_in_focus; int ovirt_server_vnc_port = 5900; /* Private functions. */ static void start_ui (void); static GtkWidget *menu_item_new (int which_menu); static void refresh_menu_vm_list (GtkWidget *, gpointer); static void connect_to_wui_on_enter (GtkWidget *, gpointer); static void connect_to_wui (GtkWidget *, gpointer); static void send_key_to_vm (GtkWidget *widget, gpointer _keyComboDef); static void login_to_wui_on_enter (GtkWidget *, gpointer); static void login_to_wui (GtkWidget *, gpointer); static gboolean delete_event (GtkWidget *widget, GdkEvent *event, gpointer data); static void destroy (GtkWidget *widget, gpointer data); static void clear_connectmenu (void); static void help_about (GtkWidget *menu); static void viewer_shutdown (GtkWidget *src, void *dummy, GtkWidget *vnc); #if 0 static void viewer_quit (GtkWidget *src, GtkWidget *vnc); #endif static void viewer_connected (GtkWidget *vnc); static void viewer_initialized (GtkWidget *vnc, GtkWidget *data); static void viewer_disconnected (GtkWidget *vnc); static void viewer_credential (GtkWidget *vnc, GValueArray *credList); static int viewer_open_vnc_socket (const char *vnchost, int vncport); static void add_vm_to_connectmenu (gpointer _vm, gpointer data); /* For any widgets accessed from multiple functions. */ static GtkWidget *window; static GtkWidget *connectitem; static GtkWidget *connectmenu; static GtkWidget *no_connections; static GtkWidget *refresh_vmlist; static GtkWidget *refresh_vmlist_separator; static GtkWidget *connection_area; static GtkWidget *ca_hostname; static GtkWidget *ca_button; static GtkWidget *ca_error; static GtkWidget *login_area; static GtkWidget *la_username; static GtkWidget *la_password; static GtkWidget *la_button; static GtkWidget *la_error; static GtkWidget *notebook; static GtkWidget *statusbar; static guint statusbar_ctx; static GdkCursor *busy_cursor; /* Menus. */ enum menuNums { CONNECT_MENU, VIEW_MENU, SEND_KEY_MENU, WINDOW_MENU, HELP_MENU, }; struct menuItem { guint menu; GtkWidget *label; const char *ungrabbed_text; const char *grabbed_text; }; static struct menuItem menuItems[] = { { CONNECT_MENU, NULL, "_Connect", "Connect" }, { VIEW_MENU, NULL, "_View", "View" }, { SEND_KEY_MENU, NULL, "_Send Key", "Send Key" }, { WINDOW_MENU, NULL, "_Window", "Window" }, { HELP_MENU, NULL, "_Help", "Help" } }; #define MAX_KEY_COMBO 3 struct keyComboDef { guint keys[MAX_KEY_COMBO]; guint nkeys; const char *label; }; #define NUM_KEY_COMBOS 17 static struct keyComboDef keyCombos[] = { { { GDK_Control_L, GDK_Alt_L, GDK_Delete }, 3, "Ctrl+Alt+Del"}, { { GDK_Control_L, GDK_Alt_L, GDK_BackSpace }, 3, "Ctrl+Alt+Backspace"}, { {}, 0, "" }, { { GDK_Control_L, GDK_Alt_L, GDK_F1 }, 3, "Ctrl+Alt+F1"}, { { GDK_Control_L, GDK_Alt_L, GDK_F2 }, 3, "Ctrl+Alt+F2"}, { { GDK_Control_L, GDK_Alt_L, GDK_F3 }, 3, "Ctrl+Alt+F3"}, { { GDK_Control_L, GDK_Alt_L, GDK_F4 }, 3, "Ctrl+Alt+F4"}, { { GDK_Control_L, GDK_Alt_L, GDK_F5 }, 3, "Ctrl+Alt+F5"}, { { GDK_Control_L, GDK_Alt_L, GDK_F6 }, 3, "Ctrl+Alt+F6"}, { { GDK_Control_L, GDK_Alt_L, GDK_F7 }, 3, "Ctrl+Alt+F7"}, { { GDK_Control_L, GDK_Alt_L, GDK_F8 }, 3, "Ctrl+Alt+F8"}, { { GDK_Control_L, GDK_Alt_L, GDK_F5 }, 3, "Ctrl+Alt+F9"}, { { GDK_Control_L, GDK_Alt_L, GDK_F6 }, 3, "Ctrl+Alt+F10"}, { { GDK_Control_L, GDK_Alt_L, GDK_F7 }, 3, "Ctrl+Alt+F11"}, { { GDK_Control_L, GDK_Alt_L, GDK_F8 }, 3, "Ctrl+Alt+F12"}, { {}, 0, "" }, { { GDK_Print }, 1, "PrintScreen"}, }; /* Window title. */ static const char *title = "oVirt Viewer"; // when running vm // 47 chars static const char *title_vm = "oVirt Viewer: (ctrl+alt to grab/release mouse) "; /* Gtk widget styles. Avoid installation hassles by keeping this * inside the binary. It can still be overridden by the user (who * will do that?) */ static const char *styles = "style \"ovirt-viewer-yellow-box\"\n" "{\n" " bg[NORMAL] = shade (1.5, \"yellow\")\n" "}\n" "widget \"*.ovirt-viewer-connection-area\" style \"ovirt-viewer-yellow-box\"\n" ; /* Command-line arguments. */ static int print_version = 0; static const char *help_msg = "Use '" PACKAGE " --help' to see a list of available command line options"; static const GOptionEntry options[] = { { "port", 'p', 0, G_OPTION_ARG_INT, &ovirt_server_vnc_port, "set port which to connect to server via vnc", NULL }, { "cainfo", 0, 0, G_OPTION_ARG_STRING, &cainfo, "set the path of the CA certificate bundle", NULL }, { "check-certificate", 0, 0, G_OPTION_ARG_NONE, &check_cert, "check the SSL certificate of the server", NULL }, { "debug", 'd', 0, G_OPTION_ARG_NONE, &debug, "turn on debugging messages", NULL }, { "verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose, "turn on verbose messages", NULL }, { "version", 'V', 0, G_OPTION_ARG_NONE, &print_version, "display version and exit", NULL }, { NULL, 0, 0, G_OPTION_ARG_NONE, NULL, NULL, NULL } }; int main (int argc, char *argv[]) { GOptionContext *context; GError *error = NULL; /* Initialize GLib threads before anything else. * * There is one main thread, which is used for all Gtk interactions * and to keep the UI responsive, and one WUI thread. The WUI * thread is used to connect to the WUI, log in, and maintain the list * of virtual machines. The WUI thread is the only thread allowed * to use the CURL library. * * The main thread sends instructions to the WUI thread (like "connect", * "disconnect", etc.) using a simple message-passing protocol and * a GAsyncQueue. * * The WUI thread keeps the UI updated by adding idle events which are * processed in the main thread - see: * http://mail.gnome.org/archives/gtk-app-devel-list/2007-March/msg00232.html * * A tunnel thread is also started to locally listen for vnc packets * and make them proxyable, adding the vm name, before forwarding onto * the server * * Note that under Win32 you must confine all Gtk/Gdk interactions * to a single thread - see: * http://developer.gimp.org/api/2.0/gdk/gdk-Threads.html */ if (!g_thread_supported ()) { g_thread_init (NULL); #ifndef WIN32 gdk_threads_init (); #endif } else { fprintf (stderr, "GLib threads not supported or not working."); exit (1); } gtk_init (&argc, &argv); /* Parse command-line options. */ context = g_option_context_new ("oVirt viewer"); g_option_context_add_main_entries (context, options, NULL); g_option_context_add_group (context, gtk_get_option_group (TRUE)); g_option_context_add_group (context, vnc_display_get_option_group ()); g_option_context_parse (context, &argc, &argv, &error); if (error) { g_print ("%s\n%s\n", error->message, help_msg); g_error_free (error); exit (1); } if (print_version) { printf ("%s %s\n", PACKAGE, VERSION); exit (0); } start_wui_thread (); start_ui (); DEBUG ("entering the Gtk main loop"); gtk_main (); stop_wui_thread (); stop_tunnel(); exit (0); } /* Create the viewer window, menus. */ static void start_ui (void) { int i; GtkWidget *vbox; GtkWidget *menubar; GtkWidget *view; GtkWidget *viewmenu; GtkWidget *sendkey; GtkWidget *sendkeymenu; GtkWidget *sendkeymenuitem; GtkWidget *wind; GtkWidget *windmenu; GtkWidget *help; GtkWidget *helpmenu; GtkWidget *about; GtkWidget *ca_vbox; GtkWidget *ca_hbox; GtkWidget *ca_label; GtkWidget *la_vbox; GtkWidget *la_hbox; GtkWidget *la_label; DEBUG ("creating viewer windows and menus"); /* Parse styles. */ gtk_rc_parse_string (styles); /* Busy cursor, used by main_busy() function. * XXX This cursor is crap - how can we use the Bluecurve/theme cursor? */ busy_cursor = gdk_cursor_new (GDK_WATCH); /* Window. */ window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size (GTK_WINDOW (window), 800, 600); gtk_window_set_resizable (GTK_WINDOW (window), TRUE); gtk_window_set_title (GTK_WINDOW (window), title); g_signal_connect (G_OBJECT (window), "delete_event", G_CALLBACK (delete_event), NULL); g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (destroy), NULL); /* VBox for layout within the window. */ vbox = gtk_vbox_new (FALSE, 0); /* Menubar. */ menubar = gtk_menu_bar_new (); connectitem = menu_item_new (CONNECT_MENU); connectmenu = gtk_menu_new (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (connectitem), connectmenu); no_connections = gtk_menu_item_new_with_label ("Not connected"); gtk_menu_append (GTK_MENU (connectmenu), no_connections); gtk_widget_set_sensitive (no_connections, FALSE); /* This is not added to the menu yet, but will be when we are * connected. */ refresh_vmlist = gtk_menu_item_new_with_label ("Refresh list of virtual machines"); g_object_ref (refresh_vmlist); refresh_vmlist_separator = gtk_separator_menu_item_new (); g_object_ref (refresh_vmlist_separator); g_signal_connect (G_OBJECT (refresh_vmlist), "activate", G_CALLBACK (refresh_menu_vm_list), NULL); #if 0 screenshot = gtk_menu_item_new_with_mnemonic ("_Screenshot"); gtk_menu_append (GTK_MENU (filemenu), screenshot); g_signal_connect (screenshot, "activate", GTK_SIGNAL_FUNC (take_screenshot), NULL); #endif view = menu_item_new (VIEW_MENU); viewmenu = gtk_menu_new (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (view), viewmenu); sendkey = menu_item_new (SEND_KEY_MENU); sendkeymenu = gtk_menu_new (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (sendkey), sendkeymenu); for(i = 0; i < NUM_KEY_COMBOS; ++i){ sendkeymenuitem = gtk_menu_item_new_with_label (keyCombos[i].label); gtk_menu_append (GTK_MENU (sendkeymenu), sendkeymenuitem); g_signal_connect (G_OBJECT (sendkeymenuitem), "activate", G_CALLBACK (send_key_to_vm), &(keyCombos[i])); } wind = menu_item_new (WINDOW_MENU); windmenu = gtk_menu_new (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (wind), windmenu); help = menu_item_new (HELP_MENU); helpmenu = gtk_menu_new (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (help), helpmenu); about = gtk_image_menu_item_new_from_stock(GTK_STOCK_ABOUT, NULL); gtk_menu_append(GTK_MENU(helpmenu), about); g_signal_connect(about, "activate", GTK_SIGNAL_FUNC (help_about), NULL); gtk_menu_bar_append (GTK_MENU_BAR (menubar), connectitem); gtk_menu_bar_append (GTK_MENU_BAR (menubar), view); gtk_menu_bar_append (GTK_MENU_BAR (menubar), sendkey); gtk_menu_bar_append (GTK_MENU_BAR (menubar), wind); gtk_menu_bar_append (GTK_MENU_BAR (menubar), help); /* For login dialogs, etc., usually invisible. */ connection_area = gtk_event_box_new (); ca_vbox = gtk_vbox_new (FALSE, 0); ca_label = gtk_label_new ("Give the name of the oVirt management server:"); ca_hbox = gtk_hbox_new (FALSE, 0); ca_hostname = gtk_entry_new (); gtk_entry_set_width_chars (GTK_ENTRY (ca_hostname), 24); ca_button = gtk_button_new_with_label ("Connect"); ca_error = gtk_label_new (NULL); gtk_box_pack_start (GTK_BOX (ca_hbox), ca_hostname, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (ca_hbox), ca_button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (ca_vbox), ca_label, FALSE, FALSE, 4); gtk_box_pack_start (GTK_BOX (ca_vbox), ca_hbox, TRUE, FALSE, 4); gtk_box_pack_start (GTK_BOX (ca_vbox), ca_error, TRUE, FALSE, 4); gtk_container_add (GTK_CONTAINER (connection_area), ca_vbox); gtk_widget_set_name (connection_area, "ovirt-viewer-connection-area"); g_signal_connect (G_OBJECT (ca_hostname), "key-release-event", G_CALLBACK (connect_to_wui_on_enter), NULL); g_signal_connect (G_OBJECT (ca_button), "clicked", G_CALLBACK (connect_to_wui), NULL); login_area = gtk_event_box_new (); la_vbox = gtk_vbox_new (FALSE, 0); la_hbox = gtk_hbox_new (FALSE, 0); la_label = gtk_label_new ("Username / password:"); la_username = gtk_entry_new (); gtk_entry_set_width_chars (GTK_ENTRY (la_username), 12); la_password = gtk_entry_new (); gtk_entry_set_width_chars (GTK_ENTRY (la_password), 12); gtk_entry_set_visibility (GTK_ENTRY (la_password), FALSE); la_button = gtk_button_new_with_label ("Login"); la_error = gtk_label_new (NULL); gtk_container_add (GTK_CONTAINER (la_hbox), la_username); gtk_container_add (GTK_CONTAINER (la_hbox), la_password); gtk_container_add (GTK_CONTAINER (la_hbox), la_button); gtk_box_pack_start (GTK_BOX (la_vbox), la_label, TRUE, FALSE, 4); gtk_box_pack_start (GTK_BOX (la_vbox), la_hbox, TRUE, FALSE, 4); gtk_box_pack_start (GTK_BOX (la_vbox), la_error, TRUE, FALSE, 4); gtk_container_add (GTK_CONTAINER (login_area), la_vbox); gtk_widget_set_name (login_area, "ovirt-viewer-login-area"); g_signal_connect (G_OBJECT (la_username), "key-release-event", G_CALLBACK (login_to_wui_on_enter), NULL); g_signal_connect (G_OBJECT (la_password), "key-release-event", G_CALLBACK (login_to_wui_on_enter), NULL); g_signal_connect (G_OBJECT (la_button), "clicked", G_CALLBACK (login_to_wui), NULL); /* Tabbed notebook. */ notebook = gtk_notebook_new (); /*gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_LEFT);*/ gtk_notebook_set_show_tabs (GTK_NOTEBOOK (notebook), TRUE); gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook), TRUE); /* Status bar. */ statusbar = gtk_statusbar_new (); statusbar_ctx = gtk_statusbar_get_context_id (GTK_STATUSBAR (statusbar), "context"); gtk_statusbar_push (GTK_STATUSBAR (statusbar), statusbar_ctx, ""); /* Packing. */ gtk_container_add (GTK_CONTAINER (window), vbox); gtk_container_add_with_properties (GTK_CONTAINER (vbox), menubar, "expand", FALSE, NULL); gtk_container_add_with_properties (GTK_CONTAINER (vbox), connection_area, "expand", FALSE, "fill", TRUE, NULL); gtk_container_add_with_properties (GTK_CONTAINER (vbox), login_area, "expand", FALSE, "fill", TRUE, NULL); gtk_container_add_with_properties (GTK_CONTAINER (vbox), notebook, "expand", TRUE, NULL); gtk_container_add_with_properties (GTK_CONTAINER (vbox), statusbar, "expand", FALSE, NULL); /* Show widgets. */ gtk_widget_show_all (window); if (wui_thread_is_connected ()) gtk_widget_hide (connection_area); if (!wui_thread_is_connected () || wui_thread_is_logged_in ()) gtk_widget_hide (login_area); } static GtkWidget * menu_item_new (int which_menu) { GtkWidget *widget; GtkWidget *label; const char *text; text = menuItems[which_menu].ungrabbed_text; widget = gtk_menu_item_new (); label = g_object_new (GTK_TYPE_ACCEL_LABEL, NULL); gtk_label_set_text_with_mnemonic (GTK_LABEL (label), text); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_container_add (GTK_CONTAINER (widget), label); gtk_accel_label_set_accel_widget (GTK_ACCEL_LABEL (label), widget); gtk_widget_show (label); menuItems[which_menu].label = label; return widget; } static gboolean delete_event (GtkWidget *widget, GdkEvent *event, gpointer data) { DEBUG ("delete_event"); return FALSE; } static void destroy (GtkWidget *widget, gpointer data) { DEBUG ("destroy"); gtk_main_quit (); } static void help_about (GtkWidget *menu) { GtkWidget *about; const char *authors[] = { "Richard W.M. Jones ", "Daniel P. Berrange ", "Mohammed Morsi ", NULL }; about = gtk_about_dialog_new(); gtk_about_dialog_set_name(GTK_ABOUT_DIALOG(about), "oVirt Viewer"); gtk_about_dialog_set_version(GTK_ABOUT_DIALOG(about), VERSION); gtk_about_dialog_set_website(GTK_ABOUT_DIALOG(about), "http://ovirt.org/"); gtk_about_dialog_set_website_label(GTK_ABOUT_DIALOG(about), "oVirt website"); gtk_about_dialog_set_authors(GTK_ABOUT_DIALOG(about), authors); gtk_about_dialog_set_license(GTK_ABOUT_DIALOG(about), "This program is free software; you can redistribute it and/or modify\n" \ "it under the terms of the GNU General Public License as published by\n" \ "the Free Software Foundation; either version 2 of the License, or\n" \ "(at your option) any later version.\n" \ "\n" \ "This program is distributed in the hope that it will be useful,\n" \ "but WITHOUT ANY WARRANTY; without even the implied warranty of\n" \ "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n" \ "GNU General Public License for more details.\n" \ "\n" \ "You should have received a copy of the GNU General Public License\n" \ "along with this program; if not, write to the Free Software\n" \ "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\n"); gtk_dialog_run(GTK_DIALOG(about)); gtk_widget_destroy(about); } static void refresh_menu_vm_list(GtkWidget *widget, gpointer data) { wui_thread_send_refresh_vm_list(); } static void connect_to_wui_on_enter (GtkWidget *widget, gpointer data) { // if key released was not 'enter' key if(((GdkEventKey *)data)->type == GDK_KEY_RELEASE && (((GdkEventKey *)data)->keyval & 0xFF) != 13 ) return; connect_to_wui(widget, data); } static void connect_to_wui (GtkWidget *widget, gpointer data) { char *uri; int len; hostname = gtk_entry_get_text (GTK_ENTRY (ca_hostname)); if (STREQ (hostname, "")) return; /* https:// + hostname + /ovirt + \0 */ len = 8 + strlen (hostname) + 6 + 1; uri = g_alloca (len); snprintf (uri, len, HTTPS "://%s/ovirt", hostname); wui_thread_send_connect (uri); start_tunnel(); } static void login_to_wui_on_enter (GtkWidget *widget, gpointer data) { // if key released was not 'enter' key if(((GdkEventKey *)data)->type == GDK_KEY_RELEASE && (((GdkEventKey *)data)->keyval & 0xFF) != 13 ) return; login_to_wui(widget, data); } static void login_to_wui (GtkWidget *widget, gpointer data) { const char *username, *password; username = gtk_entry_get_text (GTK_ENTRY (la_username)); if (STREQ (username, "")) return; password = gtk_entry_get_text (GTK_ENTRY (la_password)); wui_thread_send_login (username, password); } /* Connect to a virtual machine. This callback is called from the * connect menu. It searches the notebook of gtk-vnc widgets to see * if we have already connected to this machine, and if not it * makes a new connection. */ static void connect_to_vm (GtkWidget *widget, gpointer _vm) { struct vm *vm = (struct vm *) _vm; int n = gtk_notebook_get_n_pages (GTK_NOTEBOOK (notebook)); int i, uuidlen, len, fd; GtkWidget *child; const char *label; char *label2; char new_title[97]; // 47 chars for title + 50 for vm name DEBUG ("searching tabs for uuid %s", vm->uuid); uuidlen = strlen (vm->uuid); /* Search the tabs for this UUID, and if found, switch to it and return. */ for (i = 0; i < n; ++i) { child = gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook), i); label = gtk_notebook_get_tab_label_text (GTK_NOTEBOOK (notebook), child); len = strlen (label); if (len >= uuidlen && STREQ (label + len - uuidlen, vm->uuid)) { DEBUG ("found on tab %d", i); gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), i); return; } } DEBUG ("not found, creating new tab"); // before we open vnc connection, make sure vm is running gboolean vm_running = main_vmlist_has_running_vm(vm); if(!vm_running){ main_status_error (g_strdup ("VM not running")); return; } // FIXME on notebook tab switch, change vm_in_focus vm_in_focus = vm; /* This VM isn't in the notebook already, so create a new console. */ DEBUG ("connecting to local tunnel on port %i", tunnel_port); fd = viewer_open_vnc_socket("127.0.0.1", tunnel_port); if (fd == -1) return; /* We've already given an error. */ child = vnc_display_new (); if (! vnc_display_open_fd (VNC_DISPLAY (child), fd)) { main_status_error (g_strdup ("internal error in Gtk-VNC widget")); return; } main_status_error(g_strdup("")); for(i = 0; i < 47; ++i) new_title[i] = title_vm[i]; for(i = 0; i < 50; ++i){ if(vm->description[i] == '\0') break; new_title[47 + i] = vm->description[i]; } new_title[i < 50 ? i+47 : 96] = '\0'; gtk_window_set_title (GTK_WINDOW (window), new_title); /* gtk_signal_connect(GTK_OBJECT(child), "vnc-pointer-grab", GTK_SIGNAL_FUNC(viewer_grab), window); gtk_signal_connect(GTK_OBJECT(child), "vnc-pointer-ungrab", GTK_SIGNAL_FUNC(viewer_ungrab), window); */ gtk_signal_connect(GTK_OBJECT(child), "delete-event", GTK_SIGNAL_FUNC(viewer_shutdown), child); gtk_signal_connect(GTK_OBJECT(child), "vnc-connected", GTK_SIGNAL_FUNC(viewer_connected), NULL); gtk_signal_connect(GTK_OBJECT(child), "vnc-initialized", GTK_SIGNAL_FUNC(viewer_initialized), NULL); gtk_signal_connect(GTK_OBJECT(child), "vnc-disconnected", GTK_SIGNAL_FUNC(viewer_disconnected), NULL); g_signal_connect(GTK_OBJECT(child), "vnc-auth-credential", GTK_SIGNAL_FUNC(viewer_credential), NULL); /* NB. We have to do this before adding it to the notebook. */ gtk_widget_show (child); /* Choose a tab label, which MUST end with the uuid string, since * we use the tab label to store uuid. */ len = strlen (vm->description) + 1 + strlen (vm->uuid) + 1; label2 = g_alloca (len); snprintf (label2, len, "%s %s", vm->description, vm->uuid); i = gtk_notebook_append_page (GTK_NOTEBOOK (notebook), child, NULL); gtk_notebook_set_tab_label_text (GTK_NOTEBOOK (notebook), child, label2); gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), i); DEBUG ("finished creating new tab"); } /* Send key to a virtual machine. This callback is called from the * send key menu. If finds vm in focus, and sends specified key to it */ static void send_key_to_vm (GtkWidget *widget, gpointer _keyComboDef) { GtkWidget* viewer; struct keyComboDef* key_combo = (struct keyComboDef*) _keyComboDef; int c = gtk_notebook_get_current_page (GTK_NOTEBOOK (notebook)); if(c < 0){ return; } viewer = gtk_notebook_get_nth_page(GTK_NOTEBOOK (notebook), c); if(viewer != NULL){ DEBUG ("sending keys to vm"); vnc_display_send_keys(VNC_DISPLAY(viewer), key_combo->keys, key_combo->nkeys); } } /* static void viewer_grab(GtkWidget *vnc, GtkWidget *window) { int i; viewer_set_title(VNC_DISPLAY(vnc), window, TRUE); for (i = 0 ; i < LAST_MENU; i++) { gtk_label_set_text_with_mnemonic(GTK_LABEL(menuItems[i].label), menuItems[i].grabbed_text); } } static void viewer_ungrab(GtkWidget *vnc, GtkWidget *window) { int i; viewer_set_title(VNC_DISPLAY(vnc), window, FALSE); for (i = 0 ; i < LAST_MENU; i++) { gtk_label_set_text_with_mnemonic(GTK_LABEL(menuItems[i].label), menuItems[i].ungrabbed_text); } } */ static void viewer_shutdown (GtkWidget *src, void *dummy, GtkWidget *vnc) { vnc_display_close (VNC_DISPLAY(vnc)); /* Just close the notebook tab for now. XXX */ gtk_notebook_remove_page (GTK_NOTEBOOK (notebook), gtk_notebook_page_num (GTK_NOTEBOOK (notebook), vnc)); } #if 0 static void viewer_quit (GtkWidget *src, GtkWidget *vnc) { viewer_shutdown (src, NULL, vnc); } #endif static void viewer_connected (GtkWidget *vnc) { DEBUG ("Connected to server"); } static void viewer_initialized (GtkWidget *vnc, GtkWidget *data) { DEBUG ("Connection initialized"); } static void viewer_disconnected (GtkWidget *vnc) { DEBUG ("Disconnected from server"); } static void viewer_credential (GtkWidget *vnc, GValueArray *credList) { GtkWidget *dialog = NULL; int response; unsigned int i, prompt = 0; const char **data; DEBUG ("Got credential request for %d credential(s)", credList->n_values); data = g_new0(const char *, credList->n_values); for (i = 0 ; i < credList->n_values ; i++) { GValue *cred = g_value_array_get_nth(credList, i); switch (g_value_get_enum(cred)) { case VNC_DISPLAY_CREDENTIAL_USERNAME: case VNC_DISPLAY_CREDENTIAL_PASSWORD: prompt++; break; case VNC_DISPLAY_CREDENTIAL_CLIENTNAME: data[i] = "libvirt"; default: break; } } if (prompt) { GtkWidget **label, **entry, *box, *vbox; int row; dialog = gtk_dialog_new_with_buttons("Authentication required", NULL, 0, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK); box = gtk_table_new(credList->n_values, 2, FALSE); label = g_new(GtkWidget *, prompt); entry = g_new(GtkWidget *, prompt); for (i = 0, row =0 ; i < credList->n_values ; i++) { GValue *cred = g_value_array_get_nth(credList, i); switch (g_value_get_enum(cred)) { case VNC_DISPLAY_CREDENTIAL_USERNAME: label[row] = gtk_label_new("Username:"); break; case VNC_DISPLAY_CREDENTIAL_PASSWORD: label[row] = gtk_label_new("Password:"); break; default: continue; } entry[row] = gtk_entry_new(); if (g_value_get_enum(cred) == VNC_DISPLAY_CREDENTIAL_PASSWORD) gtk_entry_set_visibility(GTK_ENTRY(entry[row]), FALSE); gtk_table_attach(GTK_TABLE(box), label[i], 0, 1, row, row+1, GTK_SHRINK, GTK_SHRINK, 3, 3); gtk_table_attach(GTK_TABLE(box), entry[i], 1, 2, row, row+1, GTK_SHRINK, GTK_SHRINK, 3, 3); row++; } vbox = gtk_bin_get_child(GTK_BIN(dialog)); gtk_container_add(GTK_CONTAINER(vbox), box); gtk_widget_show_all(dialog); response = gtk_dialog_run(GTK_DIALOG(dialog)); gtk_widget_hide(GTK_WIDGET(dialog)); if (response == GTK_RESPONSE_OK) { for (i = 0, row = 0 ; i < credList->n_values ; i++) { GValue *cred = g_value_array_get_nth(credList, i); switch (g_value_get_enum(cred)) { case VNC_DISPLAY_CREDENTIAL_USERNAME: case VNC_DISPLAY_CREDENTIAL_PASSWORD: data[i] = gtk_entry_get_text(GTK_ENTRY(entry[row])); break; } } } } for (i = 0 ; i < credList->n_values ; i++) { GValue *cred = g_value_array_get_nth(credList, i); if (data[i]) { if (vnc_display_set_credential(VNC_DISPLAY(vnc), g_value_get_enum(cred), data[i])) { DEBUG("Failed to set credential type %d", g_value_get_enum(cred)); vnc_display_close(VNC_DISPLAY(vnc)); } } else { DEBUG("Unsupported credential type %d", g_value_get_enum(cred)); vnc_display_close(VNC_DISPLAY(vnc)); } } g_free(data); if (dialog) gtk_widget_destroy(GTK_WIDGET(dialog)); } #if defined(HAVE_SOCKET) && defined(HAVE_CONNECT) && defined(HAVE_HTONS) static int viewer_open_vnc_socket(const char* vnchost, int vncport) { int result, socketfd; char port[10]; struct addrinfo* vnc_addr; sprintf(port, "%d", vncport); result = getaddrinfo(vnchost, port, NULL, &vnc_addr); if(result != 0 || vnc_addr == NULL) return -1; // just use first found, ignoring rest socketfd = socket(vnc_addr->ai_family, vnc_addr->ai_socktype, vnc_addr->ai_protocol); if(connect(socketfd, vnc_addr->ai_addr, vnc_addr->ai_addrlen) <0) socketfd = -1; freeaddrinfo(vnc_addr); return socketfd; } #endif /* defined(HAVE_SOCKET) && defined(HAVE_CONNECT) && defined(HAVE_HTONS) */ /* Remove all menu items from the Connect menu. */ static void remove_menu_item (GtkWidget *menu_item, gpointer data) { gtk_container_remove (GTK_CONTAINER (connectmenu), menu_item); } static void clear_connectmenu (void) { DEBUG ("clear Connect menu"); gtk_container_foreach (GTK_CONTAINER (connectmenu), remove_menu_item, NULL); } /* The WUI thread has changed its state to connected. */ gboolean main_connected (gpointer data) { DEBUG ("connected"); ASSERT_IS_MAIN_THREAD (); gtk_label_set_text (GTK_LABEL (ca_error), NULL); gtk_widget_hide (connection_area); if (!wui_thread_is_logged_in ()) gtk_widget_show (login_area); return FALSE; } /* The WUI thread has changed its state to disconnected. */ gboolean main_disconnected (gpointer data) { DEBUG ("disconnected"); ASSERT_IS_MAIN_THREAD (); gtk_widget_show (connection_area); gtk_widget_hide (login_area); clear_connectmenu (); gtk_menu_append (GTK_MENU (connectmenu), no_connections); gtk_widget_show_all (connectmenu); return FALSE; } /* The WUI thread has changed its state to logged in. */ gboolean main_logged_in (gpointer data) { DEBUG ("logged in"); ASSERT_IS_MAIN_THREAD (); gtk_widget_hide (login_area); return FALSE; } /* The WUI thread has changed its state to logged out. */ gboolean main_logged_out (gpointer data) { DEBUG ("logged out"); ASSERT_IS_MAIN_THREAD (); if (wui_thread_is_connected ()) gtk_widget_show (login_area); return FALSE; } /* The WUI thread has changed its state to busy. */ gboolean main_busy (gpointer data) { GdkWindow *gdk_window; DEBUG ("busy"); ASSERT_IS_MAIN_THREAD (); gdk_window = gtk_widget_get_window (window); if (gdk_window) { gdk_window_set_cursor (gdk_window, busy_cursor); gdk_flush (); } return FALSE; } /* The WUI thread has changed its state to idle. */ gboolean main_idle (gpointer data) { GdkWindow *gdk_window; DEBUG ("idle"); ASSERT_IS_MAIN_THREAD (); gdk_window = gtk_widget_get_window (window); if (gdk_window) { gdk_window_set_cursor (gdk_window, NULL); gdk_flush (); } return FALSE; } /* The WUI thread had a connection error. This function must * free the string. */ gboolean main_connection_error (gpointer _str) { char *str = (char *) _str; DEBUG ("connection error: %s", str); ASSERT_IS_MAIN_THREAD (); gtk_label_set_text (GTK_LABEL (ca_error), str); g_free (str); return FALSE; } /* The WUI thread had a login error. This function must * free the string. */ gboolean main_login_error (gpointer _str) { char *str = (char *) _str; DEBUG ("login error: %s", str); ASSERT_IS_MAIN_THREAD (); gtk_label_set_text (GTK_LABEL (la_error), str); g_free (str); return FALSE; } /* The WUI thread reports a general status error. This function * must free the string. */ gboolean main_status_error (gpointer _str) { char *str = (char *) _str; DEBUG ("status error: %s", str); ASSERT_IS_MAIN_THREAD (); gtk_statusbar_pop (GTK_STATUSBAR (statusbar), statusbar_ctx); gtk_statusbar_push (GTK_STATUSBAR (statusbar), statusbar_ctx, str); g_free (str); return FALSE; } gboolean main_vmlist_updated (gpointer data) { GSList *new_vmlist; DEBUG ("vmlist updated"); ASSERT_IS_MAIN_THREAD (); /* Get the new vmlist. */ if (wui_thread_get_vmlist (&new_vmlist)) { /* Free the previous vmlist. This invalidates all the vm pointers * contained in the Connect menu callbacks, but we're going to * delete those callbacks and create news ones in a moment anyway ... */ free_vmlist (vmlist); vmlist = new_vmlist; clear_connectmenu (); gtk_menu_append (GTK_MENU (connectmenu), refresh_vmlist); if (vmlist != NULL) { gtk_menu_append (GTK_MENU (connectmenu), refresh_vmlist_separator); g_slist_foreach (vmlist, add_vm_to_connectmenu, NULL); } /* Grrrr Gtk is stupid. */ gtk_widget_show_all (connectmenu); } return FALSE; } static void add_vm_to_connectmenu (gpointer _vm, gpointer data) { struct vm *vm = (struct vm *) _vm; GtkWidget *item; // TODO only present running vms ? // if(vm->state == "running") DEBUG ("adding %s to Connect menu", vm->description); item = gtk_menu_item_new_with_label (vm->description); gtk_menu_append (GTK_MENU (connectmenu), item); g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (connect_to_vm), vm); }