Move the following APIs into the daemon, reimplemented in OCaml:
* inspect_os
* inspect_get_roots
* inspect_get_mountpoints
* inspect_get_filesystems
* inspect_get_format
* inspect_get_type
* inspect_get_distro
* inspect_get_package_format
* inspect_get_package_management
* inspect_get_product_name
* inspect_get_product_variant
* inspect_get_major_version
* inspect_get_minor_version
* inspect_get_arch
* inspect_get_hostname
* inspect_get_windows_systemroot
* inspect_get_windows_software_hive
* inspect_get_windows_system_hive
* inspect_get_windows_current_control_set
* inspect_get_drive_mappings
* inspect_is_live
* inspect_is_netinst
* inspect_is_multipart
The following inspection APIs have NOT been reimplemented in this commit:
* inspect_list_applications [deprecated]
* inspect_list_applications2
* inspect_get_icon
This also embeds the ocaml-augeas library (upstream here:
http://git.annexia.org/?p=ocaml-augeas.git;a=summary), but it's
identical to the upstream version and should remain so.
---
.gitignore | 2 +
daemon/Makefile.am | 19 +
daemon/augeas-c.c | 288 +++++++
daemon/augeas.README | 8 +
daemon/augeas.ml | 59 ++
daemon/augeas.mli | 95 +++
daemon/chroot.ml | 2 +-
daemon/daemon_utils_tests.ml | 15 +
daemon/inspect.ml | 253 ++++++
daemon/inspect.mli | 41 +
daemon/inspect_fs.ml | 395 +++++++++
daemon/inspect_fs.mli | 23 +
daemon/inspect_fs_cd.ml | 23 +
daemon/inspect_fs_cd.mli | 25 +
daemon/inspect_fs_unix.ml | 563 +++++++++++++
daemon/inspect_fs_unix.mli | 53 ++
daemon/inspect_fs_unix_fstab.ml | 518 ++++++++++++
daemon/inspect_fs_unix_fstab.mli | 34 +
daemon/inspect_fs_windows.ml | 498 ++++++++++++
daemon/inspect_fs_windows.mli | 25 +
daemon/inspect_types.ml | 325 ++++++++
daemon/inspect_types.mli | 175 ++++
daemon/inspect_utils.ml | 162 ++++
daemon/inspect_utils.mli | 48 ++
daemon/mount.ml | 61 ++
daemon/mount.mli | 2 +
daemon/utils.ml | 100 +++
daemon/utils.mli | 12 +
docs/C_SOURCE_FILES | 2 +-
generator/actions.ml | 1 +
generator/actions_inspection.ml | 424 +++++-----
generator/actions_inspection.mli | 1 +
generator/daemon.ml | 63 +-
generator/proc_nr.ml | 23 +
lib/MAX_PROC_NR | 2 +-
lib/Makefile.am | 1 -
lib/guestfs-internal.h | 218 ++---
lib/handle.c | 1 -
lib/inspect-apps.c | 107 ++-
lib/inspect-fs-cd.c | 4 +
lib/inspect-fs-unix.c | 1659 +-------------------------------------
lib/inspect-fs-windows.c | 739 -----------------
lib/inspect-fs.c | 681 ----------------
lib/inspect-icon.c | 261 +++---
lib/inspect.c | 732 +----------------
45 files changed, 4363 insertions(+), 4380 deletions(-)
diff --git a/.gitignore b/.gitignore
index bca927afc..b645229c9 100644
--- a/.gitignore
+++ b/.gitignore
@@ -181,6 +181,8 @@ Makefile.in
/daemon/optgroups.c
/daemon/optgroups.h
/daemon/stamp-guestfsd.pod
+/daemon/stringMap.ml
+/daemon/stringMap.mli
/daemon/structs-cleanups.c
/daemon/structs-cleanups.h
/daemon/structs.ml
diff --git a/daemon/Makefile.am b/daemon/Makefile.am
index db61b4f0d..18396f2a3 100644
--- a/daemon/Makefile.am
+++ b/daemon/Makefile.am
@@ -75,6 +75,7 @@ guestfsd_SOURCES = \
actions.h \
available.c \
augeas.c \
+ augeas-c.c \
base64.c \
blkdiscard.c \
blkid.c \
@@ -256,6 +257,7 @@ guestfsd_CFLAGS = \
# library and then linked to the daemon. See
#
https://caml.inria.fr/pub/docs/manual-ocaml/intfc.html
SOURCES_MLI = \
+ augeas.mli \
blkid.mli \
btrfs.mli \
chroot.mli \
@@ -264,6 +266,14 @@ SOURCES_MLI = \
file.mli \
filearch.mli \
findfs.mli \
+ inspect.mli \
+ inspect_fs_cd.mli \
+ inspect_fs.mli \
+ inspect_fs_unix.mli \
+ inspect_fs_unix_fstab.mli \
+ inspect_fs_windows.mli \
+ inspect_types.mli \
+ inspect_utils.mli \
is.mli \
ldm.mli \
link.mli \
@@ -277,6 +287,7 @@ SOURCES_MLI = \
utils.mli
SOURCES_ML = \
+ augeas.ml \
types.ml \
utils.ml \
structs.ml \
@@ -298,6 +309,14 @@ SOURCES_ML = \
parted.ml \
listfs.ml \
realpath.ml \
+ inspect_types.ml \
+ inspect_utils.ml \
+ inspect_fs_cd.ml \
+ inspect_fs_unix_fstab.ml \
+ inspect_fs_unix.ml \
+ inspect_fs_windows.ml \
+ inspect_fs.ml \
+ inspect.ml \
callbacks.ml \
daemon.ml
diff --git a/daemon/augeas-c.c b/daemon/augeas-c.c
new file mode 100644
index 000000000..c06bf92da
--- /dev/null
+++ b/daemon/augeas-c.c
@@ -0,0 +1,288 @@
+/* Augeas OCaml bindings
+ * Copyright (C) 2008-2012 Red Hat Inc., Richard W.M. Jones
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * $Id: augeas_c.c,v 1.1 2008/05/06 10:48:20 rjones Exp $
+ */
+
+#include "config.h"
+
+#include <augeas.h>
+
+#include <caml/alloc.h>
+#include <caml/memory.h>
+#include <caml/mlvalues.h>
+#include <caml/fail.h>
+#include <caml/callback.h>
+#include <caml/custom.h>
+
+typedef augeas *augeas_t;
+
+/* Raise an Augeas.Error exception. */
+static void
+raise_error (const char *msg)
+{
+ caml_raise_with_string (*caml_named_value ("Augeas.Error"), msg);
+}
+
+/* Map OCaml flags to C flags. */
+static int flag_map[] = {
+ /* AugSaveBackup */ AUG_SAVE_BACKUP,
+ /* AugSaveNewFile */ AUG_SAVE_NEWFILE,
+ /* AugTypeCheck */ AUG_TYPE_CHECK,
+ /* AugNoStdinc */ AUG_NO_STDINC,
+ /* AugSaveNoop */ AUG_SAVE_NOOP,
+ /* AugNoLoad */ AUG_NO_LOAD,
+};
+
+/* Wrap and unwrap augeas_t handles, with a finalizer. */
+#define Augeas_t_val(rv) (*(augeas_t *)Data_custom_val(rv))
+
+static void
+augeas_t_finalize (value tv)
+{
+ augeas_t t = Augeas_t_val (tv);
+ if (t) aug_close (t);
+}
+
+static struct custom_operations custom_operations = {
+ (char *) "augeas_t_custom_operations",
+ augeas_t_finalize,
+ custom_compare_default,
+ custom_hash_default,
+ custom_serialize_default,
+ custom_deserialize_default
+};
+
+static value Val_augeas_t (augeas_t t)
+{
+ CAMLparam0 ();
+ CAMLlocal1 (rv);
+ /* We could choose these so that the GC can make better decisions.
+ * See 18.9.2 of the OCaml manual.
+ */
+ const int used = 0;
+ const int max = 1;
+
+ rv = caml_alloc_custom (&custom_operations,
+ sizeof (augeas_t), used, max);
+ Augeas_t_val(rv) = t;
+
+ CAMLreturn (rv);
+}
+
+#pragma GCC diagnostic ignored "-Wmissing-prototypes"
+
+/* val create : string -> string option -> flag list -> t */
+CAMLprim value
+ocaml_augeas_create (value rootv, value loadpathv, value flagsv)
+{
+ CAMLparam1 (rootv);
+ char *root = String_val (rootv);
+ char *loadpath;
+ int flags = 0, i;
+ augeas_t t;
+
+ /* Optional loadpath. */
+ loadpath =
+ loadpathv == Val_int (0)
+ ? NULL
+ : String_val (Field (loadpathv, 0));
+
+ /* Convert list of flags to C. */
+ for (; flagsv != Val_int (0); flagsv = Field (flagsv, 1)) {
+ i = Int_val (Field (flagsv, 0));
+ flags |= flag_map[i];
+ }
+
+ t = aug_init (root, loadpath, flags);
+
+ if (t == NULL)
+ raise_error ("Augeas.create");
+
+ CAMLreturn (Val_augeas_t (t));
+}
+
+/* val close : t -> unit */
+CAMLprim value
+ocaml_augeas_close (value tv)
+{
+ CAMLparam1 (tv);
+ augeas_t t = Augeas_t_val (tv);
+
+ if (t) {
+ aug_close (t);
+ Augeas_t_val(tv) = NULL; /* So the finalizer doesn't double-free. */
+ }
+
+ CAMLreturn (Val_unit);
+}
+
+/* val get : t -> path -> value option */
+CAMLprim value
+ocaml_augeas_get (value tv, value pathv)
+{
+ CAMLparam2 (tv, pathv);
+ CAMLlocal2 (optv, v);
+ augeas_t t = Augeas_t_val (tv);
+ char *path = String_val (pathv);
+ const char *val;
+ int r;
+
+ r = aug_get (t, path, &val);
+ if (r == 1) { /* Return Some val */
+ v = caml_copy_string (val);
+ optv = caml_alloc (1, 0);
+ Field (optv, 0) = v;
+ } else if (r == 0) /* Return None */
+ optv = Val_int (0);
+ else if (r == -1) /* Error or multiple matches */
+ raise_error ("Augeas.get");
+ else
+ failwith ("Augeas.get: bad return value");
+
+ CAMLreturn (optv);
+}
+
+/* val exists : t -> path -> bool */
+CAMLprim value
+ocaml_augeas_exists (value tv, value pathv)
+{
+ CAMLparam2 (tv, pathv);
+ CAMLlocal1 (v);
+ augeas_t t = Augeas_t_val (tv);
+ char *path = String_val (pathv);
+ int r;
+
+ r = aug_get (t, path, NULL);
+ if (r == 1) /* Return true. */
+ v = Val_int (1);
+ else if (r == 0) /* Return false */
+ v = Val_int (0);
+ else if (r == -1) /* Error or multiple matches */
+ raise_error ("Augeas.exists");
+ else
+ failwith ("Augeas.exists: bad return value");
+
+ CAMLreturn (v);
+}
+
+/* val insert : t -> ?before:bool -> path -> string -> unit */
+CAMLprim value
+ocaml_augeas_insert (value tv, value beforev, value pathv, value labelv)
+{
+ CAMLparam4 (tv, beforev, pathv, labelv);
+ augeas_t t = Augeas_t_val (tv);
+ char *path = String_val (pathv);
+ char *label = String_val (labelv);
+ int before;
+
+ before = beforev == Val_int (0) ? 0 : Int_val (Field (beforev, 0));
+
+ if (aug_insert (t, path, label, before) == -1)
+ raise_error ("Augeas.insert");
+
+ CAMLreturn (Val_unit);
+}
+
+/* val rm : t -> path -> int */
+CAMLprim value
+ocaml_augeas_rm (value tv, value pathv)
+{
+ CAMLparam2 (tv, pathv);
+ augeas_t t = Augeas_t_val (tv);
+ char *path = String_val (pathv);
+ int r;
+
+ r = aug_rm (t, path);
+ if (r == -1)
+ raise_error ("Augeas.rm");
+
+ CAMLreturn (Val_int (r));
+}
+
+/* val matches : t -> path -> path list */
+CAMLprim value
+ocaml_augeas_match (value tv, value pathv)
+{
+ CAMLparam2 (tv, pathv);
+ CAMLlocal3 (rv, v, cons);
+ augeas_t t = Augeas_t_val (tv);
+ char *path = String_val (pathv);
+ char **matches;
+ int r, i;
+
+ r = aug_match (t, path, &matches);
+ if (r == -1)
+ raise_error ("Augeas.matches");
+
+ /* Copy the paths to a list. */
+ rv = Val_int (0);
+ for (i = 0; i < r; ++i) {
+ v = caml_copy_string (matches[i]);
+ free (matches[i]);
+ cons = caml_alloc (2, 0);
+ Field (cons, 1) = rv;
+ Field (cons, 0) = v;
+ rv = cons;
+ }
+
+ free (matches);
+
+ CAMLreturn (rv);
+}
+
+/* val count_matches : t -> path -> int */
+CAMLprim value
+ocaml_augeas_count_matches (value tv, value pathv)
+{
+ CAMLparam2 (tv, pathv);
+ augeas_t t = Augeas_t_val (tv);
+ char *path = String_val (pathv);
+ int r;
+
+ r = aug_match (t, path, NULL);
+ if (r == -1)
+ raise_error ("Augeas.count_matches");
+
+ CAMLreturn (Val_int (r));
+}
+
+/* val save : t -> unit */
+CAMLprim value
+ocaml_augeas_save (value tv)
+{
+ CAMLparam1 (tv);
+ augeas_t t = Augeas_t_val (tv);
+
+ if (aug_save (t) == -1)
+ raise_error ("Augeas.save");
+
+ CAMLreturn (Val_unit);
+}
+
+/* val load : t -> unit */
+CAMLprim value
+ocaml_augeas_load (value tv)
+{
+ CAMLparam1 (tv);
+ augeas_t t = Augeas_t_val (tv);
+
+ if (aug_load (t) == -1)
+ raise_error ("Augeas.load");
+
+ CAMLreturn (Val_unit);
+}
diff --git a/daemon/augeas.README b/daemon/augeas.README
new file mode 100644
index 000000000..938dfd255
--- /dev/null
+++ b/daemon/augeas.README
@@ -0,0 +1,8 @@
+The files augeas-c.c, augeas.ml and augeas.mli come from the
+ocaml-augeas library:
+
+
http://git.annexia.org/?p=ocaml-augeas.git
+
+which is released under a compatible license. We try to keep them
+identical, so if you make changes to these files then you must also
+submit the changes to ocaml-augeas, and vice versa.
\ No newline at end of file
diff --git a/daemon/augeas.ml b/daemon/augeas.ml
new file mode 100644
index 000000000..f556df0f1
--- /dev/null
+++ b/daemon/augeas.ml
@@ -0,0 +1,59 @@
+(* Augeas OCaml bindings
+ * Copyright (C) 2008 Red Hat Inc., Richard W.M. Jones
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * $Id: augeas.ml,v 1.2 2008/05/06 10:48:20 rjones Exp $
+ *)
+
+type t
+
+exception Error of string
+
+type flag =
+ | AugSaveBackup
+ | AugSaveNewFile
+ | AugTypeCheck
+ | AugNoStdinc
+ | AugSaveNoop
+ | AugNoLoad
+
+type path = string
+
+type value = string
+
+external create : string -> string option -> flag list -> t
+ = "ocaml_augeas_create"
+external close : t -> unit
+ = "ocaml_augeas_close"
+external get : t -> path -> value option
+ = "ocaml_augeas_get"
+external exists : t -> path -> bool
+ = "ocaml_augeas_exists"
+external insert : t -> ?before:bool -> path -> string -> unit
+ = "ocaml_augeas_insert"
+external rm : t -> path -> int
+ = "ocaml_augeas_rm"
+external matches : t -> path -> path list
+ = "ocaml_augeas_match"
+external count_matches : t -> path -> int
+ = "ocaml_augeas_count_matches"
+external save : t -> unit
+ = "ocaml_augeas_save"
+external load : t -> unit
+ = "ocaml_augeas_load"
+
+let () =
+ Callback.register_exception "Augeas.Error" (Error "")
diff --git a/daemon/augeas.mli b/daemon/augeas.mli
new file mode 100644
index 000000000..64e824014
--- /dev/null
+++ b/daemon/augeas.mli
@@ -0,0 +1,95 @@
+(** Augeas OCaml bindings *)
+(* Copyright (C) 2008 Red Hat Inc., Richard W.M. Jones
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * $Id: augeas.mli,v 1.2 2008/05/06 10:48:20 rjones Exp $
+ *)
+
+type t
+ (** Augeas library handle. *)
+
+exception Error of string
+ (** This exception is thrown when the underlying Augeas library
+ returns an error. *)
+
+type flag =
+ | AugSaveBackup (** Rename original with .augsave *)
+ | AugSaveNewFile (** Save changes to .augnew *)
+ | AugTypeCheck (** Type-check lenses *)
+ | AugNoStdinc
+ | AugSaveNoop
+ | AugNoLoad
+ (** Flags passed to the {!create} function. *)
+
+type path = string
+ (** A path expression.
+
+ Note in future we may replace this with a type-safe path constructor. *)
+
+type value = string
+ (** A value. *)
+
+val create : string -> string option -> flag list -> t
+ (** [create root loadpath flags] creates an Augeas handle.
+
+ [root] is a file system path describing the location
+ of the configuration files.
+
+ [loadpath] is an optional colon-separated list of directories
+ which are searched for schema definitions.
+
+ [flags] is a list of flags. *)
+
+val close : t -> unit
+ (** [close handle] closes the handle.
+
+ You don't need to close handles explicitly with this function:
+ they will be finalized eventually by the garbage collector.
+ However calling this function frees up any resources used by the
+ underlying Augeas library immediately.
+
+ Do not use the handle after closing it. *)
+
+val get : t -> path -> value option
+ (** [get t path] returns the value at [path], or [None] if there
+ is no value. *)
+
+val exists : t -> path -> bool
+ (** [exists t path] returns true iff there is a value at [path]. *)
+
+val insert : t -> ?before:bool -> path -> string -> unit
+ (** [insert t ?before path label] inserts [label] as a sibling
+ of [path]. By default it is inserted after [path], unless
+ [~before:true] is specified. *)
+
+val rm : t -> path -> int
+ (** [rm t path] removes all nodes matching [path].
+
+ Returns the number of nodes removed (which may be 0). *)
+
+val matches : t -> path -> path list
+ (** [matches t path] returns a list of path expressions
+ of all nodes matching [path]. *)
+
+val count_matches : t -> path -> int
+ (** [count_matches t path] counts the number of nodes matching
+ [path] but does not return them (see {!matches}). *)
+
+val save : t -> unit
+ (** [save t] saves all pending changes to disk. *)
+
+val load : t -> unit
+ (** [load t] loads files into the tree. *)
diff --git a/daemon/chroot.ml b/daemon/chroot.ml
index 40dfa1dde..0fddfcffa 100644
--- a/daemon/chroot.ml
+++ b/daemon/chroot.ml
@@ -32,7 +32,7 @@ let create ?(name = prog) chroot =
let f t func arg =
if verbose () then
- eprintf "chroot: %s: running ‘%s’\n%!" t.chroot t.name;
+ eprintf "chroot: %s: running '%s'\n%!" t.chroot t.name;
let rfd, wfd = pipe () in
diff --git a/daemon/daemon_utils_tests.ml b/daemon/daemon_utils_tests.ml
index 892509d89..b1f02de30 100644
--- a/daemon/daemon_utils_tests.ml
+++ b/daemon/daemon_utils_tests.ml
@@ -46,3 +46,18 @@ let () =
let () =
assert (proc_unmangle_path "\\040" = " ");
assert (proc_unmangle_path "\\040\\040" = " ")
+
+(* Test unix_canonical_path. *)
+let () =
+ assert (unix_canonical_path "/" = "/");
+ assert (unix_canonical_path "/usr" = "/usr");
+ assert (unix_canonical_path "/usr/" = "/usr");
+ assert (unix_canonical_path "/usr/local" = "/usr/local");
+ assert (unix_canonical_path "///" = "/");
+ assert (unix_canonical_path "///usr//local//" = "/usr/local");
+ assert (unix_canonical_path "/usr///" = "/usr")
+
+(* Test utf16le_to_utf8. *)
+let () =
+ assert (utf16le_to_utf8
"\x57\x00\x69\x00\x6e\x00\x64\x00\x6f\x00\x77\x00\x73\x00" =
"Windows");
+ assert (utf16le_to_utf8
"\x57\x00\x69\x00\x6e\x00\x64\x00\x6f\x00\x77\x00\x73\x00\xae\x00" =
"Windows\xc2\xae")
diff --git a/daemon/inspect.ml b/daemon/inspect.ml
new file mode 100644
index 000000000..5d9c84d14
--- /dev/null
+++ b/daemon/inspect.ml
@@ -0,0 +1,253 @@
+(* guestfs-inspection
+ * Copyright (C) 2009-2017 Red Hat Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *)
+
+open Printf
+
+open Std_utils
+
+open Utils
+open Inspect_types
+
+let rec inspect_os () =
+ Mount.umount_all ();
+
+ (* Iterate over all detected filesystems. Inspect each one in turn. *)
+ let fses = Listfs.list_filesystems () in
+
+ let fses =
+ filter_map (
+ fun (mountable, vfs_type) ->
+ Inspect_fs.check_for_filesystem_on mountable vfs_type
+ ) fses in
+ if verbose () then (
+ eprintf "inspect_os: fses:\n";
+ List.iter (fun fs -> eprintf "\t%s\n" (string_of_fs fs)) fses;
+ flush stderr
+ );
+
+(* XXX
+ (* The OS inspection information for CoreOS are gathered by inspecting
+ * multiple filesystems. Gather all the inspected information in the
+ * inspect_fs struct of the root filesystem.
+ *)
+ let fses = collect_coreos_inspection_info fses in
+
+ (* Check if the same filesystem was listed twice as root in fses.
+ * This may happen for the *BSD root partition where an MBR partition
+ * is a shadow of the real root partition probably /dev/sda5
+ *)
+ let fses = check_for_duplicated_bsd_root fses in
+
+ (* For Linux guests with a separate /usr filesystem, merge some of the
+ * inspected information in that partition to the inspect_fs struct
+ * of the root filesystem.
+ *)
+ let fses = collect_linux_inspection_info fses in
+ *)
+
+ (* Save what we found in a global variable. *)
+ Inspect_types.inspect_fses := fses;
+
+ (* At this point we have, in the handle, a list of all filesystems
+ * found and data about each one. Now we assemble the list of
+ * filesystems which are root devices.
+ *
+ * Fall through to inspect_get_roots to do that.
+ *)
+ inspect_get_roots ()
+
+and inspect_get_roots () =
+ let fses = !Inspect_types.inspect_fses in
+
+ let roots =
+ filter_map (
+ fun fs -> try Some (root_of_fs fs) with Invalid_argument _ -> None
+ ) fses in
+ if verbose () then (
+ eprintf "inspect_get_roots: roots:\n";
+ List.iter (fun root -> eprintf "%s" (string_of_root root)) roots;
+ flush stderr
+ );
+
+ (* Only return the list of mountables, since subsequent calls will
+ * be used to retrieve the other information.
+ *)
+ List.map (fun { root_location = { mountable = m } } -> m) roots
+
+and root_of_fs =
+ function
+ | { fs_location = location; role = RoleRoot data } ->
+ { root_location = location; inspection_data = data }
+ | { role = (RoleUsr _ | RoleSwap | RoleOther) } ->
+ invalid_arg "root_of_fs"
+
+and inspect_get_mountpoints root_mountable =
+ let root = search_for_root root_mountable in
+ let fstab = root.inspection_data.fstab in
+
+ (* If no fstab information (Windows) return just the root. *)
+ if fstab = [] then
+ [ "/", root_mountable ]
+ else (
+ filter_map (
+ fun (mountable, mp) ->
+ if String.length mp > 0 && mp.[0] = '/' then
+ Some (mp, mountable)
+ else
+ None
+ ) fstab
+ )
+
+and inspect_get_filesystems root_mountable =
+ let root = search_for_root root_mountable in
+ let fstab = root.inspection_data.fstab in
+
+ (* If no fstab information (Windows) return just the root. *)
+ if fstab = [] then
+ [ root_mountable ]
+ else
+ List.map fst fstab
+
+and inspect_get_format root =
+ let root = search_for_root root in
+ match root.inspection_data.format with
+ | Some v -> string_of_format v
+ | None -> "unknown"
+
+and inspect_get_type root =
+ let root = search_for_root root in
+ match root.inspection_data.os_type with
+ | Some v -> string_of_os_type v
+ | None -> "unknown"
+
+and inspect_get_distro root =
+ let root = search_for_root root in
+ match root.inspection_data.distro with
+ | Some v -> string_of_distro v
+ | None -> "unknown"
+
+and inspect_get_package_format root =
+ let root = search_for_root root in
+ match root.inspection_data.package_format with
+ | Some v -> string_of_package_format v
+ | None -> "unknown"
+
+and inspect_get_package_management root =
+ let root = search_for_root root in
+ match root.inspection_data.package_management with
+ | Some v -> string_of_package_management v
+ | None -> "unknown"
+
+and inspect_get_product_name root =
+ let root = search_for_root root in
+ match root.inspection_data.product_name with
+ | Some v -> v
+ | None -> "unknown"
+
+and inspect_get_product_variant root =
+ let root = search_for_root root in
+ match root.inspection_data.product_variant with
+ | Some v -> v
+ | None -> "unknown"
+
+and inspect_get_major_version root =
+ let root = search_for_root root in
+ match root.inspection_data.version with
+ | Some (major, _) -> major
+ | None -> 0
+
+and inspect_get_minor_version root =
+ let root = search_for_root root in
+ match root.inspection_data.version with
+ | Some (_, minor) -> minor
+ | None -> 0
+
+and inspect_get_arch root =
+ let root = search_for_root root in
+ match root.inspection_data.arch with
+ | Some v -> v
+ | None -> "unknown"
+
+and inspect_get_hostname root =
+ let root = search_for_root root in
+ match root.inspection_data.hostname with
+ | Some v -> v
+ | None -> "unknown"
+
+and inspect_get_windows_systemroot root =
+ let root = search_for_root root in
+ match root.inspection_data.windows_systemroot with
+ | Some v -> v
+ | None ->
+ failwith "not a Windows guest, or systemroot could not be determined"
+
+and inspect_get_windows_system_hive root =
+ let root = search_for_root root in
+ match root.inspection_data.windows_system_hive with
+ | Some v -> v
+ | None ->
+ failwith "not a Windows guest, or system hive not found"
+
+and inspect_get_windows_software_hive root =
+ let root = search_for_root root in
+ match root.inspection_data.windows_software_hive with
+ | Some v -> v
+ | None ->
+ failwith "not a Windows guest, or software hive not found"
+
+and inspect_get_windows_current_control_set root =
+ let root = search_for_root root in
+ match root.inspection_data.windows_current_control_set with
+ | Some v -> v
+ | None ->
+ failwith "not a Windows guest, or CurrentControlSet could not be
determined"
+
+and inspect_is_live root =
+ let root = search_for_root root in
+ root.inspection_data.is_live_disk
+
+and inspect_is_netinst root =
+ let root = search_for_root root in
+ root.inspection_data.is_netinst_disk
+
+and inspect_is_multipart root =
+ let root = search_for_root root in
+ root.inspection_data.is_multipart_disk
+
+and inspect_get_drive_mappings root =
+ let root = search_for_root root in
+ root.inspection_data.drive_mappings
+
+and search_for_root root =
+ let fses = !Inspect_types.inspect_fses in
+ if fses = [] then
+ failwith "no inspection data: call guestfs_inspect_os first";
+
+ let root =
+ try
+ List.find (
+ function
+ | { fs_location = { mountable = m }; role = RoleRoot _ } -> root = m
+ | _ -> false
+ ) fses
+ with
+ Not_found ->
+ failwithf "%s: root device not found: only call this function with a root
device previously returned by guestfs_inspect_os"
+ (Mountable.to_string root) in
+
+ root_of_fs root
diff --git a/daemon/inspect.mli b/daemon/inspect.mli
new file mode 100644
index 000000000..29a1c1759
--- /dev/null
+++ b/daemon/inspect.mli
@@ -0,0 +1,41 @@
+(* guestfs-inspection
+ * Copyright (C) 2009-2017 Red Hat Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *)
+
+val inspect_os : unit -> Mountable.t list
+val inspect_get_roots : unit -> Mountable.t list
+val inspect_get_mountpoints : Mountable.t -> (string * Mountable.t) list
+val inspect_get_filesystems : Mountable.t -> Mountable.t list
+val inspect_get_format : Mountable.t -> string
+val inspect_get_type : Mountable.t -> string
+val inspect_get_distro : Mountable.t -> string
+val inspect_get_package_format : Mountable.t -> string
+val inspect_get_package_management : Mountable.t -> string
+val inspect_get_product_name : Mountable.t -> string
+val inspect_get_product_variant : Mountable.t -> string
+val inspect_get_major_version : Mountable.t -> int
+val inspect_get_minor_version : Mountable.t -> int
+val inspect_get_arch : Mountable.t -> string
+val inspect_get_hostname : Mountable.t -> string
+val inspect_get_windows_systemroot : Mountable.t -> string
+val inspect_get_windows_software_hive : Mountable.t -> string
+val inspect_get_windows_system_hive : Mountable.t -> string
+val inspect_get_windows_current_control_set : Mountable.t -> string
+val inspect_get_drive_mappings : Mountable.t -> (string * string) list
+val inspect_is_live : Mountable.t -> bool
+val inspect_is_netinst : Mountable.t -> bool
+val inspect_is_multipart : Mountable.t -> bool
diff --git a/daemon/inspect_fs.ml b/daemon/inspect_fs.ml
new file mode 100644
index 000000000..24ca18e93
--- /dev/null
+++ b/daemon/inspect_fs.ml
@@ -0,0 +1,395 @@
+(* guestfs-inspection
+ * Copyright (C) 2009-2017 Red Hat Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *)
+
+open Printf
+
+open Std_utils
+
+open Mountable
+open Inspect_types
+open Inspect_utils
+
+let rec check_for_filesystem_on mountable vfs_type =
+ if verbose () then
+ eprintf "check_for_filesystem_on: %s (%s)\n%!"
+ (Mountable.to_string mountable) vfs_type;
+
+ let role =
+ let is_swap = vfs_type = "swap" in
+ if is_swap then
+ Some RoleSwap
+ else (
+ (* If it's a whole device, see if it is an install ISO. *)
+ let is_whole_device = Devsparts.is_whole_device mountable.m_device in
+ let installer_role =
+ if is_whole_device then
+ Inspect_fs_cd.check_installer_iso mountable.m_device
+ else
+ None in
+ match installer_role with
+ | Some _ as role -> role
+ | None ->
+ (* Try mounting the device. Ignore errors if we can't do this. *)
+ let mounted =
+ if vfs_type = "ufs" then ( (* Hack for the *BSDs. *)
+ (* FreeBSD fs is a variant of ufs called ufs2 ... *)
+ try
+ Mount.mount_vfs (Some "ro,ufstype=ufs2") (Some "ufs")
+ mountable "/";
+ true
+ with _ ->
+ (* while NetBSD and OpenBSD use another variant labeled 44bsd *)
+ try
+ Mount.mount_vfs (Some "ro,ufstype=44bsd") (Some
"ufs")
+ mountable "/";
+ true
+ with _ -> false
+ ) else (
+ try Mount.mount_ro mountable "/";
+ true
+ with _ -> false
+ ) in
+ if not mounted then None
+ else (
+ let role = check_filesystem mountable is_whole_device in
+ Mount.umount_all ();
+ role
+ )
+ ) in
+
+ match role with
+ | None -> None
+ | Some role ->
+ Some { fs_location = { mountable = mountable; vfs_type = vfs_type };
+ role = role }
+
+(* When this function is called, the filesystem is mounted on sysroot (). *)
+and check_filesystem mountable is_whole_device =
+ let is_only_partition =
+ if is_whole_device then false
+ else is_only_partition mountable in
+
+ let role = ref `Other in
+ let data = ref null_inspection_data in
+
+ (* Grub /boot? *)
+ if Is.is_file "/grub/menu.lst" ||
+ Is.is_file "/grub/grub.conf" ||
+ Is.is_file "/grub2/grub.cfg" then
+ ()
+ (* FreeBSD root? *)
+ else if Is.is_dir "/etc" &&
+ Is.is_dir "/bin" &&
+ Is.is_file "/etc/freebsd-update.conf" &&
+ Is.is_file "/etc/fstab" then (
+ role := `Root;
+ data := { !data with format = Some FORMAT_INSTALLED };
+ data := Inspect_fs_unix.check_freebsd_root !data
+ )
+ (* NetBSD root? *)
+ else if Is.is_dir "/etc" &&
+ Is.is_dir "/bin" &&
+ Is.is_file "/netbsd" &&
+ Is.is_file "/etc/fstab" &&
+ Is.is_file "/etc/release" then (
+ role := `Root;
+ data := { !data with format = Some FORMAT_INSTALLED };
+ data := Inspect_fs_unix.check_netbsd_root !data;
+ )
+ (* OpenBSD root? *)
+ else if Is.is_dir "/etc" &&
+ Is.is_dir "/bin" &&
+ Is.is_file "/bsd" &&
+ Is.is_file "/etc/fstab" &&
+ Is.is_file "/etc/motd" then (
+ role := `Root;
+ data := { !data with format = Some FORMAT_INSTALLED };
+ data := Inspect_fs_unix.check_openbsd_root !data;
+ )
+ (* Hurd root? *)
+ else if Is.is_file "/hurd/console" &&
+ Is.is_file "/hurd/hello" &&
+ Is.is_file "/hurd/null" then (
+ role := `Root;
+ data := { !data with format = Some FORMAT_INSTALLED };
+ data := Inspect_fs_unix.check_hurd_root !data;
+ )
+ (* Minix root? *)
+ else if Is.is_dir "/etc" &&
+ Is.is_dir "/bin" &&
+ Is.is_file "/service/vm" &&
+ Is.is_file "/etc/fstab" &&
+ Is.is_file "/etc/version" then (
+ role := `Root;
+ data := { !data with format = Some FORMAT_INSTALLED };
+ data := Inspect_fs_unix.check_minix_root !data;
+ )
+ (* Linux root? *)
+ else if Is.is_dir "/etc" &&
+ (Is.is_dir "/bin" ||
+ is_symlink_to "/bin" "usr/bin") &&
+ (Is.is_file "/etc/fstab" ||
+ Is.is_file "/etc/hosts") then (
+ role := `Root;
+ data := { !data with format = Some FORMAT_INSTALLED };
+ data := Inspect_fs_unix.check_linux_root mountable !data;
+ )
+ (* CoreOS root? *)
+ else if Is.is_dir "/etc" &&
+ Is.is_dir "/root" &&
+ Is.is_dir "/home" &&
+ Is.is_dir "/usr" &&
+ Is.is_file "/etc/coreos/update.conf" then (
+ role := `Root;
+ data := { !data with format = Some FORMAT_INSTALLED };
+ data := Inspect_fs_unix.check_coreos_root !data;
+ )
+ (* Linux /usr/local? *)
+ else if Is.is_dir "/etc" &&
+ Is.is_dir "/bin" &&
+ Is.is_dir "/share" &&
+ not (Is.is_dir "/local") &&
+ not (Is.is_file "/etc/fstab") then
+ ()
+ (* Linux /usr? *)
+ else if Is.is_dir "/etc" &&
+ Is.is_dir "/bin" &&
+ Is.is_dir "/share" &&
+ Is.is_dir "/local" &&
+ not (Is.is_file "/etc/fstab") then (
+ data := Inspect_fs_unix.check_linux_usr !data;
+ )
+ (* CoreOS /usr? *)
+ else if Is.is_dir "/bin" &&
+ Is.is_dir "/share" &&
+ Is.is_dir "/local" &&
+ Is.is_dir "/share/coreos" then (
+ data := Inspect_fs_unix.check_coreos_usr !data;
+ )
+ (* Linux /var? *)
+ else if Is.is_dir "/log" &&
+ Is.is_dir "/run" &&
+ Is.is_dir "/spool" then
+ ()
+ (* Windows root? *)
+ else if Inspect_fs_windows.is_windows_systemroot () then (
+ role := `Root;
+ data := { !data with format = Some FORMAT_INSTALLED };
+ data := Inspect_fs_windows.check_windows_root !data;
+ )
+ (* Windows volume with installed applications (but not root)? *)
+ else if is_dir_nocase "/System Volume Information" &&
+ is_dir_nocase "/Program Files" then
+ ()
+ (* Windows volume (but not root)? *)
+ else if is_dir_nocase "/System Volume Information" then
+ ()
+ (* FreeDOS? *)
+ else if is_dir_nocase "/FDOS" &&
+ is_file_nocase "/FDOS/FREEDOS.BSS" then (
+ role := `Root;
+ data := { !data with
+ format = Some FORMAT_INSTALLED;
+ os_type = Some OS_TYPE_DOS;
+ distro = Some DISTRO_FREEDOS;
+ (* FreeDOS is a mix of 16 and 32 bit, but
+ * assume it requires a 32 bit i386 processor.
+ *)
+ arch = Some "i386" }
+ )
+ (* Install CD/disk?
+ *
+ * Note that we checked (above) for an install ISO, but there are
+ * other types of install image (eg. USB keys) which that check
+ * wouldn't have picked up.
+ *
+ * Skip these checks if it's not a whole device (eg. CD) or the
+ * first partition (eg. bootable USB key).
+ *)
+ else if (is_whole_device || is_only_partition) &&
+ Is.is_file "/isolinux/isolinux.cfg" ||
+ Is.is_dir "/EFI/BOOT" ||
+ Is.is_file "/images/install.img" ||
+ Is.is_dir "/.disk" ||
+ Is.is_file "/.discinfo" ||
+ Is.is_file "/i386/txtsetup.sif" ||
+ Is.is_file "/amd64/txtsetup.sif" ||
+ Is.is_file "/freedos/freedos.ico" ||
+ Is.is_file "/boot/loader.rc" then (
+ role := `Root;
+ data := { !data with format = Some FORMAT_INSTALLER };
+ data := Inspect_fs_cd.check_installer_root !data;
+ );
+
+ (* The above code should have set [data.os_type] and [data.distro]
+ * fields, so we can now guess the package management system.
+ *)
+ let data = !data in
+ let data = { data with
+ package_format = check_package_format data;
+ package_management = check_package_management data } in
+ match !role with
+ | `Root -> Some (RoleRoot data)
+ | `Usr -> Some (RoleUsr data)
+ | `Other -> Some RoleOther
+
+(* The mountable is the first and only partition on a device
+ * with a single device.
+ *)
+and is_only_partition = function
+ | { m_type = MountablePath | MountableBtrfsVol _ } -> false
+ | { m_type = MountableDevice; m_device = device } ->
+ let partnum, nr_partitions = get_partition_context device in
+ partnum = 1 && nr_partitions = 1
+
+and get_partition_context partition =
+ let partnum = Devsparts.part_to_partnum partition in
+ let device = Devsparts.part_to_dev partition in
+ let nr_partitions = List.length (Parted.part_list device) in
+ partnum, nr_partitions
+
+and is_symlink_to file wanted_target =
+ if not (Is.is_symlink file) then false
+ else Link.readlink file = wanted_target
+
+(* At the moment, package format and package management are just a
+ * simple function of the [distro] and [version[0]] fields, so these
+ * can never return an error. We might be cleverer in future.
+ *)
+and check_package_format { distro = distro } =
+ match distro with
+ | None -> None
+ | Some DISTRO_FEDORA
+ | Some DISTRO_MEEGO
+ | Some DISTRO_REDHAT_BASED
+ | Some DISTRO_RHEL
+ | Some DISTRO_MAGEIA
+ | Some DISTRO_MANDRIVA
+ | Some DISTRO_SUSE_BASED
+ | Some DISTRO_OPENSUSE
+ | Some DISTRO_SLES
+ | Some DISTRO_CENTOS
+ | Some DISTRO_SCIENTIFIC_LINUX
+ | Some DISTRO_ORACLE_LINUX
+ | Some DISTRO_ALTLINUX ->
+ Some PACKAGE_FORMAT_RPM
+ | Some DISTRO_DEBIAN
+ | Some DISTRO_UBUNTU
+ | Some DISTRO_LINUX_MINT ->
+ Some PACKAGE_FORMAT_DEB
+ | Some DISTRO_ARCHLINUX ->
+ Some PACKAGE_FORMAT_PACMAN
+ | Some DISTRO_GENTOO ->
+ Some PACKAGE_FORMAT_EBUILD
+ | Some DISTRO_PARDUS ->
+ Some PACKAGE_FORMAT_PISI
+ | Some DISTRO_ALPINE_LINUX ->
+ Some PACKAGE_FORMAT_APK
+ | Some DISTRO_VOID_LINUX ->
+ Some PACKAGE_FORMAT_XBPS
+ | Some DISTRO_SLACKWARE
+ | Some DISTRO_TTYLINUX
+ | Some DISTRO_COREOS
+ | Some DISTRO_WINDOWS
+ | Some DISTRO_BUILDROOT
+ | Some DISTRO_CIRROS
+ | Some DISTRO_FREEDOS
+ | Some DISTRO_FREEBSD
+ | Some DISTRO_NETBSD
+ | Some DISTRO_OPENBSD
+ | Some DISTRO_FRUGALWARE
+ | Some DISTRO_PLD_LINUX ->
+ None
+
+and check_package_management { distro = distro; version = version } =
+ let major = match version with None -> 0 | Some (major, _) -> major in
+ match distro with
+ | None -> None
+
+ | Some DISTRO_MEEGO ->
+ Some PACKAGE_MANAGEMENT_YUM
+
+ | Some DISTRO_FEDORA ->
+ (* If Fedora >= 22 and dnf is installed, say "dnf". *)
+ if major >= 22 && Is.is_file ~followsymlinks:true
"/usr/bin/dnf" then
+ Some PACKAGE_MANAGEMENT_DNF
+ else if major >= 1 then
+ Some PACKAGE_MANAGEMENT_YUM
+ else
+ (* Probably parsing the release file failed, see RHBZ#1332025. *)
+ None
+
+ | Some DISTRO_REDHAT_BASED
+ | Some DISTRO_RHEL
+ | Some DISTRO_CENTOS
+ | Some DISTRO_SCIENTIFIC_LINUX
+ | Some DISTRO_ORACLE_LINUX ->
+ if major >= 8 then
+ Some PACKAGE_MANAGEMENT_DNF
+ else if major >= 5 then
+ Some PACKAGE_MANAGEMENT_YUM
+ else if major >= 2 then
+ Some PACKAGE_MANAGEMENT_UP2DATE
+ else
+ (* Probably parsing the release file failed, see RHBZ#1332025. *)
+ None
+
+ | Some DISTRO_DEBIAN
+ | Some DISTRO_UBUNTU
+ | Some DISTRO_LINUX_MINT
+ | Some DISTRO_ALTLINUX ->
+ Some PACKAGE_MANAGEMENT_APT
+
+ | Some DISTRO_ARCHLINUX ->
+ Some PACKAGE_MANAGEMENT_PACMAN
+
+ | Some DISTRO_GENTOO ->
+ Some PACKAGE_MANAGEMENT_PORTAGE
+
+ | Some DISTRO_PARDUS ->
+ Some PACKAGE_MANAGEMENT_PISI
+
+ | Some DISTRO_MAGEIA
+ | Some DISTRO_MANDRIVA ->
+ Some PACKAGE_MANAGEMENT_URPMI
+
+ | Some DISTRO_SUSE_BASED
+ | Some DISTRO_OPENSUSE
+ | Some DISTRO_SLES ->
+ Some PACKAGE_MANAGEMENT_ZYPPER
+
+ | Some DISTRO_ALPINE_LINUX ->
+ Some PACKAGE_MANAGEMENT_APK
+
+ | Some DISTRO_VOID_LINUX ->
+ Some PACKAGE_MANAGEMENT_XBPS;
+
+ | Some DISTRO_SLACKWARE
+ | Some DISTRO_TTYLINUX
+ | Some DISTRO_COREOS
+ | Some DISTRO_WINDOWS
+ | Some DISTRO_BUILDROOT
+ | Some DISTRO_CIRROS
+ | Some DISTRO_FREEDOS
+ | Some DISTRO_FREEBSD
+ | Some DISTRO_NETBSD
+ | Some DISTRO_OPENBSD
+ | Some DISTRO_FRUGALWARE
+ | Some DISTRO_PLD_LINUX ->
+ None
+
diff --git a/daemon/inspect_fs.mli b/daemon/inspect_fs.mli
new file mode 100644
index 000000000..53ea01587
--- /dev/null
+++ b/daemon/inspect_fs.mli
@@ -0,0 +1,23 @@
+(* guestfs-inspection
+ * Copyright (C) 2009-2017 Red Hat Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *)
+
+val check_for_filesystem_on : Mountable.t -> string ->
+ Inspect_types.fs option
+(** [check_for_filesystem_on cmdline mountable vfs_type] inspects
+ [mountable] looking for a single mountpoint from an operating
+ system. *)
diff --git a/daemon/inspect_fs_cd.ml b/daemon/inspect_fs_cd.ml
new file mode 100644
index 000000000..d16ee8095
--- /dev/null
+++ b/daemon/inspect_fs_cd.ml
@@ -0,0 +1,23 @@
+(* guestfs-inspection
+ * Copyright (C) 2009-2017 Red Hat Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *)
+
+let check_installer_iso device =
+ None (* XXX *)
+
+let check_installer_root data =
+ data (* XXX *)
diff --git a/daemon/inspect_fs_cd.mli b/daemon/inspect_fs_cd.mli
new file mode 100644
index 000000000..052753336
--- /dev/null
+++ b/daemon/inspect_fs_cd.mli
@@ -0,0 +1,25 @@
+(* guestfs-inspection
+ * Copyright (C) 2009-2017 Red Hat Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *)
+
+val check_installer_iso : string -> Inspect_types.role option
+(** Check the named device to see if it could be an install ISO image.
+ If so, returns [Some (RoleRoot ...)]. *)
+
+val check_installer_root : Inspect_types.inspection_data ->
+ Inspect_types.inspection_data
+(** Inspect the install CD filesystem mounted on sysroot. *)
diff --git a/daemon/inspect_fs_unix.ml b/daemon/inspect_fs_unix.ml
new file mode 100644
index 000000000..f1856e61e
--- /dev/null
+++ b/daemon/inspect_fs_unix.ml
@@ -0,0 +1,563 @@
+(* guestfs-inspection
+ * Copyright (C) 2009-2017 Red Hat Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *)
+
+open Printf
+
+open C_utils
+open Std_utils
+
+open Utils
+open Inspect_types
+open Inspect_utils
+
+let re_fedora = Str.regexp "Fedora release \\([0-9]+\\)"
+let re_rhel_old = Str.regexp "Red Hat.*release \\([0-9]+\\).*Update
\\([0-9]+\\)"
+let re_rhel = Str.regexp "Red Hat.*release \\([0-9]+\\)\\.\\([0-9]+\\)"
+let re_rhel_no_minor = Str.regexp "Red Hat.*release \\([0-9]+\\)"
+let re_centos_old = Str.regexp "CentOS.*release \\([0-9]+\\).*Update
\\([0-9]+\\)"
+let re_centos = Str.regexp "CentOS.*release \\([0-9]+\\)\\.\\([0-9]+\\)"
+let re_centos_no_minor = Str.regexp "CentOS.*release \\([0-9]+\\)"
+let re_scientific_linux_old =
+ Str.regexp "Scientific Linux.*release \\([0-9]+\\).*Update \\([0-9]+\\)"
+let re_scientific_linux =
+ Str.regexp "Scientific Linux.*release \\([0-9]+\\)\\.\\([0-9]+\\)"
+let re_scientific_linux_no_minor =
+ Str.regexp "Scientific Linux.*release \\([0-9]+\\)"
+let re_oracle_linux_old =
+ Str.regexp "Oracle Linux.*release \\([0-9]+\\).*Update \\([0-9]+\\)"
+let re_oracle_linux =
+ Str.regexp "Oracle Linux.*release \\([0-9]+\\)\\.\\([0-9]+\\)"
+let re_oracle_linux_no_minor = Str.regexp "Oracle Linux.*release \\([0-9]+\\)"
+let re_netbsd = Str.regexp "^NetBSD \\([0-9]+\\)\\.\\([0-9]+\\)"
+let re_opensuse = Str.regexp "^\\(openSUSE|SuSE Linux|SUSE LINUX\\) "
+let re_sles = Str.regexp "^SUSE \\(Linux|LINUX\\) Enterprise "
+let re_nld = Str.regexp "^Novell Linux Desktop "
+let re_sles_version = Str.regexp "^VERSION = \\([0-9]+\\)"
+let re_sles_patchlevel = Str.regexp "^PATCHLEVEL = \\([0-9]+\\)"
+let re_minix = Str.regexp "^\\([0-9]+\\)\\.\\([0-9]+\\)\\(\\.\\([0-9]+\\)\\)?"
+let re_openbsd = Str.regexp "^OpenBSD \\([0-9]+|\\?\\)\\.\\([0-9]+|\\?\\)"
+let re_frugalware = Str.regexp "Frugalware \\([0-9]+\\)\\.\\([0-9]+\\)"
+let re_pldlinux = Str.regexp "\\([0-9]+\\)\\.\\([0-9]+\\) PLD Linux"
+
+let arch_binaries =
+ [ "/bin/bash"; "/bin/ls"; "/bin/echo";
"/bin/rm"; "/bin/sh" ]
+
+let rec check_linux_root mountable data =
+ let os_type = OS_TYPE_LINUX in
+ let data = { data with os_type = Some os_type } in
+
+ let tests = [
+ (* systemd distros include /etc/os-release which is reasonably
+ * standardized. This entry should be first.
+ *)
+ "/etc/os-release", parse_os_release;
+ (* LSB is also a reasonable standard. This entry should be second. *)
+ "/etc/lsb-release", parse_lsb_release;
+
+ (* Now we enter the Wild West ... *)
+
+ (* RHEL-based distros include a [/etc/redhat-release] file, hence their
+ * checks need to be performed before the Red-Hat one.
+ *)
+ "/etc/oracle-release", parse_generic ~rex:re_oracle_linux_old
+ DISTRO_ORACLE_LINUX;
+ "/etc/oracle-release", parse_generic ~rex:re_oracle_linux
+ DISTRO_ORACLE_LINUX;
+ "/etc/oracle-release", parse_generic ~rex:re_oracle_linux_no_minor
+ DISTRO_ORACLE_LINUX;
+ "/etc/centos-release", parse_generic ~rex:re_centos_old
+ DISTRO_CENTOS;
+ "/etc/centos-release", parse_generic ~rex:re_centos
+ DISTRO_CENTOS;
+ "/etc/centos-release", parse_generic ~rex:re_centos_no_minor
+ DISTRO_CENTOS;
+ "/etc/altlinux-release", parse_generic DISTRO_ALTLINUX;
+ "/etc/redhat-release", parse_generic ~rex:re_fedora
+ DISTRO_FEDORA;
+ "/etc/redhat-release", parse_generic ~rex:re_rhel_old
+ DISTRO_RHEL;
+ "/etc/redhat-release", parse_generic ~rex:re_rhel
+ DISTRO_RHEL;
+ "/etc/redhat-release", parse_generic ~rex:re_rhel_no_minor
+ DISTRO_RHEL;
+ "/etc/redhat-release", parse_generic ~rex:re_centos_old
+ DISTRO_CENTOS;
+ "/etc/redhat-release", parse_generic ~rex:re_centos
+ DISTRO_CENTOS;
+ "/etc/redhat-release", parse_generic ~rex:re_centos_no_minor
+ DISTRO_CENTOS;
+ "/etc/redhat-release", parse_generic ~rex:re_scientific_linux_old
+ DISTRO_SCIENTIFIC_LINUX;
+ "/etc/redhat-release", parse_generic ~rex:re_scientific_linux
+ DISTRO_SCIENTIFIC_LINUX;
+ "/etc/redhat-release", parse_generic ~rex:re_scientific_linux_no_minor
+ DISTRO_SCIENTIFIC_LINUX;
+
+ (* If there's an /etc/redhat-release file, but nothing above
+ * matches, then it is a generic Red Hat-based distro.
+ *)
+ "/etc/redhat-release", parse_generic DISTRO_REDHAT_BASED;
+ "/etc/redhat-release",
+ (fun _ data -> { data with distro = Some DISTRO_REDHAT_BASED });
+
+ "/etc/debian_version", parse_generic DISTRO_DEBIAN;
+ "/etc/pardus-release", parse_generic DISTRO_PARDUS;
+
+ (* /etc/arch-release file is empty and I can't see a way to
+ * determine the actual release or product string.
+ *)
+ "/etc/arch-release",
+ (fun _ data -> { data with distro = Some DISTRO_ARCHLINUX });
+
+ "/etc/gentoo-release", parse_generic DISTRO_GENTOO;
+ "/etc/meego-release", parse_generic DISTRO_MEEGO;
+ "/etc/slackware-version", parse_generic DISTRO_SLACKWARE;
+ "/etc/ttylinux-target", parse_generic DISTRO_TTYLINUX;
+
+ "/etc/SuSE-release", parse_suse_release;
+ "/etc/SuSE-release",
+ (fun _ data -> { data with distro = Some DISTRO_SUSE_BASED });
+
+ "/etc/cirros/version", parse_generic DISTRO_CIRROS;
+ "/etc/br-version",
+ (fun release_file data ->
+ let distro =
+ if Is.is_file ~followsymlinks:true "/usr/share/cirros/logo" then
+ DISTRO_CIRROS
+ else
+ DISTRO_BUILDROOT in
+ (* /etc/br-version has the format YYYY.MM[-git/hg/svn release] *)
+ parse_generic distro release_file data);
+
+ "/etc/alpine-release", parse_generic DISTRO_ALPINE_LINUX;
+ "/etc/frugalware-release", parse_generic ~rex:re_frugalware
+ DISTRO_FRUGALWARE;
+ "/etc/pld-release", parse_generic ~rex:re_pldlinux
+ DISTRO_PLD_LINUX;
+ ] in
+
+ let rec loop = function
+ | (release_file, parse_fun) :: tests ->
+ if verbose () then
+ eprintf "check_linux_root: checking %s\n%!" release_file;
+ (try
+ if not (Is.is_file ~followsymlinks:true release_file) then
+ raise Not_found;
+ parse_fun release_file data
+ with
+ Not_found -> loop tests)
+ | [] -> data
+ in
+ let data = loop tests in
+
+ let data = {
+ data with
+ arch = check_architecture ();
+ fstab =
+ Inspect_fs_unix_fstab.check_fstab ~mdadm_conf:true mountable os_type;
+ hostname = check_hostname_linux ();
+ } in
+
+ data
+
+(* Parse a os-release file.
+ *
+ * Only few fields are parsed, falling back to the usual detection if we
+ * cannot read all of them.
+ *
+ * For the format of os-release, see also:
+ *
http://www.freedesktop.org/software/systemd/man/os-release.html
+ *)
+and parse_os_release release_file data =
+ let chroot = Chroot.create ~name:"parse_os_release" (Sysroot.sysroot ()) in
+ let lines =
+ Chroot.f chroot (
+ fun () ->
+ if not (is_small_file release_file) then (
+ eprintf "%s: not a regular file or too large\n" release_file;
+ raise Not_found
+ );
+ read_whole_file release_file
+ ) () in
+ let lines = String.nsplit "\n" lines in
+
+ let data = List.fold_left (
+ fun data line ->
+ let line = String.trim line in
+ if line = "" || line.[0] = '#' then
+ data
+ else (
+ let key, value = String.split "=" line in
+ let value =
+ let n = String.length value in
+ if n >= 2 && value.[0] = '"' && value.[n-1] =
'"' then
+ String.sub value 1 (n-2)
+ else
+ value in
+ if key = "ID" then (
+ let distro = distro_of_os_release_id value in
+ match distro with
+ | Some _ as distro -> { data with distro = distro }
+ | None -> data
+ )
+ else if key = "PRETTY_NAME" then
+ { data with product_name = Some value }
+ else if key = "VERSION_ID" then
+ parse_version_from_major_minor value data
+ else
+ data
+ )
+ ) data lines in
+
+ (* os-release in Debian and CentOS does not provide the full
+ * version number (VERSION_ID), just the major part of it. If
+ * we detect that situation then bail out and use the release
+ * files instead.
+ *)
+ (match data with
+ | { distro = Some (DISTRO_DEBIAN|DISTRO_CENTOS); version = Some (_, 0) } ->
+ raise Not_found
+ | _ -> ()
+ );
+
+ data
+
+(* ID="fedora" => Some DISTRO_FEDORA *)
+and distro_of_os_release_id = function
+ | "alpine" -> Some DISTRO_ALPINE_LINUX
+ | "altlinux" -> Some DISTRO_ALTLINUX
+ | "arch" -> Some DISTRO_ARCHLINUX
+ | "centos" -> Some DISTRO_CENTOS
+ | "coreos" -> Some DISTRO_COREOS
+ | "debian" -> Some DISTRO_DEBIAN
+ | "fedora" -> Some DISTRO_FEDORA
+ | "frugalware" -> Some DISTRO_FRUGALWARE
+ | "mageia" -> Some DISTRO_MAGEIA
+ | "opensuse" -> Some DISTRO_OPENSUSE
+ | "pld" -> Some DISTRO_PLD_LINUX
+ | "rhel" -> Some DISTRO_RHEL
+ | "sles" | "sled" -> Some DISTRO_SLES
+ | "ubuntu" -> Some DISTRO_UBUNTU
+ | "void" -> Some DISTRO_VOID_LINUX
+ | value ->
+ eprintf "/etc/os-release: unknown ID=%s\n" value;
+ None
+
+(* Ubuntu has /etc/lsb-release containing:
+ * DISTRIB_ID=Ubuntu # Distro
+ * DISTRIB_RELEASE=10.04 # Version
+ * DISTRIB_CODENAME=lucid
+ * DISTRIB_DESCRIPTION="Ubuntu 10.04.1 LTS" # Product name
+ *
+ * [Ubuntu-derived ...] Linux Mint was found to have this:
+ * DISTRIB_ID=LinuxMint
+ * DISTRIB_RELEASE=10
+ * DISTRIB_CODENAME=julia
+ * DISTRIB_DESCRIPTION="Linux Mint 10 Julia"
+ * Linux Mint also has /etc/linuxmint/info with more information,
+ * but we can use the LSB file.
+ *
+ * Mandriva has:
+ * LSB_VERSION=lsb-4.0-amd64:lsb-4.0-noarch
+ * DISTRIB_ID=MandrivaLinux
+ * DISTRIB_RELEASE=2010.1
+ * DISTRIB_CODENAME=Henry_Farman
+ * DISTRIB_DESCRIPTION="Mandriva Linux 2010.1"
+ * Mandriva also has a normal release file called /etc/mandriva-release.
+ *
+ * CoreOS has a /etc/lsb-release link to /usr/share/coreos/lsb-release containing:
+ * DISTRIB_ID=CoreOS
+ * DISTRIB_RELEASE=647.0.0
+ * DISTRIB_CODENAME="Red Dog"
+ * DISTRIB_DESCRIPTION="CoreOS 647.0.0"
+ *)
+and parse_lsb_release release_file data =
+ let chroot = Chroot.create ~name:"parse_lsb_release" (Sysroot.sysroot ()) in
+ let lines =
+ Chroot.f chroot (
+ fun () ->
+ if not (is_small_file release_file) then (
+ eprintf "%s: not a regular file or too large\n" release_file;
+ raise Not_found
+ );
+ read_whole_file release_file
+ ) () in
+ let lines = String.nsplit "\n" lines in
+
+ let data = List.fold_left (
+ fun data line ->
+ if data.distro = None && line = "DISTRIB_ID=Ubuntu" then
+ { data with distro = Some DISTRO_UBUNTU }
+ else if data.distro = None && line = "DISTRIB_ID=LinuxMint" then
+ { data with distro = Some DISTRO_LINUX_MINT }
+ else if data.distro = None && line =
"DISTRIB_ID=\"Mageia\"" then
+ { data with distro = Some DISTRO_MAGEIA }
+ else if data.distro = None && line = "DISTRIB_ID=CoreOS" then
+ { data with distro = Some DISTRO_COREOS }
+ else if String.is_prefix line "DISTRIB_RELEASE=" then
+ parse_version_from_major_minor line data
+ else if String.is_prefix line "DISTRIB_DESCRIPTION=\"" ||
+ String.is_prefix line "DISTRIB_DESCRIPTION='" then (
+ let n = String.length line in
+ let product_name = String.sub line 21 (n-20) in
+ { data with product_name = Some product_name }
+ )
+ else if String.is_prefix line "DISTRIB_DESCRIPTION=" then (
+ let n = String.length line in
+ let product_name = String.sub line 20 (n-20) in
+ { data with product_name = Some product_name }
+ )
+ else
+ data
+ ) data lines in
+
+ data
+
+and parse_suse_release release_file data =
+ let chroot = Chroot.create ~name:"parse_suse_release" (Sysroot.sysroot ())
in
+ let lines =
+ Chroot.f chroot (
+ fun () ->
+ if not (is_small_file release_file) then (
+ eprintf "%s: not a regular file or too large\n" release_file;
+ raise Not_found
+ );
+ read_whole_file release_file
+ ) () in
+ let lines = String.nsplit "\n" lines in
+
+ if lines = [] then raise Not_found;
+
+ (* First line is dist release name. *)
+ let product_name = List.hd lines in
+ let data = {
+ data with
+ product_name = Some product_name
+ } in
+
+ (* Match SLES first because openSuSE regex overlaps some SLES
+ * release strings.
+ *)
+ if Str.string_match re_sles product_name 0 ||
+ Str.string_match re_nld product_name 0 then (
+ (* Second line contains version string. *)
+ let major =
+ if List.length lines >= 2 then (
+ let line = List.nth lines 1 in
+ if Str.string_match re_sles_version line 0 then
+ Some (int_of_string (Str.matched_group 1 line))
+ else None
+ )
+ else None in
+
+ (* Third line contains service pack string. *)
+ let minor =
+ if List.length lines >= 3 then (
+ let line = List.nth lines 2 in
+ if Str.string_match re_sles_patchlevel line 0 then
+ Some (int_of_string (Str.matched_group 1 line))
+ else None
+ )
+ else None in
+
+ let version =
+ match major, minor with
+ | Some major, Some minor -> Some (major, minor)
+ | Some major, None -> Some (major, 0)
+ | None, Some _ | None, None -> None in
+
+ { data with
+ distro = Some DISTRO_SLES;
+ version = version }
+ )
+ else if Str.string_match re_opensuse product_name 0 then (
+ (* Second line contains version string. *)
+ let data =
+ if List.length lines >= 2 then (
+ let line = List.nth lines 1 in
+ parse_version_from_major_minor line data
+ )
+ else data in
+
+ { data with distro = Some DISTRO_OPENSUSE }
+ )
+ else
+ data
+
+(* Parse any generic /etc/x-release file.
+ *
+ * The optional regular expression which may match 0, 1 or 2
+ * substrings, which are used as the major and minor numbers.
+ *
+ * The fixed distro is always set, and the product name is
+ * set to the first line of the release file.
+ *)
+and parse_generic ?rex distro release_file data =
+ let chroot = Chroot.create ~name:"parse_generic" (Sysroot.sysroot ()) in
+ let product_name =
+ Chroot.f chroot (
+ fun () ->
+ if not (is_small_file release_file) then (
+ eprintf "%s: not a regular file or too large\n" release_file;
+ raise Not_found
+ );
+ read_first_line_from_file release_file
+ ) () in
+ if product_name = "" then
+ raise Not_found;
+
+ let data =
+ { data with product_name = Some product_name;
+ distro = Some distro } in
+
+ match rex with
+ | Some rex ->
+ (* If ~rex was supplied, then it must match the release file,
+ * else the parsing fails.
+ *)
+ if not (Str.string_match rex product_name 0) then
+ raise Not_found;
+
+ (* Although it's not documented, matched_group raises
+ * Invalid_argument if called with an unknown group number.
+ *)
+ let major =
+ try Some (int_of_string (Str.matched_group 1 product_name))
+ with Not_found | Invalid_argument _ | Failure _ -> None in
+ let minor =
+ try Some (int_of_string (Str.matched_group 2 product_name))
+ with Not_found | Invalid_argument _ | Failure _ -> None in
+ (match major, minor with
+ | None, None -> data
+ | None, Some _ -> data
+ | Some major, None -> { data with version = Some (major, 0) }
+ | Some major, Some minor -> { data with version = Some (major, minor) }
+ )
+
+ | None ->
+ (* However if no ~rex was supplied, then we make a best
+ * effort attempt to parse a version number, but don't
+ * fail if one cannot be found.
+ *)
+ parse_version_from_major_minor product_name data
+
+and check_architecture () =
+ let rec loop = function
+ | [] -> None
+ | bin :: bins ->
+ (* Allow symlinks when checking the binaries:,so in case they are
+ * relative ones (which can be resolved within the same partition),
+ * then we can check the architecture of their target.
+ *)
+ if Is.is_file ~followsymlinks:true bin then (
+ try
+ let resolved = Realpath.realpath bin in
+ let arch = Filearch.file_architecture resolved in
+ Some arch
+ with exn ->
+ if verbose () then
+ eprintf "check_architecture: %s: %s\n%!" bin
+ (Printexc.to_string exn);
+ loop bins
+ )
+ else
+ loop bins
+ in
+ loop arch_binaries
+
+and check_hostname_linux () =
+ let chroot =
+ Chroot.create ~name:"check_hostname_linux" (Sysroot.sysroot ()) in
+
+ (* Red Hat-derived would be in /etc/sysconfig/network or
+ * /etc/hostname (RHEL 7+, F18+). Debian-derived in the file
+ * /etc/hostname. Very old Debian and SUSE use /etc/HOSTNAME.
+ * It's best to just look for each of these files in turn, rather
+ * than try anything clever based on distro.
+ *)
+ let rec loop = function
+ | [] -> None
+ | filename :: rest ->
+ let hostname =
+ Chroot.f chroot (
+ fun () ->
+ if not (is_small_file filename) then (
+ eprintf "%s: not a regular file or too large\n" filename;
+ None
+ )
+ else
+ Some (read_first_line_from_file filename)
+ ) () in
+ match hostname with
+ | Some hostname -> Some hostname
+ | None -> loop rest
+ in
+ let hostname = loop [ "/etc/HOSTNAME"; "/etc/hostname" ] in
+ match hostname with
+ | Some hostname -> Some hostname
+ | None ->
+ if Is.is_file "/etc/sysconfig/network" then
+ Inspect_utils.with_augeas ["/etc/sysconfig/network"]
+ check_hostname_from_sysconfig_network
+ else
+ None
+
+(* Parse the hostname from /etc/sysconfig/network. This must be
+ * called from the 'with_augeas' wrapper. Note that F18+ and
+ * RHEL7+ use /etc/hostname just like Debian.
+ *)
+and check_hostname_from_sysconfig_network aug =
+ (* Errors here are not fatal (RHBZ#726739), since it could be
+ * just missing HOSTNAME field in the file.
+ *)
+ Augeas.get aug "/files/etc/sysconfig/network/HOSTNAME"
+
+let check_linux_usr data =
+ (* XXX *) data
+
+let check_coreos_root data =
+ (* XXX *) data
+
+let check_coreos_usr data =
+ (* XXX *) data
+
+let check_freebsd_root data =
+ (* XXX *) data
+
+and check_hostname_freebsd () =
+ (* XXX *) None
+
+let check_netbsd_root data =
+ (* XXX *) data
+
+let rec check_openbsd_root data =
+ (* XXX *) data
+
+and check_hostname_openbsd () =
+ (* XXX *) None
+
+let check_hurd_root data =
+ (* XXX *) data
+
+and check_hostname_hurd () = check_hostname_linux ()
+
+let rec check_minix_root data =
+ (* XXX *) data
+
+and check_hostname_minix () =
+ (* XXX *) None
diff --git a/daemon/inspect_fs_unix.mli b/daemon/inspect_fs_unix.mli
new file mode 100644
index 000000000..7ca1e2fbb
--- /dev/null
+++ b/daemon/inspect_fs_unix.mli
@@ -0,0 +1,53 @@
+(* guestfs-inspection
+ * Copyright (C) 2009-2017 Red Hat Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *)
+
+val check_coreos_usr : Inspect_types.inspection_data ->
+ Inspect_types.inspection_data
+(** Inspect the CoreOS [/usr] filesystem mounted on sysroot. *)
+
+val check_coreos_root : Inspect_types.inspection_data ->
+ Inspect_types.inspection_data
+(** Inspect the CoreOS filesystem mounted on sysroot. *)
+
+val check_freebsd_root : Inspect_types.inspection_data ->
+ Inspect_types.inspection_data
+(** Inspect the FreeBSD filesystem mounted on sysroot. *)
+
+val check_hurd_root : Inspect_types.inspection_data ->
+ Inspect_types.inspection_data
+(** Inspect the Hurd filesystem mounted on sysroot. *)
+
+val check_linux_usr : Inspect_types.inspection_data ->
+ Inspect_types.inspection_data
+(** Inspect the Linux [/usr] filesystem mounted on sysroot. *)
+
+val check_linux_root : Mountable.t -> Inspect_types.inspection_data ->
+ Inspect_types.inspection_data
+(** Inspect the Linux filesystem mounted on sysroot. *)
+
+val check_minix_root : Inspect_types.inspection_data ->
+ Inspect_types.inspection_data
+(** Inspect the Minix filesystem mounted on sysroot. *)
+
+val check_netbsd_root : Inspect_types.inspection_data ->
+ Inspect_types.inspection_data
+(** Inspect the NetBSD filesystem mounted on sysroot. *)
+
+val check_openbsd_root : Inspect_types.inspection_data ->
+ Inspect_types.inspection_data
+(** Inspect the OpenBSD filesystem mounted on sysroot. *)
diff --git a/daemon/inspect_fs_unix_fstab.ml b/daemon/inspect_fs_unix_fstab.ml
new file mode 100644
index 000000000..c566a7618
--- /dev/null
+++ b/daemon/inspect_fs_unix_fstab.ml
@@ -0,0 +1,518 @@
+(* guestfs-inspection
+ * Copyright (C) 2009-2017 Red Hat Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *)
+
+open Printf
+
+open C_utils
+open Std_utils
+
+open Utils
+open Inspect_types
+open Inspect_utils
+
+let re_cciss = Str.regexp
"^/dev/\\(cciss/c[0-9]+d[0-9]+\\)\\(p\\([0-9]+\\)\\)?$"
+let re_diskbyid = Str.regexp "^/dev/disk/by-id/.*-part\\([0-9]+\\)$"
+let re_freebsd_gpt = Str.regexp
"^/dev/\\(ada{0,1}|vtbd\\)\\([0-9]+\\)p\\([0-9]+\\)$"
+let re_freebsd_mbr = Str.regexp
"^/dev/\\(ada{0,1}|vtbd\\)\\([0-9]+\\)s\\([0-9]+\\)\\([a-z]\\)$"
+let re_hurd_dev = Str.regexp "^/dev/\\(h\\)d\\([0-9]+\\)s\\([0-9]+\\)$"
+let re_mdN = Str.regexp "^/dev/md[0-9]+$"
+let re_netbsd_dev = Str.regexp "^/dev/\\(l|s\\)d\\([0-9]\\)\\([a-z]\\)$"
+let re_openbsd_dev = Str.regexp "^/dev/\\(s|w\\)d\\([0-9]\\)\\([a-z]\\)$"
+let re_openbsd_duid = Str.regexp
"^[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]\\.\\([a-z]\\)"
+let re_xdev = Str.regexp "^/dev/\\(h|s|v|xv\\)d\\([a-z]+\\)\\([0-9]*\\)$"
+
+let rec check_fstab ?(mdadm_conf = false) (root_mountable : Mountable.t)
+ os_type =
+ let configfiles =
+ "/etc/fstab" :: if mdadm_conf then ["/etc/mdadm.conf"] else []
in
+
+ with_augeas configfiles (check_fstab_aug mdadm_conf root_mountable os_type)
+
+and check_fstab_aug mdadm_conf root_mountable os_type aug =
+ (* Generate a map of MD device paths listed in /etc/mdadm.conf
+ * to MD device paths in the guestfs appliance.
+ *)
+ let md_map = if mdadm_conf then map_md_devices aug else StringMap.empty in
+
+ let path = "/files/etc/fstab/*[label() != '#comment']" in
+ let entries = Augeas.matches aug path in
+ filter_map (check_fstab_entry md_map root_mountable os_type aug) entries
+
+and check_fstab_entry md_map root_mountable os_type aug entry =
+ if verbose () then
+ eprintf "check_fstab_entry: augeas path: %s\n%!" entry;
+
+ let is_bsd =
+ os_type = OS_TYPE_FREEBSD ||
+ os_type = OS_TYPE_NETBSD ||
+ os_type = OS_TYPE_OPENBSD in
+
+ let spec = Augeas.get aug (entry ^ "/spec") in
+ let mp = Augeas.get aug (entry ^ "/file") in
+ let vfstype = Augeas.get aug (entry ^ "/vfstype") in
+
+ match spec, mp, vfstype with
+ | None, _, _ | Some _, None, _ | Some _, Some _, None -> None
+ | Some spec, Some mp, Some vfstype ->
+ if verbose () then
+ eprintf "check_fstab_entry: spec=%s mp=%s vfstype=%s\n%!"
+ spec mp vfstype;
+
+ (* Ignore /dev/fd (floppy disks) (RHBZ#642929) and CD-ROM drives.
+ *
+ * /dev/iso9660/FREEBSD_INSTALL can be found in FreeBSD's
+ * installation discs.
+ *)
+ if (String.is_prefix spec "/dev/fd" &&
+ String.length spec >= 8 && Char.isdigit spec.[7]) ||
+ (String.is_prefix spec "/dev/cd" &&
+ String.length spec >= 8 && Char.isdigit spec.[7]) ||
+ spec = "/dev/floppy" ||
+ spec = "/dev/cdrom" ||
+ String.is_prefix spec "/dev/iso9660/" then
+ None
+ else (
+ (* Canonicalize the path, so "///usr//local//" ->
"/usr/local" *)
+ let mp = unix_canonical_path mp in
+
+ (* Ignore certain mountpoints. *)
+ if String.is_prefix mp "/dev/" ||
+ mp = "/dev" ||
+ String.is_prefix mp "/media/" ||
+ String.is_prefix mp "/proc/" ||
+ mp = "/proc" ||
+ String.is_prefix mp "/selinux/" ||
+ mp = "/selinux" ||
+ String.is_prefix mp "/sys/" ||
+ mp = "/sys" then
+ None
+ else (
+ let mountable =
+ (* Resolve UUID= and LABEL= to the actual device. *)
+ if String.is_prefix spec "UUID=" then (
+ let uuid = String.sub spec 5 (String.length spec - 5) in
+ let uuid = shell_unquote uuid in
+ Some (Mountable.of_device (Findfs.findfs_uuid uuid))
+ )
+ else if String.is_prefix spec "LABEL=" then (
+ let label = String.sub spec 6 (String.length spec - 6) in
+ let label = shell_unquote label in
+ Some (Mountable.of_device (Findfs.findfs_label label))
+ )
+ (* Resolve /dev/root to the current device.
+ * Do the same for the / partition of the *BSD
+ * systems, since the BSD -> Linux device
+ * translation is not straight forward.
+ *)
+ else if spec = "/dev/root" || (is_bsd && mp = "/")
then
+ Some root_mountable
+ (* Resolve guest block device names. *)
+ else if String.is_prefix spec "/dev/" then
+ Some (resolve_fstab_device spec md_map os_type)
+ (* In OpenBSD's fstab you can specify partitions
+ * on a disk by appending a period and a partition
+ * letter to a Disklable Unique Identifier. The
+ * DUID is a 16 hex digit field found in the
+ * OpenBSD's altered BSD disklabel. For more info
+ * see here:
+ *
http://www.openbsd.org/faq/faq14.html#intro
+ *)
+ else if Str.string_match re_openbsd_duid spec 0 then (
+ let part = Str.matched_group 1 spec in
+ (* We cannot peep into disklabels, we can only
+ * assume that this is the first disk.
+ *)
+ let device = sprintf "/dev/sd0%s" part in
+ Some (resolve_fstab_device device md_map os_type)
+ )
+ (* Ignore "/.swap" (Pardus) and pseudo-devices
+ * like "tmpfs". If we haven't resolved the device
+ * successfully by this point, just ignore it.
+ *)
+ else
+ None in
+
+ match mountable with
+ | None -> None
+ | Some mountable ->
+ let mountable =
+ if vfstype = "btrfs" then
+ get_btrfs_mountable aug entry mountable
+ else mountable in
+
+ Some (mountable, mp)
+ )
+ )
+
+(* If an fstab entry corresponds to a btrfs filesystem, look for
+ * the 'subvol' option and if it is present then return a btrfs
+ * subvolume (else return the whole device).
+ *)
+and get_btrfs_mountable aug entry mountable =
+ let device =
+ match mountable with
+ | { Mountable.m_type = Mountable.MountableDevice; m_device = device } ->
+ Some device
+ | { Mountable.m_type =
+ (Mountable.MountablePath|Mountable.MountableBtrfsVol _) } ->
+ None in
+
+ match device with
+ | None -> mountable
+ | Some device ->
+ let opts = Augeas.matches aug (entry ^ "/opt") in
+ let rec loop = function
+ | [] -> mountable (* no subvol, return whole device *)
+ | opt :: opts ->
+ let optname = Augeas.get aug opt in
+ match optname with
+ | None -> loop opts
+ | Some "subvol" ->
+ let subvol = Augeas.get aug (opt ^ "/value") in
+ (match subvol with
+ | None -> loop opts
+ | Some subvol ->
+ Mountable.of_btrfsvol device subvol
+ )
+ | Some _ ->
+ loop opts
+ in
+ loop opts
+
+(* Get a map of md device names in mdadm.conf to their device names
+ * in the appliance.
+ *)
+and map_md_devices aug =
+ (* Get a map of md device uuids to their device names in the appliance. *)
+ let uuid_map = map_app_md_devices () in
+
+ (* Nothing to do if there are no md devices. *)
+ if StringMap.is_empty uuid_map then StringMap.empty
+ else (
+ (* Get all arrays listed in mdadm.conf. *)
+ let entries = Augeas.matches aug "/files/etc/mdadm.conf/array" in
+
+ (* Log a debug entry if we've got md devices but nothing in mdadm.conf. *)
+ if verbose () && entries = [] then
+ eprintf "warning: appliance has MD devices, but augeas returned no array
matches in /etc/mdadm.conf\n%!";
+
+ List.fold_left (
+ fun md_map entry ->
+ try
+ (* Get device name and uuid for each array. *)
+ let dev = Augeas.get aug (entry ^ "/devicename") in
+ let uuid = Augeas.get aug (entry ^ "/uuid") in
+ let dev =
+ match dev with None -> raise Not_found | Some dev -> dev in
+ let uuid =
+ match uuid with None -> raise Not_found | Some uuid -> uuid in
+
+ (* Parse the uuid into an md_uuid structure so we can look
+ * it up in the uuid_map.
+ *)
+ let uuid = parse_md_uuid uuid in
+
+ let md = StringMap.find uuid uuid_map in
+
+ (* If there's a corresponding uuid in the appliance, create
+ * a new entry in the transitive map.
+ *)
+ StringMap.add dev md md_map
+ with
+ (* No Augeas devicename or uuid node found, or could not parse
+ * uuid, or uuid not present in the uuid_map.
+ *
+ * This is not fatal, just ignore the entry.
+ *)
+ Not_found | Invalid_argument _ -> md_map
+ ) StringMap.empty entries
+ )
+
+(* Create a mapping of uuids to appliance md device names. *)
+and map_app_md_devices () =
+ let mds = Md.list_md_devices () in
+ List.fold_left (
+ fun map md ->
+ let detail = Md.md_detail md in
+
+ try
+ (* Find the value of the "uuid" key. *)
+ let uuid = List.assoc "uuid" detail in
+ let uuid = parse_md_uuid uuid in
+ StringMap.add uuid md map
+ with
+ (* uuid not found, or could not be parsed - just ignore the entry *)
+ Not_found | Invalid_argument _ -> map
+ ) StringMap.empty mds
+
+(* Taken from parse_uuid in mdadm.
+ *
+ * Raises Invalid_argument if the input is not an MD UUID.
+ *)
+and parse_md_uuid uuid =
+ let len = String.length uuid in
+ let out = Bytes.create len in
+ let j = ref 0 in
+
+ for i = 0 to len-1 do
+ let c = uuid.[i] in
+ if Char.isxdigit c then (
+ Bytes.set out !j c;
+ incr j
+ )
+ else if c = ':' || c = '.' || c = ' ' || c = '-'
then
+ ()
+ else
+ invalid_arg "parse_md_uuid: invalid character"
+ done;
+
+ if !j <> 32 then
+ invalid_arg "parse_md_uuid: invalid length";
+
+ Bytes.sub_string out 0 !j
+
+(* Resolve block device name to the libguestfs device name, eg.
+ * /dev/xvdb1 => /dev/vdb1; and /dev/mapper/VG-LV => /dev/VG/LV. This
+ * assumes that disks were added in the same order as they appear to
+ * the real VM, which is a reasonable assumption to make. Return
+ * anything we don't recognize unchanged.
+ *)
+and resolve_fstab_device spec md_map os_type =
+ (* In any case where we didn't match a device pattern or there was
+ * another problem, return this default mountable derived from [spec].
+ *)
+ let default = Mountable.of_device spec in
+
+ if String.is_prefix spec "/dev/mapper" then (
+ (* LVM2 does some strange munging on /dev/mapper paths for VGs and
+ * LVs which contain '-' character:
+ *
+ * ><fs> lvcreate LV--test VG--test 32
+ * ><fs> debug ls /dev/mapper
+ * VG----test-LV----test
+ *
+ * This makes it impossible to reverse those paths directly, so
+ * we have implemented lvm_canonical_lv_name in the daemon.
+ *)
+ try
+ match Lvm.lv_canonical spec with
+ | None -> Mountable.of_device spec
+ | Some device -> Mountable.of_device device
+ with
+ (* Ignore devices that don't exist. (RHBZ#811872) *)
+ | Unix.Unix_error (Unix.ENOENT, _, _) -> default
+ )
+
+ else if Str.string_match re_xdev spec 0 then (
+ let typ = Str.matched_group 1 spec
+ and disk = Str.matched_group 2 spec
+ and part = int_of_string (Str.matched_group 3 spec) in
+ resolve_xdev typ disk part default
+ )
+
+ else if Str.string_match re_cciss spec 0 then (
+ let disk = Str.matched_group 1 spec
+ (* group 2 = optional p<NN>, group 3 = <NN> *)
+ and part =
+ try Some (int_of_string (Str.matched_group 3 spec))
+ with Not_found | Invalid_argument _ -> None in
+ resolve_cciss disk part default
+ )
+
+ else if Str.string_match re_mdN spec 0 then (
+ try
+ Mountable.of_device (StringMap.find spec md_map)
+ with
+ | Not_found -> default
+ )
+
+ else if Str.string_match re_diskbyid spec 0 then (
+ let part = int_of_string (Str.matched_group 1 spec) in
+ resolve_diskbyid part default
+ )
+
+ else if Str.string_match re_freebsd_gpt spec 0 then (
+ (* group 1 (type) is not used *)
+ let disk = int_of_string (Str.matched_group 2 spec)
+ and part = int_of_string (Str.matched_group 3 spec) in
+
+ (* If the FreeBSD disk contains GPT partitions, the translation to Linux
+ * device names is straight forward. Partitions on a virtio disk are
+ * prefixed with [vtbd]. IDE hard drives used to be prefixed with [ad]
+ * and now prefixed with [ada].
+ *)
+ if disk >= 0 && disk <= 26 && part >= 0 && part
<= 128 then (
+ let dev = sprintf "/dev/sd%c%d"
+ (Char.chr (disk + Char.code 'a')) part in
+ Mountable.of_device dev
+ )
+ else default
+ )
+
+ else if Str.string_match re_freebsd_mbr spec 0 then (
+ (* group 1 (type) is not used *)
+ let disk = int_of_string (Str.matched_group 2 spec)
+ and slice = int_of_string (Str.matched_group 3 spec)
+ (* partition number counting from 0: *)
+ and part = Char.code (Str.matched_group 4 spec).[0] - Char.code 'a' in
+
+ (* FreeBSD MBR disks are organized quite differently. See:
+ *
http://www.freebsd.org/doc/handbook/disk-organization.html
+ * FreeBSD "partitions" are exposed as quasi-extended partitions
+ * numbered from 5 in Linux. I have no idea what happens when you
+ * have multiple "slices" (the FreeBSD term for MBR partitions).
+ *)
+
+ (* Partition 'c' has the size of the enclosing slice.
+ * Not mapped under Linux.
+ *)
+ let part = if part > 2 then part - 1 else part in
+
+ if disk >= 0 && disk <= 26 &&
+ slice > 0 && slice <= 1 (* > 4 .. see comment above *)
&&
+ part >= 0 && part < 25 then (
+ let dev = sprintf "/dev/sd%c%d"
+ (Char.chr (disk + Char.code 'a')) (part + 5) in
+ Mountable.of_device dev
+ )
+ else default
+ )
+
+ else if os_type = OS_TYPE_NETBSD &&
+ Str.string_match re_netbsd_dev spec 0 then (
+ (* group 1 (type) is not used *)
+ let disk = int_of_string (Str.matched_group 2 spec)
+ (* partition number counting from 0: *)
+ and part = Char.code (Str.matched_group 3 spec).[0] - Char.code 'a' in
+
+ (* Partition 'c' is the disklabel partition and 'd' the hard disk
itself.
+ * Not mapped under Linux.
+ *)
+ let part = if part > 3 then part - 2 else part in
+
+ if disk >= 0 && part >= 0 && part < 24 then (
+ let dev = sprintf "/dev/sd%c%d"
+ (Char.chr (disk + Char.code 'a')) (part + 5) in
+ Mountable.of_device dev
+ )
+ else default
+ )
+
+ else if os_type = OS_TYPE_OPENBSD &&
+ Str.string_match re_openbsd_dev spec 0 then (
+ (* group 1 (type) is not used *)
+ let disk = int_of_string (Str.matched_group 2 spec)
+ (* partition number counting from 0: *)
+ and part = Char.code (Str.matched_group 3 spec).[0] - Char.code 'a' in
+
+ (* Partition 'c' is the hard disk itself. Not mapped under Linux. *)
+ let part = if part > 2 then part - 1 else part in
+
+ (* In OpenBSD MAXPARTITIONS is defined to 16 for all architectures. *)
+ if disk >= 0 && part >= 0 && part < 15 then (
+ let dev = sprintf "/dev/sd%c%d"
+ (Char.chr (disk + Char.code 'a')) (part + 5) in
+ Mountable.of_device dev
+ )
+ else default
+ )
+
+ else if Str.string_match re_hurd_dev spec 0 then (
+ let typ = Str.matched_group 1 spec
+ and disk = int_of_string (Str.matched_group 2 spec)
+ and part = int_of_string (Str.matched_group 3 spec) in
+
+ (* Hurd disk devices are like /dev/hdNsM, where hdN is the
+ * N-th disk and M is the M-th partition on that disk.
+ * Turn the disk number into a letter-based identifier, so
+ * we can resolve it easily.
+ *)
+ let disk = sprintf "%c" (Char.chr (disk + Char.code 'a')) in
+
+ resolve_xdev typ disk part default
+ )
+
+ else default
+
+(* type: (h|s|v|xv)
+ * disk: [a-z]+
+ * part: \d*
+ *)
+and resolve_xdev typ disk part default =
+ let devices = Devsparts.list_devices () in
+ let devices = Array.of_list devices in
+
+ (* XXX Check any hints we were passed for a non-heuristic mapping.
+ * The C code used hints here to map device names as known by
+ * the library user (eg. from metadata) to libguestfs devices here.
+ * However none of the libguestfs tools ever used this feature.
+ * Nevertheless we should reimplement it at some point because
+ * outside callers might require it, and it's a good idea in general.
+ *)
+
+ (* Guess the appliance device name if we didn't find a matching hint. *)
+ let i = drive_index disk in
+ if i >= 0 && i < Array.length devices then (
+ let dev = Array.get devices i in
+ let dev = dev ^ string_of_int part in
+ if is_block_device dev then
+ Mountable.of_device dev
+ else
+ default
+ )
+ else
+ default
+
+(* disk: (cciss/c\d+d\d+)
+ * part: (\d+)?
+ *)
+and resolve_cciss disk part default =
+ (* XXX Check any hints we were passed for a non-heuristic mapping.
+ * The C code used hints here to map device names as known by
+ * the library user (eg. from metadata) to libguestfs devices here.
+ * However none of the libguestfs tools ever used this feature.
+ * Nevertheless we should reimplement it at some point because
+ * outside callers might require it, and it's a good idea in general.
+ *)
+
+ (* We don't try to guess mappings for cciss devices. *)
+ default
+
+(* For /dev/disk/by-id there is a limit to what we can do because
+ * original SCSI ID information has likely been lost. This
+ * heuristic will only work for guests that have a single block
+ * device.
+ *
+ * So the main task here is to make sure the assumptions above are
+ * true.
+ *
+ * XXX Use hints from virt-p2v if available.
+ * See also:
https://bugzilla.redhat.com/show_bug.cgi?id=836573#c3
+ *)
+and resolve_diskbyid part default =
+ let nr_devices = Devsparts.nr_devices () in
+
+ (* If #devices isn't 1, give up trying to translate this fstab entry. *)
+ if nr_devices <> 1 then
+ default
+ else (
+ (* Make the partition name and check it exists. *)
+ let dev = sprintf "/dev/sda%d" part in
+ if is_block_device dev then Mountable.of_device dev
+ else default
+ )
diff --git a/daemon/inspect_fs_unix_fstab.mli b/daemon/inspect_fs_unix_fstab.mli
new file mode 100644
index 000000000..3ce3aef05
--- /dev/null
+++ b/daemon/inspect_fs_unix_fstab.mli
@@ -0,0 +1,34 @@
+(* guestfs-inspection
+ * Copyright (C) 2009-2017 Red Hat Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *)
+
+val check_fstab : ?mdadm_conf:bool -> Mountable.t -> Inspect_types.os_type ->
+ (Mountable.t * string) list
+(** [check_fstab] examines the [/etc/fstab] file of a mounted root
+ filesystem, returning the list of devices and their mount points.
+ Various devices (like CD-ROMs) are ignored in the process, and
+ this function also knows how to map (eg) BSD device names into
+ Linux/libguestfs device names.
+
+ [mdadm_conf] is true if you want to check [/etc/mdadm.conf] as well.
+
+ [root_mountable] is the [Mountable.t] of the root filesystem. (Note
+ that the root filesystem must be mounted on sysroot before this
+ function is called.)
+
+ [os_type] is the presumed operating system type of this root, and
+ is used to make some adjustments to fstab parsing. *)
diff --git a/daemon/inspect_fs_windows.ml b/daemon/inspect_fs_windows.ml
new file mode 100644
index 000000000..bb949be47
--- /dev/null
+++ b/daemon/inspect_fs_windows.ml
@@ -0,0 +1,498 @@
+(* guestfs-inspection
+ * Copyright (C) 2009-2017 Red Hat Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *)
+
+open Printf
+
+open Std_utils
+
+open Utils
+open Inspect_types
+open Inspect_utils
+
+(* Check a predefined list of common windows system root locations. *)
+let systemroot_paths =
+ [ "/windows"; "/winnt"; "/win32"; "/win";
"/reactos" ]
+
+let re_boot_ini_os =
+ Str.regexp
"^\\(multi|scsi\\)(\\([0-9]+\\))disk(\\([0-9]+\\))rdisk(\\([0-9]+\\))partition(\\([0-9]+\\))\\([^=]+\\)="
+
+let rec check_windows_root data =
+ let systemroot =
+ match get_windows_systemroot () with
+ | None -> assert false (* Should never happen - see caller. *)
+ | Some systemroot -> systemroot in
+
+ let data = {
+ data with os_type = Some OS_TYPE_WINDOWS;
+ distro = Some DISTRO_WINDOWS;
+ windows_systemroot = Some systemroot;
+ arch = Some (check_windows_arch systemroot)
+ } in
+
+ (* Load further fields from the Windows registry. *)
+ check_windows_registry systemroot data
+
+and is_windows_systemroot () =
+ get_windows_systemroot () <> None
+
+and get_windows_systemroot () =
+ let rec loop = function
+ | [] -> None
+ | path :: paths ->
+ let path = case_sensitive_path_silently path in
+ match path with
+ | None -> loop paths
+ | Some path ->
+ if is_systemroot path then Some path
+ else loop paths
+ in
+ let systemroot = loop systemroot_paths in
+
+ let systemroot =
+ match systemroot with
+ | Some systemroot -> Some systemroot
+ | None ->
+ (* If the fs contains boot.ini, check it for non-standard
+ * systemroot locations.
+ *)
+ let boot_ini_path = case_sensitive_path_silently "/boot.ini" in
+ match boot_ini_path with
+ | None -> None
+ | Some boot_ini_path ->
+ get_windows_systemroot_from_boot_ini boot_ini_path in
+
+ match systemroot with
+ | None -> None
+ | Some systemroot ->
+ if verbose () then
+ eprintf "get_windows_systemroot: windows %%SYSTEMROOT%% = %s\n%!"
+ systemroot;
+ Some systemroot
+
+and get_windows_systemroot_from_boot_ini boot_ini_path =
+ let chroot =
+ Chroot.create ~name:"get_windows_systemroot_from_boot_ini"
+ (Sysroot.sysroot ()) in
+ let lines =
+ Chroot.f chroot (
+ fun () ->
+ if not (is_small_file boot_ini_path) then (
+ eprintf "%s: not a regular file or too large\n" boot_ini_path;
+ None
+ )
+ else
+ Some (read_whole_file boot_ini_path)
+ ) () in
+ match lines with
+ | None -> None
+ | Some lines ->
+ let lines = String.nsplit "\n" lines in
+
+ (* Find:
+ * [operating systems]
+ * followed by multiple lines starting with "multi" or "scsi".
+ *)
+ let rec loop = function
+ | [] -> None
+ | str :: rest when String.is_prefix str "[operating systems]" ->
+ let rec loop2 = function
+ | [] -> []
+ | str :: rest when String.is_prefix str "multi(" ||
+ String.is_prefix str "scsi(" ->
+ str :: loop2 rest
+ | _ -> []
+ in
+ Some (loop2 rest)
+ | _ :: rest -> loop rest
+ in
+ match loop lines with
+ | None -> None
+ | Some oses ->
+ (* Rewrite multi|scsi lines, removing any which we cannot parse. *)
+ let oses =
+ filter_map (
+ fun line ->
+ if Str.string_match re_boot_ini_os line 0 then (
+ let ctrlr_type = Str.matched_group 1 line
+ and ctrlr = int_of_string (Str.matched_group 2 line)
+ and disk = int_of_string (Str.matched_group 3 line)
+ and rdisk = int_of_string (Str.matched_group 4 line)
+ and part = int_of_string (Str.matched_group 5 line)
+ and path = Str.matched_group 6 line in
+
+ (* Swap backslashes for forward slashes in the
+ * system root path.
+ *)
+ let path = String.replace_char path '\\' '/' in
+
+ Some (ctrlr_type, ctrlr, disk, rdisk, part, path)
+ )
+ else None
+ ) oses in
+
+ (* The Windows system root may be on any disk. However, there
+ * are currently (at least) 2 practical problems preventing us
+ * from locating it on another disk:
+ *
+ * 1. We don't have enough metadata about the disks we were
+ * given to know if what controller they were on and what
+ * index they had.
+ *
+ * 2. The way inspection of filesystems currently works, we
+ * can't mark another filesystem, which we may have already
+ * inspected, to be inspected for a specific Windows system
+ * root.
+ *
+ * Solving 1 properly would require a new API at a minimum. We
+ * might be able to fudge something practical without this,
+ * though, e.g. by looking at the <partition>th partition of
+ * every disk for the specific windows root.
+ *
+ * Solving 2 would probably require a significant refactoring
+ * of the way filesystems are inspected. We should probably do
+ * this some time.
+ *
+ * For the moment, we ignore all partition information and
+ * assume the system root is on the current partition. In
+ * practice, this will normally be correct.
+ *)
+
+ let rec loop = function
+ | [] -> None
+ | (_, _, _, _, _, path) :: rest ->
+ if is_systemroot path then Some path
+ else loop rest
+ in
+ loop oses
+
+(* Try to find Windows systemroot using some common locations.
+ *
+ * Notes:
+ *
+ * (1) We check for some directories inside to see if it is a real
+ * systemroot, and not just a directory that happens to have the same
+ * name.
+ *
+ * (2) If a Windows guest has multiple disks and applications are
+ * installed on those other disks, then those other disks will contain
+ * "/Program Files" and "/System Volume Information". Those would
+ * *not* be Windows root disks. (RHBZ#674130)
+ *)
+and is_systemroot systemroot =
+ is_dir_nocase (systemroot ^ "/system32") &&
+ is_dir_nocase (systemroot ^ "/system32/config") &&
+ is_file_nocase (systemroot ^ "/system32/cmd.exe")
+
+(* Return the architecture of the guest from cmd.exe. *)
+and check_windows_arch systemroot =
+ let cmd_exe = sprintf "%s/system32/cmd.exe" systemroot in
+
+ (* Should exist because of previous check above in is_systemroot. *)
+ let cmd_exe = Realpath.case_sensitive_path cmd_exe in
+
+ Filearch.file_architecture cmd_exe
+
+(* Read further fields from the Windows registry. *)
+and check_windows_registry systemroot data =
+ (* We know (from is_systemroot) that the config directory exists. *)
+ let software_hive = sprintf "%s/system32/config/software" systemroot in
+ let software_hive = Realpath.case_sensitive_path software_hive in
+ let software_hive =
+ if Is.is_file software_hive then Some software_hive else None in
+ let data = { data with windows_software_hive = software_hive } in
+
+ let system_hive = sprintf "%s/system32/config/system" systemroot in
+ let system_hive = Realpath.case_sensitive_path system_hive in
+ let system_hive =
+ if Is.is_file system_hive then Some system_hive else None in
+ let data = { data with windows_system_hive = system_hive } in
+
+ match software_hive, system_hive with
+ | None, _ | Some _, None -> data
+ | Some software_hive, Some system_hive ->
+ (* Check software hive. *)
+ let data = check_windows_software_registry software_hive data in
+
+ (* Check system hive. *)
+ let data = check_windows_system_registry system_hive data in
+
+ data
+
+(* At the moment, pull just the ProductName and version numbers from
+ * the registry. In future there is a case for making many more
+ * registry fields available to callers.
+ *)
+and check_windows_software_registry software_hive data =
+ with_hive (Sysroot.sysroot () // software_hive) (
+ fun h root ->
+ try
+ let path = [ "Microsoft"; "Windows NT";
"CurrentVersion" ] in
+ let node = get_node h root path in
+ let values = Hivex.node_values h node in
+ let values = Array.to_list values in
+ (* Convert to a list of (key, value) to make the following easier. *)
+ let values = List.map (fun v -> Hivex.value_key h v, v) values in
+
+ (* Look for ProductName key. *)
+ let data =
+ try
+ let v = List.assoc "ProductName" values in
+ { data with product_name = Some (hivex_value_as_utf8 h v) }
+ with
+ Not_found -> data in
+
+ (* Version is complicated. Use CurrentMajorVersionNumber and
+ * CurrentMinorVersionNumber if present. If they are not
+ * found, fall back on CurrentVersion.
+ *)
+ let data =
+ try
+ let major_v = List.assoc "CurrentMajorVersionNumber" values
+ and minor_v = List.assoc "CurrentMinorVersionNumber" values in
+ let major = Int32.to_int (Hivex.value_dword h major_v)
+ and minor = Int32.to_int (Hivex.value_dword h minor_v) in
+ { data with version = Some (major, minor) }
+ with
+ Not_found ->
+ let v = List.assoc "CurrentVersion" values in
+ let v = hivex_value_as_utf8 h v in
+ parse_version_from_major_minor v data in
+
+ (* InstallationType (product_variant). *)
+ let data =
+ try
+ let v = List.assoc "InstallationType" values in
+ { data with product_variant = Some (hivex_value_as_utf8 h v) }
+ with
+ Not_found -> data in
+
+ data
+ with
+ | Not_found ->
+ if verbose () then
+ eprintf "check_windows_software_registry: cannot locate
HKLM\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\n%!";
+ data
+ ) (* with_hive *)
+
+and check_windows_system_registry system_hive data =
+ with_hive (Sysroot.sysroot () // system_hive) (
+ fun h root ->
+ let data = get_drive_mappings h root data in
+
+ let current_control_set = get_current_control_set h root in
+ let data =
+ { data with windows_current_control_set = current_control_set } in
+
+ match current_control_set with
+ | None -> data
+ | Some current_control_set ->
+ let hostname = get_hostname h root current_control_set in
+ let data = { data with hostname = hostname } in
+ data
+ ) (* with_hive *)
+
+(* Get the CurrentControlSet. *)
+and get_current_control_set h root =
+ try
+ let path = [ "Select" ] in
+ let node = get_node h root path in
+ let current_v = Hivex.node_get_value h node "Current" in
+ let current_control_set =
+ sprintf "ControlSet%03ld" (Hivex.value_dword h current_v) in
+ Some current_control_set
+ with
+ | Not_found ->
+ if verbose () then
+ eprintf "check_windows_system_registry: cannot locate
HKLM\\SYSTEM\\Select\n%!";
+ None
+
+(* Get the drive mappings.
+ * This page explains the contents of HKLM\System\MountedDevices:
+ *
http://www.goodells.net/multiboot/partsigs.shtml
+ *)
+and get_drive_mappings h root data =
+ let devices = lazy (Devsparts.list_devices ()) in
+ let partitions = lazy (Devsparts.list_partitions ()) in
+ try
+ let path = [ "MountedDevices" ] in
+ let node = get_node h root path in
+ let values = Hivex.node_values h node in
+ let values = Array.to_list values in
+ let values =
+ filter_map (
+ fun value ->
+ let key = Hivex.value_key h value in
+ let keylen = String.length key in
+ if keylen >= 14 &&
+ String.lowercase_ascii (String.sub key 0 12) = "\\dosdevices\\"
&&
+ Char.isalpha key.[12] && key.[13] = ':' then (
+ let drive_letter = String.sub key 12 1 in
+
+ (* Get the binary value. Is it a fixed disk? *)
+ let (typ, blob) = Hivex.value_value h value in
+ let device =
+ if typ = Hivex.REG_BINARY then (
+ if String.length blob >= 24 &&
+ String.is_prefix blob "DMIO:ID:" (* GPT *) then
+ map_registry_disk_blob_gpt (Lazy.force partitions) blob
+ else if String.length blob = 12 then
+ map_registry_disk_blob (Lazy.force devices) blob
+ else
+ None
+ )
+ else None in
+
+ match device with
+ | None -> None
+ | Some device -> Some (drive_letter, device)
+ )
+ else
+ None
+ ) values in
+
+ { data with drive_mappings = values }
+
+ with
+ | Not_found ->
+ if verbose () then
+ eprintf "check_windows_system_registry: cannot find drive
mappings\n%!";
+ data
+
+(* Windows Registry HKLM\SYSTEM\MountedDevices uses a blob of data
+ * to store partitions. This blob is described here:
+ *
http://www.goodells.net/multiboot/partsigs.shtml
+ * The following function maps this blob to a libguestfs partition
+ * name, if possible.
+ *)
+and map_registry_disk_blob devices blob =
+ try
+ (* First 4 bytes are the disk ID. Search all devices to find the
+ * disk with this disk ID.
+ *)
+ let diskid = String.sub blob 0 4 in
+ let device = List.find (fun dev -> pread dev 4 0x01b8 = diskid) devices in
+
+ (* Next 8 bytes are the offset of the partition in bytes(!) given as
+ * a 64 bit little endian number. Luckily it's easy to get the
+ * partition byte offset from Parted.part_list.
+ *)
+ let offset = String.sub blob 4 8 in
+ let offset = int_of_le64 offset in
+ let partitions = Parted.part_list device in
+ let partition =
+ List.find (fun { Parted.part_start = s } -> s = offset) partitions in
+
+ (* Construct the full device name. *)
+ Some (sprintf "%s%ld" device partition.Parted.part_num)
+ with
+ | Not_found -> None
+
+(* Matches Windows registry HKLM\SYSYTEM\MountedDevices\DosDevices blob to
+ * to libguestfs GPT partition device. For GPT disks, the blob is made of
+ * "DMIO:ID:" prefix followed by the GPT partition GUID.
+ *)
+and map_registry_disk_blob_gpt partitions blob =
+ let blob_guid =
+ String.lowercase_ascii (extract_guid_from_registry_blob blob) in
+
+ try
+ let partition =
+ List.find (
+ fun part ->
+ let partnum = Devsparts.part_to_partnum part in
+ let device = Devsparts.part_to_dev part in
+ let typ = Parted.part_get_parttype device in
+ if typ <> "gpt" then false
+ else (
+ let guid = Parted.part_get_gpt_guid device partnum in
+ String.lowercase_ascii guid = blob_guid
+ )
+ ) partitions in
+ Some partition
+ with
+ | Not_found -> None
+
+(* Extracts the binary GUID stored in blob from Windows registry
+ * HKLM\SYSTYEM\MountedDevices\DosDevices value and converts it to a
+ * GUID string so that it can be matched against libguestfs partition
+ * device GPT GUID.
+ *)
+and extract_guid_from_registry_blob blob =
+ (* Copy relevant sections from blob to respective ints.
+ * Note we have to skip 8 byte "DMIO:ID:" prefix.
+ *)
+ let data1 = int_of_le32 (String.sub blob 8 4)
+ and data2 = int_of_le16 (String.sub blob 12 2)
+ and data3 = int_of_le16 (String.sub blob 14 2)
+ and data4 = int_of_be64 (String.sub blob 16 8) (* really big endian! *) in
+
+ sprintf "%08Lx-%04Lx-%04Lx-%04Lx-%012Lx"
+ data1 data2 data3
+ (Int64.shift_right data4 48)
+ (data4 &^ 0xffffffffffff_L)
+
+and pread device size offset =
+ let fd = Unix.openfile device [Unix.O_RDONLY; Unix.O_CLOEXEC] 0 in
+ let ret =
+ protect ~f:(
+ fun () ->
+ ignore (Unix.lseek fd offset Unix.SEEK_SET);
+ let ret = Bytes.create size in
+ if Unix.read fd ret 0 size < size then
+ failwithf "pread: %s: short read" device;
+ ret
+ ) ~finally:(fun () -> Unix.close fd) in
+ Bytes.to_string ret
+
+(* Get the hostname. *)
+and get_hostname h root current_control_set =
+ try
+ let path = [ current_control_set; "Services"; "Tcpip";
"Parameters" ] in
+ let node = get_node h root path in
+ let values = Hivex.node_values h node in
+ let values = Array.to_list values in
+ (* Convert to a list of (key, value) to make the following easier. *)
+ let values = List.map (fun v -> Hivex.value_key h v, v) values in
+ let hostname_v = List.assoc "Hostname" values in
+ Some (hivex_value_as_utf8 h hostname_v)
+ with
+ | Not_found ->
+ if verbose () then
+ eprintf "check_windows_system_registry: cannot locate
HKLM\\SYSTEM\\%s\\Services\\Tcpip\\Parameters and/or Hostname key\n%!"
current_control_set;
+ None
+
+(* Raises [Not_found] if the node is not found. *)
+and get_node h node = function
+ | [] -> node
+ | x :: xs ->
+ let node = Hivex.node_get_child h node x in
+ get_node h node xs
+
+(* NB: This function DOES NOT test for the existence of the file. It
+ * will return non-NULL even if the file/directory does not exist.
+ * You have to call guestfs_is_file{,_opts} etc.
+ *)
+and case_sensitive_path_silently path =
+ try
+ Some (Realpath.case_sensitive_path path)
+ with
+ | exn ->
+ if verbose () then
+ eprintf "case_sensitive_path_silently: %s: %s\n%!" path
+ (Printexc.to_string exn);
+ None
diff --git a/daemon/inspect_fs_windows.mli b/daemon/inspect_fs_windows.mli
new file mode 100644
index 000000000..936d695c6
--- /dev/null
+++ b/daemon/inspect_fs_windows.mli
@@ -0,0 +1,25 @@
+(* guestfs-inspection
+ * Copyright (C) 2009-2017 Red Hat Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *)
+
+val check_windows_root : Inspect_types.inspection_data ->
+ Inspect_types.inspection_data
+(** Inspect the Windows [C:] filesystem mounted on sysroot. *)
+
+val is_windows_systemroot : unit -> bool
+(** Decide if the filesystem mounted on sysroot looks like a
+ Windows [C:] filesystem. *)
diff --git a/daemon/inspect_types.ml b/daemon/inspect_types.ml
new file mode 100644
index 000000000..f0fa52447
--- /dev/null
+++ b/daemon/inspect_types.ml
@@ -0,0 +1,325 @@
+(* guestfs-inspection
+ * Copyright (C) 2009-2017 Red Hat Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *)
+
+open Printf
+
+open Std_utils
+
+type fs = {
+ fs_location : location;
+ role : role; (** Special cases: root filesystem or /usr *)
+}
+and root = {
+ root_location : location;
+ inspection_data : inspection_data;
+}
+and location = {
+ mountable : Mountable.t; (** The device name or other mountable object.*)
+ vfs_type : string; (** Returned from [vfs_type] API. *)
+}
+
+and role =
+ | RoleRoot of inspection_data
+ | RoleUsr of inspection_data
+ | RoleSwap
+ | RoleOther
+and inspection_data = {
+ format : format option;
+ os_type : os_type option;
+ distro : distro option;
+ package_format : package_format option;
+ package_management : package_management option;
+ product_name : string option;
+ product_variant : string option;
+ version : version option;
+ arch : string option;
+ hostname : string option;
+ fstab : fstab_entry list;
+ windows_systemroot : string option;
+ windows_software_hive : string option;
+ windows_system_hive : string option;
+ windows_current_control_set : string option;
+ drive_mappings : drive_mapping list;
+ is_live_disk : bool;
+ is_netinst_disk : bool;
+ is_multipart_disk : bool;
+}
+and format =
+ | FORMAT_INSTALLED
+ | FORMAT_INSTALLER
+ (* in future: supplemental install disks *)
+and os_type =
+ | OS_TYPE_DOS
+ | OS_TYPE_FREEBSD
+ | OS_TYPE_HURD
+ | OS_TYPE_LINUX
+ | OS_TYPE_MINIX
+ | OS_TYPE_NETBSD
+ | OS_TYPE_OPENBSD
+ | OS_TYPE_WINDOWS
+and distro =
+ | DISTRO_ALPINE_LINUX
+ | DISTRO_ALTLINUX
+ | DISTRO_ARCHLINUX
+ | DISTRO_BUILDROOT
+ | DISTRO_CENTOS
+ | DISTRO_CIRROS
+ | DISTRO_COREOS
+ | DISTRO_DEBIAN
+ | DISTRO_FEDORA
+ | DISTRO_FREEBSD
+ | DISTRO_FREEDOS
+ | DISTRO_FRUGALWARE
+ | DISTRO_GENTOO
+ | DISTRO_LINUX_MINT
+ | DISTRO_MAGEIA
+ | DISTRO_MANDRIVA
+ | DISTRO_MEEGO
+ | DISTRO_NETBSD
+ | DISTRO_OPENBSD
+ | DISTRO_OPENSUSE
+ | DISTRO_ORACLE_LINUX
+ | DISTRO_PARDUS
+ | DISTRO_PLD_LINUX
+ | DISTRO_REDHAT_BASED
+ | DISTRO_RHEL
+ | DISTRO_SCIENTIFIC_LINUX
+ | DISTRO_SLACKWARE
+ | DISTRO_SLES
+ | DISTRO_SUSE_BASED
+ | DISTRO_TTYLINUX
+ | DISTRO_UBUNTU
+ | DISTRO_VOID_LINUX
+ | DISTRO_WINDOWS
+and package_format =
+ | PACKAGE_FORMAT_APK
+ | PACKAGE_FORMAT_DEB
+ | PACKAGE_FORMAT_EBUILD
+ | PACKAGE_FORMAT_PACMAN
+ | PACKAGE_FORMAT_PISI
+ | PACKAGE_FORMAT_PKGSRC
+ | PACKAGE_FORMAT_RPM
+ | PACKAGE_FORMAT_XBPS
+and package_management =
+ | PACKAGE_MANAGEMENT_APK
+ | PACKAGE_MANAGEMENT_APT
+ | PACKAGE_MANAGEMENT_DNF
+ | PACKAGE_MANAGEMENT_PACMAN
+ | PACKAGE_MANAGEMENT_PISI
+ | PACKAGE_MANAGEMENT_PORTAGE
+ | PACKAGE_MANAGEMENT_UP2DATE
+ | PACKAGE_MANAGEMENT_URPMI
+ | PACKAGE_MANAGEMENT_XBPS
+ | PACKAGE_MANAGEMENT_YUM
+ | PACKAGE_MANAGEMENT_ZYPPER
+and version = int * int
+and fstab_entry = Mountable.t * string (* mountable, mountpoint *)
+and drive_mapping = string * string (* drive name, device *)
+
+let rec string_of_fs { fs_location = location; role = role } =
+ sprintf "fs: %s role: %s"
+ (string_of_location location)
+ (match role with
+ | RoleRoot _ -> "root"
+ | RoleUsr _ -> "usr"
+ | RoleSwap -> "swap"
+ | RoleOther -> "other")
+
+and string_of_location { mountable = mountable; vfs_type = vfs_type } =
+ sprintf "%s (%s)" (Mountable.to_string mountable) vfs_type
+
+and string_of_root { root_location = location;
+ inspection_data = inspection_data } =
+ sprintf "%s:\n%s"
+ (string_of_location location)
+ (string_of_inspection_data inspection_data)
+
+and string_of_inspection_data data =
+ let b = Buffer.create 1024 in
+ let bpf fs = bprintf b fs in
+ may (fun v -> bpf "\tformat: %s\n" (string_of_format v))
+ data.format;
+ may (fun v -> bpf "\ttype: %s\n" (string_of_os_type v))
+ data.os_type;
+ may (fun v -> bpf "\tdistro: %s\n" (string_of_distro v))
+ data.distro;
+ may (fun v -> bpf "\tpackage_format: %s\n" (string_of_package_format v))
+ data.package_format;
+ may (fun v -> bpf "\tpackage_management: %s\n"
(string_of_package_management v))
+ data.package_management;
+ may (fun v -> bpf "\tproduct_name: %s\n" v)
+ data.product_name;
+ may (fun v -> bpf "\tproduct_variant: %s\n" v)
+ data.product_variant;
+ may (fun (major, minor) -> bpf "\tversion: %d.%d\n" major minor)
+ data.version;
+ may (fun v -> bpf "\tarch: %s\n" v)
+ data.arch;
+ may (fun v -> bpf "\thostname: %s\n" v)
+ data.hostname;
+ if data.fstab <> [] then (
+ let v = List.map (
+ fun (a, b) -> sprintf "(%s, %s)" (Mountable.to_string a) b
+ ) data.fstab in
+ bpf "\tfstab: [%s]\n" (String.concat ", " v)
+ );
+ may (fun v -> bpf "\twindows_systemroot: %s\n" v)
+ data.windows_systemroot;
+ may (fun v -> bpf "\twindows_software_hive: %s\n" v)
+ data.windows_software_hive;
+ may (fun v -> bpf "\twindows_system_hive: %s\n" v)
+ data.windows_system_hive;
+ may (fun v -> bpf "\twindows_current_control_set: %s\n" v)
+ data.windows_current_control_set;
+ if data.drive_mappings <> [] then (
+ let v =
+ List.map (fun (a, b) -> sprintf "(%s, %s)" a b) data.drive_mappings
in
+ bpf "\tdrive_mappings: [%s]\n" (String.concat ", " v)
+ );
+ bpf "\tis_live_disk: %b\n" data.is_live_disk;
+ bpf "\tis_netinst_disk: %b\n" data.is_netinst_disk;
+ bpf "\tis_multipart_disk: %b\n" data.is_multipart_disk;
+ Buffer.contents b
+
+and string_of_format = function
+ | FORMAT_INSTALLED -> "installed"
+ | FORMAT_INSTALLER -> "installer"
+
+and string_of_os_type = function
+ | OS_TYPE_DOS -> "dos"
+ | OS_TYPE_FREEBSD -> "freebsd"
+ | OS_TYPE_HURD -> "hurd"
+ | OS_TYPE_LINUX -> "linux"
+ | OS_TYPE_MINIX -> "minix"
+ | OS_TYPE_NETBSD -> "netbsd"
+ | OS_TYPE_OPENBSD -> "openbsd"
+ | OS_TYPE_WINDOWS -> "windows"
+
+and string_of_distro = function
+ | DISTRO_ALPINE_LINUX -> "alpinelinux"
+ | DISTRO_ALTLINUX -> "altlinux"
+ | DISTRO_ARCHLINUX -> "archlinux"
+ | DISTRO_BUILDROOT -> "buildroot"
+ | DISTRO_CENTOS -> "centos"
+ | DISTRO_CIRROS -> "cirros"
+ | DISTRO_COREOS -> "coreos"
+ | DISTRO_DEBIAN -> "debian"
+ | DISTRO_FEDORA -> "fedora"
+ | DISTRO_FREEBSD -> "freebsd"
+ | DISTRO_FREEDOS -> "freedos"
+ | DISTRO_FRUGALWARE -> "frugalware"
+ | DISTRO_GENTOO -> "gentoo"
+ | DISTRO_LINUX_MINT -> "linuxmint"
+ | DISTRO_MAGEIA -> "mageia"
+ | DISTRO_MANDRIVA -> "mandriva"
+ | DISTRO_MEEGO -> "meego"
+ | DISTRO_NETBSD -> "netbsd"
+ | DISTRO_OPENBSD -> "openbsd"
+ | DISTRO_OPENSUSE -> "opensuse"
+ | DISTRO_ORACLE_LINUX -> "oraclelinux"
+ | DISTRO_PARDUS -> "pardus"
+ | DISTRO_PLD_LINUX -> "pldlinux"
+ | DISTRO_REDHAT_BASED -> "redhat-based"
+ | DISTRO_RHEL -> "rhel"
+ | DISTRO_SCIENTIFIC_LINUX -> "scientificlinux"
+ | DISTRO_SLACKWARE -> "slackware"
+ | DISTRO_SLES -> "sles"
+ | DISTRO_SUSE_BASED -> "suse-based"
+ | DISTRO_TTYLINUX -> "ttylinux"
+ | DISTRO_UBUNTU -> "ubuntu"
+ | DISTRO_VOID_LINUX -> "voidlinux"
+ | DISTRO_WINDOWS -> "windows"
+
+and string_of_package_format = function
+ | PACKAGE_FORMAT_APK -> "apk"
+ | PACKAGE_FORMAT_DEB -> "deb"
+ | PACKAGE_FORMAT_EBUILD -> "ebuild"
+ | PACKAGE_FORMAT_PACMAN -> "pacman"
+ | PACKAGE_FORMAT_PISI -> "pisi"
+ | PACKAGE_FORMAT_PKGSRC -> "pkgsrc"
+ | PACKAGE_FORMAT_RPM -> "rpm"
+ | PACKAGE_FORMAT_XBPS -> "xbps"
+
+and string_of_package_management = function
+ | PACKAGE_MANAGEMENT_APK -> "apk"
+ | PACKAGE_MANAGEMENT_APT -> "apt"
+ | PACKAGE_MANAGEMENT_DNF -> "dnf"
+ | PACKAGE_MANAGEMENT_PACMAN -> "pacman"
+ | PACKAGE_MANAGEMENT_PISI -> "pisi"
+ | PACKAGE_MANAGEMENT_PORTAGE -> "portage"
+ | PACKAGE_MANAGEMENT_UP2DATE -> "up2date"
+ | PACKAGE_MANAGEMENT_URPMI -> "urpmi"
+ | PACKAGE_MANAGEMENT_XBPS -> "xbps"
+ | PACKAGE_MANAGEMENT_YUM -> "yum"
+ | PACKAGE_MANAGEMENT_ZYPPER -> "zypper"
+
+let null_inspection_data = {
+ format = None;
+ os_type = None;
+ distro = None;
+ package_format = None;
+ package_management = None;
+ product_name = None;
+ product_variant = None;
+ version = None;
+ arch = None;
+ hostname = None;
+ fstab = [];
+ windows_systemroot = None;
+ windows_software_hive = None;
+ windows_system_hive = None;
+ windows_current_control_set = None;
+ drive_mappings = [];
+ is_live_disk = false;
+ is_netinst_disk = false;
+ is_multipart_disk = false;
+}
+
+let merge_inspection_data child parent =
+ let merge child parent = if parent = None then child else parent in
+
+ { format = merge child.format parent.format;
+ os_type = merge child.os_type parent.os_type;
+ distro = merge child.distro parent.distro;
+ package_format = merge child.package_format parent.package_format;
+ package_management =
+ merge child.package_management parent.package_management;
+ product_name = merge child.product_name parent.product_name;
+ product_variant = merge child.product_variant parent.product_variant;
+ version = merge child.version parent.version;
+ arch = merge child.arch parent.arch;
+ hostname = merge child.hostname parent.hostname;
+ fstab = child.fstab @ parent.fstab;
+ windows_systemroot =
+ merge child.windows_systemroot parent.windows_systemroot;
+ windows_software_hive =
+ merge child.windows_software_hive parent.windows_software_hive;
+ windows_system_hive =
+ merge child.windows_system_hive parent.windows_system_hive;
+ windows_current_control_set =
+ merge child.windows_current_control_set parent.windows_current_control_set;
+
+ (* This is what the old C code did, but I doubt that it's correct. *)
+ drive_mappings = child.drive_mappings @ parent.drive_mappings;
+
+ is_live_disk = child.is_live_disk || parent.is_live_disk;
+ is_netinst_disk = child.is_netinst_disk || parent.is_netinst_disk;
+ is_multipart_disk = child.is_multipart_disk || parent.is_multipart_disk;
+ }
+
+let inspect_fses = ref []
diff --git a/daemon/inspect_types.mli b/daemon/inspect_types.mli
new file mode 100644
index 000000000..99bffea6f
--- /dev/null
+++ b/daemon/inspect_types.mli
@@ -0,0 +1,175 @@
+(* guestfs-inspection
+ * Copyright (C) 2009-2017 Red Hat Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *)
+
+type fs = {
+ fs_location : location;
+ role : role; (** Special cases: root filesystem or /usr *)
+}
+and root = {
+ root_location : location;
+ inspection_data : inspection_data;
+}
+and location = {
+ mountable : Mountable.t; (** The device name or other mountable object.*)
+ vfs_type : string; (** Returned from [vfs_type] API. *)
+}
+
+and role =
+ | RoleRoot of inspection_data
+ | RoleUsr of inspection_data
+ | RoleSwap
+ | RoleOther
+and inspection_data = {
+ format : format option;
+ os_type : os_type option;
+ distro : distro option;
+ package_format : package_format option;
+ package_management : package_management option;
+ product_name : string option;
+ product_variant : string option;
+ version : version option;
+ arch : string option;
+ hostname : string option;
+ fstab : fstab_entry list;
+ windows_systemroot : string option;
+ windows_software_hive : string option;
+ windows_system_hive : string option;
+ windows_current_control_set : string option;
+ drive_mappings : drive_mapping list;
+ is_live_disk : bool;
+ is_netinst_disk : bool;
+ is_multipart_disk : bool;
+}
+and format =
+ | FORMAT_INSTALLED
+ | FORMAT_INSTALLER
+ (* in future: supplemental install disks *)
+and os_type =
+ | OS_TYPE_DOS
+ | OS_TYPE_FREEBSD
+ | OS_TYPE_HURD
+ | OS_TYPE_LINUX
+ | OS_TYPE_MINIX
+ | OS_TYPE_NETBSD
+ | OS_TYPE_OPENBSD
+ | OS_TYPE_WINDOWS
+and distro =
+ | DISTRO_ALPINE_LINUX
+ | DISTRO_ALTLINUX
+ | DISTRO_ARCHLINUX
+ | DISTRO_BUILDROOT
+ | DISTRO_CENTOS
+ | DISTRO_CIRROS
+ | DISTRO_COREOS
+ | DISTRO_DEBIAN
+ | DISTRO_FEDORA
+ | DISTRO_FREEBSD
+ | DISTRO_FREEDOS
+ | DISTRO_FRUGALWARE
+ | DISTRO_GENTOO
+ | DISTRO_LINUX_MINT
+ | DISTRO_MAGEIA
+ | DISTRO_MANDRIVA
+ | DISTRO_MEEGO
+ | DISTRO_NETBSD
+ | DISTRO_OPENBSD
+ | DISTRO_OPENSUSE
+ | DISTRO_ORACLE_LINUX
+ | DISTRO_PARDUS
+ | DISTRO_PLD_LINUX
+ | DISTRO_REDHAT_BASED
+ | DISTRO_RHEL
+ | DISTRO_SCIENTIFIC_LINUX
+ | DISTRO_SLACKWARE
+ | DISTRO_SLES
+ | DISTRO_SUSE_BASED
+ | DISTRO_TTYLINUX
+ | DISTRO_UBUNTU
+ | DISTRO_VOID_LINUX
+ | DISTRO_WINDOWS
+and package_format =
+ | PACKAGE_FORMAT_APK
+ | PACKAGE_FORMAT_DEB
+ | PACKAGE_FORMAT_EBUILD
+ | PACKAGE_FORMAT_PACMAN
+ | PACKAGE_FORMAT_PISI
+ | PACKAGE_FORMAT_PKGSRC
+ | PACKAGE_FORMAT_RPM
+ | PACKAGE_FORMAT_XBPS
+and package_management =
+ | PACKAGE_MANAGEMENT_APK
+ | PACKAGE_MANAGEMENT_APT
+ | PACKAGE_MANAGEMENT_DNF
+ | PACKAGE_MANAGEMENT_PACMAN
+ | PACKAGE_MANAGEMENT_PISI
+ | PACKAGE_MANAGEMENT_PORTAGE
+ | PACKAGE_MANAGEMENT_UP2DATE
+ | PACKAGE_MANAGEMENT_URPMI
+ | PACKAGE_MANAGEMENT_XBPS
+ | PACKAGE_MANAGEMENT_YUM
+ | PACKAGE_MANAGEMENT_ZYPPER
+and version = int * int
+and fstab_entry = Mountable.t * string (* mountable, mountpoint *)
+and drive_mapping = string * string (* drive name, device *)
+
+val merge_inspection_data : inspection_data -> inspection_data -> inspection_data
+(** [merge_inspection_data child parent] merges two sets of inspection
+ data into a single set. The parent inspection data fields, if
+ present, take precedence over the child inspection data fields.
+
+ It's intended that you merge upwards, ie.
+ [merge_inspection_data usr root] *)
+
+val string_of_fs : fs -> string
+(** Convert [fs] into a single line string, for debugging only. *)
+
+val string_of_root : root -> string
+(** Convert [root] into a multi-line string, for debugging only. *)
+
+val string_of_location : location -> string
+(** Convert [location] into a string, for debugging only. *)
+
+val string_of_inspection_data : inspection_data -> string
+(** Convert [inspection_data] into a multi-line string, for debugging only. *)
+
+val string_of_format : format -> string
+(** Convert [format] to a string.
+ The string is part of the public API. *)
+
+val string_of_os_type : os_type -> string
+(** Convert [os_type] to a string.
+ The string is part of the public API. *)
+
+val string_of_distro : distro -> string
+(** Convert [distro] to a string.
+ The string is part of the public API. *)
+
+val string_of_package_format : package_format -> string
+(** Convert [package_format] to a string.
+ The string is part of the public API. *)
+
+val string_of_package_management : package_management -> string
+(** Convert [package_management] to a string.
+ The string is part of the public API. *)
+
+val null_inspection_data : inspection_data
+(** {!inspection_data} structure with all fields set to [None]. *)
+
+val inspect_fses : fs list ref
+(** The global list of filesystems found by the previous call to
+ inspect_os. *)
diff --git a/daemon/inspect_utils.ml b/daemon/inspect_utils.ml
new file mode 100644
index 000000000..a75884d6b
--- /dev/null
+++ b/daemon/inspect_utils.ml
@@ -0,0 +1,162 @@
+(* guestfs-inspection
+ * Copyright (C) 2009-2017 Red Hat Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *)
+
+open Unix
+open Printf
+
+open Std_utils
+
+open Utils
+open Inspect_types
+
+let max_augeas_file_size = 100 * 1000
+
+let rec with_augeas configfiles f =
+ let sysroot = Sysroot.sysroot () in
+ let chroot = Chroot.create (Sysroot.sysroot ()) in
+
+ (* Security:
+ *
+ * The old C code had a few problems: It ignored non-regular-file
+ * objects (eg. devices), passing them to Augeas, so relying on
+ * Augeas to do the right thing. Also too-large regular files
+ * caused the whole inspection operation to fail.
+ *
+ * I have tried to improve this so that non-regular files and
+ * too large files are ignored (dropped from the configfiles list),
+ * so that Augeas won't touch them, but they also won't stop
+ * inspection.
+ *)
+ let safe_file file =
+ Is.is_file ~followsymlinks:true file && (
+ let size = (Chroot.f chroot Unix.stat file).Unix.st_size in
+ size <= max_augeas_file_size
+ )
+ in
+ let configfiles = List.filter safe_file configfiles in
+
+ let aug =
+ Augeas.create sysroot None [Augeas.AugSaveNoop; Augeas.AugNoLoad] in
+
+ protect
+ ~f:(fun () ->
+ (* Tell Augeas to only load configfiles and no other files. This
+ * prevents a rogue guest from performing a denial of service attack
+ * by having large, over-complicated configuration files which are
+ * unrelated to the task at hand. (Thanks Dominic Cleal).
+ * Note this requires Augeas >= 1.0.0 because of RHBZ#975412.
+ *)
+ let pathexpr = make_augeas_path_expression configfiles in
+ ignore (Augeas.rm aug pathexpr);
+ Augeas.load aug;
+
+ (* Check that augeas did not get a parse error for any of the
+ * configfiles, otherwise we are silently missing information.
+ *)
+ let matches = Augeas.matches aug "/augeas/files//error" in
+ List.iter (
+ fun match_ ->
+ List.iter (
+ fun file ->
+ let errorpath = sprintf "/augeas/files%s/error" file in
+ if match_ = errorpath then (
+ (* There's been an error - get the error details. *)
+ let get path =
+ match Augeas.get aug (errorpath ^ path) with
+ | None -> "<missing>"
+ | Some v -> v
+ in
+ let message = get "message" in
+ let line = get "line" in
+ let charp = get "char" in
+ failwithf "%s:%s:%s: augeas parse failure: %s"
+ file line charp message
+ )
+ ) configfiles
+ ) matches;
+
+ f aug
+ )
+ ~finally:(
+ fun () -> Augeas.close aug
+ )
+
+(* Explained here:
https://bugzilla.redhat.com/show_bug.cgi?id=975412#c0 *)
+and make_augeas_path_expression files =
+ let subexprs =
+ List.map (
+ fun file ->
+ (* v NB trailing '/' after filename *)
+ sprintf "\"%s/\" !~ regexp('^') + glob(incl) +
regexp('/.*')" file
+ ) files in
+ let subexprs = String.concat " and " subexprs in
+
+ let ret = sprintf "/augeas/load/*[ %s ]" subexprs in
+ if verbose () then
+ eprintf "augeas pathexpr = %s\n%!" ret;
+
+ ret
+
+let is_file_nocase path =
+ let path =
+ try Some (Realpath.case_sensitive_path path)
+ with _ -> None in
+ match path with
+ | None -> false
+ | Some path -> Is.is_file path
+
+and is_dir_nocase path =
+ let path =
+ try Some (Realpath.case_sensitive_path path)
+ with _ -> None in
+ match path with
+ | None -> false
+ | Some path -> Is.is_dir path
+
+let re_major_minor = Str.regexp "\\([0-9]+\\)\\.\\([0-9]+\\)"
+let re_major_no_minor = Str.regexp "\\([0-9]+\\)"
+
+let parse_version_from_major_minor str data =
+ if Str.string_match re_major_minor str 0 ||
+ Str.string_match re_major_no_minor str 0 then (
+ let major =
+ try Some (int_of_string (Str.matched_group 1 str))
+ with Not_found | Invalid_argument _ | Failure _ -> None in
+ let minor =
+ try Some (int_of_string (Str.matched_group 2 str))
+ with Not_found | Invalid_argument _ | Failure _ -> None in
+ match major, minor with
+ | None, None -> data
+ | None, Some _ -> data
+ | Some major, None -> { data with version = Some (major, 0) }
+ | Some major, Some minor -> { data with version = Some (major, minor) }
+ )
+ else (
+ eprintf "parse_version_from_major_minor: cannot parse version from ‘%s’\n"
+ str;
+ data
+ )
+
+let with_hive hive_filename f =
+ let flags = [ Hivex.OPEN_UNSAFE ] in
+ let flags = if verbose () then Hivex.OPEN_VERBOSE :: flags else flags in
+ let h = Hivex.open_file hive_filename flags in
+ protect ~f:(fun () -> f h (Hivex.root h)) ~finally:(fun () -> Hivex.close h)
+
+let hivex_value_as_utf8 h value =
+ utf16le_to_utf8 (snd (Hivex.value_value h value))
diff --git a/daemon/inspect_utils.mli b/daemon/inspect_utils.mli
new file mode 100644
index 000000000..9dd57ac09
--- /dev/null
+++ b/daemon/inspect_utils.mli
@@ -0,0 +1,48 @@
+(* guestfs-inspection
+ * Copyright (C) 2009-2017 Red Hat Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *)
+
+val with_augeas : string list -> (Augeas.t -> 'a) -> 'a
+(** Open an Augeas handle, parse only 'configfiles' (these
+ files must exist), and then call 'f' with the Augeas handle.
+
+ As a security measure, this bails if any file is too large for
+ a reasonable configuration file. After the call to 'f' the
+ Augeas handle is closed. *)
+
+val is_file_nocase : string -> bool
+val is_dir_nocase : string -> bool
+(** With a filesystem mounted under sysroot, check if [path] is
+ a file or directory under that sysroot. The [path] is
+ checked case-insensitively. *)
+
+val parse_version_from_major_minor : string -> Inspect_types.inspection_data ->
+ Inspect_types.inspection_data
+(** Make a best effort attempt to parse either X or X.Y from a string,
+ usually the product_name string. *)
+
+val with_hive : string -> (Hivex.t -> Hivex.node -> 'a) -> 'a
+(** Open a Windows registry "hive", and call the function on the
+ handle and root node.
+
+ After the call to the function, the hive is always closed.
+
+ The hive is opened readonly. *)
+
+val hivex_value_as_utf8 : Hivex.t -> Hivex.value -> string
+(** Convert a Hivex value which we interpret as UTF-16LE to UTF-8.
+ The type field stored in the registry is ignored. *)
diff --git a/daemon/mount.ml b/daemon/mount.ml
index 4bb74fb82..40c81be0e 100644
--- a/daemon/mount.ml
+++ b/daemon/mount.ml
@@ -60,3 +60,64 @@ let mount_vfs options vfs mountable mountpoint =
let mount = mount_vfs None None
let mount_ro = mount_vfs (Some "ro") None
let mount_options options = mount_vfs (Some options) None
+
+(* Unmount everything mounted under /sysroot.
+ *
+ * We have to unmount in the correct order, so we sort the paths by
+ * longest first to ensure that child paths are unmounted by parent
+ * paths.
+ *
+ * This call is more important than it appears at first, because it
+ * is widely used by both test and production code in order to
+ * get back to a known state (nothing mounted, everything synchronized).
+ *)
+let rec umount_all () =
+ (* This is called from internal_autosync and generally as a cleanup
+ * function, and since the umount will definitely fail if any
+ * handles are open, we may as well close them.
+ *)
+ (* XXX
+ aug_finalize ();
+ hivex_finalize ();
+ journal_finalize ();
+ *)
+
+ let sysroot = Sysroot.sysroot () in
+ let sysroot_len = String.length sysroot in
+
+ let info = read_whole_file "/proc/self/mountinfo" in
+ let info = String.nsplit "\n" info in
+
+ let mps = ref [] in
+ List.iter (
+ fun line ->
+ let line = String.nsplit " " line in
+ (* The field of interest is the 5th field. Whitespace is escaped
+ * with octal sequences like \040 (for space).
+ * See fs/seq_file.c:mangle_path.
+ *)
+ if List.length line >= 5 then (
+ let mp = List.nth line 4 in
+ let mp = proc_unmangle_path mp in
+
+ (* Allow a mount directory like "/sysroot" or "/sysroot/..."
*)
+ if (sysroot_len > 0 && String.is_prefix mp sysroot) ||
+ (String.is_prefix mp sysroot &&
+ String.length mp > sysroot_len &&
+ mp.[sysroot_len] = '/') then
+ push_front mp mps
+ )
+ ) info;
+
+ let mps = !mps in
+ let mps = List.sort compare_longest_first mps in
+
+ (* Unmount them. *)
+ List.iter (
+ fun mp -> ignore (command "umount" [mp])
+ ) mps
+
+and compare_longest_first s1 s2 =
+ let n1 = String.length s1 in
+ let n2 = String.length s2 in
+ n2 - n1
diff --git a/daemon/mount.mli b/daemon/mount.mli
index e43d97c42..abf538521 100644
--- a/daemon/mount.mli
+++ b/daemon/mount.mli
@@ -20,3 +20,5 @@ val mount : Mountable.t -> string -> unit
val mount_ro : Mountable.t -> string -> unit
val mount_options : string -> Mountable.t -> string -> unit
val mount_vfs : string option -> string option -> Mountable.t -> string ->
unit
+
+val umount_all : unit -> unit
diff --git a/daemon/utils.ml b/daemon/utils.ml
index 808e575fd..e53b4bf02 100644
--- a/daemon/utils.ml
+++ b/daemon/utils.ml
@@ -247,3 +247,103 @@ let proc_unmangle_path path =
let is_small_file path =
is_regular_file path &&
(stat path).st_size <= 2 * 1048 * 1024
+
+let unix_canonical_path path =
+ let is_absolute = String.length path > 0 && path.[0] = '/' in
+ let path = String.nsplit "/" path in
+ let path = List.filter ((<>) "") path in
+ (if is_absolute then "/" else "") ^ String.concat "/"
path
+
+(* Note that we cannot use iconv here because inside the appliance
+ * all i18n databases are deleted. For the same reason we cannot
+ * use functions like hivex_value_string, as they also use iconv
+ * internally.
+ *
+ *
https://en.wikipedia.org/wiki/UTF-16
+ * Also inspired by functions in glib's glib/gutf8.c
+ *)
+let rec utf16le_to_utf8 instr =
+ (* If the length is odd and the last character is ASCII NUL, just
+ * drop that. (If it's not ASCII NUL, then there's an error)
+ *)
+ let len = String.length instr in
+ let instr =
+ if len mod 1 = 1 then (
+ if instr.[len-1] = '\000' then String.sub instr 0 (len-1)
+ else invalid_arg "input is not a valid UTF16-LE string: length is odd"
+ ) else instr in
+
+ (* The length should now be even. If the last two bytes are
+ * '\0\0' then assume it's a NUL-terminated string from the
+ * Windows registry and drop both characters.
+ *)
+ let len = String.length instr in
+ let instr =
+ if len >= 2 && instr.[len-2] = '\000' && instr.[len-1] =
'\000' then
+ String.sub instr 0 (len-2)
+ else instr in
+
+ let outbuf = Buffer.create len in
+
+ (* Encode a wide character as UTF-8 and write to outbuf.
+ * Basically this is g_unichar_to_utf8 implemented in OCaml.
+ *)
+ let encode_utf8 c =
+ let first, len =
+ if c < 0x80 then
+ (0, 1)
+ else if c < 0x800 then
+ (0xc0, 2)
+ else if c < 0x10000 then
+ (0xe0, 3)
+ else if c < 0x200000 then
+ (0xf0, 4)
+ else if c < 0x4000000 then
+ (0xf8, 5)
+ else
+ (0xfc, 6) in
+ let rec loop i c =
+ if i = 0 then Buffer.add_char outbuf (Char.chr (c lor first))
+ else if i > 0 then (
+ loop (i-1) (c lsr 6);
+ Buffer.add_char outbuf (Char.chr ((c land 0x3f) lor 0x80))
+ )
+ in
+ loop (len-1) c
+ in
+
+ (* Loop over the input UTF16-LE characters. *)
+ let is_high_surrogate c = c >= 0xd800 && c < 0xdc00
+ and is_low_surrogate c = c >= 0xdc00 && c < 0xe000
+ and surrogate_value highc lowc =
+ 0x1_0000 + (highc - 0xd800) * 0x400 + lowc - 0xdc00
+ in
+
+ let len = String.length instr in
+ let rec loop i =
+ if i+1 >= len then ()
+ else (
+ let c = Char.code instr.[i] + (Char.code instr.[i+1] lsl 8) in
+
+ let wc, skip =
+ (* High surrogate - must come first. *)
+ if is_high_surrogate c then (
+ if i+3 >= len then
+ invalid_arg "input is not a valid UTF16-LE string: high surrogate at end
of string";
+ let lowc = Char.code instr.[i+2] + (Char.code instr.[i+3] lsl 8) in
+ if not (is_low_surrogate lowc) then
+ invalid_arg "input is not a valid UTF16-LE string: high surrogate not
followed by low surrogate";
+ (surrogate_value c lowc, 4)
+ )
+ else if is_low_surrogate c then
+ invalid_arg "input is not a valid UTF16-LE string: unexpected low
surrogate"
+ else
+ (c, 2) in
+
+ encode_utf8 wc;
+ loop (i+skip)
+ )
+ in
+ loop 0;
+
+ Buffer.contents outbuf
diff --git a/daemon/utils.mli b/daemon/utils.mli
index d3c8bdf4d..94a77de01 100644
--- a/daemon/utils.mli
+++ b/daemon/utils.mli
@@ -85,3 +85,15 @@ val commandr : ?flags:command_flag list -> string -> string list
-> (int * strin
val is_small_file : string -> bool
(** Return true if the path is a small regular file. *)
+
+val unix_canonical_path : string -> string
+(** Canonicalize a Unix path, so "///usr//local//" ->
"/usr/local"
+
+ The path is modified in place because the result is always
+ the same length or shorter than the argument passed. *)
+
+val utf16le_to_utf8 : string -> string
+(** Convert a UTF16-LE string to UTF-8.
+
+ This uses a simple internal implementation since we cannot use
+ iconv inside the daemon. *)
diff --git a/docs/C_SOURCE_FILES b/docs/C_SOURCE_FILES
index 02adbf73a..7fec72a62 100644
--- a/docs/C_SOURCE_FILES
+++ b/docs/C_SOURCE_FILES
@@ -65,6 +65,7 @@ customize/perl_edit-c.c
daemon/9p.c
daemon/acl.c
daemon/actions.h
+daemon/augeas-c.c
daemon/augeas.c
daemon/available.c
daemon/base64.c
@@ -308,7 +309,6 @@ lib/info.c
lib/inspect-apps.c
lib/inspect-fs-cd.c
lib/inspect-fs-unix.c
-lib/inspect-fs-windows.c
lib/inspect-fs.c
lib/inspect-icon.c
lib/inspect.c
diff --git a/generator/actions.ml b/generator/actions.ml
index 75742397a..a745f6244 100644
--- a/generator/actions.ml
+++ b/generator/actions.ml
@@ -51,6 +51,7 @@ let daemon_functions =
Actions_core_deprecated.daemon_functions @
Actions_debug.daemon_functions @
Actions_hivex.daemon_functions @
+ Actions_inspection.daemon_functions @
Actions_tsk.daemon_functions @
Actions_yara.daemon_functions
diff --git a/generator/actions_inspection.ml b/generator/actions_inspection.ml
index b7ea5a4de..93a6ed6a7 100644
--- a/generator/actions_inspection.ml
+++ b/generator/actions_inspection.ml
@@ -22,10 +22,11 @@ open Types
(* Inspection APIs. *)
-let non_daemon_functions = [
+let daemon_functions = [
{ defaults with
name = "inspect_os"; added = (1, 5, 3);
style = RStringList (RMountable, "roots"), [], [];
+ impl = OCaml "Inspect.inspect_os";
shortdesc = "inspect disk and return list of operating systems found";
longdesc = "\
This function uses other libguestfs functions and certain
@@ -61,8 +62,24 @@ Please read L<guestfs(3)/INSPECTION> for more details.
See also C<guestfs_list_filesystems>." };
{ defaults with
+ name = "inspect_get_roots"; added = (1, 7, 3);
+ style = RStringList (RMountable, "roots"), [], [];
+ impl = OCaml "Inspect.inspect_get_roots";
+ shortdesc = "return list of operating systems found by last inspection";
+ longdesc = "\
+This function is a convenient way to get the list of root
+devices, as returned from a previous call to C<guestfs_inspect_os>,
+but without redoing the whole inspection process.
+
+This returns an empty list if either no root devices were
+found or the caller has not called C<guestfs_inspect_os>.
+
+Please read L<guestfs(3)/INSPECTION> for more details." };
+
+ { defaults with
name = "inspect_get_type"; added = (1, 5, 3);
style = RString (RPlainString, "name"), [String (Mountable,
"root")], [];
+ impl = OCaml "Inspect.inspect_get_type";
shortdesc = "get type of inspected operating system";
longdesc = "\
This returns the type of the inspected operating system.
@@ -116,6 +133,7 @@ Please read L<guestfs(3)/INSPECTION> for more details." };
{ defaults with
name = "inspect_get_arch"; added = (1, 5, 3);
style = RString (RPlainString, "arch"), [String (Mountable,
"root")], [];
+ impl = OCaml "Inspect.inspect_get_arch";
shortdesc = "get architecture of inspected operating system";
longdesc = "\
This returns the architecture of the inspected operating system.
@@ -130,6 +148,7 @@ Please read L<guestfs(3)/INSPECTION> for more details." };
{ defaults with
name = "inspect_get_distro"; added = (1, 5, 3);
style = RString (RPlainString, "distro"), [String (Mountable,
"root")], [];
+ impl = OCaml "Inspect.inspect_get_distro";
shortdesc = "get distro of inspected operating system";
longdesc = "\
This returns the distro (distribution) of the inspected operating
@@ -286,6 +305,7 @@ Please read L<guestfs(3)/INSPECTION> for more details." };
{ defaults with
name = "inspect_get_major_version"; added = (1, 5, 3);
style = RInt "major", [String (Mountable, "root")], [];
+ impl = OCaml "Inspect.inspect_get_major_version";
shortdesc = "get major version of inspected operating system";
longdesc = "\
This returns the major version number of the inspected operating
@@ -305,6 +325,7 @@ Please read L<guestfs(3)/INSPECTION> for more details." };
{ defaults with
name = "inspect_get_minor_version"; added = (1, 5, 3);
style = RInt "minor", [String (Mountable, "root")], [];
+ impl = OCaml "Inspect.inspect_get_minor_version";
shortdesc = "get minor version of inspected operating system";
longdesc = "\
This returns the minor version number of the inspected operating
@@ -318,6 +339,7 @@ See also C<guestfs_inspect_get_major_version>." };
{ defaults with
name = "inspect_get_product_name"; added = (1, 5, 3);
style = RString (RPlainString, "product"), [String (Mountable,
"root")], [];
+ impl = OCaml "Inspect.inspect_get_product_name";
shortdesc = "get product name of inspected operating system";
longdesc = "\
This returns the product name of the inspected operating
@@ -331,55 +353,9 @@ string C<unknown> is returned.
Please read L<guestfs(3)/INSPECTION> for more details." };
{ defaults with
- name = "inspect_get_mountpoints"; added = (1, 5, 3);
- style = RHashtable (RPlainString, RMountable, "mountpoints"), [String
(Mountable, "root")], [];
- shortdesc = "get mountpoints of inspected operating system";
- longdesc = "\
-This returns a hash of where we think the filesystems
-associated with this operating system should be mounted.
-Callers should note that this is at best an educated guess
-made by reading configuration files such as F</etc/fstab>.
-I<In particular note> that this may return filesystems
-which are non-existent or not mountable and callers should
-be prepared to handle or ignore failures if they try to
-mount them.
-
-Each element in the returned hashtable has a key which
-is the path of the mountpoint (eg. F</boot>) and a value
-which is the filesystem that would be mounted there
-(eg. F</dev/sda1>).
-
-Non-mounted devices such as swap devices are I<not>
-returned in this list.
-
-For operating systems like Windows which still use drive
-letters, this call will only return an entry for the first
-drive \"mounted on\" F</>. For information about the
-mapping of drive letters to partitions, see
-C<guestfs_inspect_get_drive_mappings>.
-
-Please read L<guestfs(3)/INSPECTION> for more details.
-See also C<guestfs_inspect_get_filesystems>." };
-
- { defaults with
- name = "inspect_get_filesystems"; added = (1, 5, 3);
- style = RStringList (RMountable, "filesystems"), [String (Mountable,
"root")], [];
- shortdesc = "get filesystems associated with inspected operating system";
- longdesc = "\
-This returns a list of all the filesystems that we think
-are associated with this operating system. This includes
-the root filesystem, other ordinary filesystems, and
-non-mounted devices like swap partitions.
-
-In the case of a multi-boot virtual machine, it is possible
-for a filesystem to be shared between operating systems.
-
-Please read L<guestfs(3)/INSPECTION> for more details.
-See also C<guestfs_inspect_get_mountpoints>." };
-
- { defaults with
name = "inspect_get_windows_systemroot"; added = (1, 5, 25);
style = RString (RPlainString, "systemroot"), [String (Mountable,
"root")], [];
+ impl = OCaml "Inspect.inspect_get_windows_systemroot";
shortdesc = "get Windows systemroot of inspected operating system";
longdesc = "\
This returns the Windows systemroot of the inspected guest.
@@ -392,22 +368,9 @@ the case then an error is returned.
Please read L<guestfs(3)/INSPECTION> for more details." };
{ defaults with
- name = "inspect_get_roots"; added = (1, 7, 3);
- style = RStringList (RMountable, "roots"), [], [];
- shortdesc = "return list of operating systems found by last inspection";
- longdesc = "\
-This function is a convenient way to get the list of root
-devices, as returned from a previous call to C<guestfs_inspect_os>,
-but without redoing the whole inspection process.
-
-This returns an empty list if either no root devices were
-found or the caller has not called C<guestfs_inspect_os>.
-
-Please read L<guestfs(3)/INSPECTION> for more details." };
-
- { defaults with
name = "inspect_get_package_format"; added = (1, 7, 5);
style = RString (RPlainString, "packageformat"), [String (Mountable,
"root")], [];
+ impl = OCaml "Inspect.inspect_get_package_format";
shortdesc = "get package format used by the operating system";
longdesc = "\
This function and C<guestfs_inspect_get_package_management> return
@@ -430,6 +393,7 @@ Please read L<guestfs(3)/INSPECTION> for more details." };
{ defaults with
name = "inspect_get_package_management"; added = (1, 7, 5);
style = RString (RPlainString, "packagemanagement"), [String (Mountable,
"root")], [];
+ impl = OCaml "Inspect.inspect_get_package_management";
shortdesc = "get package management tool used by the operating system";
longdesc = "\
C<guestfs_inspect_get_package_format> and this function return
@@ -450,111 +414,9 @@ Future versions of libguestfs may return other strings.
Please read L<guestfs(3)/INSPECTION> for more details." };
{ defaults with
- name = "inspect_list_applications2"; added = (1, 19, 56);
- style = RStructList ("applications2", "application2"), [String
(Mountable, "root")], [];
- shortdesc = "get list of applications installed in the operating system";
- longdesc = "\
-Return the list of applications installed in the operating system.
-
-I<Note:> This call works differently from other parts of the
-inspection API. You have to call C<guestfs_inspect_os>, then
-C<guestfs_inspect_get_mountpoints>, then mount up the disks,
-before calling this. Listing applications is a significantly
-more difficult operation which requires access to the full
-filesystem. Also note that unlike the other
-C<guestfs_inspect_get_*> calls which are just returning
-data cached in the libguestfs handle, this call actually reads
-parts of the mounted filesystems during the call.
-
-This returns an empty list if the inspection code was not able
-to determine the list of applications.
-
-The application structure contains the following fields:
-
-=over 4
-
-=item C<app2_name>
-
-The name of the application. For Red Hat-derived and Debian-derived
-Linux guests, this is the package name.
-
-=item C<app2_display_name>
-
-The display name of the application, sometimes localized to the
-install language of the guest operating system.
-
-If unavailable this is returned as an empty string C<\"\">.
-Callers needing to display something can use C<app2_name> instead.
-
-=item C<app2_epoch>
-
-For package managers which use epochs, this contains the epoch of
-the package (an integer). If unavailable, this is returned as C<0>.
-
-=item C<app2_version>
-
-The version string of the application or package. If unavailable
-this is returned as an empty string C<\"\">.
-
-=item C<app2_release>
-
-The release string of the application or package, for package
-managers that use this. If unavailable this is returned as an
-empty string C<\"\">.
-
-=item C<app2_arch>
-
-The architecture string of the application or package, for package
-managers that use this. If unavailable this is returned as an empty
-string C<\"\">.
-
-=item C<app2_install_path>
-
-The installation path of the application (on operating systems
-such as Windows which use installation paths). This path is
-in the format used by the guest operating system, it is not
-a libguestfs path.
-
-If unavailable this is returned as an empty string C<\"\">.
-
-=item C<app2_trans_path>
-
-The install path translated into a libguestfs path.
-If unavailable this is returned as an empty string C<\"\">.
-
-=item C<app2_publisher>
-
-The name of the publisher of the application, for package
-managers that use this. If unavailable this is returned
-as an empty string C<\"\">.
-
-=item C<app2_url>
-
-The URL (eg. upstream URL) of the application.
-If unavailable this is returned as an empty string C<\"\">.
-
-=item C<app2_source_package>
-
-For packaging systems which support this, the name of the source
-package. If unavailable this is returned as an empty string C<\"\">.
-
-=item C<app2_summary>
-
-A short (usually one line) description of the application or package.
-If unavailable this is returned as an empty string C<\"\">.
-
-=item C<app2_description>
-
-A longer description of the application or package.
-If unavailable this is returned as an empty string C<\"\">.
-
-=back
-
-Please read L<guestfs(3)/INSPECTION> for more details." };
-
- { defaults with
name = "inspect_get_hostname"; added = (1, 7, 9);
style = RString (RPlainString, "hostname"), [String (Mountable,
"root")], [];
+ impl = OCaml "Inspect.inspect_get_hostname";
shortdesc = "get hostname of the operating system";
longdesc = "\
This function returns the hostname of the operating system
@@ -568,6 +430,7 @@ Please read L<guestfs(3)/INSPECTION> for more details." };
{ defaults with
name = "inspect_get_format"; added = (1, 9, 4);
style = RString (RPlainString, "format"), [String (Mountable,
"root")], [];
+ impl = OCaml "Inspect.inspect_get_format";
shortdesc = "get format of inspected operating system";
longdesc = "\
This returns the format of the inspected operating system. You
@@ -600,6 +463,7 @@ Please read L<guestfs(3)/INSPECTION> for more details." };
{ defaults with
name = "inspect_is_live"; added = (1, 9, 4);
style = RBool "live", [String (Mountable, "root")], [];
+ impl = OCaml "Inspect.inspect_is_live";
shortdesc = "get live flag for install disk";
longdesc = "\
If C<guestfs_inspect_get_format> returns C<installer> (this
@@ -611,6 +475,7 @@ Please read L<guestfs(3)/INSPECTION> for more details." };
{ defaults with
name = "inspect_is_netinst"; added = (1, 9, 4);
style = RBool "netinst", [String (Mountable, "root")], [];
+ impl = OCaml "Inspect.inspect_is_netinst";
shortdesc = "get netinst (network installer) flag for install disk";
longdesc = "\
If C<guestfs_inspect_get_format> returns C<installer> (this
@@ -624,6 +489,7 @@ Please read L<guestfs(3)/INSPECTION> for more details." };
{ defaults with
name = "inspect_is_multipart"; added = (1, 9, 4);
style = RBool "multipart", [String (Mountable, "root")], [];
+ impl = OCaml "Inspect.inspect_is_multipart";
shortdesc = "get multipart flag for install disk";
longdesc = "\
If C<guestfs_inspect_get_format> returns C<installer> (this
@@ -635,6 +501,7 @@ Please read L<guestfs(3)/INSPECTION> for more details." };
{ defaults with
name = "inspect_get_product_variant"; added = (1, 9, 13);
style = RString (RPlainString, "variant"), [String (Mountable,
"root")], [];
+ impl = OCaml "Inspect.inspect_get_product_variant";
shortdesc = "get product variant of inspected operating system";
longdesc = "\
This returns the product variant of the inspected operating
@@ -663,6 +530,7 @@ C<guestfs_inspect_get_major_version>." };
{ defaults with
name = "inspect_get_windows_current_control_set"; added = (1, 9, 17);
style = RString (RPlainString, "controlset"), [String (Mountable,
"root")], [];
+ impl = OCaml "Inspect.inspect_get_windows_current_control_set";
shortdesc = "get Windows CurrentControlSet of inspected operating system";
longdesc = "\
This returns the Windows CurrentControlSet of the inspected guest.
@@ -675,8 +543,94 @@ the case then an error is returned.
Please read L<guestfs(3)/INSPECTION> for more details." };
{ defaults with
+ name = "inspect_get_windows_software_hive"; added = (1, 35, 26);
+ style = RString (RPlainString, "path"), [String (Mountable,
"root")], [];
+ impl = OCaml "Inspect.inspect_get_windows_software_hive";
+ shortdesc = "get the path of the Windows software hive";
+ longdesc = "\
+This returns the path to the hive (binary Windows Registry file)
+corresponding to HKLM\\SOFTWARE.
+
+This call assumes that the guest is Windows and that the guest
+has a software hive file with the right name. If this is not the
+case then an error is returned. This call does not check that the
+hive is a valid Windows Registry hive.
+
+You can use C<guestfs_hivex_open> to read or write to the hive.
+
+Please read L<guestfs(3)/INSPECTION> for more details." };
+
+ { defaults with
+ name = "inspect_get_windows_system_hive"; added = (1, 35, 26);
+ style = RString (RPlainString, "path"), [String (Mountable,
"root")], [];
+ impl = OCaml "Inspect.inspect_get_windows_system_hive";
+ shortdesc = "get the path of the Windows system hive";
+ longdesc = "\
+This returns the path to the hive (binary Windows Registry file)
+corresponding to HKLM\\SYSTEM.
+
+This call assumes that the guest is Windows and that the guest
+has a system hive file with the right name. If this is not the
+case then an error is returned. This call does not check that the
+hive is a valid Windows Registry hive.
+
+You can use C<guestfs_hivex_open> to read or write to the hive.
+
+Please read L<guestfs(3)/INSPECTION> for more details." };
+
+ { defaults with
+ name = "inspect_get_mountpoints"; added = (1, 5, 3);
+ style = RHashtable (RPlainString, RMountable, "mountpoints"), [String
(Mountable, "root")], [];
+ impl = OCaml "Inspect.inspect_get_mountpoints";
+ shortdesc = "get mountpoints of inspected operating system";
+ longdesc = "\
+This returns a hash of where we think the filesystems
+associated with this operating system should be mounted.
+Callers should note that this is at best an educated guess
+made by reading configuration files such as F</etc/fstab>.
+I<In particular note> that this may return filesystems
+which are non-existent or not mountable and callers should
+be prepared to handle or ignore failures if they try to
+mount them.
+
+Each element in the returned hashtable has a key which
+is the path of the mountpoint (eg. F</boot>) and a value
+which is the filesystem that would be mounted there
+(eg. F</dev/sda1>).
+
+Non-mounted devices such as swap devices are I<not>
+returned in this list.
+
+For operating systems like Windows which still use drive
+letters, this call will only return an entry for the first
+drive \"mounted on\" F</>. For information about the
+mapping of drive letters to partitions, see
+C<guestfs_inspect_get_drive_mappings>.
+
+Please read L<guestfs(3)/INSPECTION> for more details.
+See also C<guestfs_inspect_get_filesystems>." };
+
+ { defaults with
+ name = "inspect_get_filesystems"; added = (1, 5, 3);
+ style = RStringList (RMountable, "filesystems"), [String (Mountable,
"root")], [];
+ impl = OCaml "Inspect.inspect_get_filesystems";
+ shortdesc = "get filesystems associated with inspected operating system";
+ longdesc = "\
+This returns a list of all the filesystems that we think
+are associated with this operating system. This includes
+the root filesystem, other ordinary filesystems, and
+non-mounted devices like swap partitions.
+
+In the case of a multi-boot virtual machine, it is possible
+for a filesystem to be shared between operating systems.
+
+Please read L<guestfs(3)/INSPECTION> for more details.
+See also C<guestfs_inspect_get_mountpoints>." };
+
+ { defaults with
name = "inspect_get_drive_mappings"; added = (1, 9, 17);
style = RHashtable (RPlainString, RDevice, "drives"), [String (Mountable,
"root")], [];
+ impl = OCaml "Inspect.inspect_get_drive_mappings";
shortdesc = "get drive letter mappings";
longdesc = "\
This call is useful for Windows which uses a primitive system
@@ -708,6 +662,112 @@ Please read L<guestfs(3)/INSPECTION> for more details.
See also C<guestfs_inspect_get_mountpoints>,
C<guestfs_inspect_get_filesystems>." };
+]
+
+let non_daemon_functions = [
+ { defaults with
+ name = "inspect_list_applications2"; added = (1, 19, 56);
+ style = RStructList ("applications2", "application2"), [String
(Mountable, "root")], [];
+ shortdesc = "get list of applications installed in the operating system";
+ longdesc = "\
+Return the list of applications installed in the operating system.
+
+I<Note:> This call works differently from other parts of the
+inspection API. You have to call C<guestfs_inspect_os>, then
+C<guestfs_inspect_get_mountpoints>, then mount up the disks,
+before calling this. Listing applications is a significantly
+more difficult operation which requires access to the full
+filesystem. Also note that unlike the other
+C<guestfs_inspect_get_*> calls which are just returning
+data cached in the libguestfs handle, this call actually reads
+parts of the mounted filesystems during the call.
+
+This returns an empty list if the inspection code was not able
+to determine the list of applications.
+
+The application structure contains the following fields:
+
+=over 4
+
+=item C<app2_name>
+
+The name of the application. For Red Hat-derived and Debian-derived
+Linux guests, this is the package name.
+
+=item C<app2_display_name>
+
+The display name of the application, sometimes localized to the
+install language of the guest operating system.
+
+If unavailable this is returned as an empty string C<\"\">.
+Callers needing to display something can use C<app2_name> instead.
+
+=item C<app2_epoch>
+
+For package managers which use epochs, this contains the epoch of
+the package (an integer). If unavailable, this is returned as C<0>.
+
+=item C<app2_version>
+
+The version string of the application or package. If unavailable
+this is returned as an empty string C<\"\">.
+
+=item C<app2_release>
+
+The release string of the application or package, for package
+managers that use this. If unavailable this is returned as an
+empty string C<\"\">.
+
+=item C<app2_arch>
+
+The architecture string of the application or package, for package
+managers that use this. If unavailable this is returned as an empty
+string C<\"\">.
+
+=item C<app2_install_path>
+
+The installation path of the application (on operating systems
+such as Windows which use installation paths). This path is
+in the format used by the guest operating system, it is not
+a libguestfs path.
+
+If unavailable this is returned as an empty string C<\"\">.
+
+=item C<app2_trans_path>
+
+The install path translated into a libguestfs path.
+If unavailable this is returned as an empty string C<\"\">.
+
+=item C<app2_publisher>
+
+The name of the publisher of the application, for package
+managers that use this. If unavailable this is returned
+as an empty string C<\"\">.
+
+=item C<app2_url>
+
+The URL (eg. upstream URL) of the application.
+If unavailable this is returned as an empty string C<\"\">.
+
+=item C<app2_source_package>
+
+For packaging systems which support this, the name of the source
+package. If unavailable this is returned as an empty string C<\"\">.
+
+=item C<app2_summary>
+
+A short (usually one line) description of the application or package.
+If unavailable this is returned as an empty string C<\"\">.
+
+=item C<app2_description>
+
+A longer description of the application or package.
+If unavailable this is returned as an empty string C<\"\">.
+
+=back
+
+Please read L<guestfs(3)/INSPECTION> for more details." };
+
{ defaults with
name = "inspect_get_icon"; added = (1, 11, 12);
style = RBufferOut "icon", [String (Mountable, "root")], [OBool
"favicon"; OBool "highquality"];
@@ -773,38 +833,4 @@ advice before using trademarks in applications.
=back" };
- { defaults with
- name = "inspect_get_windows_software_hive"; added = (1, 35, 26);
- style = RString (RPlainString, "path"), [String (Mountable,
"root")], [];
- shortdesc = "get the path of the Windows software hive";
- longdesc = "\
-This returns the path to the hive (binary Windows Registry file)
-corresponding to HKLM\\SOFTWARE.
-
-This call assumes that the guest is Windows and that the guest
-has a software hive file with the right name. If this is not the
-case then an error is returned. This call does not check that the
-hive is a valid Windows Registry hive.
-
-You can use C<guestfs_hivex_open> to read or write to the hive.
-
-Please read L<guestfs(3)/INSPECTION> for more details." };
-
- { defaults with
- name = "inspect_get_windows_system_hive"; added = (1, 35, 26);
- style = RString (RPlainString, "path"), [String (Mountable,
"root")], [];
- shortdesc = "get the path of the Windows system hive";
- longdesc = "\
-This returns the path to the hive (binary Windows Registry file)
-corresponding to HKLM\\SYSTEM.
-
-This call assumes that the guest is Windows and that the guest
-has a system hive file with the right name. If this is not the
-case then an error is returned. This call does not check that the
-hive is a valid Windows Registry hive.
-
-You can use C<guestfs_hivex_open> to read or write to the hive.
-
-Please read L<guestfs(3)/INSPECTION> for more details." };
-
]
diff --git a/generator/actions_inspection.mli b/generator/actions_inspection.mli
index 327f7aa4f..06b8116c4 100644
--- a/generator/actions_inspection.mli
+++ b/generator/actions_inspection.mli
@@ -19,3 +19,4 @@
(* Please read generator/README first. *)
val non_daemon_functions : Types.action list
+val daemon_functions : Types.action list
diff --git a/generator/daemon.ml b/generator/daemon.ml
index f20c87bea..b8d0a3a88 100644
--- a/generator/daemon.ml
+++ b/generator/daemon.ml
@@ -597,6 +597,30 @@ return_string_mountable (value retv)
}
}
+/* Implement RStringList (RMountable, _). */
+static char **
+return_string_mountable_list (value retv)
+{
+ CLEANUP_FREE_STRINGSBUF DECLARE_STRINGSBUF (ret);
+ value v;
+ char *m;
+
+ while (retv != Val_int (0)) {
+ v = Field (retv, 0);
+ m = return_string_mountable (v);
+ if (m == NULL)
+ return NULL;
+ if (add_string_nodup (&ret, m) == -1)
+ return NULL;
+ retv = Field (retv, 1);
+ }
+
+ if (end_stringsbuf (&ret) == -1)
+ return NULL;
+
+ return take_stringsbuf (&ret); /* caller frees */
+}
+
/* Implement RHashtable (RPlainString, RPlainString, _). */
static char **
return_hashtable_string_string (value retv)
@@ -649,6 +673,34 @@ return_hashtable_mountable_string (value retv)
return take_stringsbuf (&ret); /* caller frees */
}
+/* Implement RHashtable (RPlainString, RMountable, _). */
+static char **
+return_hashtable_string_mountable (value retv)
+{
+ CLEANUP_FREE_STRINGSBUF DECLARE_STRINGSBUF (ret);
+ value sv, v, mv;
+ char *m;
+
+ while (retv != Val_int (0)) {
+ v = Field (retv, 0); /* (string, Mountable.t) */
+ sv = Field (v, 0); /* string */
+ if (add_string (&ret, String_val (sv)) == -1)
+ return NULL;
+ mv = Field (v, 1); /* Mountable.t */
+ m = return_string_mountable (mv);
+ if (m == NULL)
+ return NULL;
+ if (add_string_nodup (&ret, m) == -1)
+ return NULL;
+ retv = Field (retv, 1);
+ }
+
+ if (end_stringsbuf (&ret) == -1)
+ return NULL;
+
+ return take_stringsbuf (&ret); /* caller frees */
+}
+
";
(* Implement code for returning structs and struct lists. *)
@@ -889,9 +941,12 @@ return_hashtable_mountable_string (value retv)
| RString (RMountable, _) ->
pr " char *ret = return_string_mountable (retv);\n";
pr " CAMLreturnT (char *, ret); /* caller frees */\n"
- | RStringList _ ->
+ | RStringList ((RPlainString|RDevice), _) ->
pr " char **ret = return_string_list (retv);\n";
pr " CAMLreturnT (char **, ret); /* caller frees */\n"
+ | RStringList (RMountable, _) ->
+ pr " char **ret = return_string_mountable_list (retv);\n";
+ pr " CAMLreturnT (char **, ret); /* caller frees */\n"
| RStruct (_, typ) ->
pr " guestfs_int_%s *ret =\n" typ;
pr " return_%s (retv);\n" typ;
@@ -902,12 +957,16 @@ return_hashtable_mountable_string (value retv)
pr " return_%s_list (retv);\n" typ;
pr " /* caller frees */\n";
pr " CAMLreturnT (guestfs_int_%s_list *, ret);\n" typ
- | RHashtable (RPlainString, RPlainString, _) ->
+ | RHashtable (RPlainString, RPlainString, _)
+ | RHashtable (RPlainString, RDevice, _) ->
pr " char **ret = return_hashtable_string_string (retv);\n";
pr " CAMLreturnT (char **, ret); /* caller frees */\n"
| RHashtable (RMountable, RPlainString, _) ->
pr " char **ret = return_hashtable_mountable_string (retv);\n";
pr " CAMLreturnT (char **, ret); /* caller frees */\n"
+ | RHashtable (RPlainString, RMountable, _) ->
+ pr " char **ret = return_hashtable_string_mountable (retv);\n";
+ pr " CAMLreturnT (char **, ret); /* caller frees */\n"
| RHashtable _ -> assert false
| RBufferOut _ -> assert false
);
diff --git a/generator/proc_nr.ml b/generator/proc_nr.ml
index dec02f5fa..0a41f9c24 100644
--- a/generator/proc_nr.ml
+++ b/generator/proc_nr.ml
@@ -484,6 +484,29 @@ let proc_nr = [
474, "internal_yara_scan";
475, "file_architecture";
476, "list_filesystems";
+477, "inspect_os";
+478, "inspect_get_roots";
+479, "inspect_get_format";
+480, "inspect_get_type";
+481, "inspect_get_distro";
+482, "inspect_get_package_format";
+483, "inspect_get_package_management";
+484, "inspect_get_product_name";
+485, "inspect_get_product_variant";
+486, "inspect_get_major_version";
+487, "inspect_get_minor_version";
+488, "inspect_get_arch";
+489, "inspect_get_hostname";
+490, "inspect_get_windows_systemroot";
+491, "inspect_get_windows_software_hive";
+492, "inspect_get_windows_system_hive";
+493, "inspect_get_windows_current_control_set";
+494, "inspect_is_live";
+495, "inspect_is_netinst";
+496, "inspect_is_multipart";
+497, "inspect_get_mountpoints";
+498, "inspect_get_filesystems";
+499, "inspect_get_drive_mappings";
]
(* End of list. If adding a new entry, add it at the end of the list
diff --git a/lib/MAX_PROC_NR b/lib/MAX_PROC_NR
index b86395733..761fcd3ac 100644
--- a/lib/MAX_PROC_NR
+++ b/lib/MAX_PROC_NR
@@ -1 +1 @@
-476
+499
diff --git a/lib/Makefile.am b/lib/Makefile.am
index 109330452..cc59a62d8 100644
--- a/lib/Makefile.am
+++ b/lib/Makefile.am
@@ -99,7 +99,6 @@ libguestfs_la_SOURCES = \
inspect-fs.c \
inspect-fs-cd.c \
inspect-fs-unix.c \
- inspect-fs-windows.c \
inspect-icon.c \
journal.c \
launch.c \
diff --git a/lib/guestfs-internal.h b/lib/guestfs-internal.h
index b1c3db5ff..52072b65e 100644
--- a/lib/guestfs-internal.h
+++ b/lib/guestfs-internal.h
@@ -129,7 +129,7 @@
* those.
*/
#define MAX_SMALL_FILE_SIZE (2 * 1000 * 1000)
-#define MAX_AUGEAS_FILE_SIZE (100 * 1000)
+#define MAX_AUGEAS_FILE_SIZE (100 * 1000) /* XXX REMOVE */
/* Maximum RPM or dpkg database we will download to /tmp. RPM
* 'Packages' database can get very large: 70 MB is roughly the
@@ -470,12 +470,6 @@ struct guestfs_h {
struct event *events;
size_t nr_events;
- /* Information gathered by inspect_os. Must be freed by calling
- * guestfs_int_free_inspect_info.
- */
- struct inspect_fs *fses;
- size_t nr_fses;
-
/* Private data area. */
struct hash_table *pda;
struct pda_entry *pda_next;
@@ -536,133 +530,6 @@ struct version {
int v_micro;
};
-/* Per-filesystem data stored for inspect_os. */
-enum inspect_os_format {
- OS_FORMAT_UNKNOWN = 0,
- OS_FORMAT_INSTALLED,
- OS_FORMAT_INSTALLER,
- /* in future: supplemental disks */
-};
-
-enum inspect_os_type {
- OS_TYPE_UNKNOWN = 0,
- OS_TYPE_LINUX,
- OS_TYPE_WINDOWS,
- OS_TYPE_FREEBSD,
- OS_TYPE_NETBSD,
- OS_TYPE_HURD,
- OS_TYPE_DOS,
- OS_TYPE_OPENBSD,
- OS_TYPE_MINIX,
-};
-
-enum inspect_os_distro {
- OS_DISTRO_UNKNOWN = 0,
- OS_DISTRO_DEBIAN,
- OS_DISTRO_FEDORA,
- OS_DISTRO_REDHAT_BASED,
- OS_DISTRO_RHEL,
- OS_DISTRO_WINDOWS,
- OS_DISTRO_PARDUS,
- OS_DISTRO_ARCHLINUX,
- OS_DISTRO_GENTOO,
- OS_DISTRO_UBUNTU,
- OS_DISTRO_MEEGO,
- OS_DISTRO_LINUX_MINT,
- OS_DISTRO_MANDRIVA,
- OS_DISTRO_SLACKWARE,
- OS_DISTRO_CENTOS,
- OS_DISTRO_SCIENTIFIC_LINUX,
- OS_DISTRO_TTYLINUX,
- OS_DISTRO_MAGEIA,
- OS_DISTRO_OPENSUSE,
- OS_DISTRO_BUILDROOT,
- OS_DISTRO_CIRROS,
- OS_DISTRO_FREEDOS,
- OS_DISTRO_SUSE_BASED,
- OS_DISTRO_SLES,
- OS_DISTRO_OPENBSD,
- OS_DISTRO_ORACLE_LINUX,
- OS_DISTRO_FREEBSD,
- OS_DISTRO_NETBSD,
- OS_DISTRO_COREOS,
- OS_DISTRO_ALPINE_LINUX,
- OS_DISTRO_ALTLINUX,
- OS_DISTRO_FRUGALWARE,
- OS_DISTRO_PLD_LINUX,
- OS_DISTRO_VOID_LINUX,
-};
-
-enum inspect_os_package_format {
- OS_PACKAGE_FORMAT_UNKNOWN = 0,
- OS_PACKAGE_FORMAT_RPM,
- OS_PACKAGE_FORMAT_DEB,
- OS_PACKAGE_FORMAT_PACMAN,
- OS_PACKAGE_FORMAT_EBUILD,
- OS_PACKAGE_FORMAT_PISI,
- OS_PACKAGE_FORMAT_PKGSRC,
- OS_PACKAGE_FORMAT_APK,
- OS_PACKAGE_FORMAT_XBPS,
-};
-
-enum inspect_os_package_management {
- OS_PACKAGE_MANAGEMENT_UNKNOWN = 0,
- OS_PACKAGE_MANAGEMENT_YUM,
- OS_PACKAGE_MANAGEMENT_UP2DATE,
- OS_PACKAGE_MANAGEMENT_APT,
- OS_PACKAGE_MANAGEMENT_PACMAN,
- OS_PACKAGE_MANAGEMENT_PORTAGE,
- OS_PACKAGE_MANAGEMENT_PISI,
- OS_PACKAGE_MANAGEMENT_URPMI,
- OS_PACKAGE_MANAGEMENT_ZYPPER,
- OS_PACKAGE_MANAGEMENT_DNF,
- OS_PACKAGE_MANAGEMENT_APK,
- OS_PACKAGE_MANAGEMENT_XBPS,
-};
-
-enum inspect_os_role {
- OS_ROLE_UNKNOWN = 0,
- OS_ROLE_ROOT,
- OS_ROLE_USR,
-};
-
-/**
- * The inspection code maintains one of these structures per mountable
- * filesystem found in the disk image. The struct (or structs) which
- * have the C<role> attribute set to C<OS_ROLE_ROOT> are inspection roots,
- * each corresponding to a single guest. Note that a filesystem can be
- * shared between multiple guests.
- */
-struct inspect_fs {
- enum inspect_os_role role;
- char *mountable;
- enum inspect_os_type type;
- enum inspect_os_distro distro;
- enum inspect_os_package_format package_format;
- enum inspect_os_package_management package_management;
- char *product_name;
- char *product_variant;
- struct version version;
- char *arch;
- char *hostname;
- char *windows_systemroot;
- char *windows_software_hive;
- char *windows_system_hive;
- char *windows_current_control_set;
- char **drive_mappings;
- enum inspect_os_format format;
- int is_live_disk;
- int is_netinst_disk;
- int is_multipart_disk;
- struct inspect_fstab_entry *fstab;
- size_t nr_fstab;
-};
-
-struct inspect_fstab_entry {
- char *mountable;
- char *mountpoint;
-};
-
struct guestfs_message_header;
struct guestfs_message_error;
struct guestfs_progress;
@@ -854,44 +721,12 @@ extern int guestfs_int_set_backend (guestfs_h *g, const char
*method);
} while (0)
/* inspect.c */
-extern void guestfs_int_free_inspect_info (guestfs_h *g);
-extern char *guestfs_int_download_to_tmp (guestfs_h *g, struct inspect_fs *fs, const char
*filename, const char *basename, uint64_t max_size);
-extern struct inspect_fs *guestfs_int_search_for_root (guestfs_h *g, const char *root);
-extern int guestfs_int_is_partition (guestfs_h *g, const char *partition);
+extern char *guestfs_int_download_to_tmp (guestfs_h *g, const char *filename, const char
*basename, uint64_t max_size);
/* inspect-fs.c */
-extern int guestfs_int_is_file_nocase (guestfs_h *g, const char *);
-extern int guestfs_int_is_dir_nocase (guestfs_h *g, const char *);
-extern int guestfs_int_check_for_filesystem_on (guestfs_h *g,
- const char *mountable);
extern int guestfs_int_parse_unsigned_int (guestfs_h *g, const char *str);
extern int guestfs_int_parse_unsigned_int_ignore_trailing (guestfs_h *g, const char
*str);
-extern int guestfs_int_parse_major_minor (guestfs_h *g, struct inspect_fs *fs);
-extern char *guestfs_int_first_line_of_file (guestfs_h *g, const char *filename);
extern int guestfs_int_first_egrep_of_file (guestfs_h *g, const char *filename, const
char *eregex, int iflag, char **ret);
-extern void guestfs_int_check_package_format (guestfs_h *g, struct inspect_fs *fs);
-extern void guestfs_int_check_package_management (guestfs_h *g, struct inspect_fs *fs);
-extern void guestfs_int_merge_fs_inspections (guestfs_h *g, struct inspect_fs *dst,
struct inspect_fs *src);
-
-/* inspect-fs-unix.c */
-extern int guestfs_int_check_linux_root (guestfs_h *g, struct inspect_fs *fs);
-extern int guestfs_int_check_linux_usr (guestfs_h *g, struct inspect_fs *fs);
-extern int guestfs_int_check_freebsd_root (guestfs_h *g, struct inspect_fs *fs);
-extern int guestfs_int_check_netbsd_root (guestfs_h *g, struct inspect_fs *fs);
-extern int guestfs_int_check_openbsd_root (guestfs_h *g, struct inspect_fs *fs);
-extern int guestfs_int_check_hurd_root (guestfs_h *g, struct inspect_fs *fs);
-extern int guestfs_int_check_minix_root (guestfs_h *g, struct inspect_fs *fs);
-extern int guestfs_int_check_coreos_root (guestfs_h *g, struct inspect_fs *fs);
-extern int guestfs_int_check_coreos_usr (guestfs_h *g, struct inspect_fs *fs);
-
-/* inspect-fs-windows.c */
-extern char *guestfs_int_case_sensitive_path_silently (guestfs_h *g, const char *);
-extern char * guestfs_int_get_windows_systemroot (guestfs_h *g);
-extern int guestfs_int_check_windows_root (guestfs_h *g, struct inspect_fs *fs, char
*windows_systemroot);
-
-/* inspect-fs-cd.c */
-extern int guestfs_int_check_installer_root (guestfs_h *g, struct inspect_fs *fs);
-extern int guestfs_int_check_installer_iso (guestfs_h *g, struct inspect_fs *fs, const
char *device);
/* dbdump.c */
typedef int (*guestfs_int_db_dump_callback) (guestfs_h *g, const unsigned char *key,
size_t keylen, const unsigned char *value, size_t valuelen, void *opaque);
@@ -911,6 +746,55 @@ extern virConnectPtr guestfs_int_open_libvirt_connection (guestfs_h
*g, const ch
#endif
/* osinfo.c */
+enum inspect_os_type {
+ OS_TYPE_UNKNOWN = 0,
+ OS_TYPE_LINUX,
+ OS_TYPE_WINDOWS,
+ OS_TYPE_FREEBSD,
+ OS_TYPE_NETBSD,
+ OS_TYPE_HURD,
+ OS_TYPE_DOS,
+ OS_TYPE_OPENBSD,
+ OS_TYPE_MINIX,
+};
+
+enum inspect_os_distro {
+ OS_DISTRO_UNKNOWN = 0,
+ OS_DISTRO_DEBIAN,
+ OS_DISTRO_FEDORA,
+ OS_DISTRO_REDHAT_BASED,
+ OS_DISTRO_RHEL,
+ OS_DISTRO_WINDOWS,
+ OS_DISTRO_PARDUS,
+ OS_DISTRO_ARCHLINUX,
+ OS_DISTRO_GENTOO,
+ OS_DISTRO_UBUNTU,
+ OS_DISTRO_MEEGO,
+ OS_DISTRO_LINUX_MINT,
+ OS_DISTRO_MANDRIVA,
+ OS_DISTRO_SLACKWARE,
+ OS_DISTRO_CENTOS,
+ OS_DISTRO_SCIENTIFIC_LINUX,
+ OS_DISTRO_TTYLINUX,
+ OS_DISTRO_MAGEIA,
+ OS_DISTRO_OPENSUSE,
+ OS_DISTRO_BUILDROOT,
+ OS_DISTRO_CIRROS,
+ OS_DISTRO_FREEDOS,
+ OS_DISTRO_SUSE_BASED,
+ OS_DISTRO_SLES,
+ OS_DISTRO_OPENBSD,
+ OS_DISTRO_ORACLE_LINUX,
+ OS_DISTRO_FREEBSD,
+ OS_DISTRO_NETBSD,
+ OS_DISTRO_COREOS,
+ OS_DISTRO_ALPINE_LINUX,
+ OS_DISTRO_ALTLINUX,
+ OS_DISTRO_FRUGALWARE,
+ OS_DISTRO_PLD_LINUX,
+ OS_DISTRO_VOID_LINUX,
+};
+
struct osinfo {
/* Data provided by libosinfo database. */
enum inspect_os_type type;
diff --git a/lib/handle.c b/lib/handle.c
index 91f5f755d..57fda24b1 100644
--- a/lib/handle.c
+++ b/lib/handle.c
@@ -369,7 +369,6 @@ guestfs_close (guestfs_h *g)
guestfs_int_free_fuse (g);
#endif
- guestfs_int_free_inspect_info (g);
guestfs_int_free_drives (g);
for (hp = g->hv_params; hp; hp = hp_next) {
diff --git a/lib/inspect-apps.c b/lib/inspect-apps.c
index 25192340c..7a5d45926 100644
--- a/lib/inspect-apps.c
+++ b/lib/inspect-apps.c
@@ -46,12 +46,12 @@
#include "structs-cleanups.h"
#ifdef DB_DUMP
-static struct guestfs_application2_list *list_applications_rpm (guestfs_h *g, struct
inspect_fs *fs);
+static struct guestfs_application2_list *list_applications_rpm (guestfs_h *g, const char
*root);
#endif
-static struct guestfs_application2_list *list_applications_deb (guestfs_h *g, struct
inspect_fs *fs);
-static struct guestfs_application2_list *list_applications_pacman (guestfs_h *g, struct
inspect_fs *fs);
-static struct guestfs_application2_list *list_applications_apk (guestfs_h *g, struct
inspect_fs *fs);
-static struct guestfs_application2_list *list_applications_windows (guestfs_h *g, struct
inspect_fs *fs);
+static struct guestfs_application2_list *list_applications_deb (guestfs_h *g, const char
*root);
+static struct guestfs_application2_list *list_applications_pacman (guestfs_h *g, const
char *root);
+static struct guestfs_application2_list *list_applications_apk (guestfs_h *g, const char
*root);
+static struct guestfs_application2_list *list_applications_windows (guestfs_h *g, const
char *root);
static void add_application (guestfs_h *g, struct guestfs_application2_list *, const char
*name, const char *display_name, int32_t epoch, const char *version, const char *release,
const char *arch, const char *install_path, const char *publisher, const char *url, const
char *source, const char *summary, const char *description);
static void sort_applications (struct guestfs_application2_list *);
@@ -109,66 +109,52 @@ struct guestfs_application2_list *
guestfs_impl_inspect_list_applications2 (guestfs_h *g, const char *root)
{
struct guestfs_application2_list *ret = NULL;
- struct inspect_fs *fs = guestfs_int_search_for_root (g, root);
- if (!fs)
+ CLEANUP_FREE char *format = NULL;
+ CLEANUP_FREE char *type = NULL;
+ CLEANUP_FREE char *package_format = NULL;
+
+ format = guestfs_inspect_get_format (g, root);
+ if (!format)
+ return NULL;
+ type = guestfs_inspect_get_type (g, root);
+ if (!type)
+ return NULL;
+ package_format = guestfs_inspect_get_package_format (g, root);
+ if (!package_format)
return NULL;
/* Presently we can only list applications for installed disks. It
* is possible in future to get lists of packages from installers.
*/
- if (fs->format == OS_FORMAT_INSTALLED) {
- switch (fs->type) {
- case OS_TYPE_LINUX:
- case OS_TYPE_HURD:
- switch (fs->package_format) {
- case OS_PACKAGE_FORMAT_RPM:
+ if (STREQ (format, "installed")) {
+ if (STREQ (type, "linux") || STREQ (type, "hurd")) {
+ if (STREQ (package_format, "rpm")) {
#ifdef DB_DUMP
- ret = list_applications_rpm (g, fs);
+ ret = list_applications_rpm (g, root);
if (ret == NULL)
return NULL;
#endif
- break;
-
- case OS_PACKAGE_FORMAT_DEB:
- ret = list_applications_deb (g, fs);
+ }
+ else if (STREQ (package_format, "deb")) {
+ ret = list_applications_deb (g, root);
if (ret == NULL)
return NULL;
- break;
-
- case OS_PACKAGE_FORMAT_PACMAN:
- ret = list_applications_pacman (g, fs);
+ }
+ else if (STREQ (package_format, "pacman")) {
+ ret = list_applications_pacman (g, root);
if (ret == NULL)
return NULL;
- break;
-
- case OS_PACKAGE_FORMAT_APK:
- ret = list_applications_apk (g, fs);
+ }
+ else if (STREQ (package_format, "apk")) {
+ ret = list_applications_apk (g, root);
if (ret == NULL)
return NULL;
- break;
-
- case OS_PACKAGE_FORMAT_EBUILD:
- case OS_PACKAGE_FORMAT_PISI:
- case OS_PACKAGE_FORMAT_PKGSRC:
- case OS_PACKAGE_FORMAT_XBPS:
- case OS_PACKAGE_FORMAT_UNKNOWN:
- ; /* nothing */
}
- break;
-
- case OS_TYPE_WINDOWS:
- ret = list_applications_windows (g, fs);
+ }
+ else if (STREQ (type, "windows")) {
+ ret = list_applications_windows (g, root);
if (ret == NULL)
return NULL;
- break;
-
- case OS_TYPE_FREEBSD:
- case OS_TYPE_MINIX:
- case OS_TYPE_NETBSD:
- case OS_TYPE_DOS:
- case OS_TYPE_OPENBSD:
- case OS_TYPE_UNKNOWN:
- ; /* nothing */
}
}
@@ -386,20 +372,20 @@ read_package (guestfs_h *g,
#pragma GCC diagnostic pop
static struct guestfs_application2_list *
-list_applications_rpm (guestfs_h *g, struct inspect_fs *fs)
+list_applications_rpm (guestfs_h *g, const char *root)
{
CLEANUP_FREE char *Name = NULL, *Packages = NULL;
struct rpm_names_list list = { .names = NULL, .len = 0 };
struct guestfs_application2_list *apps = NULL;
struct read_package_data data;
- Name = guestfs_int_download_to_tmp (g, fs,
+ Name = guestfs_int_download_to_tmp (g,
"/var/lib/rpm/Name", "rpm_Name",
MAX_PKG_DB_SIZE);
if (Name == NULL)
goto error;
- Packages = guestfs_int_download_to_tmp (g, fs,
+ Packages = guestfs_int_download_to_tmp (g,
"/var/lib/rpm/Packages", "rpm_Packages",
MAX_PKG_DB_SIZE);
if (Packages == NULL)
@@ -437,7 +423,7 @@ list_applications_rpm (guestfs_h *g, struct inspect_fs *fs)
#endif /* defined DB_DUMP */
static struct guestfs_application2_list *
-list_applications_deb (guestfs_h *g, struct inspect_fs *fs)
+list_applications_deb (guestfs_h *g, const char *root)
{
CLEANUP_FREE char *status = NULL;
struct guestfs_application2_list *apps = NULL, *ret = NULL;
@@ -452,7 +438,7 @@ list_applications_deb (guestfs_h *g, struct inspect_fs *fs)
char **continuation_field = NULL;
size_t continuation_field_len = 0;
- status = guestfs_int_download_to_tmp (g, fs, "/var/lib/dpkg/status",
"status",
+ status = guestfs_int_download_to_tmp (g, "/var/lib/dpkg/status",
"status",
MAX_PKG_DB_SIZE);
if (status == NULL)
return NULL;
@@ -594,7 +580,7 @@ list_applications_deb (guestfs_h *g, struct inspect_fs *fs)
}
static struct guestfs_application2_list *
-list_applications_pacman (guestfs_h *g, struct inspect_fs *fs)
+list_applications_pacman (guestfs_h *g, const char *root)
{
CLEANUP_FREE char *desc_file = NULL, *fname = NULL, *line = NULL;
CLEANUP_FREE_DIRENT_LIST struct guestfs_dirent_list *local_db = NULL;
@@ -628,7 +614,7 @@ list_applications_pacman (guestfs_h *g, struct inspect_fs *fs)
fname = safe_malloc (g, strlen (curr->name) + path_len + 1);
sprintf (fname, "/var/lib/pacman/local/%s/desc", curr->name);
free (desc_file);
- desc_file = guestfs_int_download_to_tmp (g, fs, fname, curr->name, 8192);
+ desc_file = guestfs_int_download_to_tmp (g, fname, curr->name, 8192);
/* The desc files are small (4K). If the desc file does not exist or is
* larger than the 8K limit we've used, the database is probably corrupted,
@@ -725,7 +711,7 @@ list_applications_pacman (guestfs_h *g, struct inspect_fs *fs)
}
static struct guestfs_application2_list *
-list_applications_apk (guestfs_h *g, struct inspect_fs *fs)
+list_applications_apk (guestfs_h *g, const char *root)
{
CLEANUP_FREE char *installed = NULL, *line = NULL;
struct guestfs_application2_list *apps = NULL, *ret = NULL;
@@ -736,7 +722,7 @@ list_applications_apk (guestfs_h *g, struct inspect_fs *fs)
CLEANUP_FREE char *name = NULL, *version = NULL, *release = NULL, *arch = NULL,
*url = NULL, *description = NULL;
- installed = guestfs_int_download_to_tmp (g, fs, "/lib/apk/db/installed",
+ installed = guestfs_int_download_to_tmp (g, "/lib/apk/db/installed",
"installed", MAX_PKG_DB_SIZE);
if (installed == NULL)
return NULL;
@@ -843,14 +829,15 @@ list_applications_apk (guestfs_h *g, struct inspect_fs *fs)
static void list_applications_windows_from_path (guestfs_h *g, struct
guestfs_application2_list *apps, const char **path, size_t path_len);
static struct guestfs_application2_list *
-list_applications_windows (guestfs_h *g, struct inspect_fs *fs)
+list_applications_windows (guestfs_h *g, const char *root)
{
struct guestfs_application2_list *ret = NULL;
-
- if (!fs->windows_software_hive)
+ CLEANUP_FREE char *software_hive =
+ guestfs_inspect_get_windows_software_hive (g, root);
+ if (!software_hive)
return NULL;
- if (guestfs_hivex_open (g, fs->windows_software_hive,
+ if (guestfs_hivex_open (g, software_hive,
GUESTFS_HIVEX_OPEN_VERBOSE, g->verbose,
GUESTFS_HIVEX_OPEN_UNSAFE, 1,
-1) == -1)
diff --git a/lib/inspect-fs-cd.c b/lib/inspect-fs-cd.c
index c9a4e219e..ad524c66b 100644
--- a/lib/inspect-fs-cd.c
+++ b/lib/inspect-fs-cd.c
@@ -34,6 +34,8 @@
#include "guestfs-internal.h"
#include "structs-cleanups.h"
+#if 0
+
/* Debian/Ubuntu install disks are easy ...
*
* These files are added by the debian-cd program, and it is worth
@@ -605,3 +607,5 @@ guestfs_int_check_installer_iso (guestfs_h *g, struct inspect_fs *fs,
return 1;
}
+
+#endif
diff --git a/lib/inspect-fs-unix.c b/lib/inspect-fs-unix.c
index 9b6bfbf38..cc2628e12 100644
--- a/lib/inspect-fs-unix.c
+++ b/lib/inspect-fs-unix.c
@@ -37,6 +37,7 @@
#include "guestfs.h"
#include "guestfs-internal.h"
+#if 0
COMPILE_REGEXP (re_fedora, "Fedora release (\\d+)", 0)
COMPILE_REGEXP (re_rhel_old, "Red Hat.*release (\\d+).*Update (\\d+)", 0)
COMPILE_REGEXP (re_rhel, "Red Hat.*release (\\d+)\\.(\\d+)", 0)
@@ -79,715 +80,6 @@ COMPILE_REGEXP (re_altlinux, "
(?:(\\d+)(?:\\.(\\d+)(?:[\\.\\d]+)?)?)\\s+\\((?:[
COMPILE_REGEXP (re_frugalware, "Frugalware (\\d+)\\.(\\d+)", 0)
COMPILE_REGEXP (re_pldlinux, "(\\d+)\\.(\\d+) PLD Linux", 0)
-static void check_architecture (guestfs_h *g, struct inspect_fs *fs);
-static int check_hostname_unix (guestfs_h *g, struct inspect_fs *fs);
-static int check_hostname_redhat (guestfs_h *g, struct inspect_fs *fs);
-static int check_hostname_freebsd (guestfs_h *g, struct inspect_fs *fs);
-static int check_fstab (guestfs_h *g, struct inspect_fs *fs);
-static void add_fstab_entry (guestfs_h *g, struct inspect_fs *fs,
- const char *mountable, const char *mp);
-static char *resolve_fstab_device (guestfs_h *g, const char *spec,
- Hash_table *md_map,
- enum inspect_os_type os_type);
-static int inspect_with_augeas (guestfs_h *g, struct inspect_fs *fs, const char
**configfiles, int (*f) (guestfs_h *, struct inspect_fs *));
-static void canonical_mountpoint (char *mp);
-
-/* Hash structure for uuid->path lookups */
-typedef struct md_uuid {
- uint32_t uuid[4];
- char *path;
-} md_uuid;
-
-static size_t uuid_hash(const void *x, size_t table_size);
-static bool uuid_cmp(const void *x, const void *y);
-static void md_uuid_free(void *x);
-
-static int parse_uuid(const char *str, uint32_t *uuid);
-
-/* Hash structure for path(mdadm)->path(appliance) lookup */
-typedef struct {
- char *mdadm;
- char *app;
-} mdadm_app;
-
-static size_t mdadm_app_hash(const void *x, size_t table_size);
-static bool mdadm_app_cmp(const void *x, const void *y);
-static void mdadm_app_free(void *x);
-
-static ssize_t map_app_md_devices (guestfs_h *g, Hash_table **map);
-static int map_md_devices(guestfs_h *g, Hash_table **map);
-
-/* Set fs->product_name to the first line of the release file. */
-static int
-parse_release_file (guestfs_h *g, struct inspect_fs *fs,
- const char *release_filename)
-{
- fs->product_name = guestfs_int_first_line_of_file (g, release_filename);
- if (fs->product_name == NULL)
- return -1;
- if (STREQ (fs->product_name, "")) {
- free (fs->product_name);
- fs->product_name = NULL;
- error (g, _("release file %s is empty or malformed"), release_filename);
- return -1;
- }
- return 0;
-}
-
-/* Parse a os-release file.
- *
- * Only few fields are parsed, falling back to the usual detection if we
- * cannot read all of them.
- *
- * For the format of os-release, see also:
- *
http://www.freedesktop.org/software/systemd/man/os-release.html
- */
-static int
-parse_os_release (guestfs_h *g, struct inspect_fs *fs, const char *filename)
-{
- int64_t size;
- CLEANUP_FREE_STRING_LIST char **lines = NULL;
- size_t i;
- enum inspect_os_distro distro = OS_DISTRO_UNKNOWN;
- CLEANUP_FREE char *product_name = NULL;
- struct version version;
- guestfs_int_version_from_values (&version, -1, -1, 0);
-
- /* Don't trust guestfs_read_lines not to break with very large files.
- * Check the file size is something reasonable first.
- */
- size = guestfs_filesize (g, filename);
- if (size == -1)
- /* guestfs_filesize failed and has already set error in handle */
- return -1;
- if (size > MAX_SMALL_FILE_SIZE) {
- error (g, _("size of %s is unreasonably large (%" PRIi64 "
bytes)"),
- filename, size);
- return -1;
- }
-
- lines = guestfs_read_lines (g, filename);
- if (lines == NULL)
- return -1;
-
- for (i = 0; lines[i] != NULL; ++i) {
- const char *line = lines[i];
- const char *value;
- size_t value_len;
-
- if (line[0] == '#')
- continue;
-
- value = strchr (line, '=');
- if (value == NULL)
- continue;
-
- ++value;
- value_len = strlen (line) - (value - line);
- if (value_len > 1 && value[0] == '"' &&
value[value_len-1] == '"') {
- ++value;
- value_len -= 2;
- }
-
-#define VALUE_IS(a) STREQLEN(value, a, value_len)
- if (STRPREFIX (line, "ID=")) {
- if (VALUE_IS ("alpine"))
- distro = OS_DISTRO_ALPINE_LINUX;
- else if (VALUE_IS ("altlinux"))
- distro = OS_DISTRO_ALTLINUX;
- else if (VALUE_IS ("arch"))
- distro = OS_DISTRO_ARCHLINUX;
- else if (VALUE_IS ("centos"))
- distro = OS_DISTRO_CENTOS;
- else if (VALUE_IS ("coreos"))
- distro = OS_DISTRO_COREOS;
- else if (VALUE_IS ("debian"))
- distro = OS_DISTRO_DEBIAN;
- else if (VALUE_IS ("fedora"))
- distro = OS_DISTRO_FEDORA;
- else if (VALUE_IS ("frugalware"))
- distro = OS_DISTRO_FRUGALWARE;
- else if (VALUE_IS ("mageia"))
- distro = OS_DISTRO_MAGEIA;
- else if (VALUE_IS ("opensuse"))
- distro = OS_DISTRO_OPENSUSE;
- else if (VALUE_IS ("pld"))
- distro = OS_DISTRO_PLD_LINUX;
- else if (VALUE_IS ("rhel"))
- distro = OS_DISTRO_RHEL;
- else if (VALUE_IS ("sles") || VALUE_IS ("sled"))
- distro = OS_DISTRO_SLES;
- else if (VALUE_IS ("ubuntu"))
- distro = OS_DISTRO_UBUNTU;
- else if (VALUE_IS ("void"))
- distro = OS_DISTRO_VOID_LINUX;
- } else if (STRPREFIX (line, "PRETTY_NAME=")) {
- free (product_name);
- product_name = safe_strndup (g, value, value_len);
- } else if (STRPREFIX (line, "VERSION_ID=")) {
- CLEANUP_FREE char *buf =
- safe_asprintf (g, "%.*s", (int) value_len, value);
- if (guestfs_int_version_from_x_y_or_x (g, &version, buf) == -1)
- return -1;
- }
-#undef VALUE_IS
- }
-
- /* If we haven't got all the fields, exit right away. */
- if (distro == OS_DISTRO_UNKNOWN || product_name == NULL)
- return 0;
-
- if (version.v_major == -1 || version.v_minor == -1) {
- /* Void Linux has no VERSION_ID (yet), but since it's a rolling
- * distro and has no other version/release-like file. */
- if (distro == OS_DISTRO_VOID_LINUX)
- version_init_null (&version);
- else
- return 0;
- }
-
- /* Apparently, os-release in Debian and CentOS does not provide the full
- * version number in VERSION_ID, but just the "major" part of it.
- * Hence, if version.v_minor is 0, act as there was no information in
- * os-release, which will continue the inspection using the release files
- * as done previously.
- */
- if ((distro == OS_DISTRO_DEBIAN || distro == OS_DISTRO_CENTOS) &&
- version.v_minor == 0)
- return 0;
-
- /* We got everything, so set the fields and report the inspection
- * was successful.
- */
- fs->distro = distro;
- fs->product_name = product_name;
- product_name = NULL;
- fs->version = version;
-
- return 1;
-}
-
-/* Ubuntu has /etc/lsb-release containing:
- * DISTRIB_ID=Ubuntu # Distro
- * DISTRIB_RELEASE=10.04 # Version
- * DISTRIB_CODENAME=lucid
- * DISTRIB_DESCRIPTION="Ubuntu 10.04.1 LTS" # Product name
- *
- * [Ubuntu-derived ...] Linux Mint was found to have this:
- * DISTRIB_ID=LinuxMint
- * DISTRIB_RELEASE=10
- * DISTRIB_CODENAME=julia
- * DISTRIB_DESCRIPTION="Linux Mint 10 Julia"
- * Linux Mint also has /etc/linuxmint/info with more information,
- * but we can use the LSB file.
- *
- * Mandriva has:
- * LSB_VERSION=lsb-4.0-amd64:lsb-4.0-noarch
- * DISTRIB_ID=MandrivaLinux
- * DISTRIB_RELEASE=2010.1
- * DISTRIB_CODENAME=Henry_Farman
- * DISTRIB_DESCRIPTION="Mandriva Linux 2010.1"
- * Mandriva also has a normal release file called /etc/mandriva-release.
- *
- * CoreOS has a /etc/lsb-release link to /usr/share/coreos/lsb-release containing:
- * DISTRIB_ID=CoreOS
- * DISTRIB_RELEASE=647.0.0
- * DISTRIB_CODENAME="Red Dog"
- * DISTRIB_DESCRIPTION="CoreOS 647.0.0"
- */
-static int
-parse_lsb_release (guestfs_h *g, struct inspect_fs *fs, const char *filename)
-{
- int64_t size;
- CLEANUP_FREE_STRING_LIST char **lines = NULL;
- size_t i;
- int r = 0;
-
- /* Don't trust guestfs_head_n not to break with very large files.
- * Check the file size is something reasonable first.
- */
- size = guestfs_filesize (g, filename);
- if (size == -1)
- /* guestfs_filesize failed and has already set error in handle */
- return -1;
- if (size > MAX_SMALL_FILE_SIZE) {
- error (g, _("size of %s is unreasonably large (%" PRIi64 "
bytes)"),
- filename, size);
- return -1;
- }
-
- lines = guestfs_head_n (g, 10, filename);
- if (lines == NULL)
- return -1;
-
- for (i = 0; lines[i] != NULL; ++i) {
- if (fs->distro == 0 &&
- STREQ (lines[i], "DISTRIB_ID=Ubuntu")) {
- fs->distro = OS_DISTRO_UBUNTU;
- r = 1;
- }
- else if (fs->distro == 0 &&
- STREQ (lines[i], "DISTRIB_ID=LinuxMint")) {
- fs->distro = OS_DISTRO_LINUX_MINT;
- r = 1;
- }
- else if (fs->distro == 0 &&
- STREQ (lines[i], "DISTRIB_ID=MandrivaLinux")) {
- fs->distro = OS_DISTRO_MANDRIVA;
- r = 1;
- }
- else if (fs->distro == 0 &&
- STREQ (lines[i], "DISTRIB_ID=\"Mageia\"")) {
- fs->distro = OS_DISTRO_MAGEIA;
- r = 1;
- }
- else if (fs->distro == 0 &&
- STREQ (lines[i], "DISTRIB_ID=CoreOS")) {
- fs->distro = OS_DISTRO_COREOS;
- r = 1;
- }
- else if (STRPREFIX (lines[i], "DISTRIB_RELEASE=")) {
- if (guestfs_int_version_from_x_y_or_x (g, &fs->version, &lines[i][16])
== -1)
- return -1;
- }
- else if (fs->product_name == NULL &&
- (STRPREFIX (lines[i], "DISTRIB_DESCRIPTION=\"") ||
- STRPREFIX (lines[i], "DISTRIB_DESCRIPTION='"))) {
- const size_t len = strlen (lines[i]) - 21 - 1;
- fs->product_name = safe_strndup (g, &lines[i][21], len);
- r = 1;
- }
- else if (fs->product_name == NULL &&
- STRPREFIX (lines[i], "DISTRIB_DESCRIPTION=")) {
- const size_t len = strlen (lines[i]) - 20;
- fs->product_name = safe_strndup (g, &lines[i][20], len);
- r = 1;
- }
- }
-
- /* The unnecessary construct in the next line is required to
- * workaround -Wstrict-overflow warning in gcc 4.5.1.
- */
- return r ? 1 : 0;
-}
-
-static int
-parse_suse_release (guestfs_h *g, struct inspect_fs *fs, const char *filename)
-{
- int64_t size;
- CLEANUP_FREE_STRING_LIST char **lines = NULL;
- int r = -1;
-
- /* Don't trust guestfs_head_n not to break with very large files.
- * Check the file size is something reasonable first.
- */
- size = guestfs_filesize (g, filename);
- if (size == -1)
- /* guestfs_filesize failed and has already set error in handle */
- return -1;
- if (size > MAX_SMALL_FILE_SIZE) {
- error (g, _("size of %s is unreasonably large (%" PRIi64 "
bytes)"),
- filename, size);
- return -1;
- }
-
- lines = guestfs_head_n (g, 10, filename);
- if (lines == NULL)
- return -1;
-
- if (lines[0] == NULL)
- goto out;
-
- /* First line is dist release name */
- fs->product_name = safe_strdup (g, lines[0]);
-
- /* Match SLES first because openSuSE regex overlaps some SLES release strings */
- if (match (g, fs->product_name, re_sles) || match (g, fs->product_name, re_nld))
{
- char *major, *minor;
-
- fs->distro = OS_DISTRO_SLES;
-
- /* Second line contains version string */
- if (lines[1] == NULL)
- goto out;
- major = match1 (g, lines[1], re_sles_version);
- if (major == NULL)
- goto out;
- fs->version.v_major = guestfs_int_parse_unsigned_int (g, major);
- free (major);
- if (fs->version.v_major == -1)
- goto out;
-
- /* Third line contains service pack string */
- if (lines[2] == NULL)
- goto out;
- minor = match1 (g, lines[2], re_sles_patchlevel);
- if (minor == NULL)
- goto out;
- fs->version.v_minor = guestfs_int_parse_unsigned_int (g, minor);
- free (minor);
- if (fs->version.v_minor == -1)
- goto out;
- }
- else if (match (g, fs->product_name, re_opensuse)) {
- fs->distro = OS_DISTRO_OPENSUSE;
-
- /* Second line contains version string */
- if (lines[1] == NULL)
- goto out;
- if (guestfs_int_version_from_x_y_re (g, &fs->version, lines[1],
- re_opensuse_version) == -1)
- goto out;
- }
-
- r = 0;
-
- out:
- return r;
-}
-
-/* The currently mounted device is known to be a Linux root. Try to
- * determine from this the distro, version, etc. Also parse
- * /etc/fstab to determine the arrangement of mountpoints and
- * associated devices.
- */
-int
-guestfs_int_check_linux_root (guestfs_h *g, struct inspect_fs *fs)
-{
- int r;
- char *major, *minor;
-
- fs->type = OS_TYPE_LINUX;
-
- if (guestfs_is_file_opts (g, "/etc/os-release",
- GUESTFS_IS_FILE_OPTS_FOLLOWSYMLINKS, 1, -1) > 0) {
- r = parse_os_release (g, fs, "/etc/os-release");
- if (r == -1) /* error */
- return -1;
- if (r == 1) /* ok - detected the release from this file */
- goto skip_release_checks;
- }
-
- if (guestfs_is_file_opts (g, "/etc/lsb-release",
- GUESTFS_IS_FILE_OPTS_FOLLOWSYMLINKS, 1, -1) > 0) {
- r = parse_lsb_release (g, fs, "/etc/lsb-release");
- if (r == -1) /* error */
- return -1;
- if (r == 1) /* ok - detected the release from this file */
- goto skip_release_checks;
- }
-
- /* RHEL-based distros include a "/etc/redhat-release" file, hence their
- * checks need to be performed before the Red-Hat one.
- */
- if (guestfs_is_file_opts (g, "/etc/oracle-release",
- GUESTFS_IS_FILE_OPTS_FOLLOWSYMLINKS, 1, -1) > 0) {
-
- fs->distro = OS_DISTRO_ORACLE_LINUX;
-
- if (parse_release_file (g, fs, "/etc/oracle-release") == -1)
- return -1;
-
- if (match2 (g, fs->product_name, re_oracle_linux_old, &major, &minor) ||
- match2 (g, fs->product_name, re_oracle_linux, &major, &minor)) {
- fs->version.v_major = guestfs_int_parse_unsigned_int (g, major);
- free (major);
- if (fs->version.v_major == -1) {
- free (minor);
- return -1;
- }
- fs->version.v_minor = guestfs_int_parse_unsigned_int (g, minor);
- free (minor);
- if (fs->version.v_minor == -1)
- return -1;
- } else if ((major = match1 (g, fs->product_name, re_oracle_linux_no_minor)) !=
NULL) {
- fs->version.v_major = guestfs_int_parse_unsigned_int (g, major);
- free (major);
- if (fs->version.v_major == -1)
- return -1;
- fs->version.v_minor = 0;
- }
- }
- else if (guestfs_is_file_opts (g, "/etc/centos-release",
- GUESTFS_IS_FILE_OPTS_FOLLOWSYMLINKS, 1, -1) > 0) {
- fs->distro = OS_DISTRO_CENTOS;
-
- if (parse_release_file (g, fs, "/etc/centos-release") == -1)
- return -1;
-
- if (match2 (g, fs->product_name, re_centos_old, &major, &minor) ||
- match2 (g, fs->product_name, re_centos, &major, &minor)) {
- fs->version.v_major = guestfs_int_parse_unsigned_int (g, major);
- free (major);
- if (fs->version.v_major == -1) {
- free (minor);
- return -1;
- }
- fs->version.v_minor = guestfs_int_parse_unsigned_int (g, minor);
- free (minor);
- if (fs->version.v_minor == -1)
- return -1;
- }
- else if ((major = match1 (g, fs->product_name, re_centos_no_minor)) != NULL) {
- fs->version.v_major = guestfs_int_parse_unsigned_int (g, major);
- free (major);
- if (fs->version.v_major == -1)
- return -1;
- fs->version.v_minor = 0;
- }
- }
- else if (guestfs_is_file_opts (g, "/etc/altlinux-release",
- GUESTFS_IS_FILE_OPTS_FOLLOWSYMLINKS, 1, -1) > 0) {
- fs->distro = OS_DISTRO_ALTLINUX;
-
- if (parse_release_file (g, fs, "/etc/altlinux-release") == -1)
- return -1;
-
- if (guestfs_int_version_from_x_y_re (g, &fs->version, fs->product_name,
- re_altlinux) == -1)
- return -1;
- }
- else if (guestfs_is_file_opts (g, "/etc/redhat-release",
- GUESTFS_IS_FILE_OPTS_FOLLOWSYMLINKS, 1, -1) > 0) {
- fs->distro = OS_DISTRO_REDHAT_BASED; /* Something generic Red Hat-like. */
-
- if (parse_release_file (g, fs, "/etc/redhat-release") == -1)
- return -1;
-
- if ((major = match1 (g, fs->product_name, re_fedora)) != NULL) {
- fs->distro = OS_DISTRO_FEDORA;
- fs->version.v_major = guestfs_int_parse_unsigned_int (g, major);
- free (major);
- if (fs->version.v_major == -1)
- return -1;
- }
- else if (match2 (g, fs->product_name, re_rhel_old, &major, &minor) ||
- match2 (g, fs->product_name, re_rhel, &major, &minor)) {
- fs->distro = OS_DISTRO_RHEL;
- fs->version.v_major = guestfs_int_parse_unsigned_int (g, major);
- free (major);
- if (fs->version.v_major == -1) {
- free (minor);
- return -1;
- }
- fs->version.v_minor = guestfs_int_parse_unsigned_int (g, minor);
- free (minor);
- if (fs->version.v_minor == -1)
- return -1;
- }
- else if ((major = match1 (g, fs->product_name, re_rhel_no_minor)) != NULL) {
- fs->distro = OS_DISTRO_RHEL;
- fs->version.v_major = guestfs_int_parse_unsigned_int (g, major);
- free (major);
- if (fs->version.v_major == -1)
- return -1;
- fs->version.v_minor = 0;
- }
- else if (match2 (g, fs->product_name, re_centos_old, &major, &minor) ||
- match2 (g, fs->product_name, re_centos, &major, &minor)) {
- fs->distro = OS_DISTRO_CENTOS;
- fs->version.v_major = guestfs_int_parse_unsigned_int (g, major);
- free (major);
- if (fs->version.v_major == -1) {
- free (minor);
- return -1;
- }
- fs->version.v_minor = guestfs_int_parse_unsigned_int (g, minor);
- free (minor);
- if (fs->version.v_minor == -1)
- return -1;
- }
- else if ((major = match1 (g, fs->product_name, re_centos_no_minor)) != NULL) {
- fs->distro = OS_DISTRO_CENTOS;
- fs->version.v_major = guestfs_int_parse_unsigned_int (g, major);
- free (major);
- if (fs->version.v_major == -1)
- return -1;
- fs->version.v_minor = 0;
- }
- else if (match2 (g, fs->product_name, re_scientific_linux_old, &major,
&minor) ||
- match2 (g, fs->product_name, re_scientific_linux, &major,
&minor)) {
- fs->distro = OS_DISTRO_SCIENTIFIC_LINUX;
- fs->version.v_major = guestfs_int_parse_unsigned_int (g, major);
- free (major);
- if (fs->version.v_major == -1) {
- free (minor);
- return -1;
- }
- fs->version.v_minor = guestfs_int_parse_unsigned_int (g, minor);
- free (minor);
- if (fs->version.v_minor == -1)
- return -1;
- }
- else if ((major = match1 (g, fs->product_name, re_scientific_linux_no_minor)) !=
NULL) {
- fs->distro = OS_DISTRO_SCIENTIFIC_LINUX;
- fs->version.v_major = guestfs_int_parse_unsigned_int (g, major);
- free (major);
- if (fs->version.v_major == -1)
- return -1;
- fs->version.v_minor = 0;
- }
- }
- else if (guestfs_is_file_opts (g, "/etc/debian_version",
- GUESTFS_IS_FILE_OPTS_FOLLOWSYMLINKS, 1, -1) > 0) {
- fs->distro = OS_DISTRO_DEBIAN;
-
- if (parse_release_file (g, fs, "/etc/debian_version") == -1)
- return -1;
-
- if (guestfs_int_parse_major_minor (g, fs) == -1)
- return -1;
- }
- else if (guestfs_is_file_opts (g, "/etc/pardus-release",
- GUESTFS_IS_FILE_OPTS_FOLLOWSYMLINKS, 1, -1) > 0) {
- fs->distro = OS_DISTRO_PARDUS;
-
- if (parse_release_file (g, fs, "/etc/pardus-release") == -1)
- return -1;
-
- if (guestfs_int_parse_major_minor (g, fs) == -1)
- return -1;
- }
- else if (guestfs_is_file_opts (g, "/etc/arch-release",
- GUESTFS_IS_FILE_OPTS_FOLLOWSYMLINKS, 1, -1) > 0) {
- fs->distro = OS_DISTRO_ARCHLINUX;
-
- /* /etc/arch-release file is empty and I can't see a way to
- * determine the actual release or product string.
- */
- }
- else if (guestfs_is_file_opts (g, "/etc/gentoo-release",
- GUESTFS_IS_FILE_OPTS_FOLLOWSYMLINKS, 1, -1) > 0) {
- fs->distro = OS_DISTRO_GENTOO;
-
- if (parse_release_file (g, fs, "/etc/gentoo-release") == -1)
- return -1;
-
- if (guestfs_int_parse_major_minor (g, fs) == -1)
- return -1;
- }
- else if (guestfs_is_file_opts (g, "/etc/meego-release",
- GUESTFS_IS_FILE_OPTS_FOLLOWSYMLINKS, 1, -1) > 0) {
- fs->distro = OS_DISTRO_MEEGO;
-
- if (parse_release_file (g, fs, "/etc/meego-release") == -1)
- return -1;
-
- if (guestfs_int_parse_major_minor (g, fs) == -1)
- return -1;
- }
- else if (guestfs_is_file_opts (g, "/etc/slackware-version",
- GUESTFS_IS_FILE_OPTS_FOLLOWSYMLINKS, 1, -1) > 0) {
- fs->distro = OS_DISTRO_SLACKWARE;
-
- if (parse_release_file (g, fs, "/etc/slackware-version") == -1)
- return -1;
-
- if (guestfs_int_parse_major_minor (g, fs) == -1)
- return -1;
- }
- else if (guestfs_is_file_opts (g, "/etc/ttylinux-target",
- GUESTFS_IS_FILE_OPTS_FOLLOWSYMLINKS, 1, -1) > 0) {
- fs->distro = OS_DISTRO_TTYLINUX;
-
- if (parse_release_file (g, fs, "/etc/ttylinux-target") == -1)
- return -1;
-
- if (guestfs_int_parse_major_minor (g, fs) == -1)
- return -1;
- }
- else if (guestfs_is_file_opts (g, "/etc/SuSE-release",
- GUESTFS_IS_FILE_OPTS_FOLLOWSYMLINKS, 1, -1) > 0) {
- fs->distro = OS_DISTRO_SUSE_BASED;
-
- if (parse_suse_release (g, fs, "/etc/SuSE-release") == -1)
- return -1;
-
- }
- /* CirrOS versions providing a own version file.
- */
- else if (guestfs_is_file_opts (g, "/etc/cirros/version",
- GUESTFS_IS_FILE_OPTS_FOLLOWSYMLINKS, 1, -1) > 0) {
- fs->distro = OS_DISTRO_CIRROS;
-
- if (parse_release_file (g, fs, "/etc/cirros/version") == -1)
- return -1;
-
- if (guestfs_int_parse_major_minor (g, fs) == -1)
- return -1;
- }
- /* Buildroot (
http://buildroot.net) is an embedded Linux distro
- * toolkit. It is used by specific distros such as Cirros.
- */
- else if (guestfs_is_file_opts (g, "/etc/br-version",
- GUESTFS_IS_FILE_OPTS_FOLLOWSYMLINKS, 1, -1) > 0) {
- if (guestfs_is_file_opts (g, "/usr/share/cirros/logo",
- GUESTFS_IS_FILE_OPTS_FOLLOWSYMLINKS, 1, -1) > 0)
- fs->distro = OS_DISTRO_CIRROS;
- else
- fs->distro = OS_DISTRO_BUILDROOT;
-
- /* /etc/br-version has the format YYYY.MM[-git/hg/svn release] */
- if (parse_release_file (g, fs, "/etc/br-version") == -1)
- return -1;
-
- if (guestfs_int_parse_major_minor (g, fs) == -1)
- return -1;
- }
- else if (guestfs_is_file_opts (g, "/etc/alpine-release",
- GUESTFS_IS_FILE_OPTS_FOLLOWSYMLINKS, 1, -1) > 0) {
- fs->distro = OS_DISTRO_ALPINE_LINUX;
-
- if (parse_release_file (g, fs, "/etc/alpine-release") == -1)
- return -1;
-
- if (guestfs_int_parse_major_minor (g, fs) == -1)
- return -1;
- }
- else if (guestfs_is_file_opts (g, "/etc/frugalware-release",
- GUESTFS_IS_FILE_OPTS_FOLLOWSYMLINKS, 1, -1) > 0) {
- fs->distro = OS_DISTRO_FRUGALWARE;
-
- if (parse_release_file (g, fs, "/etc/frugalware-release") == -1)
- return -1;
-
- if (guestfs_int_version_from_x_y_re (g, &fs->version, fs->product_name,
- re_frugalware) == -1)
- return -1;
- }
- else if (guestfs_is_file_opts (g, "/etc/pld-release",
- GUESTFS_IS_FILE_OPTS_FOLLOWSYMLINKS, 1, -1) > 0) {
- fs->distro = OS_DISTRO_PLD_LINUX;
-
- if (parse_release_file (g, fs, "/etc/pld-release") == -1)
- return -1;
-
- if (guestfs_int_version_from_x_y_re (g, &fs->version, fs->product_name,
- re_pldlinux) == -1)
- return -1;
- }
-
- skip_release_checks:;
-
- /* Determine the architecture. */
- check_architecture (g, fs);
-
- /* We already know /etc/fstab exists because it's part of the test
- * for Linux root above. We must now parse this file to determine
- * which filesystems are used by the operating system and how they
- * are mounted.
- */
- const char *configfiles[] = { "/etc/fstab", "/etc/mdadm.conf", NULL
};
- if (inspect_with_augeas (g, fs, configfiles, check_fstab) == -1)
- return -1;
-
- /* Determine hostname. */
- if (check_hostname_unix (g, fs) == -1)
- return -1;
-
- return 0;
-}
-
/* The currently mounted device looks like a Linux /usr. */
int
guestfs_int_check_linux_usr (guestfs_h *g, struct inspect_fs *fs)
@@ -1072,44 +364,6 @@ guestfs_int_check_coreos_usr (guestfs_h *g, struct inspect_fs *fs)
return 0;
}
-static void
-check_architecture (guestfs_h *g, struct inspect_fs *fs)
-{
- const char *binaries[] =
- { "/bin/bash", "/bin/ls", "/bin/echo",
"/bin/rm", "/bin/sh" };
- size_t i;
- char *arch = NULL;
-
- for (i = 0; i < sizeof binaries / sizeof binaries[0]; ++i) {
- /* Allow symlinks when checking the binaries:,so in case they are
- * relative ones (which can be resolved within the same partition),
- * then we can check the architecture of their target.
- */
- if (guestfs_is_file_opts (g, binaries[i],
- GUESTFS_IS_FILE_OPTS_FOLLOWSYMLINKS, 1, -1) > 0) {
- CLEANUP_FREE char *resolved = NULL;
-
- /* Ignore errors from realpath and file_architecture calls. */
- guestfs_push_error_handler (g, NULL, NULL);
- resolved = guestfs_realpath (g, binaries[i]);
- /* If is_file above succeeded realpath should too, but better
- * be safe than sorry.
- */
- if (resolved)
- arch = guestfs_file_architecture (g, resolved);
- guestfs_pop_error_handler (g);
-
- if (arch) {
- /* String will be owned by handle, freed by
- * guestfs_int_free_inspect_info.
- */
- fs->arch = arch;
- break;
- }
- }
- }
-}
-
/* Try several methods to determine the hostname from a Linux or
* FreeBSD guest. Note that type and distro have been set, so we can
* use that information to direct the search.
@@ -1198,29 +452,6 @@ check_hostname_unix (guestfs_h *g, struct inspect_fs *fs)
return 0;
}
-/* Parse the hostname from /etc/sysconfig/network. This must be
- * called from the inspect_with_augeas wrapper. Note that F18+ and
- * RHEL7+ use /etc/hostname just like Debian.
- */
-static int
-check_hostname_redhat (guestfs_h *g, struct inspect_fs *fs)
-{
- char *hostname;
-
- /* Errors here are not fatal (RHBZ#726739), since it could be
- * just missing HOSTNAME field in the file.
- */
- guestfs_push_error_handler (g, NULL, NULL);
- hostname = guestfs_aug_get (g, "/files/etc/sysconfig/network/HOSTNAME");
- guestfs_pop_error_handler (g);
-
- /* This is freed by guestfs_int_free_inspect_info. Note that hostname
- * could be NULL because we ignored errors above.
- */
- fs->hostname = hostname;
- return 0;
-}
-
/* Parse the hostname from /etc/rc.conf. On FreeBSD this file
* contains comments, blank lines and:
* hostname="freebsd8.example.com"
@@ -1269,890 +500,4 @@ check_hostname_freebsd (guestfs_h *g, struct inspect_fs *fs)
return 0;
}
-static int
-check_fstab (guestfs_h *g, struct inspect_fs *fs)
-{
- CLEANUP_FREE_STRING_LIST char **entries = NULL;
- char **entry;
- char augpath[256];
- CLEANUP_HASH_FREE Hash_table *md_map = NULL;
- bool is_bsd = (fs->type == OS_TYPE_FREEBSD ||
- fs->type == OS_TYPE_NETBSD ||
- fs->type == OS_TYPE_OPENBSD);
-
- /* Generate a map of MD device paths listed in /etc/mdadm.conf to MD device
- * paths in the guestfs appliance */
- if (map_md_devices (g, &md_map) == -1) return -1;
-
- entries = guestfs_aug_match (g, "/files/etc/fstab/*[label() !=
'#comment']");
- if (entries == NULL)
- return -1;
-
- for (entry = entries; *entry != NULL; entry++) {
- CLEANUP_FREE char *spec = NULL;
- CLEANUP_FREE char *mp = NULL;
- CLEANUP_FREE char *mountable = NULL;
- CLEANUP_FREE char *vfstype = NULL;
-
- snprintf (augpath, sizeof augpath, "%s/spec", *entry);
- spec = guestfs_aug_get (g, augpath);
- if (spec == NULL)
- return -1;
-
- /* Ignore /dev/fd (floppy disks) (RHBZ#642929) and CD-ROM drives.
- *
- * /dev/iso9660/FREEBSD_INSTALL can be found in FreeBSDs installation
- * discs.
- */
- if ((STRPREFIX (spec, "/dev/fd") && c_isdigit (spec[7])) ||
- (STRPREFIX (spec, "/dev/cd") && c_isdigit (spec[7])) ||
- STREQ (spec, "/dev/floppy") ||
- STREQ (spec, "/dev/cdrom") ||
- STRPREFIX (spec, "/dev/iso9660/"))
- continue;
-
- snprintf (augpath, sizeof augpath, "%s/file", *entry);
- mp = guestfs_aug_get (g, augpath);
- if (mp == NULL)
- return -1;
-
- /* Canonicalize the path, so "///usr//local//" -> "/usr/local"
*/
- canonical_mountpoint (mp);
-
- /* Ignore certain mountpoints. */
- if (STRPREFIX (mp, "/dev/") ||
- STREQ (mp, "/dev") ||
- STRPREFIX (mp, "/media/") ||
- STRPREFIX (mp, "/proc/") ||
- STREQ (mp, "/proc") ||
- STRPREFIX (mp, "/selinux/") ||
- STREQ (mp, "/selinux") ||
- STRPREFIX (mp, "/sys/") ||
- STREQ (mp, "/sys"))
- continue;
-
- /* Resolve UUID= and LABEL= to the actual device. */
- if (STRPREFIX (spec, "UUID=")) {
- CLEANUP_FREE char *s = guestfs_int_shell_unquote (&spec[5]);
- if (s == NULL) { perrorf (g, "guestfs_int_shell_unquote"); return -1; }
- mountable = guestfs_findfs_uuid (g, s);
- }
- else if (STRPREFIX (spec, "LABEL=")) {
- CLEANUP_FREE char *s = guestfs_int_shell_unquote (&spec[6]);
- if (s == NULL) { perrorf (g, "guestfs_int_shell_unquote"); return -1; }
- mountable = guestfs_findfs_label (g, s);
- }
- /* Ignore "/.swap" (Pardus) and pseudo-devices like "tmpfs". */
- else if (STREQ (spec, "/dev/root") || (is_bsd && STREQ (mp,
"/")))
- /* Resolve /dev/root to the current device.
- * Do the same for the / partition of the *BSD systems, since the
- * BSD -> Linux device translation is not straight forward.
- */
- mountable = safe_strdup (g, fs->mountable);
- else if (STRPREFIX (spec, "/dev/"))
- /* Resolve guest block device names. */
- mountable = resolve_fstab_device (g, spec, md_map, fs->type);
- else if (match (g, spec, re_openbsd_duid)) {
- /* In OpenBSD's fstab you can specify partitions on a disk by appending a
- * period and a partition letter to a Disklable Unique Identifier. The
- * DUID is a 16 hex digit field found in the OpenBSD's altered BSD
- * disklabel. For more info see here:
- *
http://www.openbsd.org/faq/faq14.html#intro
- */
- char device[10]; /* /dev/sd[0-9][a-z] */
- char part = spec[17];
-
- /* We cannot peep into disklables, we can only assume that this is the
- * first disk.
- */
- snprintf(device, 10, "%s%c", "/dev/sd0", part);
- mountable = resolve_fstab_device (g, device, md_map, fs->type);
- }
-
- /* If we haven't resolved the device successfully by this point,
- * we don't care, just ignore it.
- */
- if (mountable == NULL)
- continue;
-
- snprintf (augpath, sizeof augpath, "%s/vfstype", *entry);
- vfstype = guestfs_aug_get (g, augpath);
- if (vfstype == NULL) return -1;
-
- if (STREQ (vfstype, "btrfs")) {
- size_t i;
-
- snprintf (augpath, sizeof augpath, "%s/opt", *entry);
- CLEANUP_FREE_STRING_LIST char **opts = guestfs_aug_match (g, augpath);
- if (opts == NULL) return -1;
-
- for (i = 0; opts[i] != NULL; ++i) {
- CLEANUP_FREE char *optname = NULL, *optvalue = NULL, *subvol = NULL;
- char *old_mountable;
-
- optname = guestfs_aug_get (g, opts[i]);
- if (optname == NULL) return -1;
-
- if (STREQ (optname, "subvol")) {
- optvalue = safe_asprintf (g, "%s/value", opts[i]);
-
- subvol = guestfs_aug_get (g, optvalue);
- if (subvol == NULL) return -1;
-
- old_mountable = mountable;
- mountable = safe_asprintf (g, "btrfsvol:%s/%s", mountable, subvol);
- free (old_mountable);
- }
- }
- }
-
- add_fstab_entry (g, fs, mountable, mp);
- }
-
- return 0;
-}
-
-/* Add a filesystem and possibly a mountpoint entry for
- * the root filesystem 'fs'.
- *
- * 'spec' is the fstab spec field, which might be a device name or a
- * pseudodevice or 'UUID=...' or 'LABEL=...'.
- *
- * 'mp' is the mount point, which could also be 'swap' or
'none'.
- */
-static void
-add_fstab_entry (guestfs_h *g, struct inspect_fs *fs,
- const char *mountable, const char *mountpoint)
-{
- /* Add this to the fstab entry in 'fs'.
- * Note these are further filtered by guestfs_inspect_get_mountpoints
- * and guestfs_inspect_get_filesystems.
- */
- const size_t n = fs->nr_fstab + 1;
- struct inspect_fstab_entry *p;
-
- p = safe_realloc (g, fs->fstab, n * sizeof (struct inspect_fstab_entry));
-
- fs->fstab = p;
- fs->nr_fstab = n;
-
- /* These are owned by the handle and freed by guestfs_int_free_inspect_info. */
- fs->fstab[n-1].mountable = safe_strdup (g, mountable);
- fs->fstab[n-1].mountpoint = safe_strdup (g, mountpoint);
-
- debug (g, "fstab: mountable=%s mountpoint=%s", mountable, mountpoint);
-}
-
-/* Compute a uuid hash as a simple xor of of its 4 32bit components */
-static size_t
-uuid_hash(const void *x, size_t table_size)
-{
- const md_uuid *a = x;
- size_t h, i;
-
- h = a->uuid[0];
- for (i = 1; i < 4; i++) {
- h ^= a->uuid[i];
- }
-
- return h % table_size;
-}
-
-static bool
-uuid_cmp(const void *x, const void *y)
-{
- const md_uuid *a = x;
- const md_uuid *b = y;
- size_t i;
-
- for (i = 0; i < 1; i++) {
- if (a->uuid[i] != b->uuid[i]) return 0;
- }
-
- return 1;
-}
-
-static void
-md_uuid_free(void *x)
-{
- md_uuid *a = x;
- free(a->path);
- free(a);
-}
-
-/* Taken from parse_uuid in mdadm */
-static int
-parse_uuid (const char *str, uint32_t *uuid)
-{
- size_t hit = 0; /* number of Hex digIT */
- char c;
- size_t i;
- int n;
-
- for (i = 0; i < 4; i++)
- uuid[i] = 0;
-
- while ((c = *str++)) {
- if (c >= '0' && c <= '9')
- n = c - '0';
- else if (c >= 'a' && c <= 'f')
- n = 10 + c - 'a';
- else if (c >= 'A' && c <= 'F')
- n = 10 + c - 'A';
- else if (strchr (":. -", c))
- continue;
- else
- return -1;
-
- if (hit < 32) {
- uuid[hit / 8] <<= 4;
- uuid[hit / 8] += n;
- }
- hit++;
- }
- if (hit == 32) return 0;
-
- return -1;
-}
-
-/* Create a mapping of uuids to appliance md device names */
-static ssize_t
-map_app_md_devices (guestfs_h *g, Hash_table **map)
-{
- CLEANUP_FREE_STRING_LIST char **mds = NULL;
- size_t n = 0;
- char **md;
-
- /* A hash mapping uuids to md device names */
- *map = hash_initialize(16, NULL, uuid_hash, uuid_cmp, md_uuid_free);
- if (*map == NULL) g->abort_cb();
-
- mds = guestfs_list_md_devices(g);
- if (mds == NULL) goto error;
-
- for (md = mds; *md != NULL; md++) {
- char **i;
- CLEANUP_FREE_STRING_LIST char **detail = guestfs_md_detail (g, *md);
- if (detail == NULL) goto error;
-
- /* Iterate over keys until we find uuid */
- for (i = detail; *i != NULL; i += 2) {
- if (STREQ(*i, "uuid")) break;
- }
-
- /* We found it */
- if (*i) {
- md_uuid *entry;
-
- /* Next item is the uuid value */
- i++;
-
- entry = safe_malloc(g, sizeof(md_uuid));
- entry->path = safe_strdup(g, *md);
-
- if (parse_uuid(*i, entry->uuid) == -1) {
- /* Invalid UUID is weird, but not fatal. */
- debug(g, "inspect-os: guestfs_md_detail returned invalid "
- "uuid for %s: %s", *md, *i);
- md_uuid_free(entry);
- continue;
- }
-
- const void *matched = NULL;
- switch (hash_insert_if_absent(*map, entry, &matched)) {
- case -1:
- g->abort_cb();
-
- case 0:
- /* Duplicate uuid in for md device is weird, but not fatal. */
- debug(g, "inspect-os: md devices %s and %s have the same uuid",
- ((md_uuid *)matched)->path, entry->path);
- md_uuid_free(entry);
- break;
-
- default:
- n++;
- }
- }
- }
-
- return n;
-
- error:
- hash_free (*map); *map = NULL;
-
- return -1;
-}
-
-static size_t
-mdadm_app_hash(const void *x, size_t table_size)
-{
- const mdadm_app *a = x;
- return hash_pjw(a->mdadm, table_size);
-}
-
-static bool
-mdadm_app_cmp(const void *x, const void *y)
-{
- const mdadm_app *a = x;
- const mdadm_app *b = y;
-
- return STREQ (a->mdadm, b->mdadm);
-}
-
-static void
-mdadm_app_free(void *x)
-{
- mdadm_app *a = x;
- free(a->mdadm);
- free(a->app);
- free(a);
-}
-
-/* Get a map of md device names in mdadm.conf to their device names in the
- * appliance */
-static int
-map_md_devices(guestfs_h *g, Hash_table **map)
-{
- CLEANUP_HASH_FREE Hash_table *app_map = NULL;
- CLEANUP_FREE_STRING_LIST char **matches = NULL;
- ssize_t n_app_md_devices;
-
- *map = NULL;
-
- /* Get a map of md device uuids to their device names in the appliance */
- n_app_md_devices = map_app_md_devices (g, &app_map);
- if (n_app_md_devices == -1) goto error;
-
- /* Nothing to do if there are no md devices */
- if (n_app_md_devices == 0)
- return 0;
-
- /* Get all arrays listed in mdadm.conf */
- matches = guestfs_aug_match(g, "/files/etc/mdadm.conf/array");
- if (!matches) goto error;
-
- /* Log a debug message if we've got md devices, but nothing in mdadm.conf */
- if (matches[0] == NULL) {
- debug(g, "Appliance has MD devices, but augeas returned no array matches "
- "in mdadm.conf");
- return 0;
- }
-
- *map = hash_initialize(16, NULL, mdadm_app_hash, mdadm_app_cmp,
- mdadm_app_free);
- if (!*map) g->abort_cb();
-
- for (char **m = matches; *m != NULL; m++) {
- /* Get device name and uuid for each array */
- CLEANUP_FREE char *dev_path = safe_asprintf (g, "%s/devicename", *m);
- char *dev = guestfs_aug_get (g, dev_path);
- if (!dev) goto error;
-
- CLEANUP_FREE char *uuid_path = safe_asprintf (g, "%s/uuid", *m);
- CLEANUP_FREE char *uuid = guestfs_aug_get (g, uuid_path);
- if (!uuid) {
- free (dev);
- continue;
- }
-
- /* Parse the uuid into an md_uuid structure so we can look it up in the
- * uuid->appliance device map */
- md_uuid mdadm;
- mdadm.path = dev;
- if (parse_uuid(uuid, mdadm.uuid) == -1) {
- /* Invalid uuid. Weird, but not fatal. */
- debug(g, "inspect-os: mdadm.conf contains invalid uuid for %s: %s",
- dev, uuid);
- free (dev);
- continue;
- }
-
- /* If there's a corresponding uuid in the appliance, create a new
- * entry in the transitive map */
- md_uuid *app = hash_lookup(app_map, &mdadm);
- if (app) {
- mdadm_app *entry = safe_malloc(g, sizeof(mdadm_app));
- entry->mdadm = dev;
- entry->app = safe_strdup(g, app->path);
-
- switch (hash_insert_if_absent(*map, entry, NULL)) {
- case -1:
- g->abort_cb();
-
- case 0:
- /* Duplicate uuid in for md device is weird, but not fatal. */
- debug(g, "inspect-os: mdadm.conf contains multiple entries for %s",
- app->path);
- mdadm_app_free(entry);
- continue;
- }
- } else
- free (dev);
- }
-
- return 0;
-
- error:
- if (*map) hash_free (*map);
-
- return -1;
-}
-
-static int
-resolve_fstab_device_xdev (guestfs_h *g, const char *type, const char *disk,
- const char *part, char **device_ret)
-{
- CLEANUP_FREE char *name = NULL;
- char *device;
- CLEANUP_FREE_STRING_LIST char **devices = NULL;
- size_t i, count;
- struct drive *drv;
- const char *p;
-
- /* type: (h|s|v|xv)
- * disk: ([a-z]+)
- * part: (\d*)
- */
-
- devices = guestfs_list_devices (g);
- if (devices == NULL)
- return -1;
-
- /* Check any hints we were passed for a non-heuristic mapping */
- name = safe_asprintf (g, "%sd%s", type, disk);
- ITER_DRIVES (g, i, drv) {
- if (drv->name && STREQ (drv->name, name)) {
- device = safe_asprintf (g, "%s%s", devices[i], part);
- if (!guestfs_int_is_partition (g, device)) {
- free (device);
- return 0;
- }
- *device_ret = device;
- break;
- }
- }
-
- /* Guess the appliance device name if we didn't find a matching hint */
- if (!*device_ret) {
- /* Count how many disks the libguestfs appliance has */
- for (count = 0; devices[count] != NULL; count++)
- ;
-
- /* Calculate the numerical index of the disk */
- i = disk[0] - 'a';
- for (p = disk + 1; *p != '\0'; p++) {
- i += 1; i *= 26;
- i += *p - 'a';
- }
-
- /* Check the index makes sense wrt the number of disks the appliance has.
- * If it does, map it to an appliance disk.
- */
- if (i < count) {
- device = safe_asprintf (g, "%s%s", devices[i], part);
- if (!guestfs_int_is_partition (g, device)) {
- free (device);
- return 0;
- }
- *device_ret = device;
- }
- }
-
- return 0;
-}
-
-static int
-resolve_fstab_device_cciss (guestfs_h *g, const char *disk, const char *part,
- char **device_ret)
-{
- char *device;
- CLEANUP_FREE_STRING_LIST char **devices = NULL;
- size_t i;
- struct drive *drv;
-
- /* disk: (cciss/c\d+d\d+)
- * part: (\d+)?
- */
-
- devices = guestfs_list_devices (g);
- if (devices == NULL)
- return -1;
-
- /* Check any hints we were passed for a non-heuristic mapping */
- ITER_DRIVES (g, i, drv) {
- if (drv->name && STREQ (drv->name, disk)) {
- if (part) {
- device = safe_asprintf (g, "%s%s", devices[i], part);
- if (!guestfs_int_is_partition (g, device)) {
- free (device);
- return 0;
- }
- *device_ret = device;
- }
- else
- *device_ret = safe_strdup (g, devices[i]);
- break;
- }
- }
-
- /* We don't try to guess mappings for cciss devices */
- return 0;
-}
-
-static int
-resolve_fstab_device_diskbyid (guestfs_h *g, const char *part,
- char **device_ret)
-{
- int nr_devices;
- char *device;
-
- /* For /dev/disk/by-id there is a limit to what we can do because
- * original SCSI ID information has likely been lost. This
- * heuristic will only work for guests that have a single block
- * device.
- *
- * So the main task here is to make sure the assumptions above are
- * true.
- *
- * XXX Use hints from virt-p2v if available.
- * See also:
https://bugzilla.redhat.com/show_bug.cgi?id=836573#c3
- */
-
- nr_devices = guestfs_nr_devices (g);
- if (nr_devices == -1)
- return -1;
-
- /* If #devices isn't 1, give up trying to translate this fstab entry. */
- if (nr_devices != 1)
- return 0;
-
- /* Make the partition name and check it exists. */
- device = safe_asprintf (g, "/dev/sda%s", part);
- if (!guestfs_int_is_partition (g, device)) {
- free (device);
- return 0;
- }
-
- *device_ret = device;
- return 0;
-}
-
-/* Resolve block device name to the libguestfs device name, eg.
- * /dev/xvdb1 => /dev/vdb1; and /dev/mapper/VG-LV => /dev/VG/LV. This
- * assumes that disks were added in the same order as they appear to
- * the real VM, which is a reasonable assumption to make. Return
- * anything we don't recognize unchanged.
- */
-static char *
-resolve_fstab_device (guestfs_h *g, const char *spec, Hash_table *md_map,
- enum inspect_os_type os_type)
-{
- char *device = NULL;
- char *type, *slice, *disk, *part;
- int r;
-
- if (STRPREFIX (spec, "/dev/mapper/")) {
- /* LVM2 does some strange munging on /dev/mapper paths for VGs and
- * LVs which contain '-' character:
- *
- * ><fs> lvcreate LV--test VG--test 32
- * ><fs> debug ls /dev/mapper
- * VG----test-LV----test
- *
- * This makes it impossible to reverse those paths directly, so
- * we have implemented lvm_canonical_lv_name in the daemon.
- */
- guestfs_push_error_handler (g, NULL, NULL);
- device = guestfs_lvm_canonical_lv_name (g, spec);
- guestfs_pop_error_handler (g);
- if (device == NULL) {
- if (guestfs_last_errno (g) == ENOENT) {
- /* Ignore devices that don't exist. (RHBZ#811872) */
- } else {
- guestfs_int_error_errno (g, guestfs_last_errno (g), "%s",
guestfs_last_error (g));
- return NULL;
- }
- }
- }
- else if (match3 (g, spec, re_xdev, &type, &disk, &part)) {
- r = resolve_fstab_device_xdev (g, type, disk, part, &device);
- free (type);
- free (disk);
- free (part);
- if (r == -1)
- return NULL;
- }
- else if (match2 (g, spec, re_cciss, &disk, &part)) {
- r = resolve_fstab_device_cciss (g, disk, part, &device);
- free (disk);
- free (part);
- if (r == -1)
- return NULL;
- }
- else if (md_map && (disk = match1 (g, spec, re_mdN)) != NULL) {
- mdadm_app entry;
- entry.mdadm = disk;
-
- mdadm_app *app = hash_lookup (md_map, &entry);
- if (app) device = safe_strdup (g, app->app);
-
- free (disk);
- }
- else if (match3 (g, spec, re_freebsd_gpt, &type, &disk, &part)) {
- /* If the FreeBSD disk contains GPT partitions, the translation to Linux
- * device names is straight forward. Partitions on a virtio disk are
- * prefixed with vtbd. IDE hard drives used to be prefixed with ad and now
- * are with ada.
- */
- const int disk_i = guestfs_int_parse_unsigned_int (g, disk);
- const int part_i = guestfs_int_parse_unsigned_int (g, part);
- free (type);
- free (disk);
- free (part);
-
- if (disk_i != -1 && disk_i <= 26 && part_i > 0 &&
part_i <= 128)
- device = safe_asprintf (g, "/dev/sd%c%d", disk_i + 'a', part_i);
- }
- else if (match4 (g, spec, re_freebsd_mbr, &type, &disk, &slice, &part))
{
- /* FreeBSD disks are organized quite differently. See:
- *
http://www.freebsd.org/doc/handbook/disk-organization.html
- * FreeBSD "partitions" are exposed as quasi-extended partitions
- * numbered from 5 in Linux. I have no idea what happens when you
- * have multiple "slices" (the FreeBSD term for MBR partitions).
- */
- const int disk_i = guestfs_int_parse_unsigned_int (g, disk);
- const int slice_i = guestfs_int_parse_unsigned_int (g, slice);
- int part_i = part[0] - 'a' /* counting from 0 */;
- free (type);
- free (disk);
- free (slice);
- free (part);
-
- if (part_i > 2)
- /* Partition 'c' has the size of the enclosing slice. Not mapped under
Linux. */
- part_i -= 1;
-
- if (disk_i != -1 && disk_i <= 26 &&
- slice_i > 0 && slice_i <= 1 /* > 4 .. see comment above */
&&
- part_i >= 0 && part_i < 25) {
- device = safe_asprintf (g, "/dev/sd%c%d", disk_i + 'a', part_i +
5);
- }
- }
- else if ((os_type == OS_TYPE_NETBSD) &&
- match3 (g, spec, re_netbsd_dev, &type, &disk, &part)) {
- const int disk_i = guestfs_int_parse_unsigned_int (g, disk);
- int part_i = part[0] - 'a'; /* counting from 0 */
- free (type);
- free (disk);
- free (part);
-
- if (part_i > 3)
- /* Partition 'c' is the disklabel partition and 'd' the hard disk
itself.
- * Not mapped under Linux.
- */
- part_i -= 2;
-
- if (disk_i != -1 && part_i >= 0 && part_i < 24)
- device = safe_asprintf (g, "/dev/sd%c%d", disk_i + 'a', part_i +
5);
- }
- else if ((os_type == OS_TYPE_OPENBSD) &&
- match3 (g, spec, re_openbsd_dev, &type, &disk, &part)) {
- const int disk_i = guestfs_int_parse_unsigned_int (g, disk);
- int part_i = part[0] - 'a'; /* counting from 0 */
- free (type);
- free (disk);
- free (part);
-
- if (part_i > 2)
- /* Partition 'c' is the hard disk itself. Not mapped under Linux */
- part_i -= 1;
-
- /* In OpenBSD MAXPARTITIONS is defined to 16 for all architectures */
- if (disk_i != -1 && part_i >= 0 && part_i < 15)
- device = safe_asprintf (g, "/dev/sd%c%d", disk_i + 'a', part_i +
5);
- }
- else if ((part = match1 (g, spec, re_diskbyid)) != NULL) {
- r = resolve_fstab_device_diskbyid (g, part, &device);
- free (part);
- if (r == -1)
- return NULL;
- }
- else if (match3 (g, spec, re_hurd_dev, &type, &disk, &part)) {
- /* Hurd disk devices are like /dev/hdNsM, where hdN is the
- * N-th disk and M is the M-th partition on that disk.
- * Turn the disk number into a letter-based identifier, so
- * we can resolve it easily.
- */
- const int disk_i = guestfs_int_parse_unsigned_int (g, disk);
- const char disk_as_letter[2] = { disk_i + 'a', 0 };
- r = resolve_fstab_device_xdev (g, type, disk_as_letter, part, &device);
- free (type);
- free (disk);
- free (part);
- if (r == -1)
- return NULL;
- }
-
- /* Didn't match device pattern, return original spec unchanged. */
- if (device == NULL)
- device = safe_strdup (g, spec);
-
- return device;
-}
-
-static char *make_augeas_path_expression (guestfs_h *g, const char **configfiles);
-
-/* Call 'f' with Augeas opened and having parsed 'configfiles' (these
- * files must exist). As a security measure, this bails if any file
- * is too large for a reasonable configuration file. After the call
- * to 'f' the Augeas handle is closed.
- */
-static int
-inspect_with_augeas (guestfs_h *g, struct inspect_fs *fs,
- const char **configfiles,
- int (*f) (guestfs_h *, struct inspect_fs *))
-{
- size_t i;
- int64_t size;
- int r;
- CLEANUP_FREE char *pathexpr = NULL;
- CLEANUP_FREE_STRING_LIST char **matches = NULL;
- char **match;
-
- /* Security: Refuse to do this if a config file is too large. */
- for (i = 0; configfiles[i] != NULL; ++i) {
- if (guestfs_is_file_opts (g, configfiles[i],
- GUESTFS_IS_FILE_OPTS_FOLLOWSYMLINKS, 1, -1) == 0)
- continue;
-
- size = guestfs_filesize (g, configfiles[i]);
- if (size == -1)
- /* guestfs_filesize failed and has already set error in handle */
- return -1;
- if (size > MAX_AUGEAS_FILE_SIZE) {
- error (g, _("size of %s is unreasonably large (%" PRIi64 "
bytes)"),
- configfiles[i], size);
- return -1;
- }
- }
-
- if (guestfs_aug_init (g, "/", 16|32 /* AUG_SAVE_NOOP|AUG_NO_LOAD */) == -1)
- return -1;
-
- r = -1;
-
- /* Tell Augeas to only load configfiles and no other files. This
- * prevents a rogue guest from performing a denial of service attack
- * by having large, over-complicated configuration files which are
- * unrelated to the task at hand. (Thanks Dominic Cleal).
- * Note this requires Augeas >= 1.0.0 because of RHBZ#975412.
- */
- pathexpr = make_augeas_path_expression (g, configfiles);
- if (guestfs_aug_rm (g, pathexpr) == -1)
- goto out;
-
- if (guestfs_aug_load (g) == -1)
- goto out;
-
- /* Check that augeas did not get a parse error for any of the configfiles,
- * otherwise we are silently missing information.
- */
- matches = guestfs_aug_match (g, "/augeas/files//error");
- for (match = matches; *match != NULL; ++match) {
- for (i = 0; configfiles[i] != NULL; ++i) {
- CLEANUP_FREE char *errorpath =
- safe_asprintf (g, "/augeas/files%s/error", configfiles[i]);
-
- if (STREQ (*match, errorpath)) {
- /* Get the various error details. */
- guestfs_push_error_handler (g, NULL, NULL);
- CLEANUP_FREE char *messagepath =
- safe_asprintf (g, "%s/message", errorpath);
- CLEANUP_FREE char *message = guestfs_aug_get (g, messagepath);
- CLEANUP_FREE char *linepath =
- safe_asprintf (g, "%s/line", errorpath);
- CLEANUP_FREE char *line = guestfs_aug_get (g, linepath);
- CLEANUP_FREE char *charpath =
- safe_asprintf (g, "%s/char", errorpath);
- CLEANUP_FREE char *charp = guestfs_aug_get (g, charpath);
- guestfs_pop_error_handler (g);
-
- error (g, _("%s:%s:%s: augeas parse failure: %s"),
- configfiles[i],
- line ? : "<none>",
- charp ? : "<none>",
- message ? : "<none>");
- goto out;
- }
- }
- }
-
- r = f (g, fs);
-
- out:
- guestfs_aug_close (g);
-
- return r;
-}
-
-/* Explained here:
https://bugzilla.redhat.com/show_bug.cgi?id=975412#c0 */
-static char *
-make_augeas_path_expression (guestfs_h *g, const char **configfiles)
-{
- size_t i;
- size_t nr_files;
- CLEANUP_FREE_STRING_LIST char **subexprs = NULL;
- CLEANUP_FREE char *subexpr = NULL;
- char *ret;
-
- nr_files = guestfs_int_count_strings ((char **) configfiles);
- subexprs = safe_malloc (g, sizeof (char *) * (nr_files + 1));
-
- for (i = 0; i < nr_files; ++i) {
- subexprs[i] = /* v NB trailing '/' after filename */
- safe_asprintf (g, "\"%s/\" !~ regexp('^') + glob(incl) +
regexp('/.*')",
- configfiles[i]);
- }
- subexprs[nr_files] = NULL;
-
- subexpr = guestfs_int_join_strings (" and ", subexprs);
- if (subexpr == NULL)
- g->abort_cb ();
-
- ret = safe_asprintf (g, "/augeas/load/*[ %s ]", subexpr);
- debug (g, "augeas pathexpr = %s", ret);
- return ret;
-}
-
-/* Canonicalize the path, so "///usr//local//" -> "/usr/local"
- *
- * The path is modified in place because the result is always
- * the same length or shorter than the argument passed.
- */
-static void
-canonical_mountpoint (char *s)
-{
- size_t len = strlen (s);
- char *orig = s;
-
- s = strchr (s, '/');
- while (s != NULL && *s != 0) {
- char *pos = s + 1;
- char *p = pos;
- /* Find how many consecutive slashes are there after the one found,
- * and shift the characters after them accordingly. */
- while (*p == '/')
- ++p;
- if (p - pos > 0) {
- memmove (pos, p, len - (p - orig) + 1);
- len -= p - pos;
- }
-
- s = strchr (pos, '/');
- }
- /* Ignore the trailing slash, but avoid removing it for "/". */
- if (len > 1 && orig[len-1] == '/')
- --len;
- orig[len] = 0;
-}
+#endif
diff --git a/lib/inspect-fs-windows.c b/lib/inspect-fs-windows.c
deleted file mode 100644
index 34f33c908..000000000
--- a/lib/inspect-fs-windows.c
+++ /dev/null
@@ -1,739 +0,0 @@
-/* libguestfs
- * Copyright (C) 2010-2012 Red Hat Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#include <config.h>
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdbool.h>
-#include <unistd.h>
-#include <string.h>
-#include <errno.h>
-#include <iconv.h>
-#include <inttypes.h>
-
-#ifdef HAVE_ENDIAN_H
-#include <endian.h>
-#endif
-#ifdef HAVE_SYS_ENDIAN_H
-#include <sys/endian.h>
-#endif
-
-#if defined __APPLE__ && defined __MACH__
-#include <libkern/OSByteOrder.h>
-#define le32toh(x) OSSwapLittleToHostInt32(x)
-#define le64toh(x) OSSwapLittleToHostInt64(x)
-#endif
-
-#include <pcre.h>
-
-#include "c-ctype.h"
-#include "ignore-value.h"
-
-#include "guestfs.h"
-#include "guestfs-internal.h"
-#include "guestfs-internal-actions.h"
-#include "structs-cleanups.h"
-
-COMPILE_REGEXP (re_windows_version, "^(\\d+)\\.(\\d+)", 0)
-COMPILE_REGEXP (re_boot_ini_os_header, "^\\[operating systems\\]\\s*$", 0)
-COMPILE_REGEXP (re_boot_ini_os,
-
"^(multi|scsi)\\((\\d+)\\)disk\\((\\d+)\\)rdisk\\((\\d+)\\)partition\\((\\d+)\\)([^=]+)=",
0)
-
-static int check_windows_arch (guestfs_h *g, struct inspect_fs *fs);
-static int check_windows_registry_paths (guestfs_h *g, struct inspect_fs *fs);
-static int check_windows_software_registry (guestfs_h *g, struct inspect_fs *fs);
-static int check_windows_system_registry (guestfs_h *g, struct inspect_fs *fs);
-static char *map_registry_disk_blob (guestfs_h *g, const void *blob);
-static char *map_registry_disk_blob_gpt (guestfs_h *g, const void *blob);
-static char *extract_guid_from_registry_blob (guestfs_h *g, const void *blob);
-
-/* XXX Handling of boot.ini in the Perl version was pretty broken. It
- * essentially didn't do anything for modern Windows guests.
- * Therefore I've omitted all that code.
- */
-
-/* Try to find Windows systemroot using some common locations.
- *
- * Notes:
- *
- * (1) We check for some directories inside to see if it is a real
- * systemroot, and not just a directory that happens to have the same
- * name.
- *
- * (2) If a Windows guest has multiple disks and applications are
- * installed on those other disks, then those other disks will contain
- * "/Program Files" and "/System Volume Information". Those would
- * *not* be Windows root disks. (RHBZ#674130)
- */
-
-static int
-is_systemroot (guestfs_h *const g, const char *systemroot)
-{
- CLEANUP_FREE char *path1 = NULL, *path2 = NULL, *path3 = NULL;
-
- path1 = safe_asprintf (g, "%s/system32", systemroot);
- if (!guestfs_int_is_dir_nocase (g, path1))
- return 0;
-
- path2 = safe_asprintf (g, "%s/system32/config", systemroot);
- if (!guestfs_int_is_dir_nocase (g, path2))
- return 0;
-
- path3 = safe_asprintf (g, "%s/system32/cmd.exe", systemroot);
- if (!guestfs_int_is_file_nocase (g, path3))
- return 0;
-
- return 1;
-}
-
-char *
-guestfs_int_get_windows_systemroot (guestfs_h *g)
-{
- /* Check a predefined list of common windows system root locations */
- static const char *systemroots[] =
- { "/windows", "/winnt", "/win32", "/win",
"/reactos", NULL };
-
- for (size_t i = 0; i < sizeof systemroots / sizeof systemroots[0]; ++i) {
- char *systemroot =
- guestfs_int_case_sensitive_path_silently (g, systemroots[i]);
- if (!systemroot)
- continue;
-
- if (is_systemroot (g, systemroot)) {
- debug (g, "windows %%SYSTEMROOT%% = %s", systemroot);
-
- return systemroot;
- } else {
- free (systemroot);
- }
- }
-
- /* If the fs contains boot.ini, check it for non-standard
- * systemroot locations */
- CLEANUP_FREE char *boot_ini_path =
- guestfs_int_case_sensitive_path_silently (g, "/boot.ini");
- if (boot_ini_path && guestfs_is_file (g, boot_ini_path) > 0) {
- CLEANUP_FREE_STRING_LIST char **boot_ini =
- guestfs_read_lines (g, boot_ini_path);
- if (!boot_ini) {
- debug (g, "error reading %s", boot_ini_path);
- return NULL;
- }
-
- int found_os = 0;
- for (char **i = boot_ini; *i != NULL; i++) {
- CLEANUP_FREE char *controller_type = NULL;
- CLEANUP_FREE char *controller = NULL;
- CLEANUP_FREE char *disk = NULL;
- CLEANUP_FREE char *rdisk = NULL;
- CLEANUP_FREE char *partition = NULL;
- CLEANUP_FREE char *path = NULL;
-
- char *line = *i;
-
- if (!found_os) {
- if (match (g, line, re_boot_ini_os_header)) {
- found_os = 1;
- continue;
- }
- }
-
- /* See
http://support.microsoft.com/kb/102873 for a discussion
- * of what this line means */
- if (match6 (g, line, re_boot_ini_os, &controller_type,
- &controller, &disk, &rdisk, &partition, &path))
- {
- /* The Windows system root may be on any disk. However, there
- * are currently (at least) 2 practical problems preventing us
- * from locating it on another disk:
- *
- * 1. We don't have enough metadata about the disks we were
- * given to know if what controller they were on and what
- * index they had.
- *
- * 2. The way inspection of filesystems currently works, we
- * can't mark another filesystem, which we may have already
- * inspected, to be inspected for a specific Windows system
- * root.
- *
- * Solving 1 properly would require a new API at a minimum. We
- * might be able to fudge something practical without this,
- * though, e.g. by looking at the <partition>th partition of
- * every disk for the specific windows root.
- *
- * Solving 2 would probably require a significant refactoring
- * of the way filesystems are inspected. We should probably do
- * this some time.
- *
- * For the moment, we ignore all partition information and
- * assume the system root is on the current partition. In
- * practice, this will normally be correct.
- */
-
- /* Swap backslashes for forward slashes in the system root
- * path */
- for (char *j = path; *j != '\0'; j++) {
- if (*j == '\\') *j = '/';
- }
-
- char *systemroot = guestfs_int_case_sensitive_path_silently (g, path);
- if (systemroot && is_systemroot (g, systemroot)) {
- debug (g, "windows %%SYSTEMROOT%% = %s", systemroot);
-
- return systemroot;
- } else {
- free (systemroot);
- }
- }
- }
- }
-
- return NULL; /* not found */
-}
-
-int
-guestfs_int_check_windows_root (guestfs_h *g, struct inspect_fs *fs,
- char *const systemroot)
-{
- fs->type = OS_TYPE_WINDOWS;
- fs->distro = OS_DISTRO_WINDOWS;
-
- /* Freed by guestfs_int_free_inspect_info. */
- fs->windows_systemroot = systemroot;
-
- if (check_windows_arch (g, fs) == -1)
- return -1;
-
- /* Get system and software registry paths. */
- if (check_windows_registry_paths (g, fs) == -1)
- return -1;
-
- /* Product name and version. */
- if (check_windows_software_registry (g, fs) == -1)
- return -1;
-
- /* Hostname. */
- if (check_windows_system_registry (g, fs) == -1)
- return -1;
-
- return 0;
-}
-
-static int
-check_windows_arch (guestfs_h *g, struct inspect_fs *fs)
-{
- CLEANUP_FREE char *cmd_exe =
- safe_asprintf (g, "%s/system32/cmd.exe", fs->windows_systemroot);
-
- /* Should exist because of previous check above in get_windows_systemroot. */
- CLEANUP_FREE char *cmd_exe_path = guestfs_case_sensitive_path (g, cmd_exe);
- if (!cmd_exe_path)
- return -1;
-
- char *arch = guestfs_file_architecture (g, cmd_exe_path);
- if (!arch)
- return -1;
-
- fs->arch = arch; /* freed by guestfs_int_free_inspect_info */
-
- return 0;
-}
-
-static int
-check_windows_registry_paths (guestfs_h *g, struct inspect_fs *fs)
-{
- int r;
- CLEANUP_FREE char *software = NULL, *system = NULL;
-
- if (!fs->windows_systemroot)
- return 0;
-
- software = safe_asprintf (g, "%s/system32/config/software",
- fs->windows_systemroot);
-
- fs->windows_software_hive = guestfs_case_sensitive_path (g, software);
- if (!fs->windows_software_hive)
- return -1;
-
- r = guestfs_is_file (g, fs->windows_software_hive);
- if (r == -1) {
- free (fs->windows_software_hive);
- fs->windows_software_hive = NULL;
- return -1;
- }
-
- if (r == 0) { /* doesn't exist, or not a file */
- free (fs->windows_software_hive);
- fs->windows_software_hive = NULL;
- /*FALLTHROUGH*/
- }
-
- system = safe_asprintf (g, "%s/system32/config/system",
- fs->windows_systemroot);
-
- fs->windows_system_hive = guestfs_case_sensitive_path (g, system);
- if (!fs->windows_system_hive)
- return -1;
-
- r = guestfs_is_file (g, fs->windows_system_hive);
- if (r == -1) {
- free (fs->windows_system_hive);
- fs->windows_system_hive = NULL;
- return -1;
- }
-
- if (r == 0) { /* doesn't exist, or not a file */
- free (fs->windows_system_hive);
- fs->windows_system_hive = NULL;
- /*FALLTHROUGH*/
- }
-
- return 0;
-}
-
-/* At the moment, pull just the ProductName and version numbers from
- * the registry. In future there is a case for making many more
- * registry fields available to callers.
- */
-static int
-check_windows_software_registry (guestfs_h *g, struct inspect_fs *fs)
-{
- int ret = -1;
- int64_t node;
- const char *hivepath[] =
- { "Microsoft", "Windows NT", "CurrentVersion" };
- size_t i;
- CLEANUP_FREE_HIVEX_VALUE_LIST struct guestfs_hivex_value_list *values = NULL;
- bool ignore_currentversion = false;
-
- /* If the software hive doesn't exist, just accept that we cannot
- * find product_name etc.
- */
- if (!fs->windows_software_hive)
- return 0;
-
- if (guestfs_hivex_open (g, fs->windows_software_hive,
- GUESTFS_HIVEX_OPEN_VERBOSE, g->verbose,
- GUESTFS_HIVEX_OPEN_UNSAFE, 1,
- -1) == -1)
- return -1;
-
- node = guestfs_hivex_root (g);
- for (i = 0; node > 0 && i < sizeof hivepath / sizeof hivepath[0]; ++i)
- node = guestfs_hivex_node_get_child (g, node, hivepath[i]);
-
- if (node == -1)
- goto out;
-
- if (node == 0) {
- perrorf (g, "hivex: cannot locate HKLM\\SOFTWARE\\Microsoft\\Windows
NT\\CurrentVersion");
- goto out;
- }
-
- values = guestfs_hivex_node_values (g, node);
-
- for (i = 0; i < values->len; ++i) {
- const int64_t value = values->val[i].hivex_value_h;
- CLEANUP_FREE char *key = guestfs_hivex_value_key (g, value);
- if (key == NULL)
- goto out;
-
- if (STRCASEEQ (key, "ProductName")) {
- fs->product_name = guestfs_hivex_value_utf8 (g, value);
- if (!fs->product_name)
- goto out;
- }
- else if (STRCASEEQ (key, "CurrentMajorVersionNumber")) {
- size_t vsize;
- const int64_t vtype = guestfs_hivex_value_type (g, value);
- CLEANUP_FREE char *vbuf = guestfs_hivex_value_value (g, value, &vsize);
-
- if (vbuf == NULL)
- goto out;
- if (vtype != 4 || vsize != 4) {
- error (g, "hivex: expected CurrentVersion\\%s to be a DWORD field",
- "CurrentMajorVersionNumber");
- goto out;
- }
-
- fs->version.v_major = le32toh (*(int32_t *)vbuf);
-
- /* Ignore CurrentVersion if we see it after this key. */
- ignore_currentversion = true;
- }
- else if (STRCASEEQ (key, "CurrentMinorVersionNumber")) {
- size_t vsize;
- const int64_t vtype = guestfs_hivex_value_type (g, value);
- CLEANUP_FREE char *vbuf = guestfs_hivex_value_value (g, value, &vsize);
-
- if (vbuf == NULL)
- goto out;
- if (vtype != 4 || vsize != 4) {
- error (g, "hivex: expected CurrentVersion\\%s to be a DWORD field",
- "CurrentMinorVersionNumber");
- goto out;
- }
-
- fs->version.v_minor = le32toh (*(int32_t *)vbuf);
-
- /* Ignore CurrentVersion if we see it after this key. */
- ignore_currentversion = true;
- }
- else if (!ignore_currentversion && STRCASEEQ (key,
"CurrentVersion")) {
- CLEANUP_FREE char *version = guestfs_hivex_value_utf8 (g, value);
- if (!version)
- goto out;
- if (guestfs_int_version_from_x_y_re (g, &fs->version, version,
- re_windows_version) == -1)
- goto out;
- }
- else if (STRCASEEQ (key, "InstallationType")) {
- fs->product_variant = guestfs_hivex_value_utf8 (g, value);
- if (!fs->product_variant)
- goto out;
- }
- }
-
- ret = 0;
-
- out:
- guestfs_hivex_close (g);
-
- return ret;
-}
-
-static int
-check_windows_system_registry (guestfs_h *g, struct inspect_fs *fs)
-{
- static const char gpt_prefix[] = "DMIO:ID:";
- int ret = -1;
- int64_t root, node, value;
- CLEANUP_FREE_HIVEX_VALUE_LIST struct guestfs_hivex_value_list *values = NULL;
- CLEANUP_FREE_HIVEX_VALUE_LIST struct guestfs_hivex_value_list *values2 = NULL;
- int32_t dword;
- size_t i, count;
- CLEANUP_FREE void *buf = NULL;
- size_t buflen;
- const char *hivepath[] =
- { NULL /* current control set */, "Services", "Tcpip",
"Parameters" };
-
- /* If the system hive doesn't exist, just accept that we cannot
- * find hostname etc.
- */
- if (!fs->windows_system_hive)
- return 0;
-
- if (guestfs_hivex_open (g, fs->windows_system_hive,
- GUESTFS_HIVEX_OPEN_VERBOSE, g->verbose,
- GUESTFS_HIVEX_OPEN_UNSAFE, 1,
- -1) == -1)
- goto out;
-
- root = guestfs_hivex_root (g);
- if (root == 0)
- goto out;
-
- /* Get the CurrentControlSet. */
- node = guestfs_hivex_node_get_child (g, root, "Select");
- if (node == -1)
- goto out;
-
- if (node == 0) {
- error (g, "hivex: could not locate HKLM\\SYSTEM\\Select");
- goto out;
- }
-
- value = guestfs_hivex_node_get_value (g, node, "Current");
- if (value == -1)
- goto out;
-
- if (value == 0) {
- error (g, "hivex: HKLM\\System\\Select Default entry not found");
- goto out;
- }
-
- /* XXX Should check the type. */
- buf = guestfs_hivex_value_value (g, value, &buflen);
- if (buflen != 4) {
- error (g, "hivex: HKLM\\System\\Select\\Current expected to be DWORD");
- goto out;
- }
- dword = le32toh (*(int32_t *)buf);
- fs->windows_current_control_set = safe_asprintf (g, "ControlSet%03d",
dword);
-
- /* Get the drive mappings.
- * This page explains the contents of HKLM\System\MountedDevices:
- *
http://www.goodells.net/multiboot/partsigs.shtml
- */
- node = guestfs_hivex_node_get_child (g, root, "MountedDevices");
- if (node == -1)
- goto out;
-
- if (node == 0)
- /* Not found: skip getting drive letter mappings (RHBZ#803664). */
- goto skip_drive_letter_mappings;
-
- values = guestfs_hivex_node_values (g, node);
-
- /* Count how many DOS drive letter mappings there are. This doesn't
- * ignore removable devices, so it overestimates, but that doesn't
- * matter because it just means we'll allocate a few bytes extra.
- */
- for (i = count = 0; i < values->len; ++i) {
- CLEANUP_FREE char *key =
- guestfs_hivex_value_key (g, values->val[i].hivex_value_h);
- if (key == NULL)
- goto out;
- if (STRCASEEQLEN (key, "\\DosDevices\\", 12) &&
- c_isalpha (key[12]) && key[13] == ':')
- count++;
- }
-
- fs->drive_mappings = safe_calloc (g, 2*count + 1, sizeof (char *));
-
- for (i = count = 0; i < values->len; ++i) {
- const int64_t v = values->val[i].hivex_value_h;
- CLEANUP_FREE char *key = guestfs_hivex_value_key (g, v);
- if (key == NULL)
- goto out;
- if (STRCASEEQLEN (key, "\\DosDevices\\", 12) &&
- c_isalpha (key[12]) && key[13] == ':') {
- /* Get the binary value. Is it a fixed disk? */
- CLEANUP_FREE char *blob = NULL;
- char *device;
- int64_t type;
- bool is_gpt;
- size_t len;
-
- type = guestfs_hivex_value_type (g, v);
- blob = guestfs_hivex_value_value (g, v, &len);
- is_gpt = memcmp (blob, gpt_prefix, 8) == 0;
- if (blob != NULL && type == 3 && (len == 12 || is_gpt)) {
- /* Try to map the blob to a known disk and partition. */
- if (is_gpt)
- device = map_registry_disk_blob_gpt (g, blob);
- else
- device = map_registry_disk_blob (g, blob);
-
- if (device != NULL) {
- fs->drive_mappings[count++] = safe_strndup (g, &key[12], 1);
- fs->drive_mappings[count++] = device;
- }
- }
- }
- }
-
- skip_drive_letter_mappings:;
- /* Get the hostname. */
- hivepath[0] = fs->windows_current_control_set;
- for (node = root, i = 0;
- node > 0 && i < sizeof hivepath / sizeof hivepath[0];
- ++i) {
- node = guestfs_hivex_node_get_child (g, node, hivepath[i]);
- }
-
- if (node == -1)
- goto out;
-
- if (node == 0) {
- perrorf (g, "hivex: cannot locate
HKLM\\SYSTEM\\%s\\Services\\Tcpip\\Parameters",
- fs->windows_current_control_set);
- goto out;
- }
-
- values2 = guestfs_hivex_node_values (g, node);
- if (values2 == NULL)
- goto out;
-
- for (i = 0; i < values2->len; ++i) {
- const int64_t v = values2->val[i].hivex_value_h;
- CLEANUP_FREE char *key = guestfs_hivex_value_key (g, v);
- if (key == NULL)
- goto out;
-
- if (STRCASEEQ (key, "Hostname")) {
- fs->hostname = guestfs_hivex_value_utf8 (g, v);
- if (!fs->hostname)
- goto out;
- }
- /* many other interesting fields here ... */
- }
-
- ret = 0;
-
- out:
- guestfs_hivex_close (g);
-
- return ret;
-}
-
-/* Windows Registry HKLM\SYSTEM\MountedDevices uses a blob of data
- * to store partitions. This blob is described here:
- *
http://www.goodells.net/multiboot/partsigs.shtml
- * The following function maps this blob to a libguestfs partition
- * name, if possible.
- */
-static char *
-map_registry_disk_blob (guestfs_h *g, const void *blob)
-{
- CLEANUP_FREE_STRING_LIST char **devices = NULL;
- CLEANUP_FREE_PARTITION_LIST struct guestfs_partition_list *partitions = NULL;
- size_t i, j, len;
- uint64_t part_offset;
-
- /* First 4 bytes are the disk ID. Search all devices to find the
- * disk with this disk ID.
- */
- devices = guestfs_list_devices (g);
- if (devices == NULL)
- return NULL;
-
- for (i = 0; devices[i] != NULL; ++i) {
- /* Read the disk ID. */
- CLEANUP_FREE char *diskid =
- guestfs_pread_device (g, devices[i], 4, 0x01b8, &len);
- if (diskid == NULL)
- continue;
- if (len < 4)
- continue;
- if (memcmp (diskid, blob, 4) == 0) /* found it */
- goto found_disk;
- }
- return NULL;
-
- found_disk:
- /* Next 8 bytes are the offset of the partition in bytes(!) given as
- * a 64 bit little endian number. Luckily it's easy to get the
- * partition byte offset from guestfs_part_list.
- */
- memcpy (&part_offset, (char *) blob + 4, sizeof (part_offset));
- part_offset = le64toh (part_offset);
-
- partitions = guestfs_part_list (g, devices[i]);
- if (partitions == NULL)
- return NULL;
-
- for (j = 0; j < partitions->len; ++j) {
- if (partitions->val[j].part_start == part_offset) /* found it */
- goto found_partition;
- }
- return NULL;
-
- found_partition:
- /* Construct the full device name. */
- return safe_asprintf (g, "%s%d", devices[i],
partitions->val[j].part_num);
-}
-
-/* Matches Windows registry HKLM\SYSYTEM\MountedDevices\DosDevices blob to
- * to libguestfs GPT partition device. For GPT disks, the blob is made of
- * "DMIO:ID:" prefix followed by the GPT partition GUID.
- */
-static char *
-map_registry_disk_blob_gpt (guestfs_h *g, const void *blob)
-{
- CLEANUP_FREE_STRING_LIST char **parts = NULL;
- CLEANUP_FREE char *blob_guid = extract_guid_from_registry_blob (g, blob);
- size_t i;
-
- parts = guestfs_list_partitions (g);
- if (parts == NULL)
- return NULL;
-
- for (i = 0; parts[i] != NULL; ++i) {
- CLEANUP_FREE char *fs_guid = NULL;
- int partnum;
- CLEANUP_FREE char *device = NULL;
- CLEANUP_FREE char *type = NULL;
-
- partnum = guestfs_part_to_partnum (g, parts[i]);
- if (partnum == -1)
- continue;
-
- device = guestfs_part_to_dev (g, parts[i]);
- if (device == NULL)
- continue;
-
- type = guestfs_part_get_parttype (g, device);
- if (type == NULL)
- continue;
-
- if (STRCASENEQ (type, "gpt"))
- continue;
-
- /* get the GPT parition GUID from the partition block device */
- fs_guid = guestfs_part_get_gpt_guid (g, device, partnum);
- if (fs_guid == NULL)
- continue;
-
- /* if both GUIDs match, we have found the mapping for our device */
- if (STRCASEEQ (fs_guid, blob_guid))
- return safe_strdup (g, parts[i]);
- }
-
- return NULL;
-}
-
-/* Extracts the binary GUID stored in blob from Windows registry
- * HKLM\SYSTYEM\MountedDevices\DosDevices value and converts it to a
- * GUID string so that it can be matched against libguestfs partition
- * device GPT GUID.
- */
-static char *
-extract_guid_from_registry_blob (guestfs_h *g, const void *blob)
-{
- char guid_bytes[16];
- uint32_t data1;
- uint16_t data2, data3;
- uint64_t data4;
-
- /* get the GUID bytes from blob (skip 8 byte "DMIO:ID:" prefix) */
- memcpy (&guid_bytes, (char *) blob + 8, sizeof (guid_bytes));
-
- /* copy relevant sections from blob to respective ints */
- memcpy (&data1, guid_bytes, sizeof (data1));
- memcpy (&data2, guid_bytes + 4, sizeof (data2));
- memcpy (&data3, guid_bytes + 6, sizeof (data3));
- memcpy (&data4, guid_bytes + 8, sizeof (data4));
-
- /* ensure proper endianness */
- data1 = le32toh (data1);
- data2 = le16toh (data2);
- data3 = le16toh (data3);
- data4 = be64toh (data4);
-
- return safe_asprintf (g,
- "%08" PRIX32 "-%04" PRIX16 "-%04" PRIX16
"-%04" PRIX64 "-%012" PRIX64,
- data1, data2, data3, data4 >> 48, data4 & 0xffffffffffff);
-}
-
-/* NB: This function DOES NOT test for the existence of the file. It
- * will return non-NULL even if the file/directory does not exist.
- * You have to call guestfs_is_file{,_opts} etc.
- */
-char *
-guestfs_int_case_sensitive_path_silently (guestfs_h *g, const char *path)
-{
- char *ret;
-
- guestfs_push_error_handler (g, NULL, NULL);
- ret = guestfs_case_sensitive_path (g, path);
- guestfs_pop_error_handler (g);
-
- return ret;
-}
diff --git a/lib/inspect-fs.c b/lib/inspect-fs.c
index 2da73d310..f93842ae2 100644
--- a/lib/inspect-fs.c
+++ b/lib/inspect-fs.c
@@ -37,379 +37,6 @@
#include "guestfs-internal.h"
#include "structs-cleanups.h"
-static int check_filesystem (guestfs_h *g, const char *mountable,
- const struct guestfs_internal_mountable *m,
- int whole_device);
-static void extend_fses (guestfs_h *g);
-static int get_partition_context (guestfs_h *g, const char *partition, int *partnum_ret,
int *nr_partitions_ret);
-static int is_symlink_to (guestfs_h *g, const char *file, const char *wanted_target);
-
-/* Find out if 'device' contains a filesystem. If it does, add
- * another entry in g->fses.
- */
-int
-guestfs_int_check_for_filesystem_on (guestfs_h *g, const char *mountable)
-{
- CLEANUP_FREE char *vfs_type = NULL;
- int is_swap, r;
- struct inspect_fs *fs;
- CLEANUP_FREE_INTERNAL_MOUNTABLE struct guestfs_internal_mountable *m = NULL;
- int whole_device = 0;
-
- /* Get vfs-type in order to check if it's a Linux(?) swap device.
- * If there's an error we should ignore it, so to do that we have to
- * temporarily replace the error handler with a null one.
- */
- guestfs_push_error_handler (g, NULL, NULL);
- vfs_type = guestfs_vfs_type (g, mountable);
- guestfs_pop_error_handler (g);
-
- is_swap = vfs_type && STREQ (vfs_type, "swap");
- debug (g, "check_for_filesystem_on: %s (%s)",
- mountable, vfs_type ? vfs_type : "failed to get vfs type");
-
- if (is_swap) {
- extend_fses (g);
- fs = &g->fses[g->nr_fses-1];
- fs->mountable = safe_strdup (g, mountable);
- return 0;
- }
-
- m = guestfs_internal_parse_mountable (g, mountable);
- if (m == NULL)
- return -1;
-
- /* If it's a whole device, see if it is an install ISO. */
- if (m->im_type == MOUNTABLE_DEVICE) {
- whole_device = guestfs_is_whole_device (g, m->im_device);
- if (whole_device == -1) {
- return -1;
- }
- }
-
- if (whole_device) {
- extend_fses (g);
- fs = &g->fses[g->nr_fses-1];
-
- r = guestfs_int_check_installer_iso (g, fs, m->im_device);
- if (r == -1) { /* Fatal error. */
- g->nr_fses--;
- return -1;
- }
- if (r > 0) /* Found something. */
- return 0;
-
- /* Didn't find anything. Fall through ... */
- g->nr_fses--;
- }
-
- /* Try mounting the device. As above, ignore errors. */
- guestfs_push_error_handler (g, NULL, NULL);
- if (vfs_type && STREQ (vfs_type, "ufs")) { /* Hack for the *BSDs. */
- /* FreeBSD fs is a variant of ufs called ufs2 ... */
- r = guestfs_mount_vfs (g, "ro,ufstype=ufs2", "ufs", mountable,
"/");
- if (r == -1)
- /* while NetBSD and OpenBSD use another variant labeled 44bsd */
- r = guestfs_mount_vfs (g, "ro,ufstype=44bsd", "ufs", mountable,
"/");
- } else {
- r = guestfs_mount_ro (g, mountable, "/");
- }
- guestfs_pop_error_handler (g);
- if (r == -1)
- return 0;
-
- /* Do the rest of the checks. */
- r = check_filesystem (g, mountable, m, whole_device);
-
- /* Unmount the filesystem. */
- if (guestfs_umount_all (g) == -1)
- return -1;
-
- return r;
-}
-
-static int
-check_filesystem (guestfs_h *g, const char *mountable,
- const struct guestfs_internal_mountable *m,
- int whole_device)
-{
- int partnum = -1, nr_partitions = -1;
- /* Not CLEANUP_FREE, as it will be cleaned up with inspection info */
- char *windows_systemroot = NULL;
-
- extend_fses (g);
-
- if (!whole_device && m->im_type == MOUNTABLE_DEVICE &&
- guestfs_int_is_partition (g, m->im_device)) {
- if (get_partition_context (g, m->im_device,
- &partnum, &nr_partitions) == -1)
- return -1;
- }
-
- struct inspect_fs *fs = &g->fses[g->nr_fses-1];
-
- fs->mountable = safe_strdup (g, mountable);
-
- /* Optimize some of the tests by avoiding multiple tests of the same thing. */
- const int is_dir_etc = guestfs_is_dir (g, "/etc") > 0;
- const int is_dir_bin = guestfs_is_dir (g, "/bin") > 0;
- const int is_dir_share = guestfs_is_dir (g, "/share") > 0;
-
- /* Grub /boot? */
- if (guestfs_is_file (g, "/grub/menu.lst") > 0 ||
- guestfs_is_file (g, "/grub/grub.conf") > 0 ||
- guestfs_is_file (g, "/grub2/grub.cfg") > 0)
- ;
- /* FreeBSD root? */
- else if (is_dir_etc &&
- is_dir_bin &&
- guestfs_is_file (g, "/etc/freebsd-update.conf") > 0 &&
- guestfs_is_file (g, "/etc/fstab") > 0) {
- fs->role = OS_ROLE_ROOT;
- fs->format = OS_FORMAT_INSTALLED;
- if (guestfs_int_check_freebsd_root (g, fs) == -1)
- return -1;
- }
- /* NetBSD root? */
- else if (is_dir_etc &&
- is_dir_bin &&
- guestfs_is_file (g, "/netbsd") > 0 &&
- guestfs_is_file (g, "/etc/fstab") > 0 &&
- guestfs_is_file (g, "/etc/release") > 0) {
- fs->role = OS_ROLE_ROOT;
- fs->format = OS_FORMAT_INSTALLED;
- if (guestfs_int_check_netbsd_root (g, fs) == -1)
- return -1;
- }
- /* OpenBSD root? */
- else if (is_dir_etc &&
- is_dir_bin &&
- guestfs_is_file (g, "/bsd") > 0 &&
- guestfs_is_file (g, "/etc/fstab") > 0 &&
- guestfs_is_file (g, "/etc/motd") > 0) {
- fs->role = OS_ROLE_ROOT;
- fs->format = OS_FORMAT_INSTALLED;
- if (guestfs_int_check_openbsd_root (g, fs) == -1)
- return -1;
- }
- /* Hurd root? */
- else if (guestfs_is_file (g, "/hurd/console") > 0 &&
- guestfs_is_file (g, "/hurd/hello") > 0 &&
- guestfs_is_file (g, "/hurd/null") > 0) {
- fs->role = OS_ROLE_ROOT;
- fs->format = OS_FORMAT_INSTALLED; /* XXX could be more specific */
- if (guestfs_int_check_hurd_root (g, fs) == -1)
- return -1;
- }
- /* Minix root? */
- else if (is_dir_etc &&
- is_dir_bin &&
- guestfs_is_file (g, "/service/vm") > 0 &&
- guestfs_is_file (g, "/etc/fstab") > 0 &&
- guestfs_is_file (g, "/etc/version") > 0) {
- fs->role = OS_ROLE_ROOT;
- fs->format = OS_FORMAT_INSTALLED;
- if (guestfs_int_check_minix_root (g, fs) == -1)
- return -1;
- }
- /* Linux root? */
- else if (is_dir_etc &&
- (is_dir_bin ||
- is_symlink_to (g, "/bin", "usr/bin") > 0) &&
- (guestfs_is_file (g, "/etc/fstab") > 0 ||
- guestfs_is_file (g, "/etc/hosts") > 0)) {
- fs->role = OS_ROLE_ROOT;
- fs->format = OS_FORMAT_INSTALLED;
- if (guestfs_int_check_linux_root (g, fs) == -1)
- return -1;
- }
- /* CoreOS root? */
- else if (is_dir_etc &&
- guestfs_is_dir (g, "/root") > 0 &&
- guestfs_is_dir (g, "/home") > 0 &&
- guestfs_is_dir (g, "/usr") > 0 &&
- guestfs_is_file (g, "/etc/coreos/update.conf") > 0) {
- fs->role = OS_ROLE_ROOT;
- fs->format = OS_FORMAT_INSTALLED;
- if (guestfs_int_check_coreos_root (g, fs) == -1)
- return -1;
- }
- /* Linux /usr/local? */
- else if (is_dir_etc &&
- is_dir_bin &&
- is_dir_share &&
- guestfs_is_dir (g, "/local") == 0 &&
- guestfs_is_file (g, "/etc/fstab") == 0)
- ;
- /* Linux /usr? */
- else if (is_dir_etc &&
- is_dir_bin &&
- is_dir_share &&
- guestfs_is_dir (g, "/local") > 0 &&
- guestfs_is_file (g, "/etc/fstab") == 0) {
- if (guestfs_int_check_linux_usr (g, fs) == -1)
- return -1;
- }
- /* CoreOS /usr? */
- else if (is_dir_bin &&
- is_dir_share &&
- guestfs_is_dir (g, "/local") > 0 &&
- guestfs_is_dir (g, "/share/coreos") > 0) {
- if (guestfs_int_check_coreos_usr (g, fs) == -1)
- return -1;
- }
- /* Linux /var? */
- else if (guestfs_is_dir (g, "/log") > 0 &&
- guestfs_is_dir (g, "/run") > 0 &&
- guestfs_is_dir (g, "/spool") > 0)
- ;
- /* Windows root? */
- else if ((windows_systemroot = guestfs_int_get_windows_systemroot (g)) != NULL)
- {
- fs->role = OS_ROLE_ROOT;
- fs->format = OS_FORMAT_INSTALLED;
- if (guestfs_int_check_windows_root (g, fs, windows_systemroot) == -1)
- return -1;
- }
- /* Windows volume with installed applications (but not root)? */
- else if (guestfs_int_is_dir_nocase (g, "/System Volume Information") > 0
&&
- guestfs_int_is_dir_nocase (g, "/Program Files") > 0)
- ;
- /* Windows volume (but not root)? */
- else if (guestfs_int_is_dir_nocase (g, "/System Volume Information") > 0)
- ;
- /* FreeDOS? */
- else if (guestfs_int_is_dir_nocase (g, "/FDOS") > 0 &&
- guestfs_int_is_file_nocase (g, "/FDOS/FREEDOS.BSS") > 0) {
- fs->role = OS_ROLE_ROOT;
- fs->format = OS_FORMAT_INSTALLED;
- fs->type = OS_TYPE_DOS;
- fs->distro = OS_DISTRO_FREEDOS;
- /* FreeDOS is a mix of 16 and 32 bit, but assume it requires a
- * 32 bit i386 processor.
- */
- fs->arch = safe_strdup (g, "i386");
- }
- /* Install CD/disk?
- *
- * Note that we checked (above) for an install ISO, but there are
- * other types of install image (eg. USB keys) which that check
- * wouldn't have picked up.
- *
- * Skip these checks if it's not a whole device (eg. CD) or the
- * first partition (eg. bootable USB key).
- */
- else if ((whole_device || (partnum == 1 && nr_partitions == 1)) &&
- (guestfs_is_file (g, "/isolinux/isolinux.cfg") > 0 ||
- guestfs_is_dir (g, "/EFI/BOOT") > 0 ||
- guestfs_is_file (g, "/images/install.img") > 0 ||
- guestfs_is_dir (g, "/.disk") > 0 ||
- guestfs_is_file (g, "/.discinfo") > 0 ||
- guestfs_is_file (g, "/i386/txtsetup.sif") > 0 ||
- guestfs_is_file (g, "/amd64/txtsetup.sif") > 0 ||
- guestfs_is_file (g, "/freedos/freedos.ico") > 0 ||
- guestfs_is_file (g, "/boot/loader.rc") > 0)) {
- fs->role = OS_ROLE_ROOT;
- fs->format = OS_FORMAT_INSTALLER;
- if (guestfs_int_check_installer_root (g, fs) == -1)
- return -1;
- }
-
- /* The above code should have set fs->type and fs->distro fields, so
- * we can now guess the package management system.
- */
- guestfs_int_check_package_format (g, fs);
- guestfs_int_check_package_management (g, fs);
-
- return 0;
-}
-
-static void
-extend_fses (guestfs_h *g)
-{
- const size_t n = g->nr_fses + 1;
- struct inspect_fs *p;
-
- p = safe_realloc (g, g->fses, n * sizeof (struct inspect_fs));
-
- g->fses = p;
- g->nr_fses = n;
-
- memset (&g->fses[n-1], 0, sizeof (struct inspect_fs));
-}
-
-/* Given a partition (eg. /dev/sda2) then return the partition number
- * (eg. 2) and the total number of other partitions.
- */
-static int
-get_partition_context (guestfs_h *g, const char *partition,
- int *partnum_ret, int *nr_partitions_ret)
-{
- int partnum, nr_partitions;
- CLEANUP_FREE char *device = NULL;
- CLEANUP_FREE_PARTITION_LIST struct guestfs_partition_list *partitions = NULL;
-
- partnum = guestfs_part_to_partnum (g, partition);
- if (partnum == -1)
- return -1;
-
- device = guestfs_part_to_dev (g, partition);
- if (device == NULL)
- return -1;
-
- partitions = guestfs_part_list (g, device);
- if (partitions == NULL)
- return -1;
-
- nr_partitions = partitions->len;
-
- *partnum_ret = partnum;
- *nr_partitions_ret = nr_partitions;
- return 0;
-}
-
-static int
-is_symlink_to (guestfs_h *g, const char *file, const char *wanted_target)
-{
- CLEANUP_FREE char *target = NULL;
-
- if (guestfs_is_symlink (g, file) == 0)
- return 0;
-
- target = guestfs_readlink (g, file);
- /* This should not fail, but play safe. */
- if (target == NULL)
- return 0;
-
- return STREQ (target, wanted_target);
-}
-
-int
-guestfs_int_is_file_nocase (guestfs_h *g, const char *path)
-{
- CLEANUP_FREE char *p = NULL;
- int r;
-
- p = guestfs_int_case_sensitive_path_silently (g, path);
- if (!p)
- return 0;
- r = guestfs_is_file (g, p);
- return r > 0;
-}
-
-int
-guestfs_int_is_dir_nocase (guestfs_h *g, const char *path)
-{
- CLEANUP_FREE char *p = NULL;
- int r;
-
- p = guestfs_int_case_sensitive_path_silently (g, path);
- if (!p)
- return 0;
- r = guestfs_is_dir (g, p);
- return r > 0;
-}
-
/* Parse small, unsigned ints, as used in version numbers. */
int
guestfs_int_parse_unsigned_int (guestfs_h *g, const char *str)
@@ -436,214 +63,6 @@ guestfs_int_parse_unsigned_int_ignore_trailing (guestfs_h *g, const
char *str)
return ret;
}
-/* Parse generic MAJOR.MINOR from the fs->product_name string. */
-int
-guestfs_int_parse_major_minor (guestfs_h *g, struct inspect_fs *fs)
-{
- if (guestfs_int_version_from_x_y (g, &fs->version, fs->product_name) == -1)
- return -1;
-
- return 0;
-}
-
-/* At the moment, package format and package management is just a
- * simple function of the distro and version.v_major fields, so these
- * can never return an error. We might be cleverer in future.
- */
-void
-guestfs_int_check_package_format (guestfs_h *g, struct inspect_fs *fs)
-{
- switch (fs->distro) {
- case OS_DISTRO_FEDORA:
- case OS_DISTRO_MEEGO:
- case OS_DISTRO_REDHAT_BASED:
- case OS_DISTRO_RHEL:
- case OS_DISTRO_MAGEIA:
- case OS_DISTRO_MANDRIVA:
- case OS_DISTRO_SUSE_BASED:
- case OS_DISTRO_OPENSUSE:
- case OS_DISTRO_SLES:
- case OS_DISTRO_CENTOS:
- case OS_DISTRO_SCIENTIFIC_LINUX:
- case OS_DISTRO_ORACLE_LINUX:
- case OS_DISTRO_ALTLINUX:
- fs->package_format = OS_PACKAGE_FORMAT_RPM;
- break;
-
- case OS_DISTRO_DEBIAN:
- case OS_DISTRO_UBUNTU:
- case OS_DISTRO_LINUX_MINT:
- fs->package_format = OS_PACKAGE_FORMAT_DEB;
- break;
-
- case OS_DISTRO_ARCHLINUX:
- fs->package_format = OS_PACKAGE_FORMAT_PACMAN;
- break;
- case OS_DISTRO_GENTOO:
- fs->package_format = OS_PACKAGE_FORMAT_EBUILD;
- break;
- case OS_DISTRO_PARDUS:
- fs->package_format = OS_PACKAGE_FORMAT_PISI;
- break;
-
- case OS_DISTRO_ALPINE_LINUX:
- fs->package_format = OS_PACKAGE_FORMAT_APK;
- break;
-
- case OS_DISTRO_VOID_LINUX:
- fs->package_format = OS_PACKAGE_FORMAT_XBPS;
- break;
-
- case OS_DISTRO_SLACKWARE:
- case OS_DISTRO_TTYLINUX:
- case OS_DISTRO_COREOS:
- case OS_DISTRO_WINDOWS:
- case OS_DISTRO_BUILDROOT:
- case OS_DISTRO_CIRROS:
- case OS_DISTRO_FREEDOS:
- case OS_DISTRO_FREEBSD:
- case OS_DISTRO_NETBSD:
- case OS_DISTRO_OPENBSD:
- case OS_DISTRO_FRUGALWARE:
- case OS_DISTRO_PLD_LINUX:
- case OS_DISTRO_UNKNOWN:
- fs->package_format = OS_PACKAGE_FORMAT_UNKNOWN;
- break;
- }
-}
-
-void
-guestfs_int_check_package_management (guestfs_h *g, struct inspect_fs *fs)
-{
- switch (fs->distro) {
- case OS_DISTRO_MEEGO:
- fs->package_management = OS_PACKAGE_MANAGEMENT_YUM;
- break;
-
- case OS_DISTRO_FEDORA:
- /* If Fedora >= 22 and dnf is installed, say "dnf". */
- if (guestfs_int_version_ge (&fs->version, 22, 0, 0) &&
- guestfs_is_file_opts (g, "/usr/bin/dnf",
- GUESTFS_IS_FILE_OPTS_FOLLOWSYMLINKS, 1, -1) > 0)
- fs->package_management = OS_PACKAGE_MANAGEMENT_DNF;
- else if (guestfs_int_version_ge (&fs->version, 1, 0, 0))
- fs->package_management = OS_PACKAGE_MANAGEMENT_YUM;
- else
- /* Probably parsing the release file failed, see RHBZ#1332025. */
- fs->package_management = OS_PACKAGE_MANAGEMENT_UNKNOWN;
- break;
-
- case OS_DISTRO_REDHAT_BASED:
- case OS_DISTRO_RHEL:
- case OS_DISTRO_CENTOS:
- case OS_DISTRO_SCIENTIFIC_LINUX:
- case OS_DISTRO_ORACLE_LINUX:
- if (guestfs_int_version_ge (&fs->version, 5, 0, 0))
- fs->package_management = OS_PACKAGE_MANAGEMENT_YUM;
- else if (guestfs_int_version_ge (&fs->version, 2, 0, 0))
- fs->package_management = OS_PACKAGE_MANAGEMENT_UP2DATE;
- else
- /* Probably parsing the release file failed, see RHBZ#1332025. */
- fs->package_management = OS_PACKAGE_MANAGEMENT_UNKNOWN;
- break;
-
- case OS_DISTRO_DEBIAN:
- case OS_DISTRO_UBUNTU:
- case OS_DISTRO_LINUX_MINT:
- case OS_DISTRO_ALTLINUX:
- fs->package_management = OS_PACKAGE_MANAGEMENT_APT;
- break;
-
- case OS_DISTRO_ARCHLINUX:
- fs->package_management = OS_PACKAGE_MANAGEMENT_PACMAN;
- break;
- case OS_DISTRO_GENTOO:
- fs->package_management = OS_PACKAGE_MANAGEMENT_PORTAGE;
- break;
- case OS_DISTRO_PARDUS:
- fs->package_management = OS_PACKAGE_MANAGEMENT_PISI;
- break;
- case OS_DISTRO_MAGEIA:
- case OS_DISTRO_MANDRIVA:
- fs->package_management = OS_PACKAGE_MANAGEMENT_URPMI;
- break;
-
- case OS_DISTRO_SUSE_BASED:
- case OS_DISTRO_OPENSUSE:
- case OS_DISTRO_SLES:
- fs->package_management = OS_PACKAGE_MANAGEMENT_ZYPPER;
- break;
-
- case OS_DISTRO_ALPINE_LINUX:
- fs->package_management = OS_PACKAGE_MANAGEMENT_APK;
- break;
-
- case OS_DISTRO_VOID_LINUX:
- fs->package_management = OS_PACKAGE_MANAGEMENT_XBPS;
- break;
-
- case OS_DISTRO_SLACKWARE:
- case OS_DISTRO_TTYLINUX:
- case OS_DISTRO_COREOS:
- case OS_DISTRO_WINDOWS:
- case OS_DISTRO_BUILDROOT:
- case OS_DISTRO_CIRROS:
- case OS_DISTRO_FREEDOS:
- case OS_DISTRO_FREEBSD:
- case OS_DISTRO_NETBSD:
- case OS_DISTRO_OPENBSD:
- case OS_DISTRO_FRUGALWARE:
- case OS_DISTRO_PLD_LINUX:
- case OS_DISTRO_UNKNOWN:
- fs->package_management = OS_PACKAGE_MANAGEMENT_UNKNOWN;
- break;
- }
-}
-
-/* Get the first line of a small file, without any trailing newline
- * character.
- *
- * NOTE: If the file is completely empty or begins with a '\n'
- * character, this returns an empty string (not NULL). The caller
- * will usually need to check for this case.
- */
-char *
-guestfs_int_first_line_of_file (guestfs_h *g, const char *filename)
-{
- char **lines = NULL; /* sic: not CLEANUP_FREE_STRING_LIST */
- int64_t size;
- char *ret;
-
- /* Don't trust guestfs_head_n not to break with very large files.
- * Check the file size is something reasonable first.
- */
- size = guestfs_filesize (g, filename);
- if (size == -1)
- /* guestfs_filesize failed and has already set error in handle */
- return NULL;
- if (size > MAX_SMALL_FILE_SIZE) {
- error (g, _("size of %s is unreasonably large (%" PRIi64 "
bytes)"),
- filename, size);
- return NULL;
- }
-
- lines = guestfs_head_n (g, 1, filename);
- if (lines == NULL)
- return NULL;
- if (lines[0] == NULL) {
- guestfs_int_free_string_list (lines);
- /* Empty file: Return an empty string as explained above. */
- return safe_strdup (g, "");
- }
- /* lines[1] should be NULL because of '1' argument above ... */
-
- ret = lines[0]; /* caller frees */
-
- free (lines);
-
- return ret;
-}
-
/* Get the first matching line (using egrep [-i]) of a small file,
* without any trailing newline character.
*
@@ -696,103 +115,3 @@ guestfs_int_first_egrep_of_file (guestfs_h *g, const char
*filename,
return 1;
}
-
-/* Merge the missing OS inspection information found on the src inspect_fs into
- * the ones of the dst inspect_fs. This function is useful if the inspection
- * information for an OS are gathered by inspecting multiple filesystems.
- */
-void
-guestfs_int_merge_fs_inspections (guestfs_h *g, struct inspect_fs *dst, struct inspect_fs
*src)
-{
- size_t n, i, old;
- struct inspect_fstab_entry *fstab = NULL;
- char ** mappings = NULL;
-
- if (dst->type == 0)
- dst->type = src->type;
-
- if (dst->distro == 0)
- dst->distro = src->distro;
-
- if (dst->package_format == 0)
- dst->package_format = src->package_format;
-
- if (dst->package_management == 0)
- dst->package_management = src->package_management;
-
- if (dst->product_name == NULL) {
- dst->product_name = src->product_name;
- src->product_name = NULL;
- }
-
- if (dst->product_variant == NULL) {
- dst->product_variant= src->product_variant;
- src->product_variant = NULL;
- }
-
- if (version_is_null (&dst->version))
- dst->version = src->version;
-
- if (dst->arch == NULL) {
- dst->arch = src->arch;
- src->arch = NULL;
- }
-
- if (dst->hostname == NULL) {
- dst->hostname = src->hostname;
- src->hostname = NULL;
- }
-
- if (dst->windows_systemroot == NULL) {
- dst->windows_systemroot = src->windows_systemroot;
- src->windows_systemroot = NULL;
- }
-
- if (dst->windows_current_control_set == NULL) {
- dst->windows_current_control_set = src->windows_current_control_set;
- src->windows_current_control_set = NULL;
- }
-
- if (src->drive_mappings != NULL) {
- if (dst->drive_mappings == NULL) {
- /* Adopt the drive mappings of src */
- dst->drive_mappings = src->drive_mappings;
- src->drive_mappings = NULL;
- } else {
- n = 0;
- for (; dst->drive_mappings[n] != NULL; n++)
- ;
- old = n;
- for (; src->drive_mappings[n] != NULL; n++)
- ;
-
- /* Merge the src mappings to dst */
- mappings = safe_realloc (g, dst->drive_mappings,(n + 1) * sizeof (char *));
-
- for (i = old; i < n; i++)
- mappings[i] = src->drive_mappings[i - old];
-
- mappings[n] = NULL;
- dst->drive_mappings = mappings;
-
- free(src->drive_mappings);
- src->drive_mappings = NULL;
- }
- }
-
- if (src->nr_fstab > 0) {
- n = dst->nr_fstab + src->nr_fstab;
- fstab = safe_realloc (g, dst->fstab, n * sizeof (struct inspect_fstab_entry));
-
- for (i = 0; i < src->nr_fstab; i++) {
- fstab[dst->nr_fstab + i].mountable = src->fstab[i].mountable;
- fstab[dst->nr_fstab + i].mountpoint = src->fstab[i].mountpoint;
- }
- free(src->fstab);
- src->fstab = NULL;
- src->nr_fstab = 0;
-
- dst->fstab = fstab;
- dst->nr_fstab = n;
- }
-}
diff --git a/lib/inspect-icon.c b/lib/inspect-icon.c
index 89c232f5b..f4f5f0660 100644
--- a/lib/inspect-icon.c
+++ b/lib/inspect-icon.c
@@ -51,22 +51,24 @@
* An icon was found. 'ret' points to the icon buffer, and *size_r
* is the size.
*/
-static char *icon_favicon (guestfs_h *g, struct inspect_fs *fs, size_t *size_r);
-static char *icon_fedora (guestfs_h *g, struct inspect_fs *fs, size_t *size_r);
-static char *icon_rhel (guestfs_h *g, struct inspect_fs *fs, size_t *size_r);
-static char *icon_debian (guestfs_h *g, struct inspect_fs *fs, size_t *size_r);
-static char *icon_ubuntu (guestfs_h *g, struct inspect_fs *fs, size_t *size_r);
-static char *icon_mageia (guestfs_h *g, struct inspect_fs *fs, size_t *size_r);
-static char *icon_opensuse (guestfs_h *g, struct inspect_fs *fs, size_t *size_r);
+static char *icon_favicon (guestfs_h *g, const char *type, size_t *size_r);
+static char *icon_fedora (guestfs_h *g, size_t *size_r);
+static char *icon_rhel (guestfs_h *g, int major, size_t *size_r);
+static char *icon_debian (guestfs_h *g, size_t *size_r);
+static char *icon_ubuntu (guestfs_h *g, size_t *size_r);
+static char *icon_mageia (guestfs_h *g, size_t *size_r);
+static char *icon_opensuse (guestfs_h *g, size_t *size_r);
#if CAN_DO_CIRROS
-static char *icon_cirros (guestfs_h *g, struct inspect_fs *fs, size_t *size_r);
+static char *icon_cirros (guestfs_h *g, size_t *size_r);
#endif
-static char *icon_voidlinux (guestfs_h *g, struct inspect_fs *fs, size_t *size_r);
-static char *icon_altlinux (guestfs_h *g, struct inspect_fs *fs, size_t *size_r);
+static char *icon_voidlinux (guestfs_h *g, size_t *size_r);
+static char *icon_altlinux (guestfs_h *g, size_t *size_r);
#if CAN_DO_WINDOWS
-static char *icon_windows (guestfs_h *g, struct inspect_fs *fs, size_t *size_r);
+static char *icon_windows (guestfs_h *g, const char *root, size_t *size_r);
#endif
+static char *case_sensitive_path_silently (guestfs_h *g, const char *path);
+
/* Dummy static object. */
static char *NOT_FOUND = (char *) "not_found";
@@ -82,13 +84,17 @@ char *
guestfs_impl_inspect_get_icon (guestfs_h *g, const char *root, size_t *size_r,
const struct guestfs_inspect_get_icon_argv *optargs)
{
- struct inspect_fs *fs;
char *r = NOT_FOUND;
int favicon, highquality;
size_t size;
+ CLEANUP_FREE char *type = NULL;
+ CLEANUP_FREE char *distro = NULL;
- fs = guestfs_int_search_for_root (g, root);
- if (!fs)
+ type = guestfs_inspect_get_type (g, root);
+ if (!type)
+ return NULL;
+ distro = guestfs_inspect_get_distro (g, root);
+ if (!distro)
return NULL;
/* Get optargs, or defaults. */
@@ -106,7 +112,7 @@ guestfs_impl_inspect_get_icon (guestfs_h *g, const char *root, size_t
*size_r,
/* Try looking for a favicon first. */
if (favicon) {
- r = icon_favicon (g, fs, &size);
+ r = icon_favicon (g, type, &size);
if (!r)
return NULL;
@@ -120,96 +126,52 @@ guestfs_impl_inspect_get_icon (guestfs_h *g, const char *root,
size_t *size_r,
/* Favicon failed, so let's try a method based on the detected operating
* system.
*/
- switch (fs->type) {
- case OS_TYPE_LINUX:
- case OS_TYPE_HURD:
- switch (fs->distro) {
- case OS_DISTRO_FEDORA:
- r = icon_fedora (g, fs, &size);
- break;
-
- case OS_DISTRO_RHEL:
- case OS_DISTRO_REDHAT_BASED:
- case OS_DISTRO_CENTOS:
- case OS_DISTRO_SCIENTIFIC_LINUX:
- case OS_DISTRO_ORACLE_LINUX:
- r = icon_rhel (g, fs, &size);
- break;
-
- case OS_DISTRO_DEBIAN:
- r = icon_debian (g, fs, &size);
- break;
-
- case OS_DISTRO_UBUNTU:
+ if (STREQ (type, "linux") || STREQ (type, "hurd")) {
+ if (STREQ (distro, "fedora")) {
+ r = icon_fedora (g, &size);
+ }
+ else if (STREQ (distro, "rhel") ||
+ STREQ (distro, "redhat-based") ||
+ STREQ (distro, "centos") ||
+ STREQ (distro, "scientificlinux") ||
+ STREQ (distro, "oraclelinux")) {
+ r = icon_rhel (g, guestfs_inspect_get_major_version (g, root), &size);
+ }
+ else if (STREQ (distro, "debian")) {
+ r = icon_debian (g, &size);
+ }
+ else if (STREQ (distro, "ubuntu")) {
if (!highquality)
- r = icon_ubuntu (g, fs, &size);
- break;
-
- case OS_DISTRO_MAGEIA:
- r = icon_mageia (g, fs, &size);
- break;
-
- case OS_DISTRO_SUSE_BASED:
- case OS_DISTRO_OPENSUSE:
- case OS_DISTRO_SLES:
- r = icon_opensuse (g, fs, &size);
- break;
-
- case OS_DISTRO_CIRROS:
+ r = icon_ubuntu (g, &size);
+ }
+ else if (STREQ (distro, "mageia")) {
+ r = icon_mageia (g, &size);
+ }
+ else if (STREQ (distro, "suse-based") ||
+ STREQ (distro, "opensuse") ||
+ STREQ (distro, "sles")) {
+ r = icon_opensuse (g, &size);
+ }
+ else if (STREQ (distro, "cirros")) {
#if CAN_DO_CIRROS
- r = icon_cirros (g, fs, &size);
+ r = icon_cirros (g, &size);
#endif
- break;
-
- case OS_DISTRO_VOID_LINUX:
- r = icon_voidlinux (g, fs, &size);
- break;
-
- case OS_DISTRO_ALTLINUX:
- r = icon_altlinux (g, fs, &size);
- break;
-
- /* These are just to keep gcc warnings happy. */
- case OS_DISTRO_ARCHLINUX:
- case OS_DISTRO_BUILDROOT:
- case OS_DISTRO_COREOS:
- case OS_DISTRO_FREEDOS:
- case OS_DISTRO_GENTOO:
- case OS_DISTRO_LINUX_MINT:
- case OS_DISTRO_MANDRIVA:
- case OS_DISTRO_MEEGO:
- case OS_DISTRO_PARDUS:
- case OS_DISTRO_SLACKWARE:
- case OS_DISTRO_TTYLINUX:
- case OS_DISTRO_WINDOWS:
- case OS_DISTRO_FREEBSD:
- case OS_DISTRO_NETBSD:
- case OS_DISTRO_OPENBSD:
- case OS_DISTRO_ALPINE_LINUX:
- case OS_DISTRO_FRUGALWARE:
- case OS_DISTRO_PLD_LINUX:
- case OS_DISTRO_UNKNOWN:
- ; /* nothing */
}
- break;
-
- case OS_TYPE_WINDOWS:
+ else if (STREQ (distro, "voidlinux")) {
+ r = icon_voidlinux (g, &size);
+ }
+ else if (STREQ (distro, "altlinux")) {
+ r = icon_altlinux (g, &size);
+ }
+ }
+ else if (STREQ (type, "windows")) {
#if CAN_DO_WINDOWS
/* We don't know how to get high quality icons from a Windows guest,
* so disable this if high quality was specified.
*/
if (!highquality)
- r = icon_windows (g, fs, &size);
+ r = icon_windows (g, root, &size);
#endif
- break;
-
- case OS_TYPE_FREEBSD:
- case OS_TYPE_NETBSD:
- case OS_TYPE_DOS:
- case OS_TYPE_OPENBSD:
- case OS_TYPE_MINIX:
- case OS_TYPE_UNKNOWN:
- ; /* nothing */
}
if (r == NOT_FOUND) {
@@ -229,8 +191,7 @@ guestfs_impl_inspect_get_icon (guestfs_h *g, const char *root, size_t
*size_r,
* If it is, download and return it.
*/
static char *
-get_png (guestfs_h *g, struct inspect_fs *fs, const char *filename,
- size_t *size_r, size_t max_size)
+get_png (guestfs_h *g, const char *filename, size_t *size_r, size_t max_size)
{
char *ret;
CLEANUP_FREE char *real = NULL;
@@ -270,7 +231,7 @@ get_png (guestfs_h *g, struct inspect_fs *fs, const char *filename,
if (max_size == 0)
max_size = 4 * w * h;
- local = guestfs_int_download_to_tmp (g, fs, real, "icon", max_size);
+ local = guestfs_int_download_to_tmp (g, real, "icon", max_size);
if (!local)
return NOT_FOUND;
@@ -285,20 +246,20 @@ get_png (guestfs_h *g, struct inspect_fs *fs, const char *filename,
* it has a reasonable size and format.
*/
static char *
-icon_favicon (guestfs_h *g, struct inspect_fs *fs, size_t *size_r)
+icon_favicon (guestfs_h *g, const char *type, size_t *size_r)
{
char *ret;
char *filename = safe_strdup (g, "/etc/favicon.png");
- if (fs->type == OS_TYPE_WINDOWS) {
- char *f = guestfs_int_case_sensitive_path_silently (g, filename);
+ if (STREQ (type, "windows")) {
+ char *f = case_sensitive_path_silently (g, filename);
if (f) {
free (filename);
filename = f;
}
}
- ret = get_png (g, fs, filename, size_r, 0);
+ ret = get_png (g, filename, size_r, 0);
free (filename);
return ret;
}
@@ -309,9 +270,9 @@ icon_favicon (guestfs_h *g, struct inspect_fs *fs, size_t *size_r)
#define FEDORA_ICON "/usr/share/icons/hicolor/96x96/apps/fedora-logo-icon.png"
static char *
-icon_fedora (guestfs_h *g, struct inspect_fs *fs, size_t *size_r)
+icon_fedora (guestfs_h *g, size_t *size_r)
{
- return get_png (g, fs, FEDORA_ICON, size_r, 0);
+ return get_png (g, FEDORA_ICON, size_r, 0);
}
/* RHEL 3, 4:
@@ -330,28 +291,28 @@ icon_fedora (guestfs_h *g, struct inspect_fs *fs, size_t *size_r)
* RHEL clones have different sizes.
*/
static char *
-icon_rhel (guestfs_h *g, struct inspect_fs *fs, size_t *size_r)
+icon_rhel (guestfs_h *g, int major, size_t *size_r)
{
const char *shadowman;
- if (!guestfs_int_version_ge (&fs->version, 7, 0, 0))
+ if (major < 7)
shadowman = "/usr/share/pixmaps/redhat/shadowman-transparent.png";
else
shadowman = "/usr/share/pixmaps/fedora-logo-sprite.png";
- return get_png (g, fs, shadowman, size_r, 102400);
+ return get_png (g, shadowman, size_r, 102400);
}
#define DEBIAN_ICON "/usr/share/pixmaps/debian-logo.png"
static char *
-icon_debian (guestfs_h *g, struct inspect_fs *fs, size_t *size_r)
+icon_debian (guestfs_h *g, size_t *size_r)
{
- return get_png (g, fs, DEBIAN_ICON, size_r, 2048);
+ return get_png (g, DEBIAN_ICON, size_r, 2048);
}
static char *
-icon_ubuntu (guestfs_h *g, struct inspect_fs *fs, size_t *size_r)
+icon_ubuntu (guestfs_h *g, size_t *size_r)
{
const char *icons[] = {
"/usr/share/icons/gnome/24x24/places/ubuntu-logo.png",
@@ -366,7 +327,7 @@ icon_ubuntu (guestfs_h *g, struct inspect_fs *fs, size_t *size_r)
char *ret;
for (i = 0; icons[i] != NULL; ++i) {
- ret = get_png (g, fs, icons[i], size_r, 2048);
+ ret = get_png (g, icons[i], size_r, 2048);
if (ret == NULL)
return NULL;
if (ret != NOT_FOUND)
@@ -378,17 +339,17 @@ icon_ubuntu (guestfs_h *g, struct inspect_fs *fs, size_t *size_r)
#define MAGEIA_ICON "/usr/share/icons/mageia.png"
static char *
-icon_mageia (guestfs_h *g, struct inspect_fs *fs, size_t *size_r)
+icon_mageia (guestfs_h *g, size_t *size_r)
{
- return get_png (g, fs, MAGEIA_ICON, size_r, 2048);
+ return get_png (g, MAGEIA_ICON, size_r, 2048);
}
#define OPENSUSE_ICON "/usr/share/icons/hicolor/24x24/apps/distributor.png"
static char *
-icon_opensuse (guestfs_h *g, struct inspect_fs *fs, size_t *size_r)
+icon_opensuse (guestfs_h *g, size_t *size_r)
{
- return get_png (g, fs, OPENSUSE_ICON, size_r, 2048);
+ return get_png (g, OPENSUSE_ICON, size_r, 2048);
}
#if CAN_DO_CIRROS
@@ -397,7 +358,7 @@ icon_opensuse (guestfs_h *g, struct inspect_fs *fs, size_t *size_r)
#define CIRROS_LOGO "/usr/share/cirros/logo"
static char *
-icon_cirros (guestfs_h *g, struct inspect_fs *fs, size_t *size_r)
+icon_cirros (guestfs_h *g, size_t *size_r)
{
char *ret;
CLEANUP_FREE char *type = NULL;
@@ -421,7 +382,7 @@ icon_cirros (guestfs_h *g, struct inspect_fs *fs, size_t *size_r)
if (!STRPREFIX (type, "ASCII text"))
return NOT_FOUND;
- local = guestfs_int_download_to_tmp (g, fs, CIRROS_LOGO, "icon", 1024);
+ local = guestfs_int_download_to_tmp (g, CIRROS_LOGO, "icon", 1024);
if (!local)
return NOT_FOUND;
@@ -450,17 +411,17 @@ icon_cirros (guestfs_h *g, struct inspect_fs *fs, size_t *size_r)
#define VOIDLINUX_ICON "/usr/share/void-artwork/void-logo.png"
static char *
-icon_voidlinux (guestfs_h *g, struct inspect_fs *fs, size_t *size_r)
+icon_voidlinux (guestfs_h *g, size_t *size_r)
{
- return get_png (g, fs, VOIDLINUX_ICON, size_r, 20480);
+ return get_png (g, VOIDLINUX_ICON, size_r, 20480);
}
#define ALTLINUX_ICON "/usr/share/icons/hicolor/48x48/apps/altlinux.png"
static char *
-icon_altlinux (guestfs_h *g, struct inspect_fs *fs, size_t *size_r)
+icon_altlinux (guestfs_h *g, size_t *size_r)
{
- return get_png (g, fs, ALTLINUX_ICON, size_r, 20480);
+ return get_png (g, ALTLINUX_ICON, size_r, 20480);
}
#if CAN_DO_WINDOWS
@@ -481,7 +442,7 @@ icon_altlinux (guestfs_h *g, struct inspect_fs *fs, size_t *size_r)
*/
static char *
-icon_windows_xp (guestfs_h *g, struct inspect_fs *fs, size_t *size_r)
+icon_windows_xp (guestfs_h *g, const char *systemroot, size_t *size_r)
{
CLEANUP_FREE char *filename = NULL;
CLEANUP_FREE char *filename_case = NULL;
@@ -492,7 +453,7 @@ icon_windows_xp (guestfs_h *g, struct inspect_fs *fs, size_t *size_r)
char *ret;
/* Download %systemroot%\explorer.exe */
- filename = safe_asprintf (g, "%s/explorer.exe", fs->windows_systemroot);
+ filename = safe_asprintf (g, "%s/explorer.exe", systemroot);
filename_case = guestfs_case_sensitive_path (g, filename);
if (filename_case == NULL)
return NULL;
@@ -505,7 +466,7 @@ icon_windows_xp (guestfs_h *g, struct inspect_fs *fs, size_t *size_r)
if (r == 0)
return NOT_FOUND;
- filename_downloaded = guestfs_int_download_to_tmp (g, fs, filename_case,
+ filename_downloaded = guestfs_int_download_to_tmp (g, filename_case,
"explorer.exe",
MAX_WINDOWS_EXPLORER_SIZE);
if (filename_downloaded == NULL)
@@ -543,7 +504,7 @@ static const char *win7_explorer[] = {
};
static char *
-icon_windows_7 (guestfs_h *g, struct inspect_fs *fs, size_t *size_r)
+icon_windows_7 (guestfs_h *g, const char *systemroot, size_t *size_r)
{
size_t i;
CLEANUP_FREE char *filename_case = NULL;
@@ -556,11 +517,10 @@ icon_windows_7 (guestfs_h *g, struct inspect_fs *fs, size_t
*size_r)
for (i = 0; win7_explorer[i] != NULL; ++i) {
CLEANUP_FREE char *filename = NULL;
- filename = safe_asprintf (g, "%s/%s",
- fs->windows_systemroot, win7_explorer[i]);
+ filename = safe_asprintf (g, "%s/%s", systemroot, win7_explorer[i]);
free (filename_case);
- filename_case = guestfs_int_case_sensitive_path_silently (g, filename);
+ filename_case = case_sensitive_path_silently (g, filename);
if (filename_case == NULL)
continue;
@@ -575,7 +535,7 @@ icon_windows_7 (guestfs_h *g, struct inspect_fs *fs, size_t *size_r)
if (win7_explorer[i] == NULL)
return NOT_FOUND;
- filename_downloaded = guestfs_int_download_to_tmp (g, fs, filename_case,
+ filename_downloaded = guestfs_int_download_to_tmp (g, filename_case,
"explorer.exe",
MAX_WINDOWS_EXPLORER_SIZE);
if (filename_downloaded == NULL)
@@ -609,14 +569,14 @@ icon_windows_7 (guestfs_h *g, struct inspect_fs *fs, size_t
*size_r)
* - /Windows/System32/slui.exe --type=14 group icon #2
*/
static char *
-icon_windows_8 (guestfs_h *g, struct inspect_fs *fs, size_t *size_r)
+icon_windows_8 (guestfs_h *g, size_t *size_r)
{
CLEANUP_FREE char *filename_case = NULL;
CLEANUP_FREE char *filename_downloaded = NULL;
int r;
char *ret;
- filename_case = guestfs_int_case_sensitive_path_silently
+ filename_case = case_sensitive_path_silently
(g, "/ProgramData/Microsoft/Windows Live/WLive48x48.png");
if (filename_case == NULL)
return NOT_FOUND; /* Not an error since a parent dir might not exist. */
@@ -629,7 +589,7 @@ icon_windows_8 (guestfs_h *g, struct inspect_fs *fs, size_t *size_r)
if (r == 0)
return NOT_FOUND;
- filename_downloaded = guestfs_int_download_to_tmp (g, fs, filename_case,
+ filename_downloaded = guestfs_int_download_to_tmp (g, filename_case,
"wlive48x48.png", 8192);
if (filename_downloaded == NULL)
return NOT_FOUND;
@@ -641,25 +601,46 @@ icon_windows_8 (guestfs_h *g, struct inspect_fs *fs, size_t
*size_r)
}
static char *
-icon_windows (guestfs_h *g, struct inspect_fs *fs, size_t *size_r)
+icon_windows (guestfs_h *g, const char *root, size_t *size_r)
{
- if (fs->windows_systemroot == NULL)
+ CLEANUP_FREE char *systemroot =
+ guestfs_inspect_get_windows_systemroot (g, root);
+ int major = guestfs_inspect_get_major_version (g, root);
+ int minor = guestfs_inspect_get_minor_version (g, root);
+
+ if (systemroot == NULL)
return NOT_FOUND;
/* Windows XP. */
- if (fs->version.v_major == 5 && fs->version.v_minor == 1)
- return icon_windows_xp (g, fs, size_r);
+ if (major == 5 && minor == 1)
+ return icon_windows_xp (g, systemroot, size_r);
/* Windows 7. */
- else if (fs->version.v_major == 6 && fs->version.v_minor == 1)
- return icon_windows_7 (g, fs, size_r);
+ else if (major == 6 && minor == 1)
+ return icon_windows_7 (g, systemroot, size_r);
/* Windows 8. */
- else if (fs->version.v_major == 6 && fs->version.v_minor == 2)
- return icon_windows_8 (g, fs, size_r);
+ else if (major == 6 && minor == 2)
+ return icon_windows_8 (g, size_r);
/* Not (yet) a supported version of Windows. */
else return NOT_FOUND;
}
#endif /* CAN_DO_WINDOWS */
+
+/* NB: This function DOES NOT test for the existence of the file. It
+ * will return non-NULL even if the file/directory does not exist.
+ * You have to call guestfs_is_file{,_opts} etc.
+ */
+static char *
+case_sensitive_path_silently (guestfs_h *g, const char *path)
+{
+ char *ret;
+
+ guestfs_push_error_handler (g, NULL, NULL);
+ ret = guestfs_case_sensitive_path (g, path);
+ guestfs_pop_error_handler (g);
+
+ return ret;
+}
diff --git a/lib/inspect.c b/lib/inspect.c
index 1cc0942f1..f2d64b61e 100644
--- a/lib/inspect.c
+++ b/lib/inspect.c
@@ -43,688 +43,6 @@
#include "guestfs-internal.h"
#include "guestfs-internal-actions.h"
-COMPILE_REGEXP (re_primary_partition, "^/dev/(?:h|s|v)d.[1234]$", 0)
-
-static void check_for_duplicated_bsd_root (guestfs_h *g);
-static void collect_coreos_inspection_info (guestfs_h *g);
-static void collect_linux_inspection_info (guestfs_h *g);
-static void collect_linux_inspection_info_for (guestfs_h *g, struct inspect_fs *root);
-
-/**
- * The main inspection API.
- */
-char **
-guestfs_impl_inspect_os (guestfs_h *g)
-{
- CLEANUP_FREE_STRING_LIST char **fses = NULL;
- char **fs, **ret;
-
- /* Remove any information previously stored in the handle. */
- guestfs_int_free_inspect_info (g);
-
- if (guestfs_umount_all (g) == -1)
- return NULL;
-
- /* Iterate over all detected filesystems. Inspect each one in turn
- * and add that information to the handle.
- */
-
- fses = guestfs_list_filesystems (g);
- if (fses == NULL) return NULL;
-
- for (fs = fses; *fs; fs += 2) {
- if (guestfs_int_check_for_filesystem_on (g, *fs)) {
- guestfs_int_free_inspect_info (g);
- return NULL;
- }
- }
-
- /* The OS inspection information for CoreOS are gathered by inspecting
- * multiple filesystems. Gather all the inspected information in the
- * inspect_fs struct of the root filesystem.
- */
- collect_coreos_inspection_info (g);
-
- /* Check if the same filesystem was listed twice as root in g->fses.
- * This may happen for the *BSD root partition where an MBR partition
- * is a shadow of the real root partition probably /dev/sda5
- */
- check_for_duplicated_bsd_root (g);
-
- /* For Linux guests with a separate /usr filesyste, merge some of the
- * inspected information in that partition to the inspect_fs struct
- * of the root filesystem.
- */
- collect_linux_inspection_info (g);
-
- /* At this point we have, in the handle, a list of all filesystems
- * found and data about each one. Now we assemble the list of
- * filesystems which are root devices and return that to the user.
- * Fall through to guestfs_inspect_get_roots to do that.
- */
- ret = guestfs_inspect_get_roots (g);
- if (ret == NULL)
- guestfs_int_free_inspect_info (g);
- return ret;
-}
-
-/**
- * Traverse through the filesystem list and find out if it contains
- * the C</> and C</usr> filesystems of a CoreOS image. If this is the
- * case, sum up all the collected information on the root fs.
- */
-static void
-collect_coreos_inspection_info (guestfs_h *g)
-{
- size_t i;
- struct inspect_fs *root = NULL, *usr = NULL;
-
- for (i = 0; i < g->nr_fses; ++i) {
- struct inspect_fs *fs = &g->fses[i];
-
- if (fs->distro == OS_DISTRO_COREOS && fs->role == OS_ROLE_ROOT)
- root = fs;
- }
-
- if (root == NULL)
- return;
-
- for (i = 0; i < g->nr_fses; ++i) {
- struct inspect_fs *fs = &g->fses[i];
-
- if (fs->distro != OS_DISTRO_COREOS || fs->role != OS_ROLE_USR)
- continue;
-
- /* CoreOS is designed to contain 2 /usr partitions (USR-A, USR-B):
- *
https://coreos.com/docs/sdk-distributors/sdk/disk-partitions/
- * One is active and one passive. During the initial boot, the passive
- * partition is empty and it gets filled up when an update is performed.
- * Then, when the system reboots, the boot loader is instructed to boot
- * from the passive partition. If both partitions are valid, we cannot
- * determine which the active and which the passive is, unless we peep into
- * the boot loader. As a workaround, we check the OS versions and pick the
- * one with the higher version as active.
- */
- if (usr && guestfs_int_version_cmp_ge (&usr->version,
&fs->version))
- continue;
-
- usr = fs;
- }
-
- if (usr == NULL)
- return;
-
- guestfs_int_merge_fs_inspections (g, root, usr);
-}
-
-/**
- * Traverse through the filesystems and find the /usr filesystem for
- * the specified C<root>: if found, merge its basic inspection details
- * to the root when they were set (i.e. because the /usr had os-release
- * or other ways to identify the OS).
- */
-static void
-collect_linux_inspection_info_for (guestfs_h *g, struct inspect_fs *root)
-{
- size_t i;
- struct inspect_fs *usr = NULL;
-
- for (i = 0; i < g->nr_fses; ++i) {
- struct inspect_fs *fs = &g->fses[i];
- size_t j;
-
- if (!(fs->distro == root->distro || fs->distro == OS_DISTRO_UNKNOWN) ||
- fs->role != OS_ROLE_USR)
- continue;
-
- for (j = 0; j < root->nr_fstab; ++j) {
- if (STREQ (fs->mountable, root->fstab[j].mountable)) {
- usr = fs;
- goto got_usr;
- }
- }
- }
-
- assert (usr == NULL);
- return;
-
- got_usr:
- /* If the version information in /usr is not null, then most probably
- * there was an os-release file there, so reset what is in root
- * and pick the results from /usr.
- */
- if (!version_is_null (&usr->version)) {
- root->distro = OS_DISTRO_UNKNOWN;
- free (root->product_name);
- root->product_name = NULL;
- }
-
- guestfs_int_merge_fs_inspections (g, root, usr);
-}
-
-/**
- * Traverse through the filesystem list and find out if it contains
- * the C</> and C</usr> filesystems of a Linux image (but not CoreOS,
- * for which there is a separate C<collect_coreos_inspection_info>).
- * If this is the case, sum up all the collected information on each
- * root fs from the respective /usr filesystems.
- */
-static void
-collect_linux_inspection_info (guestfs_h *g)
-{
- size_t i;
-
- for (i = 0; i < g->nr_fses; ++i) {
- struct inspect_fs *fs = &g->fses[i];
-
- if (fs->distro != OS_DISTRO_COREOS && fs->role == OS_ROLE_ROOT)
- collect_linux_inspection_info_for (g, fs);
- }
-}
-
-/**
- * On *BSD systems, sometimes F</dev/sda[1234]> is a shadow of the
- * real root filesystem that is probably F</dev/sda5> (see:
- *
L<http://www.freebsd.org/doc/handbook/disk-organization.html>)
- */
-static void
-check_for_duplicated_bsd_root (guestfs_h *g)
-{
- size_t i;
- struct inspect_fs *bsd_primary = NULL;
-
- for (i = 0; i < g->nr_fses; ++i) {
- bool is_bsd;
- struct inspect_fs *fs = &g->fses[i];
-
- is_bsd =
- fs->type == OS_TYPE_FREEBSD ||
- fs->type == OS_TYPE_NETBSD ||
- fs->type == OS_TYPE_OPENBSD;
-
- if (fs->role == OS_ROLE_ROOT && is_bsd &&
- match (g, fs->mountable, re_primary_partition)) {
- bsd_primary = fs;
- continue;
- }
-
- if (fs->role == OS_ROLE_ROOT && bsd_primary &&
- bsd_primary->type == fs->type) {
- /* remove the root role from the bsd_primary */
- bsd_primary->role = OS_ROLE_UNKNOWN;
- bsd_primary->format = OS_FORMAT_UNKNOWN;
- return;
- }
- }
-}
-
-static int
-compare_strings (const void *vp1, const void *vp2)
-{
- const char *s1 = * (char * const *) vp1;
- const char *s2 = * (char * const *) vp2;
-
- return strcmp (s1, s2);
-}
-
-char **
-guestfs_impl_inspect_get_roots (guestfs_h *g)
-{
- size_t i;
- DECLARE_STRINGSBUF (ret);
-
- /* NB. Doesn't matter if g->nr_fses == 0. We just return an empty
- * list in this case.
- */
- for (i = 0; i < g->nr_fses; ++i) {
- if (g->fses[i].role == OS_ROLE_ROOT)
- guestfs_int_add_string (g, &ret, g->fses[i].mountable);
- }
- guestfs_int_end_stringsbuf (g, &ret);
-
- qsort (ret.argv, ret.size-1, sizeof (char *), compare_strings);
-
- return ret.argv;
-}
-
-char *
-guestfs_impl_inspect_get_type (guestfs_h *g, const char *root)
-{
- struct inspect_fs *fs = guestfs_int_search_for_root (g, root);
- char *ret = NULL;
-
- if (!fs)
- return NULL;
-
- switch (fs->type) {
- case OS_TYPE_DOS: ret = safe_strdup (g, "dos"); break;
- case OS_TYPE_FREEBSD: ret = safe_strdup (g, "freebsd"); break;
- case OS_TYPE_HURD: ret = safe_strdup (g, "hurd"); break;
- case OS_TYPE_LINUX: ret = safe_strdup (g, "linux"); break;
- case OS_TYPE_MINIX: ret = safe_strdup (g, "minix"); break;
- case OS_TYPE_NETBSD: ret = safe_strdup (g, "netbsd"); break;
- case OS_TYPE_OPENBSD: ret = safe_strdup (g, "openbsd"); break;
- case OS_TYPE_WINDOWS: ret = safe_strdup (g, "windows"); break;
- case OS_TYPE_UNKNOWN: ret = safe_strdup (g, "unknown"); break;
- }
-
- if (ret == NULL)
- abort ();
-
- return ret;
-}
-
-char *
-guestfs_impl_inspect_get_arch (guestfs_h *g, const char *root)
-{
- struct inspect_fs *fs = guestfs_int_search_for_root (g, root);
- if (!fs)
- return NULL;
-
- return safe_strdup (g, fs->arch ? : "unknown");
-}
-
-char *
-guestfs_impl_inspect_get_distro (guestfs_h *g, const char *root)
-{
- struct inspect_fs *fs = guestfs_int_search_for_root (g, root);
- char *ret = NULL;
-
- if (!fs)
- return NULL;
-
- switch (fs->distro) {
- case OS_DISTRO_ALPINE_LINUX: ret = safe_strdup (g, "alpinelinux"); break;
- case OS_DISTRO_ALTLINUX: ret = safe_strdup (g, "altlinux"); break;
- case OS_DISTRO_ARCHLINUX: ret = safe_strdup (g, "archlinux"); break;
- case OS_DISTRO_BUILDROOT: ret = safe_strdup (g, "buildroot"); break;
- case OS_DISTRO_CENTOS: ret = safe_strdup (g, "centos"); break;
- case OS_DISTRO_CIRROS: ret = safe_strdup (g, "cirros"); break;
- case OS_DISTRO_COREOS: ret = safe_strdup (g, "coreos"); break;
- case OS_DISTRO_DEBIAN: ret = safe_strdup (g, "debian"); break;
- case OS_DISTRO_FEDORA: ret = safe_strdup (g, "fedora"); break;
- case OS_DISTRO_FREEBSD: ret = safe_strdup (g, "freebsd"); break;
- case OS_DISTRO_FREEDOS: ret = safe_strdup (g, "freedos"); break;
- case OS_DISTRO_FRUGALWARE: ret = safe_strdup (g, "frugalware"); break;
- case OS_DISTRO_GENTOO: ret = safe_strdup (g, "gentoo"); break;
- case OS_DISTRO_LINUX_MINT: ret = safe_strdup (g, "linuxmint"); break;
- case OS_DISTRO_MAGEIA: ret = safe_strdup (g, "mageia"); break;
- case OS_DISTRO_MANDRIVA: ret = safe_strdup (g, "mandriva"); break;
- case OS_DISTRO_MEEGO: ret = safe_strdup (g, "meego"); break;
- case OS_DISTRO_NETBSD: ret = safe_strdup (g, "netbsd"); break;
- case OS_DISTRO_OPENBSD: ret = safe_strdup (g, "openbsd"); break;
- case OS_DISTRO_OPENSUSE: ret = safe_strdup (g, "opensuse"); break;
- case OS_DISTRO_ORACLE_LINUX: ret = safe_strdup (g, "oraclelinux"); break;
- case OS_DISTRO_PARDUS: ret = safe_strdup (g, "pardus"); break;
- case OS_DISTRO_PLD_LINUX: ret = safe_strdup (g, "pldlinux"); break;
- case OS_DISTRO_REDHAT_BASED: ret = safe_strdup (g, "redhat-based"); break;
- case OS_DISTRO_RHEL: ret = safe_strdup (g, "rhel"); break;
- case OS_DISTRO_SCIENTIFIC_LINUX: ret = safe_strdup (g, "scientificlinux");
break;
- case OS_DISTRO_SLACKWARE: ret = safe_strdup (g, "slackware"); break;
- case OS_DISTRO_SLES: ret = safe_strdup (g, "sles"); break;
- case OS_DISTRO_SUSE_BASED: ret = safe_strdup (g, "suse-based"); break;
- case OS_DISTRO_TTYLINUX: ret = safe_strdup (g, "ttylinux"); break;
- case OS_DISTRO_WINDOWS: ret = safe_strdup (g, "windows"); break;
- case OS_DISTRO_UBUNTU: ret = safe_strdup (g, "ubuntu"); break;
- case OS_DISTRO_VOID_LINUX: ret = safe_strdup (g, "voidlinux"); break;
- case OS_DISTRO_UNKNOWN: ret = safe_strdup (g, "unknown"); break;
- }
-
- if (ret == NULL)
- abort ();
-
- return ret;
-}
-
-int
-guestfs_impl_inspect_get_major_version (guestfs_h *g, const char *root)
-{
- struct inspect_fs *fs = guestfs_int_search_for_root (g, root);
- if (!fs)
- return -1;
-
- return fs->version.v_major;
-}
-
-int
-guestfs_impl_inspect_get_minor_version (guestfs_h *g, const char *root)
-{
- struct inspect_fs *fs = guestfs_int_search_for_root (g, root);
- if (!fs)
- return -1;
-
- return fs->version.v_minor;
-}
-
-char *
-guestfs_impl_inspect_get_product_name (guestfs_h *g, const char *root)
-{
- struct inspect_fs *fs = guestfs_int_search_for_root (g, root);
- if (!fs)
- return NULL;
-
- return safe_strdup (g, fs->product_name ? : "unknown");
-}
-
-char *
-guestfs_impl_inspect_get_product_variant (guestfs_h *g, const char *root)
-{
- struct inspect_fs *fs = guestfs_int_search_for_root (g, root);
- if (!fs)
- return NULL;
-
- return safe_strdup (g, fs->product_variant ? : "unknown");
-}
-
-char *
-guestfs_impl_inspect_get_windows_systemroot (guestfs_h *g, const char *root)
-{
- struct inspect_fs *fs = guestfs_int_search_for_root (g, root);
- if (!fs)
- return NULL;
-
- if (!fs->windows_systemroot) {
- error (g, _("not a Windows guest, or systemroot could not be
determined"));
- return NULL;
- }
-
- return safe_strdup (g, fs->windows_systemroot);
-}
-
-char *
-guestfs_impl_inspect_get_windows_software_hive (guestfs_h *g, const char *root)
-{
- struct inspect_fs *fs = guestfs_int_search_for_root (g, root);
- if (!fs)
- return NULL;
-
- if (!fs->windows_software_hive) {
- error (g, _("not a Windows guest, or software hive not found"));
- return NULL;
- }
-
- return safe_strdup (g, fs->windows_software_hive);
-}
-
-char *
-guestfs_impl_inspect_get_windows_system_hive (guestfs_h *g, const char *root)
-{
- struct inspect_fs *fs = guestfs_int_search_for_root (g, root);
- if (!fs)
- return NULL;
-
- if (!fs->windows_system_hive) {
- error (g, _("not a Windows guest, or system hive not found"));
- return NULL;
- }
-
- return safe_strdup (g, fs->windows_system_hive);
-}
-
-char *
-guestfs_impl_inspect_get_windows_current_control_set (guestfs_h *g,
- const char *root)
-{
- struct inspect_fs *fs = guestfs_int_search_for_root (g, root);
- if (!fs)
- return NULL;
-
- if (!fs->windows_current_control_set) {
- error (g, _("not a Windows guest, or CurrentControlSet could not be
determined"));
- return NULL;
- }
-
- return safe_strdup (g, fs->windows_current_control_set);
-}
-
-char *
-guestfs_impl_inspect_get_format (guestfs_h *g, const char *root)
-{
- char *ret = NULL;
- struct inspect_fs *fs = guestfs_int_search_for_root (g, root);
- if (!fs)
- return NULL;
-
- switch (fs->format) {
- case OS_FORMAT_INSTALLED: ret = safe_strdup (g, "installed"); break;
- case OS_FORMAT_INSTALLER: ret = safe_strdup (g, "installer"); break;
- case OS_FORMAT_UNKNOWN: ret = safe_strdup (g, "unknown"); break;
- }
-
- if (ret == NULL)
- abort ();
-
- return ret;
-}
-
-int
-guestfs_impl_inspect_is_live (guestfs_h *g, const char *root)
-{
- struct inspect_fs *fs = guestfs_int_search_for_root (g, root);
- if (!fs)
- return -1;
-
- return fs->is_live_disk;
-}
-
-int
-guestfs_impl_inspect_is_netinst (guestfs_h *g, const char *root)
-{
- struct inspect_fs *fs = guestfs_int_search_for_root (g, root);
- if (!fs)
- return -1;
-
- return fs->is_netinst_disk;
-}
-
-int
-guestfs_impl_inspect_is_multipart (guestfs_h *g, const char *root)
-{
- struct inspect_fs *fs = guestfs_int_search_for_root (g, root);
- if (!fs)
- return -1;
-
- return fs->is_multipart_disk;
-}
-
-char **
-guestfs_impl_inspect_get_mountpoints (guestfs_h *g, const char *root)
-{
- char **ret;
- size_t i, count, nr;
- struct inspect_fs *fs;
-
- fs = guestfs_int_search_for_root (g, root);
- if (!fs)
- return NULL;
-
-#define CRITERION(fs, i) fs->fstab[i].mountpoint[0] == '/'
-
- nr = fs->nr_fstab;
-
- if (nr == 0)
- count = 1;
- else {
- count = 0;
- for (i = 0; i < nr; ++i)
- if (CRITERION (fs, i))
- count++;
- }
-
- /* Hashtables have 2N+1 entries. */
- ret = calloc (2*count+1, sizeof (char *));
- if (ret == NULL) {
- perrorf (g, "calloc");
- return NULL;
- }
-
- /* If no fstab information (Windows) return just the root. */
- if (nr == 0) {
- ret[0] = safe_strdup (g, "/");
- ret[1] = safe_strdup (g, root);
- ret[2] = NULL;
- return ret;
- }
-
- count = 0;
- for (i = 0; i < nr; ++i)
- if (CRITERION (fs, i)) {
- ret[2*count] = safe_strdup (g, fs->fstab[i].mountpoint);
- ret[2*count+1] = safe_strdup (g, fs->fstab[i].mountable);
- count++;
- }
-#undef CRITERION
-
- return ret;
-}
-
-char **
-guestfs_impl_inspect_get_filesystems (guestfs_h *g, const char *root)
-{
- char **ret;
- size_t i, nr;
- struct inspect_fs *fs = guestfs_int_search_for_root (g, root);
-
- if (!fs)
- return NULL;
-
- nr = fs->nr_fstab;
- ret = calloc (nr == 0 ? 2 : nr+1, sizeof (char *));
- if (ret == NULL) {
- perrorf (g, "calloc");
- return NULL;
- }
-
- /* If no fstab information (Windows) return just the root. */
- if (nr == 0) {
- ret[0] = safe_strdup (g, root);
- ret[1] = NULL;
- return ret;
- }
-
- for (i = 0; i < nr; ++i)
- ret[i] = safe_strdup (g, fs->fstab[i].mountable);
-
- return ret;
-}
-
-char **
-guestfs_impl_inspect_get_drive_mappings (guestfs_h *g, const char *root)
-{
- DECLARE_STRINGSBUF (ret);
- size_t i;
- struct inspect_fs *fs;
-
- fs = guestfs_int_search_for_root (g, root);
- if (!fs)
- return NULL;
-
- if (fs->drive_mappings) {
- for (i = 0; fs->drive_mappings[i] != NULL; ++i)
- guestfs_int_add_string (g, &ret, fs->drive_mappings[i]);
- }
-
- guestfs_int_end_stringsbuf (g, &ret);
- return ret.argv;
-}
-
-char *
-guestfs_impl_inspect_get_package_format (guestfs_h *g, const char *root)
-{
- char *ret = NULL;
- struct inspect_fs *fs = guestfs_int_search_for_root (g, root);
- if (!fs)
- return NULL;
-
- switch (fs->package_format) {
- case OS_PACKAGE_FORMAT_RPM: ret = safe_strdup (g, "rpm"); break;
- case OS_PACKAGE_FORMAT_DEB: ret = safe_strdup (g, "deb"); break;
- case OS_PACKAGE_FORMAT_PACMAN: ret = safe_strdup (g, "pacman"); break;
- case OS_PACKAGE_FORMAT_EBUILD: ret = safe_strdup (g, "ebuild"); break;
- case OS_PACKAGE_FORMAT_PISI: ret = safe_strdup (g, "pisi"); break;
- case OS_PACKAGE_FORMAT_PKGSRC: ret = safe_strdup (g, "pkgsrc"); break;
- case OS_PACKAGE_FORMAT_APK: ret = safe_strdup (g, "apk"); break;
- case OS_PACKAGE_FORMAT_XBPS: ret = safe_strdup (g, "xbps"); break;
- case OS_PACKAGE_FORMAT_UNKNOWN:
- ret = safe_strdup (g, "unknown");
- break;
- }
-
- if (ret == NULL)
- abort ();
-
- return ret;
-}
-
-char *
-guestfs_impl_inspect_get_package_management (guestfs_h *g, const char *root)
-{
- char *ret = NULL;
- struct inspect_fs *fs = guestfs_int_search_for_root (g, root);
- if (!fs)
- return NULL;
-
- switch (fs->package_management) {
- case OS_PACKAGE_MANAGEMENT_APK: ret = safe_strdup (g, "apk"); break;
- case OS_PACKAGE_MANAGEMENT_APT: ret = safe_strdup (g, "apt"); break;
- case OS_PACKAGE_MANAGEMENT_DNF: ret = safe_strdup (g, "dnf"); break;
- case OS_PACKAGE_MANAGEMENT_PACMAN: ret = safe_strdup (g, "pacman"); break;
- case OS_PACKAGE_MANAGEMENT_PISI: ret = safe_strdup (g, "pisi"); break;
- case OS_PACKAGE_MANAGEMENT_PORTAGE: ret = safe_strdup (g, "portage"); break;
- case OS_PACKAGE_MANAGEMENT_UP2DATE: ret = safe_strdup (g, "up2date"); break;
- case OS_PACKAGE_MANAGEMENT_URPMI: ret = safe_strdup (g, "urpmi"); break;
- case OS_PACKAGE_MANAGEMENT_XBPS: ret = safe_strdup (g, "xbps"); break;
- case OS_PACKAGE_MANAGEMENT_YUM: ret = safe_strdup (g, "yum"); break;
- case OS_PACKAGE_MANAGEMENT_ZYPPER: ret = safe_strdup (g, "zypper"); break;
- case OS_PACKAGE_MANAGEMENT_UNKNOWN:
- ret = safe_strdup (g, "unknown");
- break;
- }
-
- if (ret == NULL)
- abort ();
-
- return ret;
-}
-
-char *
-guestfs_impl_inspect_get_hostname (guestfs_h *g, const char *root)
-{
- struct inspect_fs *fs = guestfs_int_search_for_root (g, root);
- if (!fs)
- return NULL;
-
- return safe_strdup (g, fs->hostname ? : "unknown");
-}
-
-void
-guestfs_int_free_inspect_info (guestfs_h *g)
-{
- size_t i, j;
-
- for (i = 0; i < g->nr_fses; ++i) {
- free (g->fses[i].mountable);
- free (g->fses[i].product_name);
- free (g->fses[i].product_variant);
- free (g->fses[i].arch);
- free (g->fses[i].hostname);
- free (g->fses[i].windows_systemroot);
- free (g->fses[i].windows_software_hive);
- free (g->fses[i].windows_system_hive);
- free (g->fses[i].windows_current_control_set);
- for (j = 0; j < g->fses[i].nr_fstab; ++j) {
- free (g->fses[i].fstab[j].mountable);
- free (g->fses[i].fstab[j].mountpoint);
- }
- free (g->fses[i].fstab);
- if (g->fses[i].drive_mappings)
- guestfs_int_free_string_list (g->fses[i].drive_mappings);
- }
- free (g->fses);
- g->nr_fses = 0;
- g->fses = NULL;
-}
-
/**
* Download a guest file to a local temporary file. The file is
* cached in the temporary directory, and is not downloaded again.
@@ -740,7 +58,7 @@ guestfs_int_free_inspect_info (guestfs_h *g)
* handle the case of multiple roots.
*/
char *
-guestfs_int_download_to_tmp (guestfs_h *g, struct inspect_fs *fs,
+guestfs_int_download_to_tmp (guestfs_h *g,
const char *filename,
const char *basename, uint64_t max_size)
{
@@ -749,10 +67,7 @@ guestfs_int_download_to_tmp (guestfs_h *g, struct inspect_fs *fs,
char devfd[32];
int64_t size;
- /* Make the basename unique by prefixing it with the fs number.
- * This also ensures there is one cache per filesystem.
- */
- if (asprintf (&r, "%s/%td-%s", g->tmpdir, fs - g->fses, basename)
== -1) {
+ if (asprintf (&r, "%s/%s", g->tmpdir, basename) == -1) {
perrorf (g, "asprintf");
return NULL;
}
@@ -798,46 +113,3 @@ guestfs_int_download_to_tmp (guestfs_h *g, struct inspect_fs *fs,
free (r);
return NULL;
}
-
-struct inspect_fs *
-guestfs_int_search_for_root (guestfs_h *g, const char *root)
-{
- size_t i;
-
- if (g->nr_fses == 0) {
- error (g, _("no inspection data: call guestfs_inspect_os first"));
- return NULL;
- }
-
- for (i = 0; i < g->nr_fses; ++i) {
- struct inspect_fs *fs = &g->fses[i];
- if (fs->role == OS_ROLE_ROOT && STREQ (root, fs->mountable))
- return fs;
- }
-
- error (g, _("%s: root device not found: only call this function with a root device
previously returned by guestfs_inspect_os"),
- root);
- return NULL;
-}
-
-int
-guestfs_int_is_partition (guestfs_h *g, const char *partition)
-{
- CLEANUP_FREE char *device = NULL;
-
- guestfs_push_error_handler (g, NULL, NULL);
-
- if ((device = guestfs_part_to_dev (g, partition)) == NULL) {
- guestfs_pop_error_handler (g);
- return 0;
- }
-
- if (guestfs_device_index (g, device) == -1) {
- guestfs_pop_error_handler (g);
- return 0;
- }
-
- guestfs_pop_error_handler (g);
-
- return 1;
-}
--
2.13.0