fish: Fix test-guestfish-events.sh so it works when LIBGUESTFS_DEBUG=1 is set.
[libguestfs.git] / src / inspect_icon.c
1 /* libguestfs
2  * Copyright (C) 2011 Red Hat Inc.
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with this library; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18
19 #include <config.h>
20
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <stdint.h>
24 #include <inttypes.h>
25 #include <unistd.h>
26 #include <fcntl.h>
27 #include <string.h>
28 #include <sys/stat.h>
29 #include <errno.h>
30
31 #include "guestfs.h"
32 #include "guestfs-internal.h"
33 #include "guestfs-internal-actions.h"
34 #include "guestfs_protocol.h"
35
36 static int read_whole_file (guestfs_h *g, const char *filename, char **data_r, size_t *size_r);
37
38 /* All these icon_*() functions return the same way.  One of:
39  *
40  *   ret == NULL:
41  *     An error occurred.  Error has been set in the handle.  The caller
42  *     should return NULL immediately.
43  *
44  *   ret == NOT_FOUND:
45  *     Not an error, but no icon was found.  'ret' is just a dummy value
46  *     which should be ignored (do not free it!)
47  *
48  *   ret == ordinary pointer:
49  *     An icon was found.  'ret' points to the icon buffer, and *size_r
50  *     is the size.
51  */
52 static char *icon_favicon (guestfs_h *g, struct inspect_fs *fs, size_t *size_r);
53 static char *icon_fedora (guestfs_h *g, struct inspect_fs *fs, size_t *size_r);
54 static char *icon_rhel (guestfs_h *g, struct inspect_fs *fs, size_t *size_r);
55 static char *icon_debian (guestfs_h *g, struct inspect_fs *fs, size_t *size_r);
56 static char *icon_ubuntu (guestfs_h *g, struct inspect_fs *fs, size_t *size_r);
57 static char *icon_mageia (guestfs_h *g, struct inspect_fs *fs, size_t *size_r);
58 static char *icon_opensuse (guestfs_h *g, struct inspect_fs *fs, size_t *size_r);
59 static char *icon_windows (guestfs_h *g, struct inspect_fs *fs, size_t *size_r);
60
61 /* Dummy static object. */
62 static char *NOT_FOUND = (char *) "not_found";
63
64 /* For the unexpected legal consequences of this function, see:
65  * http://lists.fedoraproject.org/pipermail/legal/2011-April/001615.html
66  *
67  * Returns an RBufferOut, so the length of the returned buffer is
68  * returned in *size_r.
69  *
70  * Check optargs for the optional argument.
71  */
72 char *
73 guestfs__inspect_get_icon (guestfs_h *g, const char *root, size_t *size_r,
74                            const struct guestfs_inspect_get_icon_argv *optargs)
75 {
76   struct inspect_fs *fs;
77   char *r = NOT_FOUND;
78   int favicon, highquality;
79   size_t size;
80
81   fs = guestfs___search_for_root (g, root);
82   if (!fs)
83     return NULL;
84
85   /* Get optargs, or defaults. */
86   favicon =
87     optargs->bitmask & GUESTFS_INSPECT_GET_ICON_FAVICON_BITMASK ?
88     optargs->favicon : 1;
89
90   highquality =
91     optargs->bitmask & GUESTFS_INSPECT_GET_ICON_HIGHQUALITY_BITMASK ?
92     optargs->highquality : 0;
93
94   /* Favicons are never high quality, so ... */
95   if (highquality)
96     favicon = 0;
97
98   /* Try looking for a favicon first. */
99   if (favicon) {
100     r = icon_favicon (g, fs, &size);
101     if (!r)
102       return NULL;
103
104     if (r != NOT_FOUND) {
105       /* try_favicon succeeded in finding a favicon. */
106       *size_r = size;
107       return r;
108     }
109   }
110
111   /* Favicon failed, so let's try a method based on the detected operating
112    * system.
113    */
114   switch (fs->type) {
115   case OS_TYPE_LINUX:
116   case OS_TYPE_HURD:
117     switch (fs->distro) {
118     case OS_DISTRO_FEDORA:
119       r = icon_fedora (g, fs, &size);
120       break;
121
122     case OS_DISTRO_RHEL:
123     case OS_DISTRO_REDHAT_BASED:
124     case OS_DISTRO_CENTOS:
125     case OS_DISTRO_SCIENTIFIC_LINUX:
126       r = icon_rhel (g, fs, &size);
127       break;
128
129     case OS_DISTRO_DEBIAN:
130       r = icon_debian (g, fs, &size);
131       break;
132
133     case OS_DISTRO_UBUNTU:
134       r = icon_ubuntu (g, fs, &size);
135       break;
136
137     case OS_DISTRO_MAGEIA:
138       r = icon_mageia (g, fs, &size);
139       break;
140
141     case OS_DISTRO_OPENSUSE:
142       r = icon_opensuse(g, fs, &size);
143       break;
144
145       /* These are just to keep gcc warnings happy. */
146     case OS_DISTRO_ARCHLINUX:
147     case OS_DISTRO_GENTOO:
148     case OS_DISTRO_LINUX_MINT:
149     case OS_DISTRO_MANDRIVA:
150     case OS_DISTRO_MEEGO:
151     case OS_DISTRO_PARDUS:
152     case OS_DISTRO_SLACKWARE:
153     case OS_DISTRO_TTYLINUX:
154     case OS_DISTRO_WINDOWS:
155     case OS_DISTRO_UNKNOWN:
156     default: ;
157     }
158     break;
159
160   case OS_TYPE_WINDOWS:
161     /* We don't know how to get high quality icons from a Windows guest,
162      * so disable this if high quality was specified.
163      */
164     if (!highquality)
165       r = icon_windows (g, fs, &size);
166     break;
167
168   case OS_TYPE_FREEBSD:
169   case OS_TYPE_NETBSD:
170   case OS_TYPE_UNKNOWN:
171   default: ;
172   }
173
174   if (r == NOT_FOUND) {
175     /* Not found, but not an error.  So return the special zero-length
176      * buffer.  Use malloc(1) here to ensure that malloc won't return
177      * NULL.
178      */
179     r = safe_malloc (g, 1);
180     size = 0;
181   }
182
183   *size_r = size;
184   return r;
185 }
186
187 /* Check that the named file 'filename' is a PNG file and is reasonable.
188  * If it is, download and return it.
189  */
190 static char *
191 get_png (guestfs_h *g, struct inspect_fs *fs, const char *filename,
192          size_t *size_r, size_t max_size)
193 {
194   char *ret = NOT_FOUND;
195   char *type = NULL;
196   char *local = NULL;
197   int r, w, h;
198
199   r = guestfs_exists (g, filename);
200   if (r == -1) {
201     ret = NULL; /* a real error */
202     goto out;
203   }
204   if (r == 0) goto out;
205
206   /* Check the file type and geometry. */
207   type = guestfs_file (g, filename);
208   if (!type) goto out;
209
210   if (!STRPREFIX (type, "PNG image data, ")) goto out;
211   if (sscanf (&type[16], "%d x %d", &w, &h) != 2) goto out;
212   if (w < 16 || h < 16 || w > 1024 || h > 1024) goto out;
213
214   /* Define a maximum reasonable size based on the geometry.  This
215    * also limits the maximum we allocate below to around 4 MB.
216    */
217   if (max_size == 0)
218     max_size = 4 * w * h;
219
220   local = guestfs___download_to_tmp (g, fs, filename, "icon", max_size);
221   if (!local) goto out;
222
223   /* Successfully passed checks and downloaded.  Read it into memory. */
224   if (read_whole_file (g, local, &ret, size_r) == -1) {
225     ret = NULL;
226     goto out;
227   }
228
229  out:
230   free (local);
231   free (type);
232
233   return ret;
234 }
235
236 /* Return /etc/favicon.png (or \etc\favicon.png) if it exists and if
237  * it has a reasonable size and format.
238  */
239 static char *
240 icon_favicon (guestfs_h *g, struct inspect_fs *fs, size_t *size_r)
241 {
242   char *ret;
243   char *filename = safe_strdup (g, "/etc/favicon.png");
244
245   if (fs->type == OS_TYPE_WINDOWS) {
246     char *f = guestfs___case_sensitive_path_silently (g, filename);
247     if (f) {
248       free (filename);
249       filename = f;
250     }
251   }
252
253   ret = get_png (g, fs, filename, size_r, 0);
254   free (filename);
255   return ret;
256 }
257
258 /* Return FEDORA_ICON.  I checked that this exists on at least Fedora 6
259  * through 16.
260  */
261 #define FEDORA_ICON "/usr/share/icons/hicolor/96x96/apps/fedora-logo-icon.png"
262
263 static char *
264 icon_fedora (guestfs_h *g, struct inspect_fs *fs, size_t *size_r)
265 {
266   return get_png (g, fs, FEDORA_ICON, size_r, 0);
267 }
268
269 /* RHEL 3, 4:
270  * /usr/share/pixmaps/redhat/shadowman-transparent.png is a 517x515
271  * PNG with alpha channel, around 64K in size.
272  *
273  * RHEL 5, 6:
274  * As above, but the file has been optimized to about 16K.
275  *
276  * Conveniently the RHEL clones also have the same file with the
277  * same name, but containing their own logos.  Sense prevails!
278  */
279 #define SHADOWMAN_ICON "/usr/share/pixmaps/redhat/shadowman-transparent.png"
280
281 static char *
282 icon_rhel (guestfs_h *g, struct inspect_fs *fs, size_t *size_r)
283 {
284   size_t max_size = 0;
285
286   if (fs->distro == OS_DISTRO_RHEL) {
287     if (fs->major_version <= 4)
288       max_size = 66000;
289     else
290       max_size = 17000;
291   }
292
293   return get_png (g, fs, SHADOWMAN_ICON, size_r, max_size);
294 }
295
296 #define DEBIAN_ICON "/usr/share/pixmaps/debian-logo.png"
297
298 static char *
299 icon_debian (guestfs_h *g, struct inspect_fs *fs, size_t *size_r)
300 {
301   return get_png (g, fs, DEBIAN_ICON, size_r, 2048);
302 }
303
304 #define UBUNTU_ICON "/usr/share/icons/gnome/24x24/places/ubuntu-logo.png"
305
306 static char *
307 icon_ubuntu (guestfs_h *g, struct inspect_fs *fs, size_t *size_r)
308 {
309   return get_png (g, fs, UBUNTU_ICON, size_r, 2048);
310 }
311
312 #define MAGEIA_ICON "/usr/share/icons/mageia.png"
313
314 static char *
315 icon_mageia (guestfs_h *g, struct inspect_fs *fs, size_t *size_r)
316 {
317   return get_png (g, fs, MAGEIA_ICON, size_r, 2048);
318 }
319
320 #define OPENSUSE_ICON "/usr/share/icons/hicolor/24x24/apps/distributor.png"
321
322 static char *
323 icon_opensuse (guestfs_h *g, struct inspect_fs *fs, size_t *size_r)
324 {
325   return get_png (g, fs, OPENSUSE_ICON, size_r, 2048);
326 }
327
328 /* Windows, as usual, has to be much more complicated and stupid than
329  * anything else.
330  *
331  * We have to download %systemroot%\explorer.exe and use a special
332  * program called 'wrestool' to extract the icons from this file.  For
333  * each version of Windows, the icon we want is in a different place.
334  * The icon is in a stupid format (BMP), and in some cases multiple
335  * icons are in a single BMP file so we have to do some manipulation
336  * on the file.
337  *
338  * XXX I've only bothered with this nonsense for a few versions of
339  * Windows that I have handy.  Please send patches to support other
340  * versions.
341  */
342
343 static char *
344 icon_windows_xp (guestfs_h *g, struct inspect_fs *fs, const char *explorer,
345                  size_t *size_r)
346 {
347   char *ret;
348   char *pngfile;
349   char *cmd;
350   int r;
351
352   pngfile = safe_asprintf (g, "%s/windows-xp-icon.png", g->tmpdir);
353
354   cmd = safe_asprintf (g,
355                        "wrestool -x --type=2 --name=143 %s | "
356                        "bmptopnm | pnmtopng > %s",
357           explorer, pngfile);
358   r = system (cmd);
359   if (r == -1 || WEXITSTATUS (r) != 0) {
360     debug (g, "external command failed: %s", cmd);
361     free (cmd);
362     free (pngfile);
363     return NOT_FOUND;
364   }
365
366   free (cmd);
367
368   if (read_whole_file (g, pngfile, &ret, size_r) == -1) {
369     free (pngfile);
370     return NULL;
371   }
372
373   free (pngfile);
374
375   return ret;
376 }
377
378 static char *
379 icon_windows_7 (guestfs_h *g, struct inspect_fs *fs, const char *explorer,
380                 size_t *size_r)
381 {
382   char *ret;
383   char *pngfile;
384   char *cmd;
385   int r;
386
387   pngfile = safe_asprintf (g, "%s/windows-7-icon.png", g->tmpdir);
388
389   cmd = safe_asprintf (g,
390                        "wrestool -x --type=2 --name=6801 %s | "
391                        "bmptopnm | pamcut -bottom 54 | pnmtopng > %s",
392           explorer, pngfile);
393   r = system (cmd);
394   if (r == -1 || WEXITSTATUS (r) != 0) {
395     debug (g, "external command failed: %s", cmd);
396     free (cmd);
397     free (pngfile);
398     return NOT_FOUND;
399   }
400
401   free (cmd);
402
403   if (read_whole_file (g, pngfile, &ret, size_r) == -1) {
404     free (pngfile);
405     return NULL;
406   }
407
408   free (pngfile);
409
410   return ret;
411 }
412
413 static char *
414 icon_windows (guestfs_h *g, struct inspect_fs *fs, size_t *size_r)
415 {
416   char *(*fn) (guestfs_h *g, struct inspect_fs *fs, const char *explorer,
417                size_t *size_r);
418   char *filename1, *filename2, *filename3;
419   char *ret;
420
421   /* Windows XP. */
422   if (fs->major_version == 5 && fs->minor_version == 1)
423     fn = icon_windows_xp;
424
425   /* Windows 7 */
426   else if (fs->major_version == 6 && fs->minor_version == 1)
427     fn = icon_windows_7;
428
429   /* Not (yet) a supported version of Windows. */
430   else return NOT_FOUND;
431
432   if (fs->windows_systemroot == NULL)
433     return NOT_FOUND;
434
435   /* Download %systemroot%\explorer.exe */
436   filename1 = safe_asprintf (g, "%s/explorer.exe", fs->windows_systemroot);
437   filename2 = guestfs___case_sensitive_path_silently (g, filename1);
438   free (filename1);
439   if (filename2 == NULL)
440     return NOT_FOUND;
441
442   filename3 = guestfs___download_to_tmp (g, fs, filename2, "explorer",
443                                          MAX_WINDOWS_EXPLORER_SIZE);
444   free (filename2);
445   if (filename3 == NULL)
446     return NOT_FOUND;
447
448   ret = fn (g, fs, filename3, size_r);
449   free (filename3);
450   return ret;
451 }
452
453 /* Read the whole file into a memory buffer and return it.  The file
454  * should be a regular, local, trusted file.
455  */
456 static int
457 read_whole_file (guestfs_h *g, const char *filename,
458                  char **data_r, size_t *size_r)
459 {
460   int fd;
461   char *data;
462   off_t size;
463   off_t n;
464   ssize_t r;
465   struct stat statbuf;
466
467   fd = open (filename, O_RDONLY);
468   if (fd == -1) {
469     perrorf (g, "open: %s", filename);
470     return -1;
471   }
472
473   if (fstat (fd, &statbuf) == -1) {
474     perrorf (g, "stat: %s", filename);
475     close (fd);
476     return -1;
477   }
478
479   size = statbuf.st_size;
480   data = safe_malloc (g, size);
481
482   n = 0;
483   while (n < size) {
484     r = read (fd, &data[n], size - n);
485     if (r == -1) {
486       perrorf (g, "read: %s", filename);
487       free (data);
488       close (fd);
489       return -1;
490     }
491     if (r == 0) {
492       error (g, _("read: %s: unexpected end of file"), filename);
493       free (data);
494       close (fd);
495       return -1;
496     }
497     n += r;
498   }
499
500   if (close (fd) == -1) {
501     perrorf (g, "close: %s", filename);
502     free (data);
503     return -1;
504   }
505
506   *data_r = data;
507   *size_r = size;
508
509   return 0;
510 }