configure: Add --with-extra flag to allow setting the extra version string.
[libguestfs.git] / src / inspect_fs.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 <fcntl.h>
27 #include <string.h>
28 #include <sys/stat.h>
29 #include <errno.h>
30 #include <endian.h>
31
32 #ifdef HAVE_PCRE
33 #include <pcre.h>
34 #endif
35
36 #ifdef HAVE_HIVEX
37 #include <hivex.h>
38 #endif
39
40 #include "c-ctype.h"
41 #include "ignore-value.h"
42 #include "xstrtol.h"
43
44 #include "guestfs.h"
45 #include "guestfs-internal.h"
46 #include "guestfs-internal-actions.h"
47 #include "guestfs_protocol.h"
48
49 #if defined(HAVE_PCRE) && defined(HAVE_HIVEX)
50
51 /* Compile all the regular expressions once when the shared library is
52  * loaded.  PCRE is thread safe so we're supposedly OK here if
53  * multiple threads call into the libguestfs API functions below
54  * simultaneously.
55  */
56 static pcre *re_first_partition;
57 static pcre *re_major_minor;
58
59 static void compile_regexps (void) __attribute__((constructor));
60 static void free_regexps (void) __attribute__((destructor));
61
62 static void
63 compile_regexps (void)
64 {
65   const char *err;
66   int offset;
67
68 #define COMPILE(re,pattern,options)                                     \
69   do {                                                                  \
70     re = pcre_compile ((pattern), (options), &err, &offset, NULL);      \
71     if (re == NULL) {                                                   \
72       ignore_value (write (2, err, strlen (err)));                      \
73       abort ();                                                         \
74     }                                                                   \
75   } while (0)
76
77   COMPILE (re_first_partition, "^/dev/(?:h|s|v)d.1$", 0);
78   COMPILE (re_major_minor, "(\\d+)\\.(\\d+)", 0);
79 }
80
81 static void
82 free_regexps (void)
83 {
84   pcre_free (re_first_partition);
85   pcre_free (re_major_minor);
86 }
87
88 static int check_filesystem (guestfs_h *g, const char *device, int is_block, int is_partnum);
89 static void check_package_format (guestfs_h *g, struct inspect_fs *fs);
90 static void check_package_management (guestfs_h *g, struct inspect_fs *fs);
91 static int extend_fses (guestfs_h *g);
92
93 /* Find out if 'device' contains a filesystem.  If it does, add
94  * another entry in g->fses.
95  */
96 int
97 guestfs___check_for_filesystem_on (guestfs_h *g, const char *device,
98                                    int is_block, int is_partnum)
99 {
100   /* Get vfs-type in order to check if it's a Linux(?) swap device.
101    * If there's an error we should ignore it, so to do that we have to
102    * temporarily replace the error handler with a null one.
103    */
104   guestfs_error_handler_cb old_error_cb = g->error_cb;
105   g->error_cb = NULL;
106   char *vfs_type = guestfs_vfs_type (g, device);
107   g->error_cb = old_error_cb;
108
109   int is_swap = vfs_type && STREQ (vfs_type, "swap");
110
111   debug (g, "check_for_filesystem_on: %s %d %d (%s)",
112          device, is_block, is_partnum,
113          vfs_type ? vfs_type : "failed to get vfs type");
114
115   if (is_swap) {
116     free (vfs_type);
117     if (extend_fses (g) == -1)
118       return -1;
119     g->fses[g->nr_fses-1].is_swap = 1;
120     return 0;
121   }
122
123   /* Try mounting the device.  As above, ignore errors. */
124   g->error_cb = NULL;
125   int r = guestfs_mount_ro (g, device, "/");
126   if (r == -1 && vfs_type && STREQ (vfs_type, "ufs")) /* Hack for the *BSDs. */
127     r = guestfs_mount_vfs (g, "ro,ufstype=ufs2", "ufs", device, "/");
128   free (vfs_type);
129   g->error_cb = old_error_cb;
130   if (r == -1)
131     return 0;
132
133   /* Do the rest of the checks. */
134   r = check_filesystem (g, device, is_block, is_partnum);
135
136   /* Unmount the filesystem. */
137   if (guestfs_umount_all (g) == -1)
138     return -1;
139
140   return r;
141 }
142
143 /* is_block and is_partnum are just hints: is_block is true if the
144  * filesystem is a whole block device (eg. /dev/sda).  is_partnum
145  * is > 0 if the filesystem is a direct partition, and in this case
146  * it is the partition number counting from 1
147  * (eg. /dev/sda1 => is_partnum == 1).
148  */
149 static int
150 check_filesystem (guestfs_h *g, const char *device,
151                   int is_block, int is_partnum)
152 {
153   if (extend_fses (g) == -1)
154     return -1;
155
156   struct inspect_fs *fs = &g->fses[g->nr_fses-1];
157
158   fs->device = safe_strdup (g, device);
159   fs->is_mountable = 1;
160
161   /* Optimize some of the tests by avoiding multiple tests of the same thing. */
162   int is_dir_etc = guestfs_is_dir (g, "/etc") > 0;
163   int is_dir_bin = guestfs_is_dir (g, "/bin") > 0;
164   int is_dir_share = guestfs_is_dir (g, "/share") > 0;
165
166   /* Grub /boot? */
167   if (guestfs_is_file (g, "/grub/menu.lst") > 0 ||
168       guestfs_is_file (g, "/grub/grub.conf") > 0)
169     fs->content = FS_CONTENT_LINUX_BOOT;
170   /* FreeBSD root? */
171   else if (is_dir_etc &&
172            is_dir_bin &&
173            guestfs_is_file (g, "/etc/freebsd-update.conf") > 0 &&
174            guestfs_is_file (g, "/etc/fstab") > 0) {
175     /* Ignore /dev/sda1 which is a shadow of the real root filesystem
176      * that is probably /dev/sda5 (see:
177      * http://www.freebsd.org/doc/handbook/disk-organization.html)
178      */
179     if (match (g, device, re_first_partition))
180       return 0;
181
182     fs->is_root = 1;
183     fs->content = FS_CONTENT_FREEBSD_ROOT;
184     fs->format = OS_FORMAT_INSTALLED;
185     if (guestfs___check_freebsd_root (g, fs) == -1)
186       return -1;
187   }
188   /* Linux root? */
189   else if (is_dir_etc &&
190            is_dir_bin &&
191            guestfs_is_file (g, "/etc/fstab") > 0) {
192     fs->is_root = 1;
193     fs->content = FS_CONTENT_LINUX_ROOT;
194     fs->format = OS_FORMAT_INSTALLED;
195     if (guestfs___check_linux_root (g, fs) == -1)
196       return -1;
197   }
198   /* Linux /usr/local? */
199   else if (is_dir_etc &&
200            is_dir_bin &&
201            is_dir_share &&
202            guestfs_exists (g, "/local") == 0 &&
203            guestfs_is_file (g, "/etc/fstab") == 0)
204     fs->content = FS_CONTENT_LINUX_USR_LOCAL;
205   /* Linux /usr? */
206   else if (is_dir_etc &&
207            is_dir_bin &&
208            is_dir_share &&
209            guestfs_exists (g, "/local") > 0 &&
210            guestfs_is_file (g, "/etc/fstab") == 0)
211     fs->content = FS_CONTENT_LINUX_USR;
212   /* Linux /var? */
213   else if (guestfs_is_dir (g, "/log") > 0 &&
214            guestfs_is_dir (g, "/run") > 0 &&
215            guestfs_is_dir (g, "/spool") > 0)
216     fs->content = FS_CONTENT_LINUX_VAR;
217   /* Windows root? */
218   else if (guestfs___has_windows_systemroot (g) >= 0) {
219     fs->is_root = 1;
220     fs->content = FS_CONTENT_WINDOWS_ROOT;
221     fs->format = OS_FORMAT_INSTALLED;
222     if (guestfs___check_windows_root (g, fs) == -1)
223       return -1;
224   }
225   /* Windows volume with installed applications (but not root)? */
226   else if (guestfs___is_dir_nocase (g, "/System Volume Information") > 0 &&
227            guestfs___is_dir_nocase (g, "/Program Files") > 0)
228     fs->content = FS_CONTENT_WINDOWS_VOLUME_WITH_APPS;
229   /* Windows volume (but not root)? */
230   else if (guestfs___is_dir_nocase (g, "/System Volume Information") > 0)
231     fs->content = FS_CONTENT_WINDOWS_VOLUME;
232   /* Install CD/disk?  Skip these checks if it's not a whole device
233    * (eg. CD) or the first partition (eg. bootable USB key).
234    */
235   else if ((is_block || is_partnum == 1) &&
236            (guestfs_is_file (g, "/isolinux/isolinux.cfg") > 0 ||
237             guestfs_is_dir (g, "/EFI/BOOT") > 0 ||
238             guestfs_is_file (g, "/images/install.img") > 0 ||
239             guestfs_is_dir (g, "/.disk") > 0 ||
240             guestfs_is_file (g, "/.discinfo") > 0 ||
241             guestfs_is_file (g, "/i386/txtsetup.sif") > 0 ||
242             guestfs_is_file (g, "/amd64/txtsetup.sif")) > 0) {
243     fs->is_root = 1;
244     fs->content = FS_CONTENT_INSTALLER;
245     fs->format = OS_FORMAT_INSTALLER;
246     if (guestfs___check_installer_root (g, fs) == -1)
247       return -1;
248   }
249
250   /* The above code should have set fs->type and fs->distro fields, so
251    * we can now guess the package management system.
252    */
253   check_package_format (g, fs);
254   check_package_management (g, fs);
255
256   return 0;
257 }
258
259 static int
260 extend_fses (guestfs_h *g)
261 {
262   size_t n = g->nr_fses + 1;
263   struct inspect_fs *p;
264
265   p = realloc (g->fses, n * sizeof (struct inspect_fs));
266   if (p == NULL) {
267     perrorf (g, "realloc");
268     return -1;
269   }
270
271   g->fses = p;
272   g->nr_fses = n;
273
274   memset (&g->fses[n-1], 0, sizeof (struct inspect_fs));
275
276   return 0;
277 }
278
279 int
280 guestfs___is_file_nocase (guestfs_h *g, const char *path)
281 {
282   char *p;
283   int r;
284
285   p = guestfs___case_sensitive_path_silently (g, path);
286   if (!p)
287     return 0;
288   r = guestfs_is_file (g, p);
289   free (p);
290   return r > 0;
291 }
292
293 int
294 guestfs___is_dir_nocase (guestfs_h *g, const char *path)
295 {
296   char *p;
297   int r;
298
299   p = guestfs___case_sensitive_path_silently (g, path);
300   if (!p)
301     return 0;
302   r = guestfs_is_dir (g, p);
303   free (p);
304   return r > 0;
305 }
306
307 /* Parse small, unsigned ints, as used in version numbers. */
308 int
309 guestfs___parse_unsigned_int (guestfs_h *g, const char *str)
310 {
311   long ret;
312   int r = xstrtol (str, NULL, 10, &ret, "");
313   if (r != LONGINT_OK) {
314     error (g, _("could not parse integer in version number: %s"), str);
315     return -1;
316   }
317   return ret;
318 }
319
320 /* Like parse_unsigned_int, but ignore trailing stuff. */
321 int
322 guestfs___parse_unsigned_int_ignore_trailing (guestfs_h *g, const char *str)
323 {
324   long ret;
325   int r = xstrtol (str, NULL, 10, &ret, NULL);
326   if (r != LONGINT_OK) {
327     error (g, _("could not parse integer in version number: %s"), str);
328     return -1;
329   }
330   return ret;
331 }
332
333 /* Parse generic MAJOR.MINOR from the fs->product_name string. */
334 int
335 guestfs___parse_major_minor (guestfs_h *g, struct inspect_fs *fs)
336 {
337   char *major, *minor;
338
339   if (match2 (g, fs->product_name, re_major_minor, &major, &minor)) {
340     fs->major_version = guestfs___parse_unsigned_int (g, major);
341     free (major);
342     if (fs->major_version == -1) {
343       free (minor);
344       return -1;
345     }
346     fs->minor_version = guestfs___parse_unsigned_int (g, minor);
347     free (minor);
348     if (fs->minor_version == -1)
349       return -1;
350   }
351   return 0;
352 }
353
354 /* At the moment, package format and package management is just a
355  * simple function of the distro and major_version fields, so these
356  * can never return an error.  We might be cleverer in future.
357  */
358 static void
359 check_package_format (guestfs_h *g, struct inspect_fs *fs)
360 {
361   switch (fs->distro) {
362   case OS_DISTRO_FEDORA:
363   case OS_DISTRO_MEEGO:
364   case OS_DISTRO_REDHAT_BASED:
365   case OS_DISTRO_RHEL:
366   case OS_DISTRO_MANDRIVA:
367   case OS_DISTRO_CENTOS:
368   case OS_DISTRO_SCIENTIFIC_LINUX:
369     fs->package_format = OS_PACKAGE_FORMAT_RPM;
370     break;
371
372   case OS_DISTRO_DEBIAN:
373   case OS_DISTRO_UBUNTU:
374   case OS_DISTRO_LINUX_MINT:
375     fs->package_format = OS_PACKAGE_FORMAT_DEB;
376     break;
377
378   case OS_DISTRO_ARCHLINUX:
379     fs->package_format = OS_PACKAGE_FORMAT_PACMAN;
380     break;
381   case OS_DISTRO_GENTOO:
382     fs->package_format = OS_PACKAGE_FORMAT_EBUILD;
383     break;
384   case OS_DISTRO_PARDUS:
385     fs->package_format = OS_PACKAGE_FORMAT_PISI;
386     break;
387
388   case OS_DISTRO_SLACKWARE:
389   case OS_DISTRO_WINDOWS:
390   case OS_DISTRO_UNKNOWN:
391   default:
392     fs->package_format = OS_PACKAGE_FORMAT_UNKNOWN;
393     break;
394   }
395 }
396
397 static void
398 check_package_management (guestfs_h *g, struct inspect_fs *fs)
399 {
400   switch (fs->distro) {
401   case OS_DISTRO_FEDORA:
402   case OS_DISTRO_MEEGO:
403     fs->package_management = OS_PACKAGE_MANAGEMENT_YUM;
404     break;
405
406   case OS_DISTRO_REDHAT_BASED:
407   case OS_DISTRO_RHEL:
408   case OS_DISTRO_CENTOS:
409   case OS_DISTRO_SCIENTIFIC_LINUX:
410     if (fs->major_version >= 5)
411       fs->package_management = OS_PACKAGE_MANAGEMENT_YUM;
412     else
413       fs->package_management = OS_PACKAGE_MANAGEMENT_UP2DATE;
414     break;
415
416   case OS_DISTRO_DEBIAN:
417   case OS_DISTRO_UBUNTU:
418   case OS_DISTRO_LINUX_MINT:
419     fs->package_management = OS_PACKAGE_MANAGEMENT_APT;
420     break;
421
422   case OS_DISTRO_ARCHLINUX:
423     fs->package_management = OS_PACKAGE_MANAGEMENT_PACMAN;
424     break;
425   case OS_DISTRO_GENTOO:
426     fs->package_management = OS_PACKAGE_MANAGEMENT_PORTAGE;
427     break;
428   case OS_DISTRO_PARDUS:
429     fs->package_management = OS_PACKAGE_MANAGEMENT_PISI;
430     break;
431   case OS_DISTRO_MANDRIVA:
432     fs->package_management = OS_PACKAGE_MANAGEMENT_URPMI;
433     break;
434
435   case OS_DISTRO_SLACKWARE:
436   case OS_DISTRO_WINDOWS:
437   case OS_DISTRO_UNKNOWN:
438   default:
439     fs->package_management = OS_PACKAGE_MANAGEMENT_UNKNOWN;
440     break;
441   }
442 }
443
444 /* Get the first line of a small file, without any trailing newline
445  * character.
446  */
447 char *
448 guestfs___first_line_of_file (guestfs_h *g, const char *filename)
449 {
450   char **lines;
451   int64_t size;
452   char *ret;
453
454   /* Don't trust guestfs_head_n not to break with very large files.
455    * Check the file size is something reasonable first.
456    */
457   size = guestfs_filesize (g, filename);
458   if (size == -1)
459     /* guestfs_filesize failed and has already set error in handle */
460     return NULL;
461   if (size > MAX_SMALL_FILE_SIZE) {
462     error (g, _("size of %s is unreasonably large (%" PRIi64 " bytes)"),
463            filename, size);
464     return NULL;
465   }
466
467   lines = guestfs_head_n (g, 1, filename);
468   if (lines == NULL)
469     return NULL;
470   if (lines[0] == NULL) {
471     error (g, _("%s: file is empty"), filename);
472     guestfs___free_string_list (lines);
473     return NULL;
474   }
475   /* lines[1] should be NULL because of '1' argument above ... */
476
477   ret = lines[0];               /* caller frees */
478   free (lines);                 /* free the array */
479
480   return ret;
481 }
482
483 /* Get the first matching line (using guestfs_egrep{,i}) of a small file,
484  * without any trailing newline character.
485  *
486  * Returns: 1 = returned a line (in *ret)
487  *          0 = no match
488  *          -1 = error
489  */
490 int
491 guestfs___first_egrep_of_file (guestfs_h *g, const char *filename,
492                                const char *eregex, int iflag, char **ret)
493 {
494   char **lines;
495   int64_t size;
496   size_t i;
497
498   /* Don't trust guestfs_egrep not to break with very large files.
499    * Check the file size is something reasonable first.
500    */
501   size = guestfs_filesize (g, filename);
502   if (size == -1)
503     /* guestfs_filesize failed and has already set error in handle */
504     return -1;
505   if (size > MAX_SMALL_FILE_SIZE) {
506     error (g, _("size of %s is unreasonably large (%" PRIi64 " bytes)"),
507            filename, size);
508     return -1;
509   }
510
511   lines = (!iflag ? guestfs_egrep : guestfs_egrepi) (g, eregex, filename);
512   if (lines == NULL)
513     return -1;
514   if (lines[0] == NULL) {
515     guestfs___free_string_list (lines);
516     return 0;
517   }
518
519   *ret = lines[0];              /* caller frees */
520
521   /* free up any other matches and the array itself */
522   for (i = 1; lines[i] != NULL; ++i)
523     free (lines[i]);
524   free (lines);
525
526   return 1;
527 }
528
529 #endif /* defined(HAVE_PCRE) && defined(HAVE_HIVEX) */