remove ssl cert checking until ssl is fully / properly integration
[ovirt-viewer.git] / wui_thread.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 /* For an explanation of the threading model, please main(). */
21
22 #include <config.h>
23
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <assert.h>
28
29 #include <glib.h>
30 #include <glib/gprintf.h>
31
32 #include <libxml/parser.h>
33
34 #include <curl/curl.h>
35
36 #include "internal.h"
37
38 /* Private functions. */
39 static gpointer wui_thread (gpointer data);
40 static void wui_thread_send_quit (void);
41 static void do_curl_init (void);
42 static void write_fn_start_capture (void);
43 static char *write_fn_finish_capture (void);
44 static void write_fn_discard_capture_buffer (void);
45 static gboolean do_connect (void);
46 static gboolean do_login (void);
47 static gboolean refresh_vm_list (void);
48 static void parse_vmlist_from_xml (const char *xml);
49 static struct vm *parse_vm_from_xml (xmlNodePtr node);
50
51 /* Messages (main thread -> WUI thread only).
52  *
53  * These are passed by reference.  They are allocated by the sender
54  * (ie. the main thread) and freed by the receiver (ie. the WUI thread).
55  */
56 enum message_type {
57   QUIT,                    /* Tell the WUI thread to quit cleanly. */
58   CONNECT,                 /* Tell to connect (just fetch the URI). */
59   DISCONNECT,              /* Tell to disconnect, forget state. */
60   LOGIN,                   /* Tell to login, and pass credentials. */
61   REFRESH_VM_LIST,         /* Tell to refresh the VM list right away. */
62 };
63
64 struct message {
65   enum message_type type;
66   char *str1;
67   char *str2;
68 };
69
70 /* Start the WUI thread.  See main() for explanation of the threading model. */
71 static GThread *wui_gthread = NULL;
72 static GThread *main_gthread = NULL;
73 static GAsyncQueue *wui_thread_queue = NULL;
74
75 void
76 start_wui_thread (void)
77 {
78   GError *error = NULL;
79
80   DEBUG ("starting the WUI thread");
81
82   assert (wui_gthread == NULL);
83
84   main_gthread = g_thread_self ();
85
86   /* Create the message queue for main -> WUI thread communications. */
87   wui_thread_queue = g_async_queue_new ();
88
89   wui_gthread = g_thread_create (wui_thread, wui_thread_queue, TRUE, &error);
90   if (error) {
91     g_print ("%s\n", error->message);
92     g_error_free (error);
93     exit (1);
94   }
95 }
96
97 void
98 stop_wui_thread (void)
99 {
100   DEBUG ("stopping the WUI thread");
101
102   assert (wui_gthread != NULL);
103   ASSERT_IS_MAIN_THREAD ();
104
105   /* Send a quit message then wait for the WUI thread to join.
106    *
107    * This "nice" shutdown could cause the UI to hang for an
108    * indefinite period (eg. if the WUI thread is engaged in some
109    * long connection or download from the remote server).  But
110    * I want to keep it this way for the moment so that we can
111    * diagnose problems with the WUI thread.
112    *
113    * (This could be solved with some sort of interruptible
114    * join, but glib doesn't support that AFAICT).
115    */
116   wui_thread_send_quit ();
117   (void) g_thread_join (wui_gthread);
118   g_async_queue_unref (wui_thread_queue);
119   wui_gthread = NULL;
120 }
121
122 void
123 assert_is_wui_thread (const char *filename, int lineno)
124 {
125   if (g_thread_self () != wui_gthread) {
126     fprintf (stderr, "%s:%d: internal error: this function should only run in the context of the WUI thread\n", filename, lineno);
127     abort ();
128   }
129 }
130
131 void
132 assert_is_main_thread (const char *filename, int lineno)
133 {
134   if (g_thread_self () != main_gthread) {
135     fprintf (stderr, "%s:%d: internal error: this function should only run in the context of the main thread\n", filename, lineno);
136     abort ();
137   }
138 }
139
140 /* Send the quit message to the WUI thread. */
141 static void
142 wui_thread_send_quit (void)
143 {
144   struct message *msg;
145
146   ASSERT_IS_MAIN_THREAD ();
147
148   msg = g_new (struct message, 1);
149   msg->type = QUIT;
150   g_async_queue_push (wui_thread_queue, msg);
151 }
152
153 /* Send the connect message to the WUI thread. */
154 void
155 wui_thread_send_connect (const char *uri)
156 {
157   struct message *msg;
158
159   ASSERT_IS_MAIN_THREAD ();
160
161   msg = g_new (struct message, 1);
162   msg->type = CONNECT;
163   msg->str1 = g_strdup (uri);
164   g_async_queue_push (wui_thread_queue, msg);
165 }
166
167 /* Send the disconnect message to the WUI thread. */
168 void
169 wui_thread_send_disconnect (void)
170 {
171   struct message *msg;
172
173   ASSERT_IS_MAIN_THREAD ();
174
175   msg = g_new (struct message, 1);
176   msg->type = DISCONNECT;
177   g_async_queue_push (wui_thread_queue, msg);
178 }
179
180 /* Send the login message to the WUI thread. */
181 void
182 wui_thread_send_login (const char *username, const char *password)
183 {
184   struct message *msg;
185
186   ASSERT_IS_MAIN_THREAD ();
187
188   msg = g_new (struct message, 1);
189   msg->type = LOGIN;
190   msg->str1 = g_strdup (username);
191   msg->str2 = g_strdup (password);
192   g_async_queue_push (wui_thread_queue, msg);
193 }
194
195 /* Send the refresh VM list message to the WUI thread. */
196 void
197 wui_thread_send_refresh_vm_list (void)
198 {
199   struct message *msg;
200
201   ASSERT_IS_MAIN_THREAD ();
202
203   msg = g_new (struct message, 1);
204   msg->type = REFRESH_VM_LIST;
205   g_async_queue_push (wui_thread_queue, msg);
206 }
207
208 /* The current state.
209  *
210  * For safety, the main thread must lock this before reading, and the
211  * WUI thread must lock this before writing.  However the WUI thread
212  * does not need to lock before reading, because no other thread
213  * can modify it.
214  */
215 static gboolean connected = FALSE;
216 static gboolean logged_in = FALSE;
217 static gboolean busy = FALSE;
218 static GStaticMutex state_mutex;
219
220 static void set_connected (gboolean);
221 static void set_logged_in (gboolean);
222 static void set_busy (gboolean);
223
224 /* The private state of the WUI thread. */
225 static int secs_between_refresh = 60;
226 static CURL *curl = NULL;
227 static char curl_error_buffer[CURL_ERROR_SIZE];
228 static char *uri = NULL;
229 static char *username = NULL;
230 static char *password = NULL;
231
232 static gboolean process_message (struct message *);
233
234 /* The WUI thread.  See main() above for explanation of
235  * the threading model.
236  */
237 static gpointer
238 wui_thread (gpointer _queue)
239 {
240   GAsyncQueue *queue = (GAsyncQueue *) _queue;
241   gboolean quit = FALSE;
242   GTimeVal tv;
243   gpointer _msg;
244   struct message *msg;
245
246   DEBUG ("WUI thread starting up");
247
248   /* This checks wui_gthread global which is actually set in the
249    * main thread.  Of course, it might not be set if the WUI thread
250    * runs first.  Hence we sleep for the main thread to run. (XXX)
251    */
252   g_usleep (100000);
253   ASSERT_IS_WUI_THREAD ();
254
255   g_async_queue_ref (queue);
256
257   /* In the thread's loop we check for new instructions from the main
258    * thread and carry them out.  Also, if we are connected and logged
259    * in then we periodically recheck the list of VMs.
260    */
261   while (!quit) {
262     set_busy (FALSE);
263
264     if (logged_in) {
265       g_get_current_time (&tv);
266       g_time_val_add (&tv, secs_between_refresh * 1000000);
267       _msg = g_async_queue_timed_pop (queue, &tv);
268     } else
269       _msg = g_async_queue_pop (queue);
270
271     set_busy (TRUE);
272
273     msg = (struct message *) _msg;
274
275     if (msg) {
276       DEBUG ("received message with msg->type = %d", msg->type);
277       quit = process_message (msg);
278       /* Don't free any strings in the message - we've saved them. */
279       g_free (msg);
280     } else {
281       /* No message, must have got a timeout instead, which means
282        * we are logged in and we should refresh the list of VMs.
283        * Note it's not an error if we temporarily lose contact
284        * with the WUI.
285        */
286       refresh_vm_list ();
287     }
288   }
289
290   DEBUG ("WUI thread shutting down cleanly");
291
292   g_async_queue_unref (queue);
293   g_thread_exit (NULL);
294   return NULL; /* not reached? */
295 }
296
297 /* The WUI thread calls this to safely update the state variables.
298  * This also updates elements in the UI by setting idle callbacks
299  * which are executed in the context of the main thread.
300  */
301 static void
302 set_connected (gboolean new_connected)
303 {
304   ASSERT_IS_WUI_THREAD ();
305
306   g_static_mutex_lock (&state_mutex);
307   connected = new_connected;
308   g_static_mutex_unlock (&state_mutex);
309
310   if (connected)
311     g_idle_add (main_connected, NULL);
312   else
313     g_idle_add (main_disconnected, NULL);
314 }
315
316 static void
317 set_logged_in (gboolean new_logged_in)
318 {
319   ASSERT_IS_WUI_THREAD ();
320
321   g_static_mutex_lock (&state_mutex);
322   logged_in = new_logged_in;
323   g_static_mutex_unlock (&state_mutex);
324
325   if (logged_in)
326     g_idle_add (main_logged_in, NULL);
327   else
328     g_idle_add (main_logged_out, NULL);
329 }
330
331 static void
332 set_busy (gboolean new_busy)
333 {
334   ASSERT_IS_WUI_THREAD ();
335
336   g_static_mutex_lock (&state_mutex);
337   busy = new_busy;
338   g_static_mutex_unlock (&state_mutex);
339
340   if (busy)
341     g_idle_add (main_busy, NULL);
342   else
343     g_idle_add (main_idle, NULL);
344 }
345
346 /* The main thread should call these functions to get the WUI thread's
347  * current state.
348  */
349 gboolean
350 wui_thread_is_connected (void)
351 {
352   gboolean ret;
353
354   ASSERT_IS_MAIN_THREAD ();
355
356   g_static_mutex_lock (&state_mutex);
357   ret = connected;
358   g_static_mutex_unlock (&state_mutex);
359   return ret;
360 }
361
362 gboolean
363 wui_thread_is_logged_in (void)
364 {
365   gboolean ret;
366
367   ASSERT_IS_MAIN_THREAD ();
368
369   g_static_mutex_lock (&state_mutex);
370   ret = logged_in;
371   g_static_mutex_unlock (&state_mutex);
372   return ret;
373 }
374
375 gboolean
376 wui_thread_is_busy (void)
377 {
378   gboolean ret;
379
380   ASSERT_IS_MAIN_THREAD ();
381
382   g_static_mutex_lock (&state_mutex);
383   ret = busy;
384   g_static_mutex_unlock (&state_mutex);
385   return ret;
386 }
387
388 /* Process a message from the main thread. */
389 static gboolean
390 process_message (struct message *msg)
391 {
392   ASSERT_IS_WUI_THREAD ();
393
394   switch (msg->type) {
395   case QUIT:
396     write_fn_discard_capture_buffer ();
397     if (curl) curl_easy_cleanup (curl);
398     if (uri) g_free (uri);
399     if (username) g_free (username);
400     if (password) g_free (password);
401     set_connected (FALSE);
402     set_logged_in (FALSE);
403     return 1;
404
405   case CONNECT:
406     write_fn_discard_capture_buffer ();
407     if (curl) curl_easy_cleanup (curl);
408     do_curl_init ();
409     if (uri) g_free (uri);
410     uri = msg->str1;
411
412     if (do_connect ()) {
413       set_connected (TRUE);
414     } else {
415       set_connected (FALSE);
416       set_logged_in (FALSE);
417     }
418     break;
419
420   case DISCONNECT:
421     /* This just forgets the state. REST is connectionless. */
422     write_fn_discard_capture_buffer ();
423     if (curl) curl_easy_cleanup (curl);
424     curl = NULL;
425     if (uri) g_free (uri);
426     uri = NULL;
427     if (username) g_free (username);
428     username = NULL;
429     if (password) g_free (password);
430     password = NULL;
431     set_connected (FALSE);
432     set_logged_in (FALSE);
433     break;
434
435   case LOGIN:
436     if (username) g_free (username);
437     username = msg->str1;
438     if (password) g_free (password);
439     password = msg->str2;
440
441     /* If we're not connected, this message just updates the
442      * username and password.  Otherwise if we are connected,
443      * try to login and grab the initial list of VMs.
444      */
445     if (connected) {
446       if (do_login ()) {
447         set_logged_in (TRUE);
448         if (refresh_vm_list ())
449           secs_between_refresh = 60;
450       } else {
451         set_logged_in (FALSE);
452       }
453     }
454     break;
455
456   case REFRESH_VM_LIST:
457     if (connected && logged_in) {
458       refresh_vm_list ();
459       secs_between_refresh = 60;
460     }
461     break;
462
463   default:
464     DEBUG ("unknown message type %d", msg->type);
465     abort ();
466   }
467
468   return 0;
469 }
470
471 /* Macro for easy handling of CURL errors. */
472 #define CURL_CHECK_ERROR(fn, args)                                      \
473   ({                                                                    \
474     CURLcode __r = fn args;                                             \
475     if (__r != CURLE_OK) {                                              \
476       fprintf (stderr, "%s: %s\n", #fn, curl_easy_strerror (__r));      \
477     }                                                                   \
478     __r;                                                                \
479   })
480
481 /* Libcurl has a really crufty method for handling HTTP headers and
482  * data.  We set these functions as callbacks, because the default
483  * callback functions print the data out to stderr.  In order to
484  * capture the data, we have to keep state here.
485  */
486
487 static char *write_fn_buffer = NULL;
488 static ssize_t write_fn_len = -1;
489
490 static size_t
491 write_fn (void *ptr, size_t size, size_t nmemb, void *stream)
492 {
493   int bytes = size * nmemb;
494   int old_start;
495
496   ASSERT_IS_WUI_THREAD ();
497
498   if (write_fn_len >= 0) {      /* We're capturing. */
499     old_start = write_fn_len;
500     write_fn_len += bytes;
501     write_fn_buffer = g_realloc (write_fn_buffer, write_fn_len);
502     memcpy (write_fn_buffer + old_start, ptr, bytes);
503   }
504
505   return bytes;
506 }
507
508 /* Start capturing HTTP response data. */
509 static void
510 write_fn_start_capture (void)
511 {
512   ASSERT_IS_WUI_THREAD ();
513
514   write_fn_discard_capture_buffer ();
515   write_fn_buffer = NULL;
516   write_fn_len = 0;
517 }
518
519 /* Finish capture and return the capture buffer.  Caller must free. */
520 static char *
521 write_fn_finish_capture (void)
522 {
523   char *ret;
524
525   ASSERT_IS_WUI_THREAD ();
526
527   /* Make sure the buffer is NUL-terminated before returning it. */
528   write_fn_buffer = g_realloc (write_fn_buffer, write_fn_len+1);
529   write_fn_buffer[write_fn_len] = '\0';
530   ret = write_fn_buffer;
531
532   write_fn_buffer = NULL;
533   write_fn_len = -1;
534   return ret;
535 }
536
537 /* Stop capturing and discard the capture buffer, if any. */
538 static void
539 write_fn_discard_capture_buffer (void)
540 {
541   ASSERT_IS_WUI_THREAD ();
542
543   g_free (write_fn_buffer);
544   write_fn_buffer = NULL;
545   write_fn_len = -1;
546 }
547
548 static size_t
549 header_fn (void *ptr, size_t size, size_t nmemb, void *stream)
550 {
551   int bytes = size * nmemb;
552
553   ASSERT_IS_WUI_THREAD ();
554
555   return bytes;
556 }
557
558 /* Called from the message loop to initialize the CURL handle. */
559 static void
560 do_curl_init (void)
561 {
562   DEBUG ("initializing libcurl");
563
564   ASSERT_IS_WUI_THREAD ();
565
566   curl = curl_easy_init ();
567   if (!curl) {             /* This is probably quite bad, so abort. */
568     DEBUG ("curl_easy_init failed");
569     abort ();
570   }
571
572   CURL_CHECK_ERROR (curl_easy_setopt,
573                     (curl, CURLOPT_CAINFO, cainfo));
574   CURL_CHECK_ERROR (curl_easy_setopt,
575                     (curl, CURLOPT_SSL_VERIFYHOST, check_cert ? 2 : 0));
576   CURL_CHECK_ERROR (curl_easy_setopt,
577                     (curl, CURLOPT_SSL_VERIFYPEER, check_cert ? 1 : 0));
578
579   CURL_CHECK_ERROR (curl_easy_setopt,
580                     (curl, CURLOPT_WRITEFUNCTION, write_fn));
581   CURL_CHECK_ERROR (curl_easy_setopt,
582                     (curl, CURLOPT_HEADERFUNCTION, header_fn));
583
584   /* This enables error messages in curl_easy_perform. */
585   CURL_CHECK_ERROR (curl_easy_setopt,
586                     (curl, CURLOPT_ERRORBUFFER, curl_error_buffer));
587
588   /* This enables cookie handling, using an internal cookiejar. */
589   CURL_CHECK_ERROR (curl_easy_setopt,
590                     (curl, CURLOPT_COOKIEFILE, ""));
591 }
592
593 /* Called from the message loop.  Try to connect to the current URI.
594  * Returns true on success.
595  */
596 static gboolean
597 do_connect (void)
598 {
599   long code = 0;
600   CURLcode r;
601   char *error_str;
602
603   DEBUG ("connecting to uri %s", uri);
604   ASSERT_IS_WUI_THREAD ();
605
606   /* Set the URI for libcurl. */
607   CURL_CHECK_ERROR (curl_easy_setopt, (curl, CURLOPT_URL, uri));
608
609   /* Try to fetch the URI. */
610   r = CURL_CHECK_ERROR (curl_easy_perform, (curl));
611   if (r != CURLE_OK) {
612     /* Signal an error back to the main thread. */
613     error_str = g_strdup (curl_easy_strerror (r));
614     g_idle_add (main_connection_error, error_str);
615     return FALSE;
616   }
617
618   CURL_CHECK_ERROR (curl_easy_getinfo, (curl, CURLINFO_RESPONSE_CODE, &code));
619   DEBUG ("HTTP return code is %ld", code);
620   if (code != 200 && code != 302 && code != 401) {
621     /* XXX If only glib had g_asprintf. */
622     error_str = g_strdup ("unexpected HTTP return code from server");
623     g_idle_add (main_connection_error, error_str);
624     return FALSE;
625   }
626
627   return TRUE;
628 }
629
630 /* Called from the message loop.  Try to login to 'URI/login' with the
631  * current username and password.  Returns true on success.
632  */
633 static gboolean
634 do_login (void)
635 {
636   int len;
637   char *login_uri;
638   char *userpwd;
639   char *error_str;
640   CURLcode r;
641   long code = 0;
642
643   DEBUG ("logging in with username %s, password *****", username);
644   ASSERT_IS_WUI_THREAD ();
645
646   /* Generate the login URI from the base URI. */
647   len = strlen (uri) + 6 + 1;
648   login_uri = g_alloca (len);
649   snprintf (login_uri, len, "%s/login", uri);
650
651   DEBUG ("login URI %s", login_uri);
652
653   /* Set the URI for libcurl. */
654   CURL_CHECK_ERROR (curl_easy_setopt, (curl, CURLOPT_URL, login_uri));
655
656   /* Construct the username:password for CURL. */
657   len = strlen (username) + strlen (password) + 2;
658   userpwd = g_alloca (len);
659   snprintf (userpwd, len, "%s:%s", username, password);
660
661   CURL_CHECK_ERROR (curl_easy_setopt, (curl, CURLOPT_USERPWD, userpwd));
662
663   /* HTTP Basic authentication is OK since we should be sending
664    * this only over HTTPS.
665    */
666   CURL_CHECK_ERROR (curl_easy_setopt, (curl, CURLOPT_HTTPAUTH, CURLAUTH_BASIC));
667
668   /* Follow redirects. */
669   CURL_CHECK_ERROR (curl_easy_setopt, (curl, CURLOPT_FOLLOWLOCATION, (long) 1));
670   CURL_CHECK_ERROR (curl_easy_setopt, (curl, CURLOPT_MAXREDIRS, (long) 10));
671
672   // FIXME when ssl is introduced into ovirt-viewer, remove there two lines
673   CURL_CHECK_ERROR(curl_easy_setopt, (curl, CURLOPT_SSL_VERIFYHOST, 0));
674   CURL_CHECK_ERROR(curl_easy_setopt, (curl, CURLOPT_SSL_VERIFYPEER, 0));
675
676   /* Try to fetch the URI. */
677   r = CURL_CHECK_ERROR (curl_easy_perform, (curl));
678   if (r != CURLE_OK) {
679     /* Signal an error back to the main thread. */
680     error_str = g_strdup (curl_easy_strerror (r));
681     g_idle_add (main_login_error, error_str);
682     return FALSE;
683   }
684
685   CURL_CHECK_ERROR (curl_easy_getinfo, (curl, CURLINFO_RESPONSE_CODE, &code));
686   DEBUG ("HTTP return code is %ld", code);
687   switch (code)
688     {
689     case 200:
690       DEBUG ("login was successful");
691       return TRUE;
692
693     case 401:
694       error_str = g_strdup ("server rejected the username or password");
695       g_idle_add (main_login_error, error_str);
696       return FALSE;
697
698     default:
699       /* XXX If only glib had g_asprintf. */
700       error_str = g_strdup ("unexpected HTTP return code from server");
701       g_idle_add (main_login_error, error_str);
702       return FALSE;
703     }
704 }
705
706 /* Called from the message loop.  Refresh the list of VMs. */
707 static gboolean
708 refresh_vm_list (void)
709 {
710   int len;
711   char *vms_uri;
712   char *error_str;
713   CURLcode r;
714   long code = 0;
715   char *xml;
716
717   DEBUG ("refreshing list of VMs");
718   ASSERT_IS_WUI_THREAD ();
719
720   /* Generate the vms URI from the base URI. */
721   len = strlen (uri) + 4 + 1;
722   vms_uri = g_alloca (len);
723   snprintf (vms_uri, len, "%s/vms", uri);
724
725   DEBUG ("vms URI %s", vms_uri);
726
727   /* Set the URI for libcurl. */
728   CURL_CHECK_ERROR (curl_easy_setopt, (curl, CURLOPT_URL, vms_uri));
729
730   /* We want to capture the output, so tell our write function
731    * to place the output into a buffer.
732    */
733   write_fn_start_capture ();
734
735   /* Try to fetch the URI. */
736   r = CURL_CHECK_ERROR (curl_easy_perform, (curl));
737   if (r != CURLE_OK) {
738     /* Signal an error back to the main thread. */
739     error_str = g_strdup (curl_easy_strerror (r));
740     g_idle_add (main_login_error, error_str);
741     return FALSE;
742   }
743
744   CURL_CHECK_ERROR (curl_easy_getinfo, (curl, CURLINFO_RESPONSE_CODE, &code));
745   DEBUG ("HTTP return code is %ld", code);
746   switch (code)
747     {
748     case 200: break;
749
750       /* Hmm - even though we previously logged in, the server is
751        * rejecting our attempts now with an authorization error.
752        * We move to the logged out state.
753        */
754     case 401:
755       set_logged_in (FALSE);
756       error_str = g_strdup ("server rejected the username or password");
757       g_idle_add (main_login_error, error_str);
758       return FALSE;
759
760     default:
761       /* XXX If only glib had g_asprintf. */
762       error_str = g_strdup ("unexpected HTTP return code from server");
763       g_idle_add (main_status_error, error_str);
764       return FALSE;
765     }
766
767   /* If we got here then we appear to have a correct
768    * XML document describing the list of VMs.
769    */
770   secs_between_refresh <<= 1;
771
772   xml = write_fn_finish_capture ();
773
774   parse_vmlist_from_xml (xml);
775   g_free (xml);
776
777   return TRUE;
778 }
779
780 /* Functions to deal with the list of VMs, parsing it from the XML, etc.
781  *
782  * A vmlist is a GSList (glib singly-linked list) of vm structures.
783  * The caller must call free_vmlist to free up this list correctly.
784  */
785
786 static void
787 free_vm (gpointer _vm, gpointer data)
788 {
789   struct vm *vm = (struct vm *) _vm;
790
791   g_free (vm->description);
792   g_free (vm->state);
793   g_free (vm->uuid);
794   g_free (vm->mac_addr);
795   g_free (vm);
796 }
797
798 void
799 free_vmlist (GSList *vmlist)
800 {
801   g_slist_foreach (vmlist, free_vm, NULL);
802   g_slist_free (vmlist);
803 }
804
805 static struct vm *
806 copy_vm (struct vm *vm)
807 {
808   struct vm *vm2;
809
810   vm2 = g_memdup (vm, sizeof (*vm));
811   vm2->description = g_strdup (vm->description);
812   vm2->uuid = g_strdup (vm->uuid);
813   vm2->state = vm->state ? g_strdup (vm->state) : NULL;
814   vm2->mac_addr = vm->mac_addr ? g_strdup (vm->mac_addr) : NULL;
815   return vm2;
816 }
817
818 static int
819 compare_vm (gconstpointer _vm1, gconstpointer _vm2)
820 {
821   const struct vm *vm1 = (const struct vm *) _vm1;
822   const struct vm *vm2 = (const struct vm *) _vm2;
823
824   return strcmp (vm1->description, vm2->description);
825 }
826
827 static GSList *vmlist = NULL;
828 static gboolean vmlist_valid = FALSE;
829 static GStaticMutex vmlist_mutex;
830
831 /* Called from the main thread to find out if we have a valid vmlist. */
832 gboolean
833 wui_thread_has_valid_vmlist (void)
834 {
835   gboolean ret;
836
837   ASSERT_IS_MAIN_THREAD ();
838
839   g_static_mutex_lock (&vmlist_mutex);
840   ret = vmlist_valid;
841   g_static_mutex_unlock (&vmlist_mutex);
842   return ret;
843 }
844
845 /* Called from the main thread to find return the current vmlist.  This
846  * actually returns a deep copy of it that the caller must free.
847  */
848 static void
849 duplicate_and_insert_vm (gpointer _vm, gpointer _ret)
850 {
851   struct vm *vm = (struct vm *) _vm;
852   GSList **ret = (GSList **) _ret;
853
854   *ret = g_slist_prepend (*ret, copy_vm (vm));
855 }
856
857 gboolean
858 wui_thread_get_vmlist (GSList **ret)
859 {
860   gboolean r;
861
862   ASSERT_IS_MAIN_THREAD ();
863
864   r = FALSE;
865   *ret = NULL;
866
867   g_static_mutex_lock (&vmlist_mutex);
868   if (!vmlist_valid) goto done;
869
870   g_slist_foreach (vmlist, duplicate_and_insert_vm, ret);
871   *ret = g_slist_sort (*ret, compare_vm);
872
873   r = TRUE;
874  done:
875   g_static_mutex_unlock (&vmlist_mutex);
876   return r;
877 }
878
879 /* Called from the message loop in the WUI thread, with an XML document
880  * which we turn into a list of VM structures, and update the vmlist
881  * if we can.
882  */
883 static void
884 parse_vmlist_from_xml (const char *xml)
885 {
886   xmlDocPtr doc = NULL;
887   xmlNodePtr root;
888   xmlNodePtr node;
889   char *error_str;
890   GSList *new_vmlist = NULL;
891   struct vm *vm;
892   int len;
893
894   /*DEBUG ("XML =\n%s", xml);*/
895   ASSERT_IS_WUI_THREAD ();
896
897   /* We don't really expect that we won't be able to parse the XML ... */
898   len = strlen (xml);
899   doc = xmlReadMemory (xml, len, NULL, NULL, 0);
900
901   if (!doc) {
902     DEBUG ("error parsing XML document, xml =\n%s", xml);
903     error_str = g_strdup ("error parsing XML document from remote server");
904     g_idle_add (main_status_error, error_str);
905     goto done;
906   }
907
908   root = xmlDocGetRootElement (doc);
909   if (!root) {
910     DEBUG ("XML document was empty");
911     error_str = g_strdup ("XML document was empty");
912     g_idle_add (main_status_error, error_str);
913     goto done;
914   }
915
916   /* We expect the root element will be either "nil-classes"
917    * or "vms", with the former indicating an empty list of VMs.
918    */
919   if (xmlStrcmp (root->name, (const xmlChar *) "nil-classes") == 0) {
920     g_static_mutex_lock (&vmlist_mutex);
921     vmlist_valid = TRUE;
922     free_vmlist (vmlist);
923     vmlist = NULL;
924     g_static_mutex_unlock (&vmlist_mutex);
925
926     /* Signal to the main UI thread that the list has been updated. */
927     g_idle_add (main_vmlist_updated, NULL);
928
929     goto done;
930   }
931
932   if (xmlStrcmp (root->name, (const xmlChar *) "vms") != 0) {
933     DEBUG ("unexpected root node in XML document, xml =\n%s", xml);
934     error_str = g_strdup ("unexpected root node in XML document");
935     g_idle_add (main_status_error, error_str);
936     goto done;
937   }
938
939   /* The document is <vms> with a list of <vm> elements which
940    * we process in turn.
941    */
942   for (node = root->xmlChildrenNode; node != NULL; node = node->next) {
943     if (xmlStrcmp (node->name, (const xmlChar *) "vm") == 0) {
944       vm = parse_vm_from_xml (node);
945       if (!vm) {
946         error_str = g_strdup ("could not parse <vm> element");
947         g_idle_add (main_status_error, error_str);
948
949         free_vmlist (new_vmlist);
950         goto done;
951       }
952       new_vmlist = g_slist_prepend (new_vmlist, vm);
953     }
954   }
955
956   /* Successfully parsed all the <vm> nodes, so swap the old and new
957    * vmlists.
958    */
959   g_static_mutex_lock (&vmlist_mutex);
960   vmlist_valid = TRUE;
961   free_vmlist (vmlist);
962   vmlist = new_vmlist;
963   g_static_mutex_unlock (&vmlist_mutex);
964
965   /* Signal that the vmlist has been updated. */
966   g_idle_add (main_vmlist_updated, NULL);
967
968  done:
969   /* Free up XML resources used before returning. */
970   if (doc) xmlFreeDoc (doc);
971 }
972
973 static struct vm *
974 parse_vm_from_xml (xmlNodePtr node)
975 {
976   xmlNodePtr p;
977   struct vm vm, *ret;
978   xmlChar *str;
979
980   memset (&vm, 0, sizeof vm);
981   vm.hostid = -1;
982   vm.id = -1;
983   vm.vnc_port = -1;
984   vm.forward_vnc_port = -1;
985   vm.mem_allocated = -1;
986   vm.mem_used = -1;
987   vm.vcpus_allocated = -1;
988   vm.vcpus_used = -1;
989
990   for (p = node->xmlChildrenNode; p != NULL; p = p->next) {
991     if (xmlStrcmp (p->name, (const xmlChar *) "description") == 0) {
992       str = xmlNodeGetContent (p);
993       if (str != NULL) {
994         vm.description = g_strdup ((char *) str);
995         xmlFree (str);
996       }
997     }
998     else if (xmlStrcmp (p->name, (const xmlChar *) "host-id") == 0) {
999       str = xmlNodeGetContent (p);
1000       if (str != NULL) {
1001         vm.hostid = strtol ((char *) str, NULL, 10);
1002         xmlFree (str);
1003       }
1004     }
1005     else if (xmlStrcmp (p->name, (const xmlChar *) "id") == 0) {
1006       str = xmlNodeGetContent (p);
1007       if (str != NULL) {
1008         vm.id = strtol ((char *) str, NULL, 10);
1009         xmlFree (str);
1010       }
1011     }
1012     else if (xmlStrcmp (p->name, (const xmlChar *) "memory-allocated") == 0) {
1013       str = xmlNodeGetContent (p);
1014       if (str != NULL) {
1015         vm.mem_allocated = strtol ((char *) str, NULL, 10);
1016         xmlFree (str);
1017       }
1018     }
1019     else if (xmlStrcmp (p->name, (const xmlChar *) "memory-used") == 0) {
1020       str = xmlNodeGetContent (p);
1021       if (str != NULL) {
1022         vm.mem_used = strtol ((char *) str, NULL, 10);
1023         xmlFree (str);
1024       }
1025     }
1026     else if (xmlStrcmp (p->name, (const xmlChar *) "num-vcpus-allocated") == 0) {
1027       str = xmlNodeGetContent (p);
1028       if (str != NULL) {
1029         vm.vcpus_allocated = strtol ((char *) str, NULL, 10);
1030         xmlFree (str);
1031       }
1032     }
1033     else if (xmlStrcmp (p->name, (const xmlChar *) "num-vcpus-used") == 0) {
1034       str = xmlNodeGetContent (p);
1035       if (str != NULL) {
1036         vm.vcpus_used = strtol ((char *) str, NULL, 10);
1037         xmlFree (str);
1038       }
1039     }
1040     else if (xmlStrcmp (p->name, (const xmlChar *) "state") == 0) {
1041       str = xmlNodeGetContent (p);
1042       if (str != NULL) {
1043         vm.state = g_strdup ((char *) str);
1044         xmlFree (str);
1045       }
1046     }
1047     else if (xmlStrcmp (p->name, (const xmlChar *) "uuid") == 0) {
1048       str = xmlNodeGetContent (p);
1049       if (str != NULL) {
1050         vm.uuid = g_strdup ((char *) str);
1051         xmlFree (str);
1052       }
1053     }
1054     else if (xmlStrcmp (p->name, (const xmlChar *) "vnc-port") == 0) {
1055       str = xmlNodeGetContent (p);
1056       if (str != NULL) {
1057         vm.vnc_port = strtol ((char *) str, NULL, 10);
1058         xmlFree (str);
1059       }
1060     }
1061     else if (xmlStrcmp (p->name, (const xmlChar *) "forward-vnc-port") == 0) {
1062       str = xmlNodeGetContent (p);
1063       if (str != NULL) {
1064         vm.forward_vnc_port = strtol ((char *) str, NULL, 10);
1065         xmlFree (str);
1066       }
1067     }
1068     else if (xmlStrcmp (p->name, (const xmlChar *) "vnic-mac-addr") == 0) {
1069       str = xmlNodeGetContent (p);
1070       if (str != NULL) {
1071         vm.mac_addr = g_strdup ((char *) str);
1072         xmlFree (str);
1073       }
1074     }
1075   }
1076
1077   /* Make sure we've got the required fields. */
1078   ret = NULL;
1079   if (vm.description == NULL)
1080     DEBUG ("required field \"description\" missing from <vm> structure");
1081   else if (vm.hostid == -1)
1082     DEBUG ("required field \"description\" missing from <vm> structure");
1083   else if (vm.id == -1)
1084     DEBUG ("required field \"description\" missing from <vm> structure");
1085   else if (vm.vnc_port == -1)
1086     DEBUG ("required field \"vnc-port\" missing from <vm> structure");
1087   else if (vm.forward_vnc_port == -1)
1088     DEBUG ("required field \"forward-vnc-port\" missing from <vm> structure");
1089   else if (vm.uuid == NULL)
1090     DEBUG ("required field \"uuid\" missing from <vm> structure");
1091   else
1092     ret = g_memdup (&vm, sizeof vm);
1093
1094   return ret;
1095 }