inspector: Add detection of Slackware.
[libguestfs.git] / src / inspect.c
1 /* libguestfs
2  * Copyright (C) 2010-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 <string.h>
27 #include <sys/stat.h>
28
29 #ifdef HAVE_PCRE
30 #include <pcre.h>
31 #endif
32
33 #ifdef HAVE_HIVEX
34 #include <hivex.h>
35 #endif
36
37 #include "c-ctype.h"
38 #include "ignore-value.h"
39 #include "xstrtol.h"
40
41 #include "guestfs.h"
42 #include "guestfs-internal.h"
43 #include "guestfs-internal-actions.h"
44 #include "guestfs_protocol.h"
45
46 #if defined(HAVE_PCRE) && defined(HAVE_HIVEX)
47
48 /* Some limits on what we will read, for safety. */
49
50 /* Small text configuration files.
51  *
52  * The upper limit is for general files that we grep or download.  The
53  * largest such file is probably "txtsetup.sif" from Windows CDs
54  * (~500K).  This number has to be larger than any legitimate file and
55  * smaller than the protocol message size.
56  *
57  * The lower limit is for files parsed by Augeas on the daemon side,
58  * where Augeas is running in reduced memory and can potentially
59  * create a lot of metadata so we really need to be careful about
60  * those.
61  */
62 #define MAX_SMALL_FILE_SIZE    (2 * 1000 * 1000)
63 #define MAX_AUGEAS_FILE_SIZE        (100 * 1000)
64
65 /* Maximum Windows Registry hive that we will download to /tmp.  Some
66  * registries can be legitimately very large.
67  */
68 #define MAX_REGISTRY_SIZE    (100 * 1000 * 1000)
69
70 /* Maximum RPM or dpkg database we will download to /tmp. */
71 #define MAX_PKG_DB_SIZE       (10 * 1000 * 1000)
72
73 /* Compile all the regular expressions once when the shared library is
74  * loaded.  PCRE is thread safe so we're supposedly OK here if
75  * multiple threads call into the libguestfs API functions below
76  * simultaneously.
77  */
78 static pcre *re_fedora;
79 static pcre *re_rhel_old;
80 static pcre *re_rhel;
81 static pcre *re_rhel_no_minor;
82 static pcre *re_major_minor;
83 static pcre *re_aug_seq;
84 static pcre *re_xdev;
85 static pcre *re_first_partition;
86 static pcre *re_freebsd;
87 static pcre *re_windows_version;
88
89 static void compile_regexps (void) __attribute__((constructor));
90 static void free_regexps (void) __attribute__((destructor));
91
92 static void
93 compile_regexps (void)
94 {
95   const char *err;
96   int offset;
97
98 #define COMPILE(re,pattern,options)                                     \
99   do {                                                                  \
100     re = pcre_compile ((pattern), (options), &err, &offset, NULL);      \
101     if (re == NULL) {                                                   \
102       ignore_value (write (2, err, strlen (err)));                      \
103       abort ();                                                         \
104     }                                                                   \
105   } while (0)
106
107   COMPILE (re_fedora, "Fedora release (\\d+)", 0);
108   COMPILE (re_rhel_old,
109            "(?:Red Hat|CentOS|Scientific Linux).*release (\\d+).*Update (\\d+)", 0);
110   COMPILE (re_rhel,
111            "(?:Red Hat|CentOS|Scientific Linux).*release (\\d+)\\.(\\d+)", 0);
112   COMPILE (re_rhel_no_minor,
113            "(?:Red Hat|CentOS|Scientific Linux).*release (\\d+)", 0);
114   COMPILE (re_major_minor, "(\\d+)\\.(\\d+)", 0);
115   COMPILE (re_aug_seq, "/\\d+$", 0);
116   COMPILE (re_xdev, "^/dev/(?:h|s|v|xv)d([a-z]\\d*)$", 0);
117   COMPILE (re_first_partition, "^/dev/(?:h|s|v)d.1$", 0);
118   COMPILE (re_freebsd, "^/dev/ad(\\d+)s(\\d+)([a-z])$", 0);
119   COMPILE (re_windows_version, "^(\\d+)\\.(\\d+)", 0);
120 }
121
122 static void
123 free_regexps (void)
124 {
125   pcre_free (re_fedora);
126   pcre_free (re_rhel_old);
127   pcre_free (re_rhel);
128   pcre_free (re_rhel_no_minor);
129   pcre_free (re_major_minor);
130   pcre_free (re_aug_seq);
131   pcre_free (re_xdev);
132   pcre_free (re_first_partition);
133   pcre_free (re_freebsd);
134   pcre_free (re_windows_version);
135 }
136
137 /* The main inspection code. */
138 static int check_for_filesystem_on (guestfs_h *g, const char *device, int is_block, int is_partnum);
139
140 char **
141 guestfs__inspect_os (guestfs_h *g)
142 {
143   /* Remove any information previously stored in the handle. */
144   guestfs___free_inspect_info (g);
145
146   if (guestfs_umount_all (g) == -1)
147     return NULL;
148
149   /* Iterate over all possible devices.  Try to mount each
150    * (read-only).  Examine ones which contain filesystems and add that
151    * information to the handle.
152    */
153   /* Look to see if any devices directly contain filesystems (RHBZ#590167). */
154   char **devices;
155   devices = guestfs_list_devices (g);
156   if (devices == NULL)
157     return NULL;
158
159   size_t i;
160   for (i = 0; devices[i] != NULL; ++i) {
161     if (check_for_filesystem_on (g, devices[i], 1, 0) == -1) {
162       guestfs___free_string_list (devices);
163       guestfs___free_inspect_info (g);
164       return NULL;
165     }
166   }
167   guestfs___free_string_list (devices);
168
169   /* Look at all partitions. */
170   char **partitions;
171   partitions = guestfs_list_partitions (g);
172   if (partitions == NULL) {
173     guestfs___free_inspect_info (g);
174     return NULL;
175   }
176
177   for (i = 0; partitions[i] != NULL; ++i) {
178     if (check_for_filesystem_on (g, partitions[i], 0, i+1) == -1) {
179       guestfs___free_string_list (partitions);
180       guestfs___free_inspect_info (g);
181       return NULL;
182     }
183   }
184   guestfs___free_string_list (partitions);
185
186   /* Look at all LVs. */
187   if (guestfs___feature_available (g, "lvm2")) {
188     char **lvs;
189     lvs = guestfs_lvs (g);
190     if (lvs == NULL) {
191       guestfs___free_inspect_info (g);
192       return NULL;
193     }
194
195     for (i = 0; lvs[i] != NULL; ++i) {
196       if (check_for_filesystem_on (g, lvs[i], 0, 0) == -1) {
197         guestfs___free_string_list (lvs);
198         guestfs___free_inspect_info (g);
199         return NULL;
200       }
201     }
202     guestfs___free_string_list (lvs);
203   }
204
205   /* At this point we have, in the handle, a list of all filesystems
206    * found and data about each one.  Now we assemble the list of
207    * filesystems which are root devices and return that to the user.
208    * Fall through to guestfs__inspect_get_roots to do that.
209    */
210   char **ret = guestfs__inspect_get_roots (g);
211   if (ret == NULL)
212     guestfs___free_inspect_info (g);
213   return ret;
214 }
215
216 /* Find out if 'device' contains a filesystem.  If it does, add
217  * another entry in g->fses.
218  */
219 static int check_filesystem (guestfs_h *g, const char *device, int is_block, int is_partnum);
220 static int check_linux_root (guestfs_h *g, struct inspect_fs *fs);
221 static int check_freebsd_root (guestfs_h *g, struct inspect_fs *fs);
222 static int check_installer_root (guestfs_h *g, struct inspect_fs *fs);
223 static void check_architecture (guestfs_h *g, struct inspect_fs *fs);
224 static int check_hostname_unix (guestfs_h *g, struct inspect_fs *fs);
225 static int check_hostname_redhat (guestfs_h *g, struct inspect_fs *fs);
226 static int check_hostname_freebsd (guestfs_h *g, struct inspect_fs *fs);
227 static int check_fstab (guestfs_h *g, struct inspect_fs *fs);
228 static int check_windows_root (guestfs_h *g, struct inspect_fs *fs);
229 static int check_windows_arch (guestfs_h *g, struct inspect_fs *fs);
230 static int check_windows_software_registry (guestfs_h *g, struct inspect_fs *fs);
231 static int check_windows_system_registry (guestfs_h *g, struct inspect_fs *fs);
232 static char *resolve_windows_path_silently (guestfs_h *g, const char *);
233 static int is_file_nocase (guestfs_h *g, const char *);
234 static int is_dir_nocase (guestfs_h *g, const char *);
235 static int extend_fses (guestfs_h *g);
236 static int parse_unsigned_int (guestfs_h *g, const char *str);
237 static int parse_unsigned_int_ignore_trailing (guestfs_h *g, const char *str);
238 static int add_fstab_entry (guestfs_h *g, struct inspect_fs *fs,
239                             const char *spec, const char *mp);
240 static char *resolve_fstab_device (guestfs_h *g, const char *spec);
241 static void check_package_format (guestfs_h *g, struct inspect_fs *fs);
242 static void check_package_management (guestfs_h *g, struct inspect_fs *fs);
243 static int download_to_tmp (guestfs_h *g, const char *filename, char *localtmp, int64_t max_size);
244 static int inspect_with_augeas (guestfs_h *g, struct inspect_fs *fs, const char *filename, int (*f) (guestfs_h *, struct inspect_fs *));
245 static char *first_line_of_file (guestfs_h *g, const char *filename);
246 static int first_egrep_of_file (guestfs_h *g, const char *filename, const char *eregex, int iflag, char **ret);
247
248 static int
249 check_for_filesystem_on (guestfs_h *g, const char *device,
250                          int is_block, int is_partnum)
251 {
252   /* Get vfs-type in order to check if it's a Linux(?) swap device.
253    * If there's an error we should ignore it, so to do that we have to
254    * temporarily replace the error handler with a null one.
255    */
256   guestfs_error_handler_cb old_error_cb = g->error_cb;
257   g->error_cb = NULL;
258   char *vfs_type = guestfs_vfs_type (g, device);
259   g->error_cb = old_error_cb;
260
261   int is_swap = vfs_type && STREQ (vfs_type, "swap");
262
263   debug (g, "check_for_filesystem_on: %s %d %d (%s)",
264          device, is_block, is_partnum,
265          vfs_type ? vfs_type : "failed to get vfs type");
266
267   if (is_swap) {
268     free (vfs_type);
269     if (extend_fses (g) == -1)
270       return -1;
271     g->fses[g->nr_fses-1].is_swap = 1;
272     return 0;
273   }
274
275   /* Try mounting the device.  As above, ignore errors. */
276   g->error_cb = NULL;
277   int r = guestfs_mount_ro (g, device, "/");
278   if (r == -1 && vfs_type && STREQ (vfs_type, "ufs")) /* Hack for the *BSDs. */
279     r = guestfs_mount_vfs (g, "ro,ufstype=ufs2", "ufs", device, "/");
280   free (vfs_type);
281   g->error_cb = old_error_cb;
282   if (r == -1)
283     return 0;
284
285   /* Do the rest of the checks. */
286   r = check_filesystem (g, device, is_block, is_partnum);
287
288   /* Unmount the filesystem. */
289   if (guestfs_umount_all (g) == -1)
290     return -1;
291
292   return r;
293 }
294
295 /* is_block and is_partnum are just hints: is_block is true if the
296  * filesystem is a whole block device (eg. /dev/sda).  is_partnum
297  * is > 0 if the filesystem is a direct partition, and in this case
298  * it is the partition number counting from 1
299  * (eg. /dev/sda1 => is_partnum == 1).
300  */
301 static int
302 check_filesystem (guestfs_h *g, const char *device,
303                   int is_block, int is_partnum)
304 {
305   if (extend_fses (g) == -1)
306     return -1;
307
308   struct inspect_fs *fs = &g->fses[g->nr_fses-1];
309
310   fs->device = safe_strdup (g, device);
311   fs->is_mountable = 1;
312
313   /* Optimize some of the tests by avoiding multiple tests of the same thing. */
314   int is_dir_etc = guestfs_is_dir (g, "/etc") > 0;
315   int is_dir_bin = guestfs_is_dir (g, "/bin") > 0;
316   int is_dir_share = guestfs_is_dir (g, "/share") > 0;
317
318   /* Grub /boot? */
319   if (guestfs_is_file (g, "/grub/menu.lst") > 0 ||
320       guestfs_is_file (g, "/grub/grub.conf") > 0)
321     fs->content = FS_CONTENT_LINUX_BOOT;
322   /* FreeBSD root? */
323   else if (is_dir_etc &&
324            is_dir_bin &&
325            guestfs_is_file (g, "/etc/freebsd-update.conf") > 0 &&
326            guestfs_is_file (g, "/etc/fstab") > 0) {
327     /* Ignore /dev/sda1 which is a shadow of the real root filesystem
328      * that is probably /dev/sda5 (see:
329      * http://www.freebsd.org/doc/handbook/disk-organization.html)
330      */
331     if (match (g, device, re_first_partition))
332       return 0;
333
334     fs->is_root = 1;
335     fs->content = FS_CONTENT_FREEBSD_ROOT;
336     fs->format = OS_FORMAT_INSTALLED;
337     if (check_freebsd_root (g, fs) == -1)
338       return -1;
339   }
340   /* Linux root? */
341   else if (is_dir_etc &&
342            is_dir_bin &&
343            guestfs_is_file (g, "/etc/fstab") > 0) {
344     fs->is_root = 1;
345     fs->content = FS_CONTENT_LINUX_ROOT;
346     fs->format = OS_FORMAT_INSTALLED;
347     if (check_linux_root (g, fs) == -1)
348       return -1;
349   }
350   /* Linux /usr/local? */
351   else if (is_dir_etc &&
352            is_dir_bin &&
353            is_dir_share &&
354            guestfs_exists (g, "/local") == 0 &&
355            guestfs_is_file (g, "/etc/fstab") == 0)
356     fs->content = FS_CONTENT_LINUX_USR_LOCAL;
357   /* Linux /usr? */
358   else if (is_dir_etc &&
359            is_dir_bin &&
360            is_dir_share &&
361            guestfs_exists (g, "/local") > 0 &&
362            guestfs_is_file (g, "/etc/fstab") == 0)
363     fs->content = FS_CONTENT_LINUX_USR;
364   /* Linux /var? */
365   else if (guestfs_is_dir (g, "/log") > 0 &&
366            guestfs_is_dir (g, "/run") > 0 &&
367            guestfs_is_dir (g, "/spool") > 0)
368     fs->content = FS_CONTENT_LINUX_VAR;
369   /* Windows root?
370    * Note that if a Windows guest has multiple disks and applications
371    * are installed on those other disks, then those other disks will
372    * contain "/Program Files" and "/System Volume Information".  Those
373    * would *not* be Windows root disks.  (RHBZ#674130)
374    */
375   else if (is_file_nocase (g, "/AUTOEXEC.BAT") > 0 ||
376            is_dir_nocase (g, "/WINDOWS") > 0 ||
377            is_dir_nocase (g, "/WIN32") > 0 ||
378            is_dir_nocase (g, "/WINNT") > 0 ||
379            is_file_nocase (g, "/boot.ini") > 0 ||
380            is_file_nocase (g, "/ntldr") > 0) {
381     fs->is_root = 1;
382     fs->content = FS_CONTENT_WINDOWS_ROOT;
383     fs->format = OS_FORMAT_INSTALLED;
384     if (check_windows_root (g, fs) == -1)
385       return -1;
386   }
387   /* Windows volume with installed applications (but not root)? */
388   else if (is_dir_nocase (g, "/System Volume Information") > 0 &&
389            is_dir_nocase (g, "/Program Files") > 0)
390     fs->content = FS_CONTENT_WINDOWS_VOLUME_WITH_APPS;
391   /* Windows volume (but not root)? */
392   else if (is_dir_nocase (g, "/System Volume Information") > 0)
393     fs->content = FS_CONTENT_WINDOWS_VOLUME;
394   /* Install CD/disk?  Skip these checks if it's not a whole device
395    * (eg. CD) or the first partition (eg. bootable USB key).
396    */
397   else if ((is_block || is_partnum == 1) &&
398            (guestfs_is_file (g, "/isolinux/isolinux.cfg") > 0 ||
399             guestfs_is_dir (g, "/EFI/BOOT") > 0 ||
400             guestfs_is_file (g, "/images/install.img") > 0 ||
401             guestfs_is_dir (g, "/.disk") > 0 ||
402             guestfs_is_file (g, "/.discinfo") > 0 ||
403             guestfs_is_file (g, "/i386/txtsetup.sif") > 0 ||
404             guestfs_is_file (g, "/amd64/txtsetup.sif")) > 0) {
405     fs->is_root = 1;
406     fs->content = FS_CONTENT_INSTALLER;
407     fs->format = OS_FORMAT_INSTALLER;
408     if (check_installer_root (g, fs) == -1)
409       return -1;
410   }
411
412   return 0;
413 }
414
415 /* Set fs->product_name to the first line of the release file. */
416 static int
417 parse_release_file (guestfs_h *g, struct inspect_fs *fs,
418                     const char *release_filename)
419 {
420   fs->product_name = first_line_of_file (g, release_filename);
421   if (fs->product_name == NULL)
422     return -1;
423   return 0;
424 }
425
426 /* Parse generic MAJOR.MINOR from the fs->product_name string. */
427 static int
428 parse_major_minor (guestfs_h *g, struct inspect_fs *fs)
429 {
430   char *major, *minor;
431
432   if (match2 (g, fs->product_name, re_major_minor, &major, &minor)) {
433     fs->major_version = parse_unsigned_int (g, major);
434     free (major);
435     if (fs->major_version == -1) {
436       free (minor);
437       return -1;
438     }
439     fs->minor_version = parse_unsigned_int (g, minor);
440     free (minor);
441     if (fs->minor_version == -1)
442       return -1;
443   }
444   return 0;
445 }
446
447 /* Ubuntu has /etc/lsb-release containing:
448  *   DISTRIB_ID=Ubuntu                                # Distro
449  *   DISTRIB_RELEASE=10.04                            # Version
450  *   DISTRIB_CODENAME=lucid
451  *   DISTRIB_DESCRIPTION="Ubuntu 10.04.1 LTS"         # Product name
452  *
453  * [Ubuntu-derived ...] Linux Mint was found to have this:
454  *   DISTRIB_ID=LinuxMint
455  *   DISTRIB_RELEASE=10
456  *   DISTRIB_CODENAME=julia
457  *   DISTRIB_DESCRIPTION="Linux Mint 10 Julia"
458  * Linux Mint also has /etc/linuxmint/info with more information,
459  * but we can use the LSB file.
460  *
461  * Mandriva has:
462  *   LSB_VERSION=lsb-4.0-amd64:lsb-4.0-noarch
463  *   DISTRIB_ID=MandrivaLinux
464  *   DISTRIB_RELEASE=2010.1
465  *   DISTRIB_CODENAME=Henry_Farman
466  *   DISTRIB_DESCRIPTION="Mandriva Linux 2010.1"
467  * Mandriva also has a normal release file called /etc/mandriva-release.
468  */
469 static int
470 parse_lsb_release (guestfs_h *g, struct inspect_fs *fs)
471 {
472   const char *filename = "/etc/lsb-release";
473   int64_t size;
474   char **lines;
475   size_t i;
476   int r = 0;
477
478   /* Don't trust guestfs_head_n not to break with very large files.
479    * Check the file size is something reasonable first.
480    */
481   size = guestfs_filesize (g, filename);
482   if (size == -1)
483     /* guestfs_filesize failed and has already set error in handle */
484     return -1;
485   if (size > MAX_SMALL_FILE_SIZE) {
486     error (g, _("size of %s is unreasonably large (%" PRIi64 " bytes)"),
487            filename, size);
488     return -1;
489   }
490
491   lines = guestfs_head_n (g, 10, filename);
492   if (lines == NULL)
493     return -1;
494
495   for (i = 0; lines[i] != NULL; ++i) {
496     if (fs->distro == 0 &&
497         STREQ (lines[i], "DISTRIB_ID=Ubuntu")) {
498       fs->distro = OS_DISTRO_UBUNTU;
499       r = 1;
500     }
501     else if (fs->distro == 0 &&
502              STREQ (lines[i], "DISTRIB_ID=LinuxMint")) {
503       fs->distro = OS_DISTRO_LINUX_MINT;
504       r = 1;
505     }
506     else if (fs->distro == 0 &&
507              STREQ (lines[i], "DISTRIB_ID=MandrivaLinux")) {
508       fs->distro = OS_DISTRO_MANDRIVA;
509       r = 1;
510     }
511     else if (STRPREFIX (lines[i], "DISTRIB_RELEASE=")) {
512       char *major, *minor;
513       if (match2 (g, &lines[i][16], re_major_minor, &major, &minor)) {
514         fs->major_version = parse_unsigned_int (g, major);
515         free (major);
516         if (fs->major_version == -1) {
517           free (minor);
518           guestfs___free_string_list (lines);
519           return -1;
520         }
521         fs->minor_version = parse_unsigned_int (g, minor);
522         free (minor);
523         if (fs->minor_version == -1) {
524           guestfs___free_string_list (lines);
525           return -1;
526         }
527       }
528     }
529     else if (fs->product_name == NULL &&
530              (STRPREFIX (lines[i], "DISTRIB_DESCRIPTION=\"") ||
531               STRPREFIX (lines[i], "DISTRIB_DESCRIPTION='"))) {
532       size_t len = strlen (lines[i]) - 21 - 1;
533       fs->product_name = safe_strndup (g, &lines[i][21], len);
534       r = 1;
535     }
536     else if (fs->product_name == NULL &&
537              STRPREFIX (lines[i], "DISTRIB_DESCRIPTION=")) {
538       size_t len = strlen (lines[i]) - 20;
539       fs->product_name = safe_strndup (g, &lines[i][20], len);
540       r = 1;
541     }
542   }
543
544   guestfs___free_string_list (lines);
545   return r;
546 }
547
548 /* The currently mounted device is known to be a Linux root.  Try to
549  * determine from this the distro, version, etc.  Also parse
550  * /etc/fstab to determine the arrangement of mountpoints and
551  * associated devices.
552  */
553 static int
554 check_linux_root (guestfs_h *g, struct inspect_fs *fs)
555 {
556   int r;
557
558   fs->type = OS_TYPE_LINUX;
559
560   if (guestfs_exists (g, "/etc/lsb-release") > 0) {
561     r = parse_lsb_release (g, fs);
562     if (r == -1)        /* error */
563       return -1;
564     if (r == 1)         /* ok - detected the release from this file */
565       goto skip_release_checks;
566   }
567
568   if (guestfs_exists (g, "/etc/redhat-release") > 0) {
569     fs->distro = OS_DISTRO_REDHAT_BASED; /* Something generic Red Hat-like. */
570
571     if (parse_release_file (g, fs, "/etc/redhat-release") == -1)
572       return -1;
573
574     char *major, *minor;
575     if ((major = match1 (g, fs->product_name, re_fedora)) != NULL) {
576       fs->distro = OS_DISTRO_FEDORA;
577       fs->major_version = parse_unsigned_int (g, major);
578       free (major);
579       if (fs->major_version == -1)
580         return -1;
581     }
582     else if (match2 (g, fs->product_name, re_rhel_old, &major, &minor) ||
583              match2 (g, fs->product_name, re_rhel, &major, &minor)) {
584       fs->distro = OS_DISTRO_RHEL;
585       fs->major_version = parse_unsigned_int (g, major);
586       free (major);
587       if (fs->major_version == -1) {
588         free (minor);
589         return -1;
590       }
591       fs->minor_version = parse_unsigned_int (g, minor);
592       free (minor);
593       if (fs->minor_version == -1)
594         return -1;
595     }
596     else if ((major = match1 (g, fs->product_name, re_rhel_no_minor)) != NULL) {
597       fs->distro = OS_DISTRO_RHEL;
598       fs->major_version = parse_unsigned_int (g, major);
599       free (major);
600       if (fs->major_version == -1)
601         return -1;
602       fs->minor_version = 0;
603     }
604   }
605   else if (guestfs_exists (g, "/etc/debian_version") > 0) {
606     fs->distro = OS_DISTRO_DEBIAN;
607
608     if (parse_release_file (g, fs, "/etc/debian_version") == -1)
609       return -1;
610
611     if (parse_major_minor (g, fs) == -1)
612       return -1;
613   }
614   else if (guestfs_exists (g, "/etc/pardus-release") > 0) {
615     fs->distro = OS_DISTRO_PARDUS;
616
617     if (parse_release_file (g, fs, "/etc/pardus-release") == -1)
618       return -1;
619
620     if (parse_major_minor (g, fs) == -1)
621       return -1;
622   }
623   else if (guestfs_exists (g, "/etc/arch-release") > 0) {
624     fs->distro = OS_DISTRO_ARCHLINUX;
625
626     /* /etc/arch-release file is empty and I can't see a way to
627      * determine the actual release or product string.
628      */
629   }
630   else if (guestfs_exists (g, "/etc/gentoo-release") > 0) {
631     fs->distro = OS_DISTRO_GENTOO;
632
633     if (parse_release_file (g, fs, "/etc/gentoo-release") == -1)
634       return -1;
635
636     if (parse_major_minor (g, fs) == -1)
637       return -1;
638   }
639   else if (guestfs_exists (g, "/etc/meego-release") > 0) {
640     fs->distro = OS_DISTRO_MEEGO;
641
642     if (parse_release_file (g, fs, "/etc/meego-release") == -1)
643       return -1;
644
645     if (parse_major_minor (g, fs) == -1)
646       return -1;
647   }
648   else if (guestfs_exists (g, "/etc/slackware-version") > 0) {
649     fs->distro = OS_DISTRO_SLACKWARE;
650
651     if (parse_release_file (g, fs, "/etc/slackware-version") == -1)
652       return -1;
653
654     if (parse_major_minor (g, fs) == -1)
655       return -1;
656   }
657
658  skip_release_checks:;
659
660   /* If distro test above was successful, work out the package format. */
661   check_package_format (g, fs);
662   check_package_management (g, fs);
663
664   /* Determine the architecture. */
665   check_architecture (g, fs);
666
667   /* We already know /etc/fstab exists because it's part of the test
668    * for Linux root above.  We must now parse this file to determine
669    * which filesystems are used by the operating system and how they
670    * are mounted.
671    */
672   if (inspect_with_augeas (g, fs, "/etc/fstab", check_fstab) == -1)
673     return -1;
674
675   /* Determine hostname. */
676   if (check_hostname_unix (g, fs) == -1)
677     return -1;
678
679   return 0;
680 }
681
682 /* The currently mounted device is known to be a FreeBSD root. */
683 static int
684 check_freebsd_root (guestfs_h *g, struct inspect_fs *fs)
685 {
686   fs->type = OS_TYPE_FREEBSD;
687
688   /* FreeBSD has no authoritative version file.  The version number is
689    * in /etc/motd, which the system administrator might edit, but
690    * we'll use that anyway.
691    */
692
693   if (guestfs_exists (g, "/etc/motd") > 0) {
694     if (parse_release_file (g, fs, "/etc/motd") == -1)
695       return -1;
696
697     if (parse_major_minor (g, fs) == -1)
698       return -1;
699   }
700
701   /* Determine the architecture. */
702   check_architecture (g, fs);
703
704   /* We already know /etc/fstab exists because it's part of the test above. */
705   if (inspect_with_augeas (g, fs, "/etc/fstab", check_fstab) == -1)
706     return -1;
707
708   /* Determine hostname. */
709   if (check_hostname_unix (g, fs) == -1)
710     return -1;
711
712   return 0;
713 }
714
715 /* Debian/Ubuntu install disks are easy ...
716  *
717  * These files are added by the debian-cd program, and it is worth
718  * looking at the source code to determine exact values, in
719  * particular '/usr/share/debian-cd/tools/start_new_disc'
720  *
721  * XXX Architecture?  We could parse it out of the product name
722  * string, but that seems quite hairy.  We could look for the names
723  * of packages.  Also note that some Debian install disks are
724  * multiarch.
725  */
726 static int
727 check_debian_installer_root (guestfs_h *g, struct inspect_fs *fs)
728 {
729   fs->product_name = first_line_of_file (g, "/.disk/info");
730   if (!fs->product_name)
731     return -1;
732
733   fs->type = OS_TYPE_LINUX;
734   if (STRPREFIX (fs->product_name, "Ubuntu"))
735     fs->distro = OS_DISTRO_UBUNTU;
736   else if (STRPREFIX (fs->product_name, "Debian"))
737     fs->distro = OS_DISTRO_DEBIAN;
738
739   (void) parse_major_minor (g, fs);
740
741   if (guestfs_is_file (g, "/.disk/cd_type") > 0) {
742     char *cd_type = first_line_of_file (g, "/.disk/cd_type");
743     if (!cd_type)
744       return -1;
745
746     if (STRPREFIX (cd_type, "dvd/single") ||
747         STRPREFIX (cd_type, "full_cd/single")) {
748       fs->is_multipart_disk = 0;
749       fs->is_netinst_disk = 0;
750     }
751     else if (STRPREFIX (cd_type, "dvd") ||
752              STRPREFIX (cd_type, "full_cd")) {
753       fs->is_multipart_disk = 1;
754       fs->is_netinst_disk = 0;
755     }
756     else if (STRPREFIX (cd_type, "not_complete")) {
757       fs->is_multipart_disk = 0;
758       fs->is_netinst_disk = 1;
759     }
760
761     free (cd_type);
762   }
763
764   return 0;
765 }
766
767 /* Take string which must look like "key = value" and find the value.
768  * There may or may not be spaces before and after the equals sign.
769  * This function is used by both check_fedora_installer_root and
770  * check_w2k3_installer_root.
771  */
772 static const char *
773 find_value (const char *kv)
774 {
775   const char *p;
776
777   p = strchr (kv, '=');
778   if (!p)
779     abort ();
780
781   do {
782     ++p;
783   } while (c_isspace (*p));
784
785   return p;
786 }
787
788 /* Fedora CDs and DVD (not netinst).  The /.treeinfo file contains
789  * an initial section somewhat like this:
790  *
791  * [general]
792  * version = 14
793  * arch = x86_64
794  * family = Fedora
795  * variant = Fedora
796  * discnum = 1
797  * totaldiscs = 1
798  */
799 static int
800 check_fedora_installer_root (guestfs_h *g, struct inspect_fs *fs)
801 {
802   char *str;
803   const char *v;
804   int r;
805   int discnum = 0, totaldiscs = 0;
806
807   fs->type = OS_TYPE_LINUX;
808
809   r = first_egrep_of_file (g, "/.treeinfo",
810                            "^family = Fedora$", 0, &str);
811   if (r == -1)
812     return -1;
813   if (r > 0) {
814     fs->distro = OS_DISTRO_FEDORA;
815     free (str);
816   }
817
818   r = first_egrep_of_file (g, "/.treeinfo",
819                            "^family = Red Hat Enterprise Linux$", 0, &str);
820   if (r == -1)
821     return -1;
822   if (r > 0) {
823     fs->distro = OS_DISTRO_RHEL;
824     free (str);
825   }
826
827   /* XXX should do major.minor before this */
828   r = first_egrep_of_file (g, "/.treeinfo",
829                            "^version = [[:digit:]]+", 0, &str);
830   if (r == -1)
831     return -1;
832   if (r > 0) {
833     v = find_value (str);
834     fs->major_version = parse_unsigned_int_ignore_trailing (g, v);
835     free (str);
836     if (fs->major_version == -1)
837       return -1;
838   }
839
840   r = first_egrep_of_file (g, "/.treeinfo",
841                            "^arch = [-_[:alnum:]]+$", 0, &str);
842   if (r == -1)
843     return -1;
844   if (r > 0) {
845     v = find_value (str);
846     fs->arch = safe_strdup (g, v);
847     free (str);
848   }
849
850   r = first_egrep_of_file (g, "/.treeinfo",
851                            "^discnum = [[:digit:]]+$", 0, &str);
852   if (r == -1)
853     return -1;
854   if (r > 0) {
855     v = find_value (str);
856     discnum = parse_unsigned_int (g, v);
857     free (str);
858     if (discnum == -1)
859       return -1;
860   }
861
862   r = first_egrep_of_file (g, "/.treeinfo",
863                            "^totaldiscs = [[:digit:]]+$", 0, &str);
864   if (r == -1)
865     return -1;
866   if (r > 0) {
867     v = find_value (str);
868     totaldiscs = parse_unsigned_int (g, v);
869     free (str);
870     if (totaldiscs == -1)
871       return -1;
872   }
873
874   fs->is_multipart_disk = totaldiscs > 0;
875   /* and what about discnum? */
876
877   return 0;
878 }
879
880 /* Linux with /isolinux/isolinux.cfg.
881  *
882  * This file is not easily parsable so we have to do our best.
883  * Look for the "menu title" line which contains:
884  *   menu title Welcome to Fedora 14!   # since at least Fedora 10
885  *   menu title Welcome to Red Hat Enterprise Linux 6.0!
886  */
887 static int
888 check_isolinux_installer_root (guestfs_h *g, struct inspect_fs *fs)
889 {
890   char *str;
891   int r;
892
893   fs->type = OS_TYPE_LINUX;
894
895   r = first_egrep_of_file (g, "/isolinux/isolinux.cfg",
896                            "^menu title Welcome to Fedora [[:digit:]]+",
897                            0, &str);
898   if (r == -1)
899     return -1;
900   if (r > 0) {
901     fs->distro = OS_DISTRO_FEDORA;
902     fs->major_version = parse_unsigned_int_ignore_trailing (g, &str[29]);
903     free (str);
904     if (fs->major_version == -1)
905       return -1;
906   }
907
908   /* XXX parse major.minor */
909   r = first_egrep_of_file (g, "/isolinux/isolinux.cfg",
910                            "^menu title Welcome to Red Hat Enterprise Linux [[:digit:]]+",
911                            0, &str);
912   if (r == -1)
913     return -1;
914   if (r > 0) {
915     fs->distro = OS_DISTRO_RHEL;
916     fs->major_version = parse_unsigned_int_ignore_trailing (g, &str[47]);
917     free (str);
918     if (fs->major_version == -1)
919       return -1;
920   }
921
922   return 0;
923 }
924
925 /* Windows 2003 and similar versions.
926  *
927  * NB: txtsetup file contains Windows \r\n line endings, which guestfs_grep
928  * does not remove.  We have to remove them by hand here.
929  */
930 static void
931 trim_cr (char *str)
932 {
933   size_t n = strlen (str);
934   if (n > 0 && str[n-1] == '\r')
935     str[n-1] = '\0';
936 }
937
938 static void
939 trim_quot (char *str)
940 {
941   size_t n = strlen (str);
942   if (n > 0 && str[n-1] == '"')
943     str[n-1] = '\0';
944 }
945
946 static int
947 check_w2k3_installer_root (guestfs_h *g, struct inspect_fs *fs,
948                            const char *txtsetup)
949 {
950   char *str;
951   const char *v;
952   int r;
953
954   fs->type = OS_TYPE_WINDOWS;
955   fs->distro = OS_DISTRO_WINDOWS;
956
957   r = first_egrep_of_file (g, txtsetup,
958                            "^productname[[:space:]]*=[[:space:]]*\"", 1, &str);
959   if (r == -1)
960     return -1;
961   if (r > 0) {
962     trim_cr (str);
963     trim_quot (str);
964     v = find_value (str);
965     fs->product_name = safe_strdup (g, v+1);
966     free (str);
967   }
968
969   r = first_egrep_of_file (g, txtsetup,
970                            "^majorversion[[:space:]]*=[[:space:]]*[[:digit:]]+",
971                            1, &str);
972   if (r == -1)
973     return -1;
974   if (r > 0) {
975     trim_cr (str);
976     v = find_value (str);
977     fs->major_version = parse_unsigned_int_ignore_trailing (g, v);
978     free (str);
979     if (fs->major_version == -1)
980       return -1;
981   }
982
983   r = first_egrep_of_file (g, txtsetup,
984                            "^minorversion[[:space:]]*=[[:space:]]*[[:digit:]]+",
985                            1, &str);
986   if (r == -1)
987     return -1;
988   if (r > 0) {
989     trim_cr (str);
990     v = find_value (str);
991     fs->minor_version = parse_unsigned_int_ignore_trailing (g, v);
992     free (str);
993     if (fs->minor_version == -1)
994       return -1;
995   }
996
997   /* This is the windows systemroot that would be chosen on
998    * installation by default, although not necessarily the one that
999    * the user will finally choose.
1000    */
1001   r = first_egrep_of_file (g, txtsetup, "^defaultpath[[:space:]]*=[[:space:]]*",
1002                            1, &str);
1003   if (r == -1)
1004     return -1;
1005   if (r > 0) {
1006     trim_cr (str);
1007     v = find_value (str);
1008     fs->windows_systemroot = safe_strdup (g, v);
1009     free (str);
1010   }
1011
1012   return 0;
1013 }
1014
1015 /* The currently mounted device is very likely to be an installer. */
1016 static int
1017 check_installer_root (guestfs_h *g, struct inspect_fs *fs)
1018 {
1019   /* The presence of certain files indicates a live CD.
1020    *
1021    * XXX Fedora netinst contains a ~120MB squashfs called
1022    * /images/install.img.  However this is not a live CD (unlike the
1023    * Fedora live CDs which contain the same, but larger file).  We
1024    * need to unpack this and look inside to tell the difference.
1025    */
1026   if (guestfs_is_file (g, "/casper/filesystem.squashfs") > 0)
1027     fs->is_live_disk = 1;
1028
1029   /* Debian/Ubuntu. */
1030   if (guestfs_is_file (g, "/.disk/info") > 0) {
1031     if (check_debian_installer_root (g, fs) == -1)
1032       return -1;
1033   }
1034
1035   /* Fedora CDs and DVD (not netinst). */
1036   else if (guestfs_is_file (g, "/.treeinfo") > 0) {
1037     if (check_fedora_installer_root (g, fs) == -1)
1038       return -1;
1039   }
1040
1041   /* Linux with /isolinux/isolinux.cfg. */
1042   else if (guestfs_is_file (g, "/isolinux/isolinux.cfg") > 0) {
1043     if (check_isolinux_installer_root (g, fs) == -1)
1044       return -1;
1045   }
1046
1047   /* Windows 2003 64 bit */
1048   else if (guestfs_is_file (g, "/amd64/txtsetup.sif") > 0) {
1049     fs->arch = safe_strdup (g, "x86_64");
1050     if (check_w2k3_installer_root (g, fs, "/amd64/txtsetup.sif") == -1)
1051       return -1;
1052   }
1053
1054   /* Windows 2003 32 bit */
1055   else if (guestfs_is_file (g, "/i386/txtsetup.sif") > 0) {
1056     fs->arch = safe_strdup (g, "i386");
1057     if (check_w2k3_installer_root (g, fs, "/i386/txtsetup.sif") == -1)
1058       return -1;
1059   }
1060
1061   return 0;
1062 }
1063
1064 static void
1065 check_architecture (guestfs_h *g, struct inspect_fs *fs)
1066 {
1067   const char *binaries[] =
1068     { "/bin/bash", "/bin/ls", "/bin/echo", "/bin/rm", "/bin/sh" };
1069   size_t i;
1070
1071   for (i = 0; i < sizeof binaries / sizeof binaries[0]; ++i) {
1072     if (guestfs_is_file (g, binaries[i]) > 0) {
1073       /* Ignore errors from file_architecture call. */
1074       guestfs_error_handler_cb old_error_cb = g->error_cb;
1075       g->error_cb = NULL;
1076       char *arch = guestfs_file_architecture (g, binaries[i]);
1077       g->error_cb = old_error_cb;
1078
1079       if (arch) {
1080         /* String will be owned by handle, freed by
1081          * guestfs___free_inspect_info.
1082          */
1083         fs->arch = arch;
1084         break;
1085       }
1086     }
1087   }
1088 }
1089
1090 /* Try several methods to determine the hostname from a Linux or
1091  * FreeBSD guest.  Note that type and distro have been set, so we can
1092  * use that information to direct the search.
1093  */
1094 static int
1095 check_hostname_unix (guestfs_h *g, struct inspect_fs *fs)
1096 {
1097   switch (fs->type) {
1098   case OS_TYPE_LINUX:
1099     /* Red Hat-derived would be in /etc/sysconfig/network, and
1100      * Debian-derived in the file /etc/hostname.  Very old Debian and
1101      * SUSE use /etc/HOSTNAME.  It's best to just look for each of
1102      * these files in turn, rather than try anything clever based on
1103      * distro.
1104      */
1105     if (guestfs_is_file (g, "/etc/HOSTNAME")) {
1106       fs->hostname = first_line_of_file (g, "/etc/HOSTNAME");
1107       if (fs->hostname == NULL)
1108         return -1;
1109     }
1110     else if (guestfs_is_file (g, "/etc/hostname")) {
1111       fs->hostname = first_line_of_file (g, "/etc/hostname");
1112       if (fs->hostname == NULL)
1113         return -1;
1114     }
1115     else if (guestfs_is_file (g, "/etc/sysconfig/network")) {
1116       if (inspect_with_augeas (g, fs, "/etc/sysconfig/network",
1117                                check_hostname_redhat) == -1)
1118         return -1;
1119     }
1120     break;
1121
1122   case OS_TYPE_FREEBSD:
1123     /* /etc/rc.conf contains the hostname, but there is no Augeas lens
1124      * for this file.
1125      */
1126     if (guestfs_is_file (g, "/etc/rc.conf")) {
1127       if (check_hostname_freebsd (g, fs) == -1)
1128         return -1;
1129     }
1130     break;
1131
1132   case OS_TYPE_WINDOWS: /* not here, see check_windows_system_registry */
1133   case OS_TYPE_UNKNOWN:
1134   default:
1135     /* nothing, keep GCC warnings happy */;
1136   }
1137
1138   return 0;
1139 }
1140
1141 /* Parse the hostname from /etc/sysconfig/network.  This must be called
1142  * from the inspect_with_augeas wrapper.
1143  */
1144 static int
1145 check_hostname_redhat (guestfs_h *g, struct inspect_fs *fs)
1146 {
1147   char *hostname;
1148
1149   hostname = guestfs_aug_get (g, "/files/etc/sysconfig/network/HOSTNAME");
1150   if (!hostname)
1151     return -1;
1152
1153   fs->hostname = hostname;  /* freed by guestfs___free_inspect_info */
1154   return 0;
1155 }
1156
1157 /* Parse the hostname from /etc/rc.conf.  On FreeBSD this file
1158  * contains comments, blank lines and:
1159  *   hostname="freebsd8.example.com"
1160  *   ifconfig_re0="DHCP"
1161  *   keymap="uk.iso"
1162  *   sshd_enable="YES"
1163  */
1164 static int
1165 check_hostname_freebsd (guestfs_h *g, struct inspect_fs *fs)
1166 {
1167   const char *filename = "/etc/rc.conf";
1168   int64_t size;
1169   char **lines;
1170   size_t i;
1171
1172   /* Don't trust guestfs_read_lines not to break with very large files.
1173    * Check the file size is something reasonable first.
1174    */
1175   size = guestfs_filesize (g, filename);
1176   if (size == -1)
1177     /* guestfs_filesize failed and has already set error in handle */
1178     return -1;
1179   if (size > MAX_SMALL_FILE_SIZE) {
1180     error (g, _("size of %s is unreasonably large (%" PRIi64 " bytes)"),
1181            filename, size);
1182     return -1;
1183   }
1184
1185   lines = guestfs_read_lines (g, filename);
1186   if (lines == NULL)
1187     return -1;
1188
1189   for (i = 0; lines[i] != NULL; ++i) {
1190     if (STRPREFIX (lines[i], "hostname=\"") ||
1191         STRPREFIX (lines[i], "hostname='")) {
1192       size_t len = strlen (lines[i]) - 10 - 1;
1193       fs->hostname = safe_strndup (g, &lines[i][10], len);
1194       break;
1195     } else if (STRPREFIX (lines[i], "hostname=")) {
1196       size_t len = strlen (lines[i]) - 9;
1197       fs->hostname = safe_strndup (g, &lines[i][9], len);
1198       break;
1199     }
1200   }
1201
1202   guestfs___free_string_list (lines);
1203   return 0;
1204 }
1205
1206 static int
1207 check_fstab (guestfs_h *g, struct inspect_fs *fs)
1208 {
1209   char **lines = guestfs_aug_ls (g, "/files/etc/fstab");
1210   if (lines == NULL)
1211     return -1;
1212
1213   if (lines[0] == NULL) {
1214     error (g, _("could not parse /etc/fstab or empty file"));
1215     guestfs___free_string_list (lines);
1216     return -1;
1217   }
1218
1219   size_t i;
1220   char augpath[256];
1221   for (i = 0; lines[i] != NULL; ++i) {
1222     /* Ignore comments.  Only care about sequence lines which
1223      * match m{/\d+$}.
1224      */
1225     if (match (g, lines[i], re_aug_seq)) {
1226       snprintf (augpath, sizeof augpath, "%s/spec", lines[i]);
1227       char *spec = guestfs_aug_get (g, augpath);
1228       if (spec == NULL) {
1229         guestfs___free_string_list (lines);
1230         return -1;
1231       }
1232
1233       snprintf (augpath, sizeof augpath, "%s/file", lines[i]);
1234       char *mp = guestfs_aug_get (g, augpath);
1235       if (mp == NULL) {
1236         guestfs___free_string_list (lines);
1237         free (spec);
1238         return -1;
1239       }
1240
1241       int r = add_fstab_entry (g, fs, spec, mp);
1242       free (spec);
1243       free (mp);
1244
1245       if (r == -1) {
1246         guestfs___free_string_list (lines);
1247         return -1;
1248       }
1249     }
1250   }
1251
1252   guestfs___free_string_list (lines);
1253   return 0;
1254 }
1255
1256 /* Add a filesystem and possibly a mountpoint entry for
1257  * the root filesystem 'fs'.
1258  *
1259  * 'spec' is the fstab spec field, which might be a device name or a
1260  * pseudodevice or 'UUID=...' or 'LABEL=...'.
1261  *
1262  * 'mp' is the mount point, which could also be 'swap' or 'none'.
1263  */
1264 static int
1265 add_fstab_entry (guestfs_h *g, struct inspect_fs *fs,
1266                  const char *spec, const char *mp)
1267 {
1268   /* Ignore certain mountpoints. */
1269   if (STRPREFIX (mp, "/dev/") ||
1270       STREQ (mp, "/dev") ||
1271       STRPREFIX (mp, "/media/") ||
1272       STRPREFIX (mp, "/proc/") ||
1273       STREQ (mp, "/proc") ||
1274       STRPREFIX (mp, "/selinux/") ||
1275       STREQ (mp, "/selinux") ||
1276       STRPREFIX (mp, "/sys/") ||
1277       STREQ (mp, "/sys"))
1278     return 0;
1279
1280   /* Ignore /dev/fd (floppy disks) (RHBZ#642929) and CD-ROM drives. */
1281   if ((STRPREFIX (spec, "/dev/fd") && c_isdigit (spec[7])) ||
1282       STREQ (spec, "/dev/floppy") ||
1283       STREQ (spec, "/dev/cdrom"))
1284     return 0;
1285
1286   /* Resolve UUID= and LABEL= to the actual device. */
1287   char *device = NULL;
1288   if (STRPREFIX (spec, "UUID="))
1289     device = guestfs_findfs_uuid (g, &spec[5]);
1290   else if (STRPREFIX (spec, "LABEL="))
1291     device = guestfs_findfs_label (g, &spec[6]);
1292   /* Ignore "/.swap" (Pardus) and pseudo-devices like "tmpfs". */
1293   else if (STRPREFIX (spec, "/dev/"))
1294     /* Resolve guest block device names. */
1295     device = resolve_fstab_device (g, spec);
1296
1297   /* If we haven't resolved the device successfully by this point,
1298    * we don't care, just ignore it.
1299    */
1300   if (device == NULL)
1301     return 0;
1302
1303   char *mountpoint = safe_strdup (g, mp);
1304
1305   /* Add this to the fstab entry in 'fs'.
1306    * Note these are further filtered by guestfs_inspect_get_mountpoints
1307    * and guestfs_inspect_get_filesystems.
1308    */
1309   size_t n = fs->nr_fstab + 1;
1310   struct inspect_fstab_entry *p;
1311
1312   p = realloc (fs->fstab, n * sizeof (struct inspect_fstab_entry));
1313   if (p == NULL) {
1314     perrorf (g, "realloc");
1315     free (device);
1316     free (mountpoint);
1317     return -1;
1318   }
1319
1320   fs->fstab = p;
1321   fs->nr_fstab = n;
1322
1323   /* These are owned by the handle and freed by guestfs___free_inspect_info. */
1324   fs->fstab[n-1].device = device;
1325   fs->fstab[n-1].mountpoint = mountpoint;
1326
1327   debug (g, "fstab: device=%s mountpoint=%s", device, mountpoint);
1328
1329   return 0;
1330 }
1331
1332 /* Resolve block device name to the libguestfs device name, eg.
1333  * /dev/xvdb1 => /dev/vdb1; and /dev/mapper/VG-LV => /dev/VG/LV.  This
1334  * assumes that disks were added in the same order as they appear to
1335  * the real VM, which is a reasonable assumption to make.  Return
1336  * anything we don't recognize unchanged.
1337  */
1338 static char *
1339 resolve_fstab_device (guestfs_h *g, const char *spec)
1340 {
1341   char *a1;
1342   char *device = NULL;
1343   char *bsddisk, *bsdslice, *bsdpart;
1344
1345   if (STRPREFIX (spec, "/dev/mapper/")) {
1346     /* LVM2 does some strange munging on /dev/mapper paths for VGs and
1347      * LVs which contain '-' character:
1348      *
1349      * ><fs> lvcreate LV--test VG--test 32
1350      * ><fs> debug ls /dev/mapper
1351      * VG----test-LV----test
1352      *
1353      * This makes it impossible to reverse those paths directly, so
1354      * we have implemented lvm_canonical_lv_name in the daemon.
1355      */
1356     device = guestfs_lvm_canonical_lv_name (g, spec);
1357   }
1358   else if ((a1 = match1 (g, spec, re_xdev)) != NULL) {
1359     char **devices = guestfs_list_devices (g);
1360     if (devices == NULL)
1361       return NULL;
1362
1363     size_t count;
1364     for (count = 0; devices[count] != NULL; count++)
1365       ;
1366
1367     size_t i = a1[0] - 'a'; /* a1[0] is always [a-z] because of regex. */
1368     if (i < count) {
1369       size_t len = strlen (devices[i]) + strlen (a1) + 16;
1370       device = safe_malloc (g, len);
1371       snprintf (device, len, "%s%s", devices[i], &a1[1]);
1372     }
1373
1374     free (a1);
1375     guestfs___free_string_list (devices);
1376   }
1377   else if (match3 (g, spec, re_freebsd, &bsddisk, &bsdslice, &bsdpart)) {
1378     /* FreeBSD disks are organized quite differently.  See:
1379      * http://www.freebsd.org/doc/handbook/disk-organization.html
1380      * FreeBSD "partitions" are exposed as quasi-extended partitions
1381      * numbered from 5 in Linux.  I have no idea what happens when you
1382      * have multiple "slices" (the FreeBSD term for MBR partitions).
1383      */
1384     int disk = parse_unsigned_int (g, bsddisk);
1385     int slice = parse_unsigned_int (g, bsdslice);
1386     int part = bsdpart[0] - 'a' /* counting from 0 */;
1387     free (bsddisk);
1388     free (bsdslice);
1389     free (bsdpart);
1390
1391     if (disk == -1 || disk > 26 ||
1392         slice <= 0 || slice > 1 /* > 4 .. see comment above */ ||
1393         part < 0 || part >= 26)
1394       goto out;
1395
1396     device = safe_asprintf (g, "/dev/sd%c%d", disk + 'a', part + 5);
1397   }
1398
1399  out:
1400   /* Didn't match device pattern, return original spec unchanged. */
1401   if (device == NULL)
1402     device = safe_strdup (g, spec);
1403
1404   return device;
1405 }
1406
1407 /* XXX Handling of boot.ini in the Perl version was pretty broken.  It
1408  * essentially didn't do anything for modern Windows guests.
1409  * Therefore I've omitted all that code.
1410  */
1411 static int
1412 check_windows_root (guestfs_h *g, struct inspect_fs *fs)
1413 {
1414   fs->type = OS_TYPE_WINDOWS;
1415   fs->distro = OS_DISTRO_WINDOWS;
1416
1417   /* Try to find Windows systemroot using some common locations. */
1418   const char *systemroots[] =
1419     { "/windows", "/winnt", "/win32", "/win" };
1420   size_t i;
1421   char *systemroot = NULL;
1422   for (i = 0;
1423        systemroot == NULL && i < sizeof systemroots / sizeof systemroots[0];
1424        ++i) {
1425     systemroot = resolve_windows_path_silently (g, systemroots[i]);
1426   }
1427
1428   if (!systemroot) {
1429     error (g, _("cannot resolve Windows %%SYSTEMROOT%%"));
1430     return -1;
1431   }
1432
1433   debug (g, "windows %%SYSTEMROOT%% = %s", systemroot);
1434
1435   /* Freed by guestfs___free_inspect_info. */
1436   fs->windows_systemroot = systemroot;
1437
1438   if (check_windows_arch (g, fs) == -1)
1439     return -1;
1440
1441   /* Product name and version. */
1442   if (check_windows_software_registry (g, fs) == -1)
1443     return -1;
1444
1445   check_package_format (g, fs);
1446   check_package_management (g, fs);
1447
1448   /* Hostname. */
1449   if (check_windows_system_registry (g, fs) == -1)
1450     return -1;
1451
1452   return 0;
1453 }
1454
1455 static int
1456 check_windows_arch (guestfs_h *g, struct inspect_fs *fs)
1457 {
1458   size_t len = strlen (fs->windows_systemroot) + 32;
1459   char cmd_exe[len];
1460   snprintf (cmd_exe, len, "%s/system32/cmd.exe", fs->windows_systemroot);
1461
1462   char *cmd_exe_path = resolve_windows_path_silently (g, cmd_exe);
1463   if (!cmd_exe_path)
1464     return 0;
1465
1466   char *arch = guestfs_file_architecture (g, cmd_exe_path);
1467   free (cmd_exe_path);
1468
1469   if (arch)
1470     fs->arch = arch;        /* freed by guestfs___free_inspect_info */
1471
1472   return 0;
1473 }
1474
1475 /* At the moment, pull just the ProductName and version numbers from
1476  * the registry.  In future there is a case for making many more
1477  * registry fields available to callers.
1478  */
1479 static int
1480 check_windows_software_registry (guestfs_h *g, struct inspect_fs *fs)
1481 {
1482   TMP_TEMPLATE_ON_STACK (software_local);
1483
1484   size_t len = strlen (fs->windows_systemroot) + 64;
1485   char software[len];
1486   snprintf (software, len, "%s/system32/config/software",
1487             fs->windows_systemroot);
1488
1489   char *software_path = resolve_windows_path_silently (g, software);
1490   if (!software_path)
1491     /* If the software hive doesn't exist, just accept that we cannot
1492      * find product_name etc.
1493      */
1494     return 0;
1495
1496   int ret = -1;
1497   hive_h *h = NULL;
1498   hive_value_h *values = NULL;
1499
1500   if (download_to_tmp (g, software_path, software_local,
1501                        MAX_REGISTRY_SIZE) == -1)
1502     goto out;
1503
1504   h = hivex_open (software_local, g->verbose ? HIVEX_OPEN_VERBOSE : 0);
1505   if (h == NULL) {
1506     perrorf (g, "hivex_open");
1507     goto out;
1508   }
1509
1510   hive_node_h node = hivex_root (h);
1511   const char *hivepath[] =
1512     { "Microsoft", "Windows NT", "CurrentVersion" };
1513   size_t i;
1514   for (i = 0;
1515        node != 0 && i < sizeof hivepath / sizeof hivepath[0];
1516        ++i) {
1517     node = hivex_node_get_child (h, node, hivepath[i]);
1518   }
1519
1520   if (node == 0) {
1521     perrorf (g, "hivex: cannot locate HKLM\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion");
1522     goto out;
1523   }
1524
1525   values = hivex_node_values (h, node);
1526
1527   for (i = 0; values[i] != 0; ++i) {
1528     char *key = hivex_value_key (h, values[i]);
1529     if (key == NULL) {
1530       perrorf (g, "hivex_value_key");
1531       goto out;
1532     }
1533
1534     if (STRCASEEQ (key, "ProductName")) {
1535       fs->product_name = hivex_value_string (h, values[i]);
1536       if (!fs->product_name) {
1537         perrorf (g, "hivex_value_string");
1538         free (key);
1539         goto out;
1540       }
1541     }
1542     else if (STRCASEEQ (key, "CurrentVersion")) {
1543       char *version = hivex_value_string (h, values[i]);
1544       if (!version) {
1545         perrorf (g, "hivex_value_string");
1546         free (key);
1547         goto out;
1548       }
1549       char *major, *minor;
1550       if (match2 (g, version, re_windows_version, &major, &minor)) {
1551         fs->major_version = parse_unsigned_int (g, major);
1552         free (major);
1553         if (fs->major_version == -1) {
1554           free (minor);
1555           free (key);
1556           free (version);
1557           goto out;
1558         }
1559         fs->minor_version = parse_unsigned_int (g, minor);
1560         free (minor);
1561         if (fs->minor_version == -1) {
1562           free (key);
1563           free (version);
1564           goto out;
1565         }
1566       }
1567
1568       free (version);
1569     }
1570     else if (STRCASEEQ (key, "InstallationType")) {
1571       fs->product_variant = hivex_value_string (h, values[i]);
1572       if (!fs->product_variant) {
1573         perrorf (g, "hivex_value_string");
1574         free (key);
1575         goto out;
1576       }
1577     }
1578
1579     free (key);
1580   }
1581
1582   ret = 0;
1583
1584  out:
1585   if (h) hivex_close (h);
1586   free (values);
1587   free (software_path);
1588
1589   /* Free up the temporary file. */
1590   unlink (software_local);
1591 #undef software_local_len
1592
1593   return ret;
1594 }
1595
1596 static int
1597 check_windows_system_registry (guestfs_h *g, struct inspect_fs *fs)
1598 {
1599   TMP_TEMPLATE_ON_STACK (system_local);
1600
1601   size_t len = strlen (fs->windows_systemroot) + 64;
1602   char system[len];
1603   snprintf (system, len, "%s/system32/config/system",
1604             fs->windows_systemroot);
1605
1606   char *system_path = resolve_windows_path_silently (g, system);
1607   if (!system_path)
1608     /* If the system hive doesn't exist, just accept that we cannot
1609      * find hostname etc.
1610      */
1611     return 0;
1612
1613   int ret = -1;
1614   hive_h *h = NULL;
1615   hive_value_h *values = NULL;
1616
1617   if (download_to_tmp (g, system_path, system_local, MAX_REGISTRY_SIZE) == -1)
1618     goto out;
1619
1620   h = hivex_open (system_local, g->verbose ? HIVEX_OPEN_VERBOSE : 0);
1621   if (h == NULL) {
1622     perrorf (g, "hivex_open");
1623     goto out;
1624   }
1625
1626   hive_node_h node = hivex_root (h);
1627   /* XXX Don't hard-code ControlSet001.  The current control set would
1628    * be another good thing to expose up through the inspection API.
1629    */
1630   const char *hivepath[] =
1631     { "ControlSet001", "Services", "Tcpip", "Parameters" };
1632   size_t i;
1633   for (i = 0;
1634        node != 0 && i < sizeof hivepath / sizeof hivepath[0];
1635        ++i) {
1636     node = hivex_node_get_child (h, node, hivepath[i]);
1637   }
1638
1639   if (node == 0) {
1640     perrorf (g, "hivex: cannot locate HKLM\\SYSTEM\\ControlSet001\\Services\\Tcpip\\Parameters");
1641     goto out;
1642   }
1643
1644   values = hivex_node_values (h, node);
1645
1646   for (i = 0; values[i] != 0; ++i) {
1647     char *key = hivex_value_key (h, values[i]);
1648     if (key == NULL) {
1649       perrorf (g, "hivex_value_key");
1650       goto out;
1651     }
1652
1653     if (STRCASEEQ (key, "Hostname")) {
1654       fs->hostname = hivex_value_string (h, values[i]);
1655       if (!fs->hostname) {
1656         perrorf (g, "hivex_value_string");
1657         free (key);
1658         goto out;
1659       }
1660     }
1661     /* many other interesting fields here ... */
1662
1663     free (key);
1664   }
1665
1666   ret = 0;
1667
1668  out:
1669   if (h) hivex_close (h);
1670   free (values);
1671   free (system_path);
1672
1673   /* Free up the temporary file. */
1674   unlink (system_local);
1675 #undef system_local_len
1676
1677   return ret;
1678 }
1679
1680 static char *
1681 resolve_windows_path_silently (guestfs_h *g, const char *path)
1682 {
1683   guestfs_error_handler_cb old_error_cb = g->error_cb;
1684   g->error_cb = NULL;
1685   char *ret = guestfs_case_sensitive_path (g, path);
1686   g->error_cb = old_error_cb;
1687   return ret;
1688 }
1689
1690 static int
1691 is_file_nocase (guestfs_h *g, const char *path)
1692 {
1693   char *p;
1694   int r;
1695
1696   p = resolve_windows_path_silently (g, path);
1697   if (!p)
1698     return 0;
1699   r = guestfs_is_file (g, p);
1700   free (p);
1701   return r > 0;
1702 }
1703
1704 static int
1705 is_dir_nocase (guestfs_h *g, const char *path)
1706 {
1707   char *p;
1708   int r;
1709
1710   p = resolve_windows_path_silently (g, path);
1711   if (!p)
1712     return 0;
1713   r = guestfs_is_dir (g, p);
1714   free (p);
1715   return r > 0;
1716 }
1717
1718 static int
1719 extend_fses (guestfs_h *g)
1720 {
1721   size_t n = g->nr_fses + 1;
1722   struct inspect_fs *p;
1723
1724   p = realloc (g->fses, n * sizeof (struct inspect_fs));
1725   if (p == NULL) {
1726     perrorf (g, "realloc");
1727     return -1;
1728   }
1729
1730   g->fses = p;
1731   g->nr_fses = n;
1732
1733   memset (&g->fses[n-1], 0, sizeof (struct inspect_fs));
1734
1735   return 0;
1736 }
1737
1738 /* Parse small, unsigned ints, as used in version numbers. */
1739 static int
1740 parse_unsigned_int (guestfs_h *g, const char *str)
1741 {
1742   long ret;
1743   int r = xstrtol (str, NULL, 10, &ret, "");
1744   if (r != LONGINT_OK) {
1745     error (g, _("could not parse integer in version number: %s"), str);
1746     return -1;
1747   }
1748   return ret;
1749 }
1750
1751 /* Like parse_unsigned_int, but ignore trailing stuff. */
1752 static int
1753 parse_unsigned_int_ignore_trailing (guestfs_h *g, const char *str)
1754 {
1755   long ret;
1756   int r = xstrtol (str, NULL, 10, &ret, NULL);
1757   if (r != LONGINT_OK) {
1758     error (g, _("could not parse integer in version number: %s"), str);
1759     return -1;
1760   }
1761   return ret;
1762 }
1763
1764 /* At the moment, package format and package management is just a
1765  * simple function of the distro and major_version fields, so these
1766  * can never return an error.  We might be cleverer in future.
1767  */
1768 static void
1769 check_package_format (guestfs_h *g, struct inspect_fs *fs)
1770 {
1771   switch (fs->distro) {
1772   case OS_DISTRO_FEDORA:
1773   case OS_DISTRO_MEEGO:
1774   case OS_DISTRO_REDHAT_BASED:
1775   case OS_DISTRO_RHEL:
1776   case OS_DISTRO_MANDRIVA:
1777     fs->package_format = OS_PACKAGE_FORMAT_RPM;
1778     break;
1779
1780   case OS_DISTRO_DEBIAN:
1781   case OS_DISTRO_UBUNTU:
1782   case OS_DISTRO_LINUX_MINT:
1783     fs->package_format = OS_PACKAGE_FORMAT_DEB;
1784     break;
1785
1786   case OS_DISTRO_ARCHLINUX:
1787     fs->package_format = OS_PACKAGE_FORMAT_PACMAN;
1788     break;
1789   case OS_DISTRO_GENTOO:
1790     fs->package_format = OS_PACKAGE_FORMAT_EBUILD;
1791     break;
1792   case OS_DISTRO_PARDUS:
1793     fs->package_format = OS_PACKAGE_FORMAT_PISI;
1794     break;
1795
1796   case OS_DISTRO_SLACKWARE:
1797   case OS_DISTRO_WINDOWS:
1798   case OS_DISTRO_UNKNOWN:
1799   default:
1800     fs->package_format = OS_PACKAGE_FORMAT_UNKNOWN;
1801     break;
1802   }
1803 }
1804
1805 static void
1806 check_package_management (guestfs_h *g, struct inspect_fs *fs)
1807 {
1808   switch (fs->distro) {
1809   case OS_DISTRO_FEDORA:
1810   case OS_DISTRO_MEEGO:
1811     fs->package_management = OS_PACKAGE_MANAGEMENT_YUM;
1812     break;
1813
1814   case OS_DISTRO_REDHAT_BASED:
1815   case OS_DISTRO_RHEL:
1816     if (fs->major_version >= 5)
1817       fs->package_management = OS_PACKAGE_MANAGEMENT_YUM;
1818     else
1819       fs->package_management = OS_PACKAGE_MANAGEMENT_UP2DATE;
1820     break;
1821
1822   case OS_DISTRO_DEBIAN:
1823   case OS_DISTRO_UBUNTU:
1824   case OS_DISTRO_LINUX_MINT:
1825     fs->package_management = OS_PACKAGE_MANAGEMENT_APT;
1826     break;
1827
1828   case OS_DISTRO_ARCHLINUX:
1829     fs->package_management = OS_PACKAGE_MANAGEMENT_PACMAN;
1830     break;
1831   case OS_DISTRO_GENTOO:
1832     fs->package_management = OS_PACKAGE_MANAGEMENT_PORTAGE;
1833     break;
1834   case OS_DISTRO_PARDUS:
1835     fs->package_management = OS_PACKAGE_MANAGEMENT_PISI;
1836     break;
1837   case OS_DISTRO_MANDRIVA:
1838     fs->package_management = OS_PACKAGE_MANAGEMENT_URPMI;
1839     break;
1840
1841   case OS_DISTRO_SLACKWARE:
1842   case OS_DISTRO_WINDOWS:
1843   case OS_DISTRO_UNKNOWN:
1844   default:
1845     fs->package_management = OS_PACKAGE_MANAGEMENT_UNKNOWN;
1846     break;
1847   }
1848 }
1849
1850 static struct inspect_fs *
1851 search_for_root (guestfs_h *g, const char *root)
1852 {
1853   if (g->nr_fses == 0) {
1854     error (g, _("no inspection data: call guestfs_inspect_os first"));
1855     return NULL;
1856   }
1857
1858   size_t i;
1859   struct inspect_fs *fs;
1860   for (i = 0; i < g->nr_fses; ++i) {
1861     fs = &g->fses[i];
1862     if (fs->is_root && STREQ (root, fs->device))
1863       return fs;
1864   }
1865
1866   error (g, _("%s: root device not found: only call this function with a root device previously returned by guestfs_inspect_os"),
1867          root);
1868   return NULL;
1869 }
1870
1871 char **
1872 guestfs__inspect_get_roots (guestfs_h *g)
1873 {
1874   /* NB. Doesn't matter if g->nr_fses == 0.  We just return an empty
1875    * list in this case.
1876    */
1877
1878   size_t i;
1879   size_t count = 0;
1880   for (i = 0; i < g->nr_fses; ++i)
1881     if (g->fses[i].is_root)
1882       count++;
1883
1884   char **ret = calloc (count+1, sizeof (char *));
1885   if (ret == NULL) {
1886     perrorf (g, "calloc");
1887     return NULL;
1888   }
1889
1890   count = 0;
1891   for (i = 0; i < g->nr_fses; ++i) {
1892     if (g->fses[i].is_root) {
1893       ret[count] = safe_strdup (g, g->fses[i].device);
1894       count++;
1895     }
1896   }
1897   ret[count] = NULL;
1898
1899   return ret;
1900 }
1901
1902 char *
1903 guestfs__inspect_get_type (guestfs_h *g, const char *root)
1904 {
1905   struct inspect_fs *fs = search_for_root (g, root);
1906   if (!fs)
1907     return NULL;
1908
1909   char *ret;
1910   switch (fs->type) {
1911   case OS_TYPE_LINUX: ret = safe_strdup (g, "linux"); break;
1912   case OS_TYPE_WINDOWS: ret = safe_strdup (g, "windows"); break;
1913   case OS_TYPE_FREEBSD: ret = safe_strdup (g, "freebsd"); break;
1914   case OS_TYPE_UNKNOWN: default: ret = safe_strdup (g, "unknown"); break;
1915   }
1916
1917   return ret;
1918 }
1919
1920 char *
1921 guestfs__inspect_get_arch (guestfs_h *g, const char *root)
1922 {
1923   struct inspect_fs *fs = search_for_root (g, root);
1924   if (!fs)
1925     return NULL;
1926
1927   return safe_strdup (g, fs->arch ? : "unknown");
1928 }
1929
1930 char *
1931 guestfs__inspect_get_distro (guestfs_h *g, const char *root)
1932 {
1933   struct inspect_fs *fs = search_for_root (g, root);
1934   if (!fs)
1935     return NULL;
1936
1937   char *ret;
1938   switch (fs->distro) {
1939   case OS_DISTRO_ARCHLINUX: ret = safe_strdup (g, "archlinux"); break;
1940   case OS_DISTRO_DEBIAN: ret = safe_strdup (g, "debian"); break;
1941   case OS_DISTRO_FEDORA: ret = safe_strdup (g, "fedora"); break;
1942   case OS_DISTRO_GENTOO: ret = safe_strdup (g, "gentoo"); break;
1943   case OS_DISTRO_LINUX_MINT: ret = safe_strdup (g, "linuxmint"); break;
1944   case OS_DISTRO_MANDRIVA: ret = safe_strdup (g, "mandriva"); break;
1945   case OS_DISTRO_MEEGO: ret = safe_strdup (g, "meego"); break;
1946   case OS_DISTRO_PARDUS: ret = safe_strdup (g, "pardus"); break;
1947   case OS_DISTRO_REDHAT_BASED: ret = safe_strdup (g, "redhat-based"); break;
1948   case OS_DISTRO_RHEL: ret = safe_strdup (g, "rhel"); break;
1949   case OS_DISTRO_SLACKWARE: ret = safe_strdup (g, "slackware"); break;
1950   case OS_DISTRO_WINDOWS: ret = safe_strdup (g, "windows"); break;
1951   case OS_DISTRO_UBUNTU: ret = safe_strdup (g, "ubuntu"); break;
1952   case OS_DISTRO_UNKNOWN: default: ret = safe_strdup (g, "unknown"); break;
1953   }
1954
1955   return ret;
1956 }
1957
1958 int
1959 guestfs__inspect_get_major_version (guestfs_h *g, const char *root)
1960 {
1961   struct inspect_fs *fs = search_for_root (g, root);
1962   if (!fs)
1963     return -1;
1964
1965   return fs->major_version;
1966 }
1967
1968 int
1969 guestfs__inspect_get_minor_version (guestfs_h *g, const char *root)
1970 {
1971   struct inspect_fs *fs = search_for_root (g, root);
1972   if (!fs)
1973     return -1;
1974
1975   return fs->minor_version;
1976 }
1977
1978 char *
1979 guestfs__inspect_get_product_name (guestfs_h *g, const char *root)
1980 {
1981   struct inspect_fs *fs = search_for_root (g, root);
1982   if (!fs)
1983     return NULL;
1984
1985   return safe_strdup (g, fs->product_name ? : "unknown");
1986 }
1987
1988 char *
1989 guestfs__inspect_get_product_variant (guestfs_h *g, const char *root)
1990 {
1991   struct inspect_fs *fs = search_for_root (g, root);
1992   if (!fs)
1993     return NULL;
1994
1995   return safe_strdup (g, fs->product_variant ? : "unknown");
1996 }
1997
1998 char *
1999 guestfs__inspect_get_windows_systemroot (guestfs_h *g, const char *root)
2000 {
2001   struct inspect_fs *fs = search_for_root (g, root);
2002   if (!fs)
2003     return NULL;
2004
2005   if (!fs->windows_systemroot) {
2006     error (g, _("not a Windows guest, or systemroot could not be determined"));
2007     return NULL;
2008   }
2009
2010   return safe_strdup (g, fs->windows_systemroot);
2011 }
2012
2013 char *
2014 guestfs__inspect_get_format (guestfs_h *g, const char *root)
2015 {
2016   struct inspect_fs *fs = search_for_root (g, root);
2017   if (!fs)
2018     return NULL;
2019
2020   char *ret;
2021   switch (fs->format) {
2022   case OS_FORMAT_INSTALLED: ret = safe_strdup (g, "installed"); break;
2023   case OS_FORMAT_INSTALLER: ret = safe_strdup (g, "installer"); break;
2024   case OS_FORMAT_UNKNOWN: default: ret = safe_strdup (g, "unknown"); break;
2025   }
2026
2027   return ret;
2028 }
2029
2030 int
2031 guestfs__inspect_is_live (guestfs_h *g, const char *root)
2032 {
2033   struct inspect_fs *fs = search_for_root (g, root);
2034   if (!fs)
2035     return -1;
2036
2037   return fs->is_live_disk;
2038 }
2039
2040 int
2041 guestfs__inspect_is_netinst (guestfs_h *g, const char *root)
2042 {
2043   struct inspect_fs *fs = search_for_root (g, root);
2044   if (!fs)
2045     return -1;
2046
2047   return fs->is_netinst_disk;
2048 }
2049
2050 int
2051 guestfs__inspect_is_multipart (guestfs_h *g, const char *root)
2052 {
2053   struct inspect_fs *fs = search_for_root (g, root);
2054   if (!fs)
2055     return -1;
2056
2057   return fs->is_multipart_disk;
2058 }
2059
2060 char **
2061 guestfs__inspect_get_mountpoints (guestfs_h *g, const char *root)
2062 {
2063   struct inspect_fs *fs = search_for_root (g, root);
2064   if (!fs)
2065     return NULL;
2066
2067   char **ret;
2068
2069   /* If no fstab information (Windows) return just the root. */
2070   if (fs->nr_fstab == 0) {
2071     ret = calloc (3, sizeof (char *));
2072     ret[0] = safe_strdup (g, "/");
2073     ret[1] = safe_strdup (g, root);
2074     ret[2] = NULL;
2075     return ret;
2076   }
2077
2078 #define CRITERION fs->fstab[i].mountpoint[0] == '/'
2079   size_t i, count = 0;
2080   for (i = 0; i < fs->nr_fstab; ++i)
2081     if (CRITERION)
2082       count++;
2083
2084   /* Hashtables have 2N+1 entries. */
2085   ret = calloc (2*count+1, sizeof (char *));
2086   if (ret == NULL) {
2087     perrorf (g, "calloc");
2088     return NULL;
2089   }
2090
2091   count = 0;
2092   for (i = 0; i < fs->nr_fstab; ++i)
2093     if (CRITERION) {
2094       ret[2*count] = safe_strdup (g, fs->fstab[i].mountpoint);
2095       ret[2*count+1] = safe_strdup (g, fs->fstab[i].device);
2096       count++;
2097     }
2098 #undef CRITERION
2099
2100   return ret;
2101 }
2102
2103 char **
2104 guestfs__inspect_get_filesystems (guestfs_h *g, const char *root)
2105 {
2106   struct inspect_fs *fs = search_for_root (g, root);
2107   if (!fs)
2108     return NULL;
2109
2110   char **ret;
2111
2112   /* If no fstab information (Windows) return just the root. */
2113   if (fs->nr_fstab == 0) {
2114     ret = calloc (2, sizeof (char *));
2115     ret[0] = safe_strdup (g, root);
2116     ret[1] = NULL;
2117     return ret;
2118   }
2119
2120   ret = calloc (fs->nr_fstab + 1, sizeof (char *));
2121   if (ret == NULL) {
2122     perrorf (g, "calloc");
2123     return NULL;
2124   }
2125
2126   size_t i;
2127   for (i = 0; i < fs->nr_fstab; ++i)
2128     ret[i] = safe_strdup (g, fs->fstab[i].device);
2129
2130   return ret;
2131 }
2132
2133 char *
2134 guestfs__inspect_get_package_format (guestfs_h *g, const char *root)
2135 {
2136   struct inspect_fs *fs = search_for_root (g, root);
2137   if (!fs)
2138     return NULL;
2139
2140   char *ret;
2141   switch (fs->package_format) {
2142   case OS_PACKAGE_FORMAT_RPM: ret = safe_strdup (g, "rpm"); break;
2143   case OS_PACKAGE_FORMAT_DEB: ret = safe_strdup (g, "deb"); break;
2144   case OS_PACKAGE_FORMAT_PACMAN: ret = safe_strdup (g, "pacman"); break;
2145   case OS_PACKAGE_FORMAT_EBUILD: ret = safe_strdup (g, "ebuild"); break;
2146   case OS_PACKAGE_FORMAT_PISI: ret = safe_strdup (g, "pisi"); break;
2147   case OS_PACKAGE_FORMAT_UNKNOWN:
2148   default:
2149     ret = safe_strdup (g, "unknown");
2150     break;
2151   }
2152
2153   return ret;
2154 }
2155
2156 char *
2157 guestfs__inspect_get_package_management (guestfs_h *g, const char *root)
2158 {
2159   struct inspect_fs *fs = search_for_root (g, root);
2160   if (!fs)
2161     return NULL;
2162
2163   char *ret;
2164   switch (fs->package_management) {
2165   case OS_PACKAGE_MANAGEMENT_YUM: ret = safe_strdup (g, "yum"); break;
2166   case OS_PACKAGE_MANAGEMENT_UP2DATE: ret = safe_strdup (g, "up2date"); break;
2167   case OS_PACKAGE_MANAGEMENT_APT: ret = safe_strdup (g, "apt"); break;
2168   case OS_PACKAGE_MANAGEMENT_PACMAN: ret = safe_strdup (g, "pacman"); break;
2169   case OS_PACKAGE_MANAGEMENT_PORTAGE: ret = safe_strdup (g, "portage"); break;
2170   case OS_PACKAGE_MANAGEMENT_PISI: ret = safe_strdup (g, "pisi"); break;
2171   case OS_PACKAGE_MANAGEMENT_URPMI: ret = safe_strdup (g, "urpmi"); break;
2172   case OS_PACKAGE_MANAGEMENT_UNKNOWN:
2173   default:
2174     ret = safe_strdup (g, "unknown");
2175     break;
2176   }
2177
2178   return ret;
2179 }
2180
2181 char *
2182 guestfs__inspect_get_hostname (guestfs_h *g, const char *root)
2183 {
2184   struct inspect_fs *fs = search_for_root (g, root);
2185   if (!fs)
2186     return NULL;
2187
2188   return safe_strdup (g, fs->hostname ? : "unknown");
2189 }
2190
2191 #ifdef DB_DUMP
2192 static struct guestfs_application_list *list_applications_rpm (guestfs_h *g, struct inspect_fs *fs);
2193 #endif
2194 static struct guestfs_application_list *list_applications_deb (guestfs_h *g, struct inspect_fs *fs);
2195 static struct guestfs_application_list *list_applications_windows (guestfs_h *g, struct inspect_fs *fs);
2196 static void add_application (guestfs_h *g, struct guestfs_application_list *, const char *name, const char *display_name, int32_t epoch, const char *version, const char *release, const char *install_path, const char *publisher, const char *url, const char *description);
2197 static void sort_applications (struct guestfs_application_list *);
2198
2199 /* Unlike the simple inspect-get-* calls, this one assumes that the
2200  * disks are mounted up, and reads files from the mounted disks.
2201  */
2202 struct guestfs_application_list *
2203 guestfs__inspect_list_applications (guestfs_h *g, const char *root)
2204 {
2205   struct inspect_fs *fs = search_for_root (g, root);
2206   if (!fs)
2207     return NULL;
2208
2209   struct guestfs_application_list *ret = NULL;
2210
2211   /* Presently we can only list applications for installed disks.  It
2212    * is possible in future to get lists of packages from installers.
2213    */
2214   if (fs->format == OS_FORMAT_INSTALLED) {
2215     switch (fs->type) {
2216     case OS_TYPE_LINUX:
2217       switch (fs->package_format) {
2218       case OS_PACKAGE_FORMAT_RPM:
2219 #ifdef DB_DUMP
2220         ret = list_applications_rpm (g, fs);
2221         if (ret == NULL)
2222           return NULL;
2223 #endif
2224         break;
2225
2226       case OS_PACKAGE_FORMAT_DEB:
2227         ret = list_applications_deb (g, fs);
2228         if (ret == NULL)
2229           return NULL;
2230         break;
2231
2232       case OS_PACKAGE_FORMAT_PACMAN:
2233       case OS_PACKAGE_FORMAT_EBUILD:
2234       case OS_PACKAGE_FORMAT_PISI:
2235       case OS_PACKAGE_FORMAT_UNKNOWN:
2236       default:
2237         /* nothing - keep GCC happy */;
2238       }
2239       break;
2240
2241     case OS_TYPE_WINDOWS:
2242       ret = list_applications_windows (g, fs);
2243       if (ret == NULL)
2244         return NULL;
2245       break;
2246
2247     case OS_TYPE_FREEBSD:
2248     case OS_TYPE_UNKNOWN:
2249     default:
2250       /* nothing - keep GCC happy */;
2251     }
2252   }
2253
2254   if (ret == NULL) {
2255     /* Don't know how to do inspection.  Not an error, return an
2256      * empty list.
2257      */
2258     ret = safe_malloc (g, sizeof *ret);
2259     ret->len = 0;
2260     ret->val = NULL;
2261   }
2262
2263   sort_applications (ret);
2264
2265   return ret;
2266 }
2267
2268 #ifdef DB_DUMP
2269 static struct guestfs_application_list *
2270 list_applications_rpm (guestfs_h *g, struct inspect_fs *fs)
2271 {
2272   TMP_TEMPLATE_ON_STACK (tmpfile);
2273
2274   if (download_to_tmp (g, "/var/lib/rpm/Name", tmpfile, MAX_PKG_DB_SIZE) == -1)
2275     return NULL;
2276
2277   struct guestfs_application_list *apps = NULL, *ret = NULL;
2278 #define cmd_len (strlen (tmpfile) + 64)
2279   char cmd[cmd_len];
2280   FILE *pp = NULL;
2281   char line[1024];
2282   size_t len;
2283
2284   snprintf (cmd, cmd_len, DB_DUMP " -p '%s'", tmpfile);
2285
2286   debug (g, "list_applications_rpm: %s", cmd);
2287
2288   pp = popen (cmd, "r");
2289   if (pp == NULL) {
2290     perrorf (g, "popen: %s", cmd);
2291     goto out;
2292   }
2293
2294   /* Ignore everything to end-of-header marker. */
2295   for (;;) {
2296     if (fgets (line, sizeof line, pp) == NULL) {
2297       error (g, _("unexpected end of output from db_dump command"));
2298       goto out;
2299     }
2300
2301     len = strlen (line);
2302     if (len > 0 && line[len-1] == '\n') {
2303       line[len-1] = '\0';
2304       len--;
2305     }
2306
2307     if (STREQ (line, "HEADER=END"))
2308       break;
2309   }
2310
2311   /* Allocate 'apps' list. */
2312   apps = safe_malloc (g, sizeof *apps);
2313   apps->len = 0;
2314   apps->val = NULL;
2315
2316   /* Read alternate lines until end of data marker. */
2317   for (;;) {
2318     if (fgets (line, sizeof line, pp) == NULL) {
2319       error (g, _("unexpected end of output from db_dump command"));
2320       goto out;
2321     }
2322
2323     len = strlen (line);
2324     if (len > 0 && line[len-1] == '\n') {
2325       line[len-1] = '\0';
2326       len--;
2327     }
2328
2329     if (STREQ (line, "DATA=END"))
2330       break;
2331
2332     char *p = line;
2333     if (len > 0 && line[0] == ' ')
2334       p = line+1;
2335     /* Ignore any application name that contains non-printable chars.
2336      * In the db_dump output these would be escaped with backslash, so
2337      * we can just ignore any such line.
2338      */
2339     if (strchr (p, '\\') == NULL)
2340       add_application (g, apps, p, "", 0, "", "", "", "", "", "");
2341
2342     /* Discard next line. */
2343     if (fgets (line, sizeof line, pp) == NULL) {
2344       error (g, _("unexpected end of output from db_dump command"));
2345       goto out;
2346     }
2347   }
2348
2349   /* Catch errors from the db_dump command. */
2350   if (pclose (pp) == -1) {
2351     perrorf (g, "pclose: %s", cmd);
2352     goto out;
2353   }
2354   pp = NULL;
2355
2356   ret = apps;
2357
2358  out:
2359   if (ret == NULL && apps != NULL)
2360     guestfs_free_application_list (apps);
2361   if (pp)
2362     pclose (pp);
2363   unlink (tmpfile);
2364 #undef cmd_len
2365
2366   return ret;
2367 }
2368 #endif /* defined DB_DUMP */
2369
2370 static struct guestfs_application_list *
2371 list_applications_deb (guestfs_h *g, struct inspect_fs *fs)
2372 {
2373   TMP_TEMPLATE_ON_STACK (tmpfile);
2374
2375   if (download_to_tmp (g, "/var/lib/dpkg/status", tmpfile,
2376                        MAX_PKG_DB_SIZE) == -1)
2377     return NULL;
2378
2379   struct guestfs_application_list *apps = NULL, *ret = NULL;
2380   FILE *fp = NULL;
2381   char line[1024];
2382   size_t len;
2383   char *name = NULL, *version = NULL, *release = NULL;
2384   int installed_flag = 0;
2385
2386   fp = fopen (tmpfile, "r");
2387   if (fp == NULL) {
2388     perrorf (g, "fopen: %s", tmpfile);
2389     goto out;
2390   }
2391
2392   /* Allocate 'apps' list. */
2393   apps = safe_malloc (g, sizeof *apps);
2394   apps->len = 0;
2395   apps->val = NULL;
2396
2397   /* Read the temporary file.  Each package entry is separated by
2398    * a blank line.
2399    * XXX Strictly speaking this is in mailbox header format, so it
2400    * would be possible for fields to spread across multiple lines,
2401    * although for the short fields that we are concerned about this is
2402    * unlikely and not seen in practice.
2403    */
2404   while (fgets (line, sizeof line, fp) != NULL) {
2405     len = strlen (line);
2406     if (len > 0 && line[len-1] == '\n') {
2407       line[len-1] = '\0';
2408       len--;
2409     }
2410
2411     if (STRPREFIX (line, "Package: ")) {
2412       free (name);
2413       name = safe_strdup (g, &line[9]);
2414     }
2415     else if (STRPREFIX (line, "Status: ")) {
2416       installed_flag = strstr (&line[8], "installed") != NULL;
2417     }
2418     else if (STRPREFIX (line, "Version: ")) {
2419       free (version);
2420       free (release);
2421       char *p = strchr (&line[9], '-');
2422       if (p) {
2423         *p = '\0';
2424         version = safe_strdup (g, &line[9]);
2425         release = safe_strdup (g, p+1);
2426       } else {
2427         version = safe_strdup (g, &line[9]);
2428         release = NULL;
2429       }
2430     }
2431     else if (STREQ (line, "")) {
2432       if (installed_flag && name && version)
2433         add_application (g, apps, name, "", 0, version, release ? : "",
2434                          "", "", "", "");
2435       free (name);
2436       free (version);
2437       free (release);
2438       name = version = release = NULL;
2439       installed_flag = 0;
2440     }
2441   }
2442
2443   if (fclose (fp) == -1) {
2444     perrorf (g, "fclose: %s", tmpfile);
2445     goto out;
2446   }
2447   fp = NULL;
2448
2449   ret = apps;
2450
2451  out:
2452   if (ret == NULL && apps != NULL)
2453     guestfs_free_application_list (apps);
2454   if (fp)
2455     fclose (fp);
2456   free (name);
2457   free (version);
2458   free (release);
2459   unlink (tmpfile);
2460   return ret;
2461 }
2462
2463 /* XXX We already download the SOFTWARE hive when doing general
2464  * inspection.  We could avoid this second download of the same file
2465  * by caching these entries in the handle.
2466  */
2467 static struct guestfs_application_list *
2468 list_applications_windows (guestfs_h *g, struct inspect_fs *fs)
2469 {
2470   TMP_TEMPLATE_ON_STACK (software_local);
2471
2472   size_t len = strlen (fs->windows_systemroot) + 64;
2473   char software[len];
2474   snprintf (software, len, "%s/system32/config/software",
2475             fs->windows_systemroot);
2476
2477   char *software_path = resolve_windows_path_silently (g, software);
2478   if (!software_path)
2479     /* If the software hive doesn't exist, just accept that we cannot
2480      * find product_name etc.
2481      */
2482     return 0;
2483
2484   struct guestfs_application_list *apps = NULL, *ret = NULL;
2485   hive_h *h = NULL;
2486   hive_node_h *children = NULL;
2487
2488   if (download_to_tmp (g, software_path, software_local,
2489                        MAX_REGISTRY_SIZE) == -1)
2490     goto out;
2491
2492   h = hivex_open (software_local, g->verbose ? HIVEX_OPEN_VERBOSE : 0);
2493   if (h == NULL) {
2494     perrorf (g, "hivex_open");
2495     goto out;
2496   }
2497
2498   hive_node_h node = hivex_root (h);
2499   const char *hivepath[] =
2500     { "Microsoft", "Windows", "CurrentVersion", "Uninstall" };
2501   size_t i;
2502   for (i = 0;
2503        node != 0 && i < sizeof hivepath / sizeof hivepath[0];
2504        ++i) {
2505     node = hivex_node_get_child (h, node, hivepath[i]);
2506   }
2507
2508   if (node == 0) {
2509     perrorf (g, "hivex: cannot locate HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall");
2510     goto out;
2511   }
2512
2513   children = hivex_node_children (h, node);
2514   if (children == NULL) {
2515     perrorf (g, "hivex_node_children");
2516     goto out;
2517   }
2518
2519   /* Allocate 'apps' list. */
2520   apps = safe_malloc (g, sizeof *apps);
2521   apps->len = 0;
2522   apps->val = NULL;
2523
2524   /* Consider any child node that has a DisplayName key.
2525    * See also:
2526    * http://nsis.sourceforge.net/Add_uninstall_information_to_Add/Remove_Programs#Optional_values
2527    */
2528   for (i = 0; children[i] != 0; ++i) {
2529     hive_value_h value;
2530     char *name = NULL;
2531     char *display_name = NULL;
2532     char *version = NULL;
2533     char *install_path = NULL;
2534     char *publisher = NULL;
2535     char *url = NULL;
2536     char *comments = NULL;
2537
2538     /* Use the node name as a proxy for the package name in Linux.  The
2539      * display name is not language-independent, so it cannot be used.
2540      */
2541     name = hivex_node_name (h, children[i]);
2542     if (name == NULL) {
2543       perrorf (g, "hivex_node_get_name");
2544       goto out;
2545     }
2546
2547     value = hivex_node_get_value (h, children[i], "DisplayName");
2548     if (value) {
2549       display_name = hivex_value_string (h, value);
2550       if (display_name) {
2551         value = hivex_node_get_value (h, children[i], "DisplayVersion");
2552         if (value)
2553           version = hivex_value_string (h, value);
2554         value = hivex_node_get_value (h, children[i], "InstallLocation");
2555         if (value)
2556           install_path = hivex_value_string (h, value);
2557         value = hivex_node_get_value (h, children[i], "Publisher");
2558         if (value)
2559           publisher = hivex_value_string (h, value);
2560         value = hivex_node_get_value (h, children[i], "URLInfoAbout");
2561         if (value)
2562           url = hivex_value_string (h, value);
2563         value = hivex_node_get_value (h, children[i], "Comments");
2564         if (value)
2565           comments = hivex_value_string (h, value);
2566
2567         add_application (g, apps, name, display_name, 0,
2568                          version ? : "",
2569                          "",
2570                          install_path ? : "",
2571                          publisher ? : "",
2572                          url ? : "",
2573                          comments ? : "");
2574       }
2575     }
2576
2577     free (name);
2578     free (display_name);
2579     free (version);
2580     free (install_path);
2581     free (publisher);
2582     free (url);
2583     free (comments);
2584   }
2585
2586   ret = apps;
2587
2588  out:
2589   if (ret == NULL && apps != NULL)
2590     guestfs_free_application_list (apps);
2591   if (h) hivex_close (h);
2592   free (children);
2593   free (software_path);
2594
2595   /* Free up the temporary file. */
2596   unlink (software_local);
2597 #undef software_local_len
2598
2599   return ret;
2600 }
2601
2602 static void
2603 add_application (guestfs_h *g, struct guestfs_application_list *apps,
2604                  const char *name, const char *display_name, int32_t epoch,
2605                  const char *version, const char *release,
2606                  const char *install_path,
2607                  const char *publisher, const char *url,
2608                  const char *description)
2609 {
2610   apps->len++;
2611   apps->val = safe_realloc (g, apps->val,
2612                             apps->len * sizeof (struct guestfs_application));
2613   apps->val[apps->len-1].app_name = safe_strdup (g, name);
2614   apps->val[apps->len-1].app_display_name = safe_strdup (g, display_name);
2615   apps->val[apps->len-1].app_epoch = epoch;
2616   apps->val[apps->len-1].app_version = safe_strdup (g, version);
2617   apps->val[apps->len-1].app_release = safe_strdup (g, release);
2618   apps->val[apps->len-1].app_install_path = safe_strdup (g, install_path);
2619   /* XXX Translated path is not implemented yet. */
2620   apps->val[apps->len-1].app_trans_path = safe_strdup (g, "");
2621   apps->val[apps->len-1].app_publisher = safe_strdup (g, publisher);
2622   apps->val[apps->len-1].app_url = safe_strdup (g, url);
2623   /* XXX The next two are not yet implemented for any package
2624    * format, but we could easily support them for rpm and deb.
2625    */
2626   apps->val[apps->len-1].app_source_package = safe_strdup (g, "");
2627   apps->val[apps->len-1].app_summary = safe_strdup (g, "");
2628   apps->val[apps->len-1].app_description = safe_strdup (g, description);
2629 }
2630
2631 /* Sort applications by name before returning the list. */
2632 static int
2633 compare_applications (const void *vp1, const void *vp2)
2634 {
2635   const struct guestfs_application *v1 = vp1;
2636   const struct guestfs_application *v2 = vp2;
2637
2638   return strcmp (v1->app_name, v2->app_name);
2639 }
2640
2641 static void
2642 sort_applications (struct guestfs_application_list *apps)
2643 {
2644   if (apps && apps->val)
2645     qsort (apps->val, apps->len, sizeof (struct guestfs_application),
2646            compare_applications);
2647 }
2648
2649 /* Download to a guest file to a local temporary file.  Refuse to
2650  * download the guest file if it is larger than max_size.  The caller
2651  * is responsible for deleting the temporary file after use.
2652  */
2653 static int
2654 download_to_tmp (guestfs_h *g, const char *filename,
2655                  char *localtmp, int64_t max_size)
2656 {
2657   int fd;
2658   char buf[32];
2659   int64_t size;
2660
2661   size = guestfs_filesize (g, filename);
2662   if (size == -1)
2663     /* guestfs_filesize failed and has already set error in handle */
2664     return -1;
2665   if (size > max_size) {
2666     error (g, _("size of %s is unreasonably large (%" PRIi64 " bytes)"),
2667            filename, size);
2668     return -1;
2669   }
2670
2671   fd = mkstemp (localtmp);
2672   if (fd == -1) {
2673     perrorf (g, "mkstemp");
2674     return -1;
2675   }
2676
2677   snprintf (buf, sizeof buf, "/dev/fd/%d", fd);
2678
2679   if (guestfs_download (g, filename, buf) == -1) {
2680     close (fd);
2681     unlink (localtmp);
2682     return -1;
2683   }
2684
2685   if (close (fd) == -1) {
2686     perrorf (g, "close: %s", localtmp);
2687     unlink (localtmp);
2688     return -1;
2689   }
2690
2691   return 0;
2692 }
2693
2694 /* Call 'f' with Augeas opened and having parsed 'filename' (this file
2695  * must exist).  As a security measure, this bails if the file is too
2696  * large for a reasonable configuration file.  After the call to 'f'
2697  * Augeas is closed.
2698  */
2699 static int
2700 inspect_with_augeas (guestfs_h *g, struct inspect_fs *fs, const char *filename,
2701                      int (*f) (guestfs_h *, struct inspect_fs *))
2702 {
2703   /* Security: Refuse to do this if filename is too large. */
2704   int64_t size = guestfs_filesize (g, filename);
2705   if (size == -1)
2706     /* guestfs_filesize failed and has already set error in handle */
2707     return -1;
2708   if (size > MAX_AUGEAS_FILE_SIZE) {
2709     error (g, _("size of %s is unreasonably large (%" PRIi64 " bytes)"),
2710            filename, size);
2711     return -1;
2712   }
2713
2714   /* If !feature_available (g, "augeas") then the next call will fail.
2715    * Arguably we might want to fall back to a non-Augeas method in
2716    * this case.
2717    */
2718   if (guestfs_aug_init (g, "/", 16|32) == -1)
2719     return -1;
2720
2721   int r = -1;
2722
2723   /* Tell Augeas to only load one file (thanks RaphaĆ«l Pinson). */
2724   char buf[strlen (filename) + 64];
2725   snprintf (buf, strlen (filename) + 64, "/augeas/load//incl[. != \"%s\"]",
2726             filename);
2727   if (guestfs_aug_rm (g, buf) == -1)
2728     goto out;
2729
2730   if (guestfs_aug_load (g) == -1)
2731     goto out;
2732
2733   r = f (g, fs);
2734
2735  out:
2736   guestfs_aug_close (g);
2737
2738   return r;
2739 }
2740
2741 /* Get the first line of a small file, without any trailing newline
2742  * character.
2743  */
2744 static char *
2745 first_line_of_file (guestfs_h *g, const char *filename)
2746 {
2747   char **lines;
2748   int64_t size;
2749   char *ret;
2750
2751   /* Don't trust guestfs_head_n not to break with very large files.
2752    * Check the file size is something reasonable first.
2753    */
2754   size = guestfs_filesize (g, filename);
2755   if (size == -1)
2756     /* guestfs_filesize failed and has already set error in handle */
2757     return NULL;
2758   if (size > MAX_SMALL_FILE_SIZE) {
2759     error (g, _("size of %s is unreasonably large (%" PRIi64 " bytes)"),
2760            filename, size);
2761     return NULL;
2762   }
2763
2764   lines = guestfs_head_n (g, 1, filename);
2765   if (lines == NULL)
2766     return NULL;
2767   if (lines[0] == NULL) {
2768     error (g, _("%s: file is empty"), filename);
2769     guestfs___free_string_list (lines);
2770     return NULL;
2771   }
2772   /* lines[1] should be NULL because of '1' argument above ... */
2773
2774   ret = lines[0];               /* caller frees */
2775   free (lines);                 /* free the array */
2776
2777   return ret;
2778 }
2779
2780 /* Get the first matching line (using guestfs_egrep{,i}) of a small file,
2781  * without any trailing newline character.
2782  *
2783  * Returns: 1 = returned a line (in *ret)
2784  *          0 = no match
2785  *          -1 = error
2786  */
2787 static int
2788 first_egrep_of_file (guestfs_h *g, const char *filename,
2789                      const char *eregex, int iflag, char **ret)
2790 {
2791   char **lines;
2792   int64_t size;
2793   size_t i;
2794
2795   /* Don't trust guestfs_egrep not to break with very large files.
2796    * Check the file size is something reasonable first.
2797    */
2798   size = guestfs_filesize (g, filename);
2799   if (size == -1)
2800     /* guestfs_filesize failed and has already set error in handle */
2801     return -1;
2802   if (size > MAX_SMALL_FILE_SIZE) {
2803     error (g, _("size of %s is unreasonably large (%" PRIi64 " bytes)"),
2804            filename, size);
2805     return -1;
2806   }
2807
2808   lines = (!iflag ? guestfs_egrep : guestfs_egrepi) (g, eregex, filename);
2809   if (lines == NULL)
2810     return -1;
2811   if (lines[0] == NULL) {
2812     guestfs___free_string_list (lines);
2813     return 0;
2814   }
2815
2816   *ret = lines[0];              /* caller frees */
2817
2818   /* free up any other matches and the array itself */
2819   for (i = 1; lines[i] != NULL; ++i)
2820     free (lines[i]);
2821   free (lines);
2822
2823   return 1;
2824 }
2825
2826 #else /* no PCRE or hivex at compile time */
2827
2828 /* XXX These functions should be in an optgroup. */
2829
2830 #define NOT_IMPL(r)                                                     \
2831   error (g, _("inspection API not available since this version of libguestfs was compiled without PCRE or hivex libraries")); \
2832   return r
2833
2834 char **
2835 guestfs__inspect_os (guestfs_h *g)
2836 {
2837   NOT_IMPL(NULL);
2838 }
2839
2840 char **
2841 guestfs__inspect_get_roots (guestfs_h *g)
2842 {
2843   NOT_IMPL(NULL);
2844 }
2845
2846 char *
2847 guestfs__inspect_get_type (guestfs_h *g, const char *root)
2848 {
2849   NOT_IMPL(NULL);
2850 }
2851
2852 char *
2853 guestfs__inspect_get_arch (guestfs_h *g, const char *root)
2854 {
2855   NOT_IMPL(NULL);
2856 }
2857
2858 char *
2859 guestfs__inspect_get_distro (guestfs_h *g, const char *root)
2860 {
2861   NOT_IMPL(NULL);
2862 }
2863
2864 int
2865 guestfs__inspect_get_major_version (guestfs_h *g, const char *root)
2866 {
2867   NOT_IMPL(-1);
2868 }
2869
2870 int
2871 guestfs__inspect_get_minor_version (guestfs_h *g, const char *root)
2872 {
2873   NOT_IMPL(-1);
2874 }
2875
2876 char *
2877 guestfs__inspect_get_product_name (guestfs_h *g, const char *root)
2878 {
2879   NOT_IMPL(NULL);
2880 }
2881
2882 char *
2883 guestfs__inspect_get_product_variant (guestfs_h *g, const char *root)
2884 {
2885   NOT_IMPL(NULL);
2886 }
2887
2888 char *
2889 guestfs__inspect_get_windows_systemroot (guestfs_h *g, const char *root)
2890 {
2891   NOT_IMPL(NULL);
2892 }
2893
2894 char **
2895 guestfs__inspect_get_mountpoints (guestfs_h *g, const char *root)
2896 {
2897   NOT_IMPL(NULL);
2898 }
2899
2900 char **
2901 guestfs__inspect_get_filesystems (guestfs_h *g, const char *root)
2902 {
2903   NOT_IMPL(NULL);
2904 }
2905
2906 char *
2907 guestfs__inspect_get_package_format (guestfs_h *g, const char *root)
2908 {
2909   NOT_IMPL(NULL);
2910 }
2911
2912 char *
2913 guestfs__inspect_get_package_management (guestfs_h *g, const char *root)
2914 {
2915   NOT_IMPL(NULL);
2916 }
2917
2918 char *
2919 guestfs__inspect_get_hostname (guestfs_h *g, const char *root)
2920 {
2921   NOT_IMPL(NULL);
2922 }
2923
2924 struct guestfs_application_list *
2925 guestfs__inspect_list_applications (guestfs_h *g, const char *root)
2926 {
2927   NOT_IMPL(NULL);
2928 }
2929
2930 char *
2931 guestfs__inspect_get_format (guestfs_h *g, const char *root)
2932 {
2933   NOT_IMPL(NULL);
2934 }
2935
2936 int
2937 guestfs__inspect_is_live (guestfs_h *g, const char *root)
2938 {
2939   NOT_IMPL(-1);
2940 }
2941
2942 int
2943 guestfs__inspect_is_netinst (guestfs_h *g, const char *root)
2944 {
2945   NOT_IMPL(-1);
2946 }
2947
2948 int
2949 guestfs__inspect_is_multipart (guestfs_h *g, const char *root)
2950 {
2951   NOT_IMPL(-1);
2952 }
2953
2954 #endif /* no PCRE or hivex at compile time */
2955
2956 void
2957 guestfs___free_inspect_info (guestfs_h *g)
2958 {
2959   size_t i;
2960   for (i = 0; i < g->nr_fses; ++i) {
2961     free (g->fses[i].device);
2962     free (g->fses[i].product_name);
2963     free (g->fses[i].product_variant);
2964     free (g->fses[i].arch);
2965     free (g->fses[i].hostname);
2966     free (g->fses[i].windows_systemroot);
2967     size_t j;
2968     for (j = 0; j < g->fses[i].nr_fstab; ++j) {
2969       free (g->fses[i].fstab[j].device);
2970       free (g->fses[i].fstab[j].mountpoint);
2971     }
2972     free (g->fses[i].fstab);
2973   }
2974   free (g->fses);
2975   g->nr_fses = 0;
2976   g->fses = NULL;
2977 }
2978
2979 /* In the Perl code this is a public function. */
2980 int
2981 guestfs___feature_available (guestfs_h *g, const char *feature)
2982 {
2983   /* If there's an error we should ignore it, so to do that we have to
2984    * temporarily replace the error handler with a null one.
2985    */
2986   guestfs_error_handler_cb old_error_cb = g->error_cb;
2987   g->error_cb = NULL;
2988
2989   const char *groups[] = { feature, NULL };
2990   int r = guestfs_available (g, (char * const *) groups);
2991
2992   g->error_cb = old_error_cb;
2993
2994   return r == 0 ? 1 : 0;
2995 }
2996
2997 #ifdef HAVE_PCRE
2998
2999 /* Match a regular expression which contains no captures.  Returns
3000  * true if it matches or false if it doesn't.
3001  */
3002 int
3003 guestfs___match (guestfs_h *g, const char *str, const pcre *re)
3004 {
3005   size_t len = strlen (str);
3006   int vec[30], r;
3007
3008   r = pcre_exec (re, NULL, str, len, 0, 0, vec, sizeof vec / sizeof vec[0]);
3009   if (r == PCRE_ERROR_NOMATCH)
3010     return 0;
3011   if (r != 1) {
3012     /* Internal error -- should not happen. */
3013     warning (g, "%s: %s: pcre_exec returned unexpected error code %d when matching against the string \"%s\"\n",
3014              __FILE__, __func__, r, str);
3015     return 0;
3016   }
3017
3018   return 1;
3019 }
3020
3021 /* Match a regular expression which contains exactly one capture.  If
3022  * the string matches, return the capture, otherwise return NULL.  The
3023  * caller must free the result.
3024  */
3025 char *
3026 guestfs___match1 (guestfs_h *g, const char *str, const pcre *re)
3027 {
3028   size_t len = strlen (str);
3029   int vec[30], r;
3030
3031   r = pcre_exec (re, NULL, str, len, 0, 0, vec, sizeof vec / sizeof vec[0]);
3032   if (r == PCRE_ERROR_NOMATCH)
3033     return NULL;
3034   if (r != 2) {
3035     /* Internal error -- should not happen. */
3036     warning (g, "%s: %s: internal error: pcre_exec returned unexpected error code %d when matching against the string \"%s\"",
3037              __FILE__, __func__, r, str);
3038     return NULL;
3039   }
3040
3041   return safe_strndup (g, &str[vec[2]], vec[3]-vec[2]);
3042 }
3043
3044 /* Match a regular expression which contains exactly two captures. */
3045 int
3046 guestfs___match2 (guestfs_h *g, const char *str, const pcre *re,
3047                   char **ret1, char **ret2)
3048 {
3049   size_t len = strlen (str);
3050   int vec[30], r;
3051
3052   r = pcre_exec (re, NULL, str, len, 0, 0, vec, 30);
3053   if (r == PCRE_ERROR_NOMATCH)
3054     return 0;
3055   if (r != 3) {
3056     /* Internal error -- should not happen. */
3057     warning (g, "%s: %s: internal error: pcre_exec returned unexpected error code %d when matching against the string \"%s\"",
3058              __FILE__, __func__, r, str);
3059     return 0;
3060   }
3061
3062   *ret1 = safe_strndup (g, &str[vec[2]], vec[3]-vec[2]);
3063   *ret2 = safe_strndup (g, &str[vec[4]], vec[5]-vec[4]);
3064
3065   return 1;
3066 }
3067
3068 /* Match a regular expression which contains exactly three captures. */
3069 int
3070 guestfs___match3 (guestfs_h *g, const char *str, const pcre *re,
3071                   char **ret1, char **ret2, char **ret3)
3072 {
3073   size_t len = strlen (str);
3074   int vec[30], r;
3075
3076   r = pcre_exec (re, NULL, str, len, 0, 0, vec, 30);
3077   if (r == PCRE_ERROR_NOMATCH)
3078     return 0;
3079   if (r != 4) {
3080     /* Internal error -- should not happen. */
3081     warning (g, "%s: %s: internal error: pcre_exec returned unexpected error code %d when matching against the string \"%s\"",
3082              __FILE__, __func__, r, str);
3083     return 0;
3084   }
3085
3086   *ret1 = safe_strndup (g, &str[vec[2]], vec[3]-vec[2]);
3087   *ret2 = safe_strndup (g, &str[vec[4]], vec[5]-vec[4]);
3088   *ret3 = safe_strndup (g, &str[vec[6]], vec[7]-vec[6]);
3089
3090   return 1;
3091 }
3092
3093 #endif /* HAVE_PCRE */