main.c

   1 /* ovirt viewer console application
   2  * Copyright (C) 2008 Red Hat Inc.
   3  * Written by Richard W.M. Jones <rjones@redhat.com>
   4  *
   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.
   9  *
  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.
  14  *
  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.
  18  */
  19
  20 #include <config.h>
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <unistd.h>
  25
  26 #include <glib.h>
  27 #include <gtk/gtk.h>
  28 #include <gdk/gdkkeysyms.h>
  29 #include <vncdisplay.h>
  30
  31 #ifdef HAVE_NETDB_H
  32 #include <netdb.h>
  33 #endif
  34
  35 #ifdef HAVE_NETINET_IN_H
  36 #include <netinet/in.h>
  37 #endif
  38
  39 #include <arpa/inet.h>
  40
  41 #ifdef HAVE_SYS_SOCKET_H
  42 #include <sys/socket.h>
  43 #endif
  44
  45 #ifdef HAVE_SYS_UN_H
  46 #include <sys/un.h>
  47 #endif
  48
  49 #ifdef HAVE_WINDOWS_H
  50 #include <windows.h>
  51 #endif
  52
  53 #include "internal.h"
  54
  55 /*#define HTTPS "https"*/
  56 #define HTTPS "http"
  57
  58 gboolean debug = 0;
  59
  60 gboolean verbose = 0;
  61
  62 /* Usually /etc/pki/tls/certs/ca-bundle.crt unless overridden during
  63  * configure or on the command line.
  64  */
  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)
  69
  70 /* The WUI thread has updated the vm list.  Here in the main thread
  71 * we keep our own copy of the vmlist.
  72 */
  73 static GSList *vmlist = NULL;
  74
  75 /*  internal.h shared constructs */
  76 const char* hostname;
  77 struct vm* vm_in_focus;
  78
  79 /* Private functions. */
  80 static void start_ui (void);
  81 static GtkWidget *menu_item_new (int which_menu);
  82 static void refresh_menu_vm_list (GtkWidget *, gpointer);
  83 static void connect_to_wui_on_enter (GtkWidget *, gpointer);
  84 static void connect_to_wui (GtkWidget *, gpointer);
  85 static void send_key_to_vm (GtkWidget *widget, gpointer _keyComboDef);
  86 static void login_to_wui_on_enter (GtkWidget *, gpointer);
  87 static void login_to_wui (GtkWidget *, gpointer);
  88 static gboolean delete_event (GtkWidget *widget, GdkEvent *event, gpointer data);
  89 static void destroy (GtkWidget *widget, gpointer data);
  90 static void clear_connectmenu (void);
  91 static void help_about (GtkWidget *menu);
  92 static void viewer_shutdown (GtkWidget *src, void *dummy, GtkWidget *vnc);
  93 #if 0
  94 static void viewer_quit (GtkWidget *src, GtkWidget *vnc);
  95 #endif
  96 static void viewer_connected (GtkWidget *vnc);
  97 static void viewer_initialized (GtkWidget *vnc, GtkWidget *data);
  98 static void viewer_disconnected (GtkWidget *vnc);
  99 static void viewer_credential (GtkWidget *vnc, GValueArray *credList);
 100 static int viewer_open_vnc_socket (const char *vnchost, int vncport);
 101 static void add_vm_to_connectmenu (gpointer _vm, gpointer data);
 102
 103 /* For any widgets accessed from multiple functions. */
 104 static GtkWidget *window;
 105 static GtkWidget *connectitem;
 106 static GtkWidget *connectmenu;
 107 static GtkWidget *no_connections;
 108 static GtkWidget *refresh_vmlist;
 109 static GtkWidget *refresh_vmlist_separator;
 110 static GtkWidget *connection_area;
 111 static GtkWidget *ca_hostname;
 112 static GtkWidget *ca_button;
 113 static GtkWidget *ca_error;
 114 static GtkWidget *login_area;
 115 static GtkWidget *la_username;
 116 static GtkWidget *la_password;
 117 static GtkWidget *la_button;
 118 static GtkWidget *la_error;
 119 static GtkWidget *notebook;
 120 static GtkWidget *statusbar;
 121 static guint statusbar_ctx;
 122 static GdkCursor *busy_cursor;
 123
 124 /* Menus. */
 125 enum menuNums {
 126   CONNECT_MENU,
 127   VIEW_MENU,
 128   SEND_KEY_MENU,
 129   WINDOW_MENU,
 130   HELP_MENU,
 131 };
 132
 133 struct menuItem {
 134   guint menu;
 135   GtkWidget *label;
 136   const char *ungrabbed_text;
 137   const char *grabbed_text;
 138 };
 139
 140 static struct menuItem menuItems[] = {
 141   { CONNECT_MENU, NULL, "_Connect", "Connect" },
 142   { VIEW_MENU, NULL, "_View", "View" },
 143   { SEND_KEY_MENU, NULL, "_Send Key", "Send Key" },
 144   { WINDOW_MENU, NULL, "_Window", "Window" },
 145   { HELP_MENU, NULL, "_Help", "Help" }
 146 };
 147
 148 #define MAX_KEY_COMBO 3
 149  struct keyComboDef {
 150  guint keys[MAX_KEY_COMBO];
 151  guint nkeys;
 152  const char *label;
 153  };
 154
 155 #define NUM_KEY_COMBOS 17
 156 static struct keyComboDef keyCombos[] = {
 157  { { GDK_Control_L, GDK_Alt_L, GDK_Delete }, 3, "Ctrl+Alt+Del"},
 158  { { GDK_Control_L, GDK_Alt_L, GDK_BackSpace }, 3, "Ctrl+Alt+Backspace"},
 159  { {}, 0, "" },
 160  { { GDK_Control_L, GDK_Alt_L, GDK_F1 }, 3, "Ctrl+Alt+F1"},
 161  { { GDK_Control_L, GDK_Alt_L, GDK_F2 }, 3, "Ctrl+Alt+F2"},
 162  { { GDK_Control_L, GDK_Alt_L, GDK_F3 }, 3, "Ctrl+Alt+F3"},
 163  { { GDK_Control_L, GDK_Alt_L, GDK_F4 }, 3, "Ctrl+Alt+F4"},
 164  { { GDK_Control_L, GDK_Alt_L, GDK_F5 }, 3, "Ctrl+Alt+F5"},
 165  { { GDK_Control_L, GDK_Alt_L, GDK_F6 }, 3, "Ctrl+Alt+F6"},
 166  { { GDK_Control_L, GDK_Alt_L, GDK_F7 }, 3, "Ctrl+Alt+F7"},
 167  { { GDK_Control_L, GDK_Alt_L, GDK_F8 }, 3, "Ctrl+Alt+F8"},
 168  { { GDK_Control_L, GDK_Alt_L, GDK_F5 }, 3, "Ctrl+Alt+F9"},
 169  { { GDK_Control_L, GDK_Alt_L, GDK_F6 }, 3, "Ctrl+Alt+F10"},
 170  { { GDK_Control_L, GDK_Alt_L, GDK_F7 }, 3, "Ctrl+Alt+F11"},
 171  { { GDK_Control_L, GDK_Alt_L, GDK_F8 }, 3, "Ctrl+Alt+F12"},
 172  { {}, 0, "" },
 173  { { GDK_Print }, 1, "PrintScreen"},
 174 };
 175
 176 /* Window title. */
 177 static const char *title = "oVirt Viewer";
 178
 179 // when running vm
 180 // 47 chars
 181 static const char *title_vm =
 182    "oVirt Viewer: (ctrl+alt to grab/release mouse) ";
 183
 184 /* Gtk widget styles.  Avoid installation hassles by keeping this
 185  * inside the binary.  It can still be overridden by the user (who
 186  * will do that?)
 187  */
 188 static const char *styles =
 189   "style \"ovirt-viewer-yellow-box\"\n"
 190   "{\n"
 191   "  bg[NORMAL] = shade (1.5, \"yellow\")\n"
 192   "}\n"
 193   "widget \"*.ovirt-viewer-connection-area\" style \"ovirt-viewer-yellow-box\"\n"
 194   ;
 195
 196 /* Command-line arguments. */
 197 static int print_version = 0;
 198
 199 static const char *help_msg =
 200   "Use '" PACKAGE " --help' to see a list of available command line options";
 201
 202 static const GOptionEntry options[] = {
 203   { "cainfo", 0, 0, G_OPTION_ARG_STRING, &cainfo,
 204     "set the path of the CA certificate bundle", NULL },
 205   { "check-certificate", 0, 0, G_OPTION_ARG_NONE, &check_cert,
 206     "check the SSL certificate of the server", NULL },
 207   { "debug", 'd', 0, G_OPTION_ARG_NONE, &debug,
 208     "turn on debugging messages", NULL },
 209   { "verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose,
 210     "turn on verbose messages", NULL },
 211   { "version", 'V', 0, G_OPTION_ARG_NONE, &print_version,
 212     "display version and exit", NULL },
 213   { NULL, 0, 0, G_OPTION_ARG_NONE, NULL, NULL, NULL }
 214 };
 215
 216 int
 217 main (int argc, char *argv[])
 218 {
 219   GOptionContext *context;
 220   GError *error = NULL;
 221
 222   /* Initialize GLib threads before anything else.
 223    *
 224    * There is one main thread, which is used for all Gtk interactions
 225    * and to keep the UI responsive, and one WUI thread.  The WUI
 226    * thread is used to connect to the WUI, log in, and maintain the list
 227    * of virtual machines.  The WUI thread is the only thread allowed
 228    * to use the CURL library.
 229    *
 230    * The main thread sends instructions to the WUI thread (like "connect",
 231    * "disconnect", etc.) using a simple message-passing protocol and
 232    * a GAsyncQueue.
 233    *
 234    * The WUI thread keeps the UI updated by adding idle events which are
 235    * processed in the main thread - see:
 236    * http://mail.gnome.org/archives/gtk-app-devel-list/2007-March/msg00232.html
 237    *
 238    * A tunnel thread is also started to locally listen for vnc packets
 239    * and make them proxyable, adding the vm name, before forwarding onto
 240    * the server
 241    *
 242    * Note that under Win32 you must confine all Gtk/Gdk interactions
 243    * to a single thread - see:
 244    * http://developer.gimp.org/api/2.0/gdk/gdk-Threads.html
 245    */
 246   if (!g_thread_supported ()) {
 247     g_thread_init (NULL);
 248 #ifndef WIN32
 249     gdk_threads_init ();
 250 #endif
 251   } else {
 252     fprintf (stderr, "GLib threads not supported or not working.");
 253     exit (1);
 254   }
 255
 256   gtk_init (&argc, &argv);
 257
 258   /* Parse command-line options. */
 259   context = g_option_context_new ("oVirt viewer");
 260   g_option_context_add_main_entries (context, options, NULL);
 261   g_option_context_add_group (context, gtk_get_option_group (TRUE));
 262   g_option_context_add_group (context, vnc_display_get_option_group ());
 263   g_option_context_parse (context, &argc, &argv, &error);
 264
 265   if (error) {
 266     g_print ("%s\n%s\n", error->message, help_msg);
 267     g_error_free (error);
 268     exit (1);
 269   }
 270
 271   if (print_version) {
 272     printf ("%s %s\n", PACKAGE, VERSION);
 273     exit (0);
 274   }
 275
 276   start_wui_thread ();
 277   start_ui ();
 278
 279   DEBUG ("entering the Gtk main loop");
 280
 281   gtk_main ();
 282
 283   stop_wui_thread ();
 284   stop_tunnel();
 285
 286   exit (0);
 287 }
 288
 289 /* Create the viewer window, menus. */
 290 static void
 291 start_ui (void)
 292 {
 293   int i;
 294   GtkWidget *vbox;
 295   GtkWidget *menubar;
 296   GtkWidget *view;
 297   GtkWidget *viewmenu;
 298   GtkWidget *sendkey;
 299   GtkWidget *sendkeymenu;
 300   GtkWidget *sendkeymenuitem;
 301   GtkWidget *wind;
 302   GtkWidget *windmenu;
 303   GtkWidget *help;
 304   GtkWidget *helpmenu;
 305   GtkWidget *about;
 306   GtkWidget *ca_vbox;
 307   GtkWidget *ca_hbox;
 308   GtkWidget *ca_label;
 309   GtkWidget *la_vbox;
 310   GtkWidget *la_hbox;
 311   GtkWidget *la_label;
 312
 313   DEBUG ("creating viewer windows and menus");
 314
 315   /* Parse styles. */
 316   gtk_rc_parse_string (styles);
 317
 318   /* Busy cursor, used by main_busy() function.
 319    * XXX This cursor is crap - how can we use the Bluecurve/theme cursor?
 320    */
 321   busy_cursor = gdk_cursor_new (GDK_WATCH);
 322
 323   /* Window. */
 324   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 325   gtk_window_set_default_size (GTK_WINDOW (window), 800, 600);
 326   gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
 327   gtk_window_set_title (GTK_WINDOW (window), title);
 328
 329   g_signal_connect (G_OBJECT (window), "delete_event",
 330                     G_CALLBACK (delete_event), NULL);
 331   g_signal_connect (G_OBJECT (window), "destroy",
 332                     G_CALLBACK (destroy), NULL);
 333
 334   /* VBox for layout within the window. */
 335   vbox = gtk_vbox_new (FALSE, 0);
 336
 337   /* Menubar. */
 338   menubar = gtk_menu_bar_new ();
 339   connectitem = menu_item_new (CONNECT_MENU);
 340   connectmenu = gtk_menu_new ();
 341   gtk_menu_item_set_submenu (GTK_MENU_ITEM (connectitem), connectmenu);
 342
 343   no_connections = gtk_menu_item_new_with_label ("Not connected");
 344   gtk_menu_append (GTK_MENU (connectmenu), no_connections);
 345   gtk_widget_set_sensitive (no_connections, FALSE);
 346
 347   /* This is not added to the menu yet, but will be when we are
 348    * connected.
 349    */
 350   refresh_vmlist =
 351     gtk_menu_item_new_with_label ("Refresh list of virtual machines");
 352   g_object_ref (refresh_vmlist);
 353   refresh_vmlist_separator = gtk_separator_menu_item_new ();
 354   g_object_ref (refresh_vmlist_separator);
 355
 356   g_signal_connect (G_OBJECT (refresh_vmlist), "activate",
 357                     G_CALLBACK (refresh_menu_vm_list), NULL);
 358
 359 #if 0
 360   screenshot = gtk_menu_item_new_with_mnemonic ("_Screenshot");
 361   gtk_menu_append (GTK_MENU (filemenu), screenshot);
 362   g_signal_connect (screenshot, "activate",
 363                     GTK_SIGNAL_FUNC (take_screenshot), NULL);
 364 #endif
 365
 366   view = menu_item_new (VIEW_MENU);
 367   viewmenu = gtk_menu_new ();
 368   gtk_menu_item_set_submenu (GTK_MENU_ITEM (view), viewmenu);
 369
 370   sendkey = menu_item_new (SEND_KEY_MENU);
 371   sendkeymenu = gtk_menu_new ();
 372   gtk_menu_item_set_submenu (GTK_MENU_ITEM (sendkey), sendkeymenu);
 373
 374   for(i = 0; i < NUM_KEY_COMBOS; ++i){
 375     sendkeymenuitem = gtk_menu_item_new_with_label (keyCombos[i].label);
 376     gtk_menu_append (GTK_MENU (sendkeymenu), sendkeymenuitem);
 377     g_signal_connect (G_OBJECT (sendkeymenuitem), "activate",
 378                       G_CALLBACK (send_key_to_vm), &(keyCombos[i]));
 379   }
 380
 381   wind = menu_item_new (WINDOW_MENU);
 382   windmenu = gtk_menu_new ();
 383   gtk_menu_item_set_submenu (GTK_MENU_ITEM (wind), windmenu);
 384
 385   help = menu_item_new (HELP_MENU);
 386   helpmenu = gtk_menu_new ();
 387   gtk_menu_item_set_submenu (GTK_MENU_ITEM (help), helpmenu);
 388
 389   about = gtk_image_menu_item_new_from_stock(GTK_STOCK_ABOUT, NULL);
 390   gtk_menu_append(GTK_MENU(helpmenu), about);
 391   g_signal_connect(about, "activate", GTK_SIGNAL_FUNC (help_about), NULL);
 392
 393   gtk_menu_bar_append (GTK_MENU_BAR (menubar), connectitem);
 394   gtk_menu_bar_append (GTK_MENU_BAR (menubar), view);
 395   gtk_menu_bar_append (GTK_MENU_BAR (menubar), sendkey);
 396   gtk_menu_bar_append (GTK_MENU_BAR (menubar), wind);
 397   gtk_menu_bar_append (GTK_MENU_BAR (menubar), help);
 398
 399   /* For login dialogs, etc., usually invisible. */
 400   connection_area = gtk_event_box_new ();
 401   ca_vbox = gtk_vbox_new (FALSE, 0);
 402   ca_label = gtk_label_new ("Give the name of the oVirt management server:");
 403   ca_hbox = gtk_hbox_new (FALSE, 0);
 404   ca_hostname = gtk_entry_new ();
 405   gtk_entry_set_width_chars (GTK_ENTRY (ca_hostname), 24);
 406   ca_button = gtk_button_new_with_label ("Connect");
 407   ca_error = gtk_label_new (NULL);
 408   gtk_box_pack_start (GTK_BOX (ca_hbox), ca_hostname, FALSE, FALSE, 0);
 409   gtk_box_pack_start (GTK_BOX (ca_hbox), ca_button,   FALSE, FALSE, 0);
 410   gtk_box_pack_start (GTK_BOX (ca_vbox), ca_label,    FALSE, FALSE, 4);
 411   gtk_box_pack_start (GTK_BOX (ca_vbox), ca_hbox,     TRUE,  FALSE, 4);
 412   gtk_box_pack_start (GTK_BOX (ca_vbox), ca_error,    TRUE,  FALSE, 4);
 413   gtk_container_add (GTK_CONTAINER (connection_area), ca_vbox);
 414
 415   gtk_widget_set_name (connection_area, "ovirt-viewer-connection-area");
 416
 417   g_signal_connect (G_OBJECT (ca_hostname), "key-release-event",
 418                     G_CALLBACK (connect_to_wui_on_enter), NULL);
 419   g_signal_connect (G_OBJECT (ca_button), "clicked",
 420                     G_CALLBACK (connect_to_wui), NULL);
 421
 422   login_area = gtk_event_box_new ();
 423   la_vbox = gtk_vbox_new (FALSE, 0);
 424   la_hbox = gtk_hbox_new (FALSE, 0);
 425   la_label = gtk_label_new ("Username / password:");
 426   la_username = gtk_entry_new ();
 427   gtk_entry_set_width_chars (GTK_ENTRY (la_username), 12);
 428   la_password = gtk_entry_new ();
 429   gtk_entry_set_width_chars (GTK_ENTRY (la_password), 12);
 430   gtk_entry_set_visibility (GTK_ENTRY (la_password), FALSE);
 431   la_button = gtk_button_new_with_label ("Login");
 432   la_error = gtk_label_new (NULL);
 433   gtk_container_add (GTK_CONTAINER (la_hbox), la_username);
 434   gtk_container_add (GTK_CONTAINER (la_hbox), la_password);
 435   gtk_container_add (GTK_CONTAINER (la_hbox), la_button);
 436   gtk_box_pack_start (GTK_BOX (la_vbox), la_label,     TRUE,  FALSE, 4);
 437   gtk_box_pack_start (GTK_BOX (la_vbox), la_hbox,     TRUE,  FALSE, 4);
 438   gtk_box_pack_start (GTK_BOX (la_vbox), la_error,    TRUE,  FALSE, 4);
 439   gtk_container_add (GTK_CONTAINER (login_area), la_vbox);
 440
 441   gtk_widget_set_name (login_area, "ovirt-viewer-login-area");
 442
 443   g_signal_connect (G_OBJECT (la_username), "key-release-event",
 444                     G_CALLBACK (login_to_wui_on_enter), NULL);
 445   g_signal_connect (G_OBJECT (la_password), "key-release-event",
 446                     G_CALLBACK (login_to_wui_on_enter), NULL);
 447   g_signal_connect (G_OBJECT (la_button), "clicked",
 448                     G_CALLBACK (login_to_wui), NULL);
 449
 450   /* Tabbed notebook. */
 451   notebook = gtk_notebook_new ();
 452   /*gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_LEFT);*/
 453   gtk_notebook_set_show_tabs (GTK_NOTEBOOK (notebook), TRUE);
 454   gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook), TRUE);
 455
 456   /* Status bar. */
 457   statusbar = gtk_statusbar_new ();
 458   statusbar_ctx = gtk_statusbar_get_context_id (GTK_STATUSBAR (statusbar),
 459                                                 "context");
 460   gtk_statusbar_push (GTK_STATUSBAR (statusbar), statusbar_ctx, "");
 461
 462   /* Packing. */
 463   gtk_container_add (GTK_CONTAINER (window), vbox);
 464   gtk_container_add_with_properties (GTK_CONTAINER (vbox), menubar,
 465                                      "expand", FALSE, NULL);
 466   gtk_container_add_with_properties (GTK_CONTAINER (vbox), connection_area,
 467                                      "expand", FALSE, "fill", TRUE, NULL);
 468   gtk_container_add_with_properties (GTK_CONTAINER (vbox), login_area,
 469                                      "expand", FALSE, "fill", TRUE, NULL);
 470   gtk_container_add_with_properties (GTK_CONTAINER (vbox), notebook,
 471                                      "expand", TRUE, NULL);
 472   gtk_container_add_with_properties (GTK_CONTAINER (vbox), statusbar,
 473                                      "expand", FALSE, NULL);
 474
 475   /* Show widgets. */
 476   gtk_widget_show_all (window);
 477
 478   if (wui_thread_is_connected ())
 479     gtk_widget_hide (connection_area);
 480   if (!wui_thread_is_connected () || wui_thread_is_logged_in ())
 481     gtk_widget_hide (login_area);
 482 }
 483
 484 static GtkWidget *
 485 menu_item_new (int which_menu)
 486 {
 487   GtkWidget *widget;
 488   GtkWidget *label;
 489   const char *text;
 490
 491   text = menuItems[which_menu].ungrabbed_text;
 492
 493   widget = gtk_menu_item_new ();
 494   label = g_object_new (GTK_TYPE_ACCEL_LABEL, NULL);
 495   gtk_label_set_text_with_mnemonic (GTK_LABEL (label), text);
 496   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
 497
 498   gtk_container_add (GTK_CONTAINER (widget), label);
 499   gtk_accel_label_set_accel_widget (GTK_ACCEL_LABEL (label), widget);
 500   gtk_widget_show (label);
 501
 502   menuItems[which_menu].label = label;
 503
 504   return widget;
 505 }
 506
 507 static gboolean
 508 delete_event (GtkWidget *widget, GdkEvent *event, gpointer data)
 509 {
 510   DEBUG ("delete_event");
 511   return FALSE;
 512 }
 513
 514 static void
 515 destroy (GtkWidget *widget, gpointer data)
 516 {
 517   DEBUG ("destroy");
 518   gtk_main_quit ();
 519 }
 520
 521 static void
 522 help_about (GtkWidget *menu)
 523 {
 524   GtkWidget *about;
 525   const char *authors[] = {
 526     "Richard W.M. Jones <rjones@redhat.com>",
 527     "Daniel P. Berrange <berrange@redhat.com>",
 528     "Mohammed Morsi <mmorsi@redhat.com>",
 529     NULL
 530   };
 531
 532   about = gtk_about_dialog_new();
 533
 534   gtk_about_dialog_set_name(GTK_ABOUT_DIALOG(about), "oVirt Viewer");
 535   gtk_about_dialog_set_version(GTK_ABOUT_DIALOG(about), VERSION);
 536   gtk_about_dialog_set_website(GTK_ABOUT_DIALOG(about), "http://ovirt.org/");
 537   gtk_about_dialog_set_website_label(GTK_ABOUT_DIALOG(about), "oVirt website");
 538   gtk_about_dialog_set_authors(GTK_ABOUT_DIALOG(about), authors);
 539   gtk_about_dialog_set_license(GTK_ABOUT_DIALOG(about),
 540  "This program is free software; you can redistribute it and/or modify\n" \
 541  "it under the terms of the GNU General Public License as published by\n" \
 542  "the Free Software Foundation; either version 2 of the License, or\n" \
 543  "(at your option) any later version.\n" \
 544  "\n" \
 545  "This program is distributed in the hope that it will be useful,\n" \
 546  "but WITHOUT ANY WARRANTY; without even the implied warranty of\n" \
 547  "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n" \
 548  "GNU General Public License for more details.\n" \
 549  "\n" \
 550  "You should have received a copy of the GNU General Public License\n" \
 551  "along with this program; if not, write to the Free Software\n" \
 552  "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n");
 553
 554   gtk_dialog_run(GTK_DIALOG(about));
 555   gtk_widget_destroy(about);
 556 }
 557
 558 static void
 559 refresh_menu_vm_list(GtkWidget *widget, gpointer data)
 560 {
 561    wui_thread_send_refresh_vm_list();
 562 }
 563
 564 static void
 565 connect_to_wui_on_enter (GtkWidget *widget, gpointer data)
 566 {
 567   // if key released was not 'enter' key
 568   if(((GdkEventKey *)data)->type == GDK_KEY_RELEASE && (((GdkEventKey *)data)->keyval & 0xFF) != 13 ) return;
 569
 570   connect_to_wui(widget, data);
 571 }
 572
 573 static void
 574 connect_to_wui (GtkWidget *widget, gpointer data)
 575 {
 576   char *uri;
 577   int len;
 578
 579   hostname = gtk_entry_get_text (GTK_ENTRY (ca_hostname));
 580   if (STREQ (hostname, "")) return;
 581
 582   /* https:// + hostname + /ovirt + \0 */
 583   len = 8 + strlen (hostname) + 6 + 1;
 584   uri = g_alloca (len);
 585   snprintf (uri, len, HTTPS "://%s/ovirt", hostname);
 586
 587   wui_thread_send_connect (uri);
 588   start_tunnel();
 589 }
 590
 591 static void
 592 login_to_wui_on_enter (GtkWidget *widget, gpointer data)
 593 {
 594   // if key released was not 'enter' key
 595   if(((GdkEventKey *)data)->type == GDK_KEY_RELEASE && (((GdkEventKey *)data)->keyval & 0xFF) != 13 ) return;
 596
 597   login_to_wui(widget, data);
 598 }
 599
 600 static void
 601 login_to_wui (GtkWidget *widget, gpointer data)
 602 {
 603   const char *username, *password;
 604
 605   username = gtk_entry_get_text (GTK_ENTRY (la_username));
 606   if (STREQ (username, "")) return;
 607   password = gtk_entry_get_text (GTK_ENTRY (la_password));
 608
 609   wui_thread_send_login (username, password);
 610 }
 611
 612 /* Connect to a virtual machine.  This callback is called from the
 613  * connect menu.  It searches the notebook of gtk-vnc widgets to see
 614  * if we have already connected to this machine, and if not it
 615  * makes a new connection.
 616  */
 617 static void
 618 connect_to_vm (GtkWidget *widget, gpointer _vm)
 619 {
 620   struct vm *vm = (struct vm *) _vm;
 621   int n = gtk_notebook_get_n_pages (GTK_NOTEBOOK (notebook));
 622   int i, uuidlen, len, fd;
 623   GtkWidget *child;
 624   const char *label;
 625   char *label2;
 626   char new_title[97]; // 47 chars for title + 50 for vm name
 627
 628   DEBUG ("searching tabs for uuid %s", vm->uuid);
 629
 630   uuidlen = strlen (vm->uuid);
 631
 632   /* Search the tabs for this UUID, and if found, switch to it and return. */
 633   for (i = 0; i < n; ++i) {
 634     child = gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook), i);
 635     label = gtk_notebook_get_tab_label_text (GTK_NOTEBOOK (notebook), child);
 636     len = strlen (label);
 637     if (len >= uuidlen &&
 638         STREQ (label + len - uuidlen, vm->uuid)) {
 639       DEBUG ("found on tab %d", i);
 640       gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), i);
 641       return;
 642     }
 643   }
 644
 645   DEBUG ("not found, creating new tab");
 646
 647   // before we open vnc connection, make sure vm is running
 648   gboolean vm_running = main_vmlist_has_running_vm(vm);
 649
 650   if(!vm_running){
 651     main_status_error (g_strdup ("VM not running"));
 652     return;
 653   }
 654
 655   // FIXME on notebook tab switch, change vm_in_focus
 656   vm_in_focus = vm;
 657
 658   /* This VM isn't in the notebook already, so create a new console. */
 659   DEBUG ("connecting to local tunnel on port %i", tunnel_port);
 660   fd = viewer_open_vnc_socket("127.0.0.1", tunnel_port);
 661   if (fd == -1) return;         /* We've already given an error. */
 662
 663   child = vnc_display_new ();
 664   if (! vnc_display_open_fd (VNC_DISPLAY (child), fd)) {
 665     main_status_error (g_strdup ("internal error in Gtk-VNC widget"));
 666     return;
 667   }
 668
 669   main_status_error(g_strdup(""));
 670
 671   for(i = 0; i < 47; ++i) new_title[i] = title_vm[i];
 672   for(i = 0; i < 50; ++i){
 673      if(vm->description[i] == '\0') break;
 674      new_title[47 + i] = vm->description[i];
 675   }
 676   new_title[i < 50 ? i+47 : 96] = '\0';
 677   gtk_window_set_title (GTK_WINDOW (window), new_title);
 678
 679   /*
 680   gtk_signal_connect(GTK_OBJECT(child), "vnc-pointer-grab",
 681                      GTK_SIGNAL_FUNC(viewer_grab), window);
 682   gtk_signal_connect(GTK_OBJECT(child), "vnc-pointer-ungrab",
 683                      GTK_SIGNAL_FUNC(viewer_ungrab), window);
 684   */
 685
 686   gtk_signal_connect(GTK_OBJECT(child), "delete-event",
 687                      GTK_SIGNAL_FUNC(viewer_shutdown), child);
 688
 689   gtk_signal_connect(GTK_OBJECT(child), "vnc-connected",
 690                      GTK_SIGNAL_FUNC(viewer_connected), NULL);
 691   gtk_signal_connect(GTK_OBJECT(child), "vnc-initialized",
 692                      GTK_SIGNAL_FUNC(viewer_initialized), NULL);
 693   gtk_signal_connect(GTK_OBJECT(child), "vnc-disconnected",
 694                      GTK_SIGNAL_FUNC(viewer_disconnected), NULL);
 695
 696   g_signal_connect(GTK_OBJECT(child), "vnc-auth-credential",
 697                    GTK_SIGNAL_FUNC(viewer_credential), NULL);
 698
 699   /* NB. We have to do this before adding it to the notebook. */
 700   gtk_widget_show (child);
 701
 702   /* Choose a tab label, which MUST end with the uuid string, since
 703    * we use the tab label to store uuid.
 704    */
 705   len = strlen (vm->description) + 1 + strlen (vm->uuid) + 1;
 706   label2 = g_alloca (len);
 707   snprintf (label2, len, "%s %s", vm->description, vm->uuid);
 708
 709   i = gtk_notebook_append_page (GTK_NOTEBOOK (notebook), child, NULL);
 710   gtk_notebook_set_tab_label_text (GTK_NOTEBOOK (notebook), child, label2);
 711   gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), i);
 712
 713   DEBUG ("finished creating new tab");
 714 }
 715
 716 /* Send key to a virtual machine.  This callback is called from the
 717  * send key menu.  If finds vm in focus, and sends specified key to it
 718  */
 719 static void
 720 send_key_to_vm (GtkWidget *widget, gpointer _keyComboDef)
 721 {
 722   GtkWidget* viewer;
 723   struct keyComboDef* key_combo = (struct keyComboDef*) _keyComboDef;
 724   int c = gtk_notebook_get_current_page (GTK_NOTEBOOK (notebook));
 725
 726   if(c < 0){
 727     return;
 728   }
 729
 730   viewer = gtk_notebook_get_nth_page(GTK_NOTEBOOK (notebook), c);
 731   if(viewer != NULL){
 732     DEBUG ("sending keys to vm");
 733     vnc_display_send_keys(VNC_DISPLAY(viewer),
 734                           key_combo->keys,
 735                           key_combo->nkeys);
 736   }
 737 }
 738
 739
 740 /*
 741 static void viewer_grab(GtkWidget *vnc, GtkWidget *window)
 742 {
 743         int i;
 744
 745         viewer_set_title(VNC_DISPLAY(vnc), window, TRUE);
 746
 747         for (i = 0 ; i < LAST_MENU; i++) {
 748                 gtk_label_set_text_with_mnemonic(GTK_LABEL(menuItems[i].label), menuItems[i].grabbed_text);
 749         }
 750 }
 751
 752 static void viewer_ungrab(GtkWidget *vnc, GtkWidget *window)
 753 {
 754         int i;
 755
 756         viewer_set_title(VNC_DISPLAY(vnc), window, FALSE);
 757
 758         for (i = 0 ; i < LAST_MENU; i++) {
 759                 gtk_label_set_text_with_mnemonic(GTK_LABEL(menuItems[i].label), menuItems[i].ungrabbed_text);
 760         }
 761 }
 762 */
 763
 764 static void
 765 viewer_shutdown (GtkWidget *src, void *dummy, GtkWidget *vnc)
 766 {
 767   vnc_display_close (VNC_DISPLAY(vnc));
 768
 769   /* Just close the notebook tab for now. XXX */
 770   gtk_notebook_remove_page (GTK_NOTEBOOK (notebook),
 771                             gtk_notebook_page_num (GTK_NOTEBOOK (notebook),
 772                                                    vnc));
 773 }
 774
 775 #if 0
 776 static void
 777 viewer_quit (GtkWidget *src, GtkWidget *vnc)
 778 {
 779   viewer_shutdown (src, NULL, vnc);
 780 }
 781 #endif
 782
 783 static void
 784 viewer_connected (GtkWidget *vnc)
 785 {
 786   DEBUG ("Connected to server");
 787 }
 788
 789 static void
 790 viewer_initialized (GtkWidget *vnc, GtkWidget *data)
 791 {
 792   DEBUG ("Connection initialized");
 793 }
 794
 795 static void
 796 viewer_disconnected (GtkWidget *vnc)
 797 {
 798   DEBUG ("Disconnected from server");
 799 }
 800
 801 static void
 802 viewer_credential (GtkWidget *vnc, GValueArray *credList)
 803 {
 804         GtkWidget *dialog = NULL;
 805         int response;
 806         unsigned int i, prompt = 0;
 807         const char **data;
 808
 809         DEBUG ("Got credential request for %d credential(s)",
 810                credList->n_values);
 811
 812         data = g_new0(const char *, credList->n_values);
 813
 814         for (i = 0 ; i < credList->n_values ; i++) {
 815                 GValue *cred = g_value_array_get_nth(credList, i);
 816                 switch (g_value_get_enum(cred)) {
 817                 case VNC_DISPLAY_CREDENTIAL_USERNAME:
 818                 case VNC_DISPLAY_CREDENTIAL_PASSWORD:
 819                         prompt++;
 820                         break;
 821                 case VNC_DISPLAY_CREDENTIAL_CLIENTNAME:
 822                         data[i] = "libvirt";
 823                 default:
 824                         break;
 825                 }
 826         }
 827
 828         if (prompt) {
 829                 GtkWidget **label, **entry, *box, *vbox;
 830                 int row;
 831                 dialog = gtk_dialog_new_with_buttons("Authentication required",
 832                                                      NULL,
 833                                                      0,
 834                                                      GTK_STOCK_CANCEL,
 835                                                      GTK_RESPONSE_CANCEL,
 836                                                      GTK_STOCK_OK,
 837                                                      GTK_RESPONSE_OK,
 838                                                      NULL);
 839                 gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
 840
 841                 box = gtk_table_new(credList->n_values, 2, FALSE);
 842                 label = g_new(GtkWidget *, prompt);
 843                 entry = g_new(GtkWidget *, prompt);
 844
 845                 for (i = 0, row =0 ; i < credList->n_values ; i++) {
 846                         GValue *cred = g_value_array_get_nth(credList, i);
 847                         switch (g_value_get_enum(cred)) {
 848                         case VNC_DISPLAY_CREDENTIAL_USERNAME:
 849                                 label[row] = gtk_label_new("Username:");
 850                                 break;
 851                         case VNC_DISPLAY_CREDENTIAL_PASSWORD:
 852                                 label[row] = gtk_label_new("Password:");
 853                                 break;
 854                         default:
 855                                 continue;
 856                         }
 857                         entry[row] = gtk_entry_new();
 858                         if (g_value_get_enum(cred) == VNC_DISPLAY_CREDENTIAL_PASSWORD)
 859                                 gtk_entry_set_visibility(GTK_ENTRY(entry[row]), FALSE);
 860
 861                         gtk_table_attach(GTK_TABLE(box), label[i], 0, 1, row, row+1, GTK_SHRINK, GTK_SHRINK, 3, 3);
 862                         gtk_table_attach(GTK_TABLE(box), entry[i], 1, 2, row, row+1, GTK_SHRINK, GTK_SHRINK, 3, 3);
 863                         row++;
 864                 }
 865
 866                 vbox = gtk_bin_get_child(GTK_BIN(dialog));
 867                 gtk_container_add(GTK_CONTAINER(vbox), box);
 868
 869                 gtk_widget_show_all(dialog);
 870                 response = gtk_dialog_run(GTK_DIALOG(dialog));
 871                 gtk_widget_hide(GTK_WIDGET(dialog));
 872
 873                 if (response == GTK_RESPONSE_OK) {
 874                         for (i = 0, row = 0 ; i < credList->n_values ; i++) {
 875                                 GValue *cred = g_value_array_get_nth(credList, i);
 876                                 switch (g_value_get_enum(cred)) {
 877                                 case VNC_DISPLAY_CREDENTIAL_USERNAME:
 878                                 case VNC_DISPLAY_CREDENTIAL_PASSWORD:
 879                                         data[i] = gtk_entry_get_text(GTK_ENTRY(entry[row]));
 880                                         break;
 881                                 }
 882                         }
 883                 }
 884         }
 885
 886         for (i = 0 ; i < credList->n_values ; i++) {
 887                 GValue *cred = g_value_array_get_nth(credList, i);
 888                 if (data[i]) {
 889                         if (vnc_display_set_credential(VNC_DISPLAY(vnc),
 890                                                        g_value_get_enum(cred),
 891                                                        data[i])) {
 892                                 DEBUG("Failed to set credential type %d",
 893                                       g_value_get_enum(cred));
 894                                 vnc_display_close(VNC_DISPLAY(vnc));
 895                         }
 896                 } else {
 897                         DEBUG("Unsupported credential type %d",
 898                               g_value_get_enum(cred));
 899                         vnc_display_close(VNC_DISPLAY(vnc));
 900                 }
 901         }
 902
 903         g_free(data);
 904         if (dialog)
 905                 gtk_widget_destroy(GTK_WIDGET(dialog));
 906 }
 907
 908 #if defined(HAVE_SOCKET) && defined(HAVE_CONNECT) && defined(HAVE_HTONS)
 909
 910 static int
 911 viewer_open_vnc_socket(const char* vnchost, int vncport)
 912 {
 913   int result, socketfd;
 914   char port[10];
 915   struct addrinfo* vnc_addr;
 916
 917   sprintf(port, "%d", vncport);
 918
 919   result = getaddrinfo(vnchost, port, NULL, &vnc_addr);
 920   if(result != 0 || vnc_addr == NULL)
 921       return -1;
 922
 923   // just use first found, ignoring rest
 924   socketfd = socket(vnc_addr->ai_family,
 925                     vnc_addr->ai_socktype,
 926                     vnc_addr->ai_protocol);
 927
 928   if(connect(socketfd, vnc_addr->ai_addr, vnc_addr->ai_addrlen) <0)
 929       socketfd = -1;
 930
 931   freeaddrinfo(vnc_addr);
 932
 933   return socketfd;
 934 }
 935
 936 #endif /* defined(HAVE_SOCKET) && defined(HAVE_CONNECT) && defined(HAVE_HTONS) */
 937
 938 /* Remove all menu items from the Connect menu. */
 939 static void
 940 remove_menu_item (GtkWidget *menu_item, gpointer data)
 941 {
 942   gtk_container_remove (GTK_CONTAINER (connectmenu), menu_item);
 943 }
 944
 945 static void
 946 clear_connectmenu (void)
 947 {
 948   DEBUG ("clear Connect menu");
 949   gtk_container_foreach (GTK_CONTAINER (connectmenu), remove_menu_item, NULL);
 950 }
 951
 952 /* The WUI thread has changed its state to connected. */
 953 gboolean
 954 main_connected (gpointer data)
 955 {
 956   DEBUG ("connected");
 957   ASSERT_IS_MAIN_THREAD ();
 958
 959   gtk_label_set_text (GTK_LABEL (ca_error), NULL);
 960
 961   gtk_widget_hide (connection_area);
 962   if (!wui_thread_is_logged_in ())
 963     gtk_widget_show (login_area);
 964   return FALSE;
 965 }
 966
 967 /* The WUI thread has changed its state to disconnected. */
 968 gboolean
 969 main_disconnected (gpointer data)
 970 {
 971   DEBUG ("disconnected");
 972   ASSERT_IS_MAIN_THREAD ();
 973
 974   gtk_widget_show (connection_area);
 975   gtk_widget_hide (login_area);
 976
 977   clear_connectmenu ();
 978   gtk_menu_append (GTK_MENU (connectmenu), no_connections);
 979   gtk_widget_show_all (connectmenu);
 980
 981   return FALSE;
 982 }
 983
 984 /* The WUI thread has changed its state to logged in. */
 985 gboolean
 986 main_logged_in (gpointer data)
 987 {
 988   DEBUG ("logged in");
 989   ASSERT_IS_MAIN_THREAD ();
 990
 991   gtk_widget_hide (login_area);
 992   return FALSE;
 993 }
 994
 995 /* The WUI thread has changed its state to logged out. */
 996 gboolean
 997 main_logged_out (gpointer data)
 998 {
 999   DEBUG ("logged out");
1000   ASSERT_IS_MAIN_THREAD ();
1001
1002   if (wui_thread_is_connected ())
1003     gtk_widget_show (login_area);
1004   return FALSE;
1005 }
1006
1007 /* The WUI thread has changed its state to busy. */
1008 gboolean
1009 main_busy (gpointer data)
1010 {
1011   GdkWindow *gdk_window;
1012
1013   DEBUG ("busy");
1014   ASSERT_IS_MAIN_THREAD ();
1015
1016   gdk_window = gtk_widget_get_window (window);
1017   if (gdk_window) {
1018     gdk_window_set_cursor (gdk_window, busy_cursor);
1019     gdk_flush ();
1020   }
1021
1022   return FALSE;
1023 }
1024
1025 /* The WUI thread has changed its state to idle. */
1026 gboolean
1027 main_idle (gpointer data)
1028 {
1029   GdkWindow *gdk_window;
1030
1031   DEBUG ("idle");
1032   ASSERT_IS_MAIN_THREAD ();
1033
1034   gdk_window = gtk_widget_get_window (window);
1035   if (gdk_window) {
1036     gdk_window_set_cursor (gdk_window, NULL);
1037     gdk_flush ();
1038   }
1039
1040   return FALSE;
1041 }
1042
1043 /* The WUI thread had a connection error.  This function must
1044  * free the string.
1045  */
1046 gboolean
1047 main_connection_error (gpointer _str)
1048 {
1049   char *str = (char *) _str;
1050
1051   DEBUG ("connection error: %s", str);
1052   ASSERT_IS_MAIN_THREAD ();
1053
1054   gtk_label_set_text (GTK_LABEL (ca_error), str);
1055   g_free (str);
1056
1057   return FALSE;
1058 }
1059
1060 /* The WUI thread had a login error.  This function must
1061  * free the string.
1062  */
1063 gboolean
1064 main_login_error (gpointer _str)
1065 {
1066   char *str = (char *) _str;
1067
1068   DEBUG ("login error: %s", str);
1069   ASSERT_IS_MAIN_THREAD ();
1070
1071   gtk_label_set_text (GTK_LABEL (la_error), str);
1072   g_free (str);
1073
1074   return FALSE;
1075 }
1076
1077 /* The WUI thread reports a general status error.  This function
1078  * must free the string.
1079  */
1080 gboolean
1081 main_status_error (gpointer _str)
1082 {
1083   char *str = (char *) _str;
1084
1085   DEBUG ("status error: %s", str);
1086   ASSERT_IS_MAIN_THREAD ();
1087
1088   gtk_statusbar_pop (GTK_STATUSBAR (statusbar), statusbar_ctx);
1089   gtk_statusbar_push (GTK_STATUSBAR (statusbar), statusbar_ctx, str);
1090   g_free (str);
1091
1092   return FALSE;
1093 }
1094
1095 gboolean
1096 main_vmlist_updated (gpointer data)
1097 {
1098   GSList *new_vmlist;
1099
1100   DEBUG ("vmlist updated");
1101   ASSERT_IS_MAIN_THREAD ();
1102
1103   /* Get the new vmlist. */
1104   if (wui_thread_get_vmlist (&new_vmlist)) {
1105     /* Free the previous vmlist.  This invalidates all the vm pointers
1106      * contained in the Connect menu callbacks, but we're going to
1107      * delete those callbacks and create news ones in a moment anyway ...
1108      */
1109     free_vmlist (vmlist);
1110
1111     vmlist = new_vmlist;
1112
1113     clear_connectmenu ();
1114
1115     gtk_menu_append (GTK_MENU (connectmenu), refresh_vmlist);
1116
1117     if (vmlist != NULL) {
1118       gtk_menu_append (GTK_MENU (connectmenu), refresh_vmlist_separator);
1119       g_slist_foreach (vmlist, add_vm_to_connectmenu, NULL);
1120     }
1121
1122     /* Grrrr Gtk is stupid. */
1123     gtk_widget_show_all (connectmenu);
1124   }
1125
1126   return FALSE;
1127 }
1128
1129 static void
1130 add_vm_to_connectmenu (gpointer _vm, gpointer data)
1131 {
1132   struct vm *vm = (struct vm *) _vm;
1133   GtkWidget *item;
1134
1135   // TODO only present running vms ?
1136   // if(vm->state == "running")
1137
1138   DEBUG ("adding %s to Connect menu", vm->description);
1139
1140   item = gtk_menu_item_new_with_label (vm->description);
1141   gtk_menu_append (GTK_MENU (connectmenu), item);
1142
1143   g_signal_connect (G_OBJECT (item), "activate",
1144                     G_CALLBACK (connect_to_vm), vm);
1145 }