X-Git-Url: http://git.annexia.org/?a=blobdiff_plain;f=main.c;h=356d379261ce3cb642a5d9a62a1fabd268f9cfca;hb=96d85a3aa82d2efe8a0f83fcb1bc17e86f8e56b5;hp=039cf3903c215acabf63ecabd690d5d0d42ef47b;hpb=06576813e9eee9338ade91bb2486a52af9507471;p=ovirt-viewer.git diff --git a/main.c b/main.c index 039cf39..356d379 100644 --- a/main.c +++ b/main.c @@ -22,12 +22,20 @@ #include #include #include -#include #include #include +#include #include +#ifdef HAVE_NETDB_H +#include +#endif + +#ifdef HAVE_NETINET_IN_H +#include +#endif + #ifdef HAVE_SYS_SOCKET_H #include #endif @@ -40,10 +48,6 @@ #include #endif -#ifndef G_THREADS_ENABLED -#error "This program requires GLib threads, and cannot be compiled without." -#endif - #include "internal.h" /*#define HTTPS "https"*/ @@ -55,27 +59,63 @@ gboolean debug = 0; * configure or on the command line. */ const char *cainfo = CAINFO; -gboolean check_cert = TRUE; +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; /* 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 { - FILE_MENU, + CONNECT_MENU, VIEW_MENU, SEND_KEY_MENU, WINDOW_MENU, @@ -90,28 +130,60 @@ struct menuItem { }; static struct menuItem menuItems[] = { - { FILE_MENU, NULL, "_File", "File" }, + { 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?). + * 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\ -"; + "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; @@ -123,7 +195,7 @@ static const GOptionEntry options[] = { { "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, - "if --no-check-certificate is passed we don't check the SSL certificate of the server", NULL }, + "check the SSL certificate of the server", NULL }, { "debug", 'd', 0, G_OPTION_ARG_NONE, &debug, "turn on debugging messages", NULL }, { "version", 'V', 0, G_OPTION_ARG_NONE, &print_version, @@ -152,13 +224,19 @@ main (int argc, char *argv[]) * 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 + * + * 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); - gdk_threads_init (); + g_thread_init (NULL); +#ifndef WIN32 + gdk_threads_init (); +#endif } else { - fprintf (stderr, "GLib threads not supported or not working."); - exit (1); + fprintf (stderr, "GLib threads not supported or not working."); + exit (1); } gtk_init (&argc, &argv); @@ -184,6 +262,8 @@ main (int argc, char *argv[]) start_wui_thread (); start_ui (); + DEBUG ("entering the Gtk main loop"); + gtk_main (); stop_wui_thread (); @@ -195,28 +275,36 @@ main (int argc, char *argv[]) static void start_ui (void) { - GtkWidget *window; + int i; GtkWidget *vbox; GtkWidget *menubar; - GtkWidget *file; - GtkWidget *filemenu; 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 *notebook; + 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); @@ -233,9 +321,25 @@ start_ui (void) /* Menubar. */ menubar = gtk_menu_bar_new (); - file = menu_item_new (FILE_MENU); - filemenu = gtk_menu_new (); - gtk_menu_item_set_submenu (GTK_MENU_ITEM (file), filemenu); + 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"); @@ -252,6 +356,13 @@ start_ui (void) 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); @@ -260,7 +371,11 @@ start_ui (void) helpmenu = gtk_menu_new (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (help), helpmenu); - gtk_menu_bar_append (GTK_MENU_BAR (menubar), file); + 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); @@ -274,38 +389,61 @@ start_ui (void) 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_container_add (GTK_CONTAINER (login_area), la_hbox); + 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_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, @@ -316,6 +454,8 @@ start_ui (void) "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); @@ -327,7 +467,7 @@ start_ui (void) } static GtkWidget * -menu_item_new(int which_menu) +menu_item_new (int which_menu) { GtkWidget *widget; GtkWidget *label; @@ -335,14 +475,14 @@ menu_item_new(int which_menu) 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); + 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); + 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; @@ -364,6 +504,57 @@ destroy (GtkWidget *widget, gpointer data) } static void +help_about (GtkWidget *menu) +{ + GtkWidget *about; + const char *authors[] = { + "Richard W.M. Jones ", + "Daniel P. Berrange ", + 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) { const char *hostname; @@ -375,8 +566,564 @@ connect_to_wui (GtkWidget *widget, gpointer data) /* https:// + hostname + /ovirt + \0 */ len = 8 + strlen (hostname) + 6 + 1; - uri = alloca (len); + uri = g_alloca (len); snprintf (uri, len, HTTPS "://%s/ovirt", hostname); wui_thread_send_connect (uri); } + +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; + const char* hostname; + 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; + } + + /* This VM isn't in the notebook already, so create a new console. */ + hostname = gtk_entry_get_text (GTK_ENTRY (ca_hostname)); + fd = viewer_open_vnc_socket(hostname, vm->forward_vnc_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) && defined(HAVE_GETHOSTBYNAME) + +static int +viewer_open_vnc_socket(const char* vnchost, int vncport) +{ + int socketfd; + struct hostent *serv; + struct sockaddr_in serv_addr; + + socketfd = socket(PF_INET, SOCK_STREAM, 0); + if(socketfd < 0){ + return -1; + } + + serv = gethostbyname(vnchost); + if(serv == NULL){ + return -1; + } + + serv_addr.sin_family = PF_INET; + serv_addr.sin_port = htons(vncport); + serv_addr.sin_addr.s_addr = ((struct in_addr *)(serv->h_addr))->s_addr; + + if (connect(socketfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr)) < 0){ + return -1; + } + + return socketfd; +} + +#endif /* defined(HAVE_SOCKET) && defined(HAVE_CONNECT) && defined(HAVE_HTONS) && defined(HAVE_GETHOSTBYNAME) */ + +/* 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); +}