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