Simply a file rename, no other change. --- daemon/Makefile.am | 2 +- daemon/command.c | 319 ----------------------------------------------------- daemon/sh.c | 319 +++++++++++++++++++++++++++++++++++++++++++++++++++++ po/POTFILES | 2 +- 4 files changed, 321 insertions(+), 321 deletions(-) delete mode 100644 daemon/command.c create mode 100644 daemon/sh.c diff --git a/daemon/Makefile.am b/daemon/Makefile.am index 8055235..c1a33e3 100644 --- a/daemon/Makefile.am +++ b/daemon/Makefile.am @@ -96,7 +96,6 @@ guestfsd_SOURCES = \ cap.c \ checksum.c \ cmp.c \ - command.c \ compress.c \ copy.c \ cpio.c \ @@ -166,6 +165,7 @@ guestfsd_SOURCES = \ scrub.c \ selinux.c \ sfdisk.c \ + sh.c \ sleep.c \ stat.c \ statvfs.c \ diff --git a/daemon/command.c b/daemon/command.c deleted file mode 100644 index c4efa5b..0000000 --- a/daemon/command.c +++ /dev/null @@ -1,319 +0,0 @@ -/* libguestfs - the guestfsd daemon - * Copyright (C) 2009 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. - */ - -#include <config.h> - -#include <stdio.h> -#include <stdlib.h> -#include <stdbool.h> -#include <string.h> -#include <sys/stat.h> -#include <sys/types.h> -#include <fcntl.h> - -#include "guestfs_protocol.h" -#include "daemon.h" -#include "actions.h" - -#include "ignore-value.h" - -GUESTFSD_EXT_CMD(str_cp, cp); -GUESTFSD_EXT_CMD(str_mount, mount); -GUESTFSD_EXT_CMD(str_umount, umount); - -#ifdef HAVE_ATTRIBUTE_CLEANUP -#define CLEANUP_BIND_STATE __attribute__((cleanup(free_bind_state))) -#define CLEANUP_RESOLVER_STATE __attribute__((cleanup(free_resolver_state))) -#else -#define CLEANUP_BIND_STATE -#define CLEANUP_RESOLVER_STATE -#endif - -struct bind_state { - bool mounted; - char *sysroot_dev; - char *sysroot_dev_pts; - char *sysroot_proc; - char *sysroot_selinux; - char *sysroot_sys; - char *sysroot_sys_fs_selinux; - bool dev_ok, dev_pts_ok, proc_ok, selinux_ok, sys_ok, sys_fs_selinux_ok; -}; - -struct resolver_state { - bool mounted; - char *sysroot_etc_resolv_conf; - char *sysroot_etc_resolv_conf_old; -}; - -/* While running the command, bind-mount /dev, /proc, /sys - * into the chroot. However we must be careful to unmount them - * afterwards because otherwise they would interfere with - * future mount and unmount operations. - * - * We deliberately allow these commands to fail silently, BUT - * if a mount fails, don't unmount the corresponding mount. - */ -static int -bind_mount (struct bind_state *bs) -{ - int r; - - memset (bs, 0, sizeof *bs); - - bs->sysroot_dev = sysroot_path ("/dev"); - bs->sysroot_dev_pts = sysroot_path ("/dev/pts"); - bs->sysroot_proc = sysroot_path ("/proc"); - bs->sysroot_selinux = sysroot_path ("/selinux"); - bs->sysroot_sys = sysroot_path ("/sys"); - bs->sysroot_sys_fs_selinux = sysroot_path ("/sys/fs/selinux"); - - if (bs->sysroot_dev == NULL || bs->sysroot_dev_pts == NULL || - bs->sysroot_proc == NULL || bs->sysroot_selinux == NULL || - bs->sysroot_sys == NULL || bs->sysroot_sys_fs_selinux == NULL) { - reply_with_perror ("malloc"); - free (bs->sysroot_dev); - free (bs->sysroot_dev_pts); - free (bs->sysroot_proc); - free (bs->sysroot_selinux); - free (bs->sysroot_sys); - free (bs->sysroot_sys_fs_selinux); - return -1; - } - - /* Note it is tempting to use --rbind here (to bind submounts). - * However I have not found a reliable way to unmount the same set - * of directories (umount -R does NOT work). - */ - r = command (NULL, NULL, str_mount, "--bind", "/dev", bs->sysroot_dev, NULL); - bs->dev_ok = r != -1; - r = command (NULL, NULL, str_mount, "--bind", "/dev/pts", bs->sysroot_dev_pts, NULL); - bs->dev_pts_ok = r != -1; - r = command (NULL, NULL, str_mount, "--bind", "/proc", bs->sysroot_proc, NULL); - bs->proc_ok = r != -1; - /* Note on the next line we have to bind-mount /sys/fs/selinux (appliance - * kernel) on top of /selinux (where guest is expecting selinux). - */ - r = command (NULL, NULL, str_mount, "--bind", "/sys/fs/selinux", bs->sysroot_selinux, NULL); - bs->selinux_ok = r != -1; - r = command (NULL, NULL, str_mount, "--bind", "/sys", bs->sysroot_sys, NULL); - bs->sys_ok = r != -1; - r = command (NULL, NULL, str_mount, "--bind", "/sys/fs/selinux", bs->sysroot_sys_fs_selinux, NULL); - bs->sys_fs_selinux_ok = r != -1; - - bs->mounted = true; - - return 0; -} - -static inline void -umount_ignore_fail (const char *path) -{ - ignore_value (command (NULL, NULL, str_umount, path, NULL)); -} - -static void -free_bind_state (struct bind_state *bs) -{ - if (bs->mounted) { - if (bs->sys_fs_selinux_ok) umount_ignore_fail (bs->sysroot_sys_fs_selinux); - free (bs->sysroot_sys_fs_selinux); - if (bs->sys_ok) umount_ignore_fail (bs->sysroot_sys); - free (bs->sysroot_sys); - if (bs->selinux_ok) umount_ignore_fail (bs->sysroot_selinux); - free (bs->sysroot_selinux); - if (bs->proc_ok) umount_ignore_fail (bs->sysroot_proc); - free (bs->sysroot_proc); - if (bs->dev_pts_ok) umount_ignore_fail (bs->sysroot_dev_pts); - free (bs->sysroot_dev_pts); - if (bs->dev_ok) umount_ignore_fail (bs->sysroot_dev); - free (bs->sysroot_dev); - bs->mounted = false; - } -} - -/* If the network is enabled, we want <sysroot>/etc/resolv.conf to - * reflect the contents of /etc/resolv.conf so that name resolution - * works. It would be nice to bind-mount the file (single file bind - * mounts are possible). However annoyingly that doesn't work for - * Ubuntu guests where the guest resolv.conf is a dangling symlink, - * and for reasons unknown mount tries to follow the symlink and - * fails (likely a bug). So this is a hack. Note we only invoke - * this if the network is enabled. - */ -static int -set_up_etc_resolv_conf (struct resolver_state *rs) -{ - struct stat statbuf; - - rs->sysroot_etc_resolv_conf_old = NULL; - - rs->sysroot_etc_resolv_conf = sysroot_path ("/etc/resolv.conf"); - - if (!rs->sysroot_etc_resolv_conf) { - reply_with_perror ("malloc"); - goto error; - } - - /* If /etc/resolv.conf exists, rename it to the backup file. Note - * that on Ubuntu it's a dangling symlink. - */ - if (lstat (rs->sysroot_etc_resolv_conf, &statbuf) == 0) { - size_t len = sysroot_len + 32; - char buf[len]; - - /* Make a random name for the backup file. */ - snprintf (buf, len, "%s/etc/XXXXXXXX", sysroot); - if (random_name (buf) == -1) { - reply_with_perror ("random_name"); - goto error; - } - rs->sysroot_etc_resolv_conf_old = strdup (buf); - if (!rs->sysroot_etc_resolv_conf_old) { - reply_with_perror ("strdup"); - goto error; - } - - if (verbose) - fprintf (stderr, "renaming %s to %s\n", rs->sysroot_etc_resolv_conf, - rs->sysroot_etc_resolv_conf_old); - - if (rename (rs->sysroot_etc_resolv_conf, - rs->sysroot_etc_resolv_conf_old) == -1) { - reply_with_perror ("rename: %s to %s", rs->sysroot_etc_resolv_conf, - rs->sysroot_etc_resolv_conf_old); - goto error; - } - } - - /* Now that the guest's <sysroot>/etc/resolv.conf is out the way, we - * can create our own copy of the appliance /etc/resolv.conf. - */ - ignore_value (command (NULL, NULL, str_cp, "/etc/resolv.conf", - rs->sysroot_etc_resolv_conf, NULL)); - - rs->mounted = true; - return 0; - - error: - free (rs->sysroot_etc_resolv_conf); - free (rs->sysroot_etc_resolv_conf_old); - return -1; -} - -static void -free_resolver_state (struct resolver_state *rs) -{ - if (rs->mounted) { - unlink (rs->sysroot_etc_resolv_conf); - - if (rs->sysroot_etc_resolv_conf_old) { - if (verbose) - fprintf (stderr, "renaming %s to %s\n", rs->sysroot_etc_resolv_conf_old, - rs->sysroot_etc_resolv_conf); - - if (rename (rs->sysroot_etc_resolv_conf_old, - rs->sysroot_etc_resolv_conf) == -1) - perror ("error: could not restore /etc/resolv.conf"); - - free (rs->sysroot_etc_resolv_conf_old); - } - - free (rs->sysroot_etc_resolv_conf); - rs->mounted = false; - } -} - -char * -do_command (char *const *argv) -{ - char *out; - CLEANUP_FREE char *err = NULL; - int r, flags; - CLEANUP_BIND_STATE struct bind_state bind_state = { .mounted = false }; - CLEANUP_RESOLVER_STATE struct resolver_state resolver_state = - { .mounted = false }; - - /* We need a root filesystem mounted to do this. */ - NEED_ROOT (, return NULL); - - /* Conveniently, argv is already a NULL-terminated argv-style array - * of parameters, so we can pass it straight in to our internal - * commandv. We just have to check the list is non-empty. - */ - if (argv[0] == NULL) { - reply_with_error ("passed an empty list"); - return NULL; - } - - if (bind_mount (&bind_state) == -1) - return NULL; - if (enable_network) { - if (set_up_etc_resolv_conf (&resolver_state) == -1) - return NULL; - } - - flags = COMMAND_FLAG_DO_CHROOT; - - r = commandvf (&out, &err, flags, (const char * const *) argv); - - free_bind_state (&bind_state); - free_resolver_state (&resolver_state); - - if (r == -1) { - reply_with_error ("%s", err); - free (out); - return NULL; - } - - return out; /* Caller frees. */ -} - -char ** -do_command_lines (char *const *argv) -{ - CLEANUP_FREE char *out = NULL; - char **lines; - - out = do_command (argv); - if (out == NULL) - return NULL; - - lines = split_lines (out); - - if (lines == NULL) - return NULL; - - return lines; /* Caller frees. */ -} - -char * -do_sh (const char *cmd) -{ - const char *argv[] = { "/bin/sh", "-c", cmd, NULL }; - - return do_command ((char **) argv); -} - -char ** -do_sh_lines (const char *cmd) -{ - const char *argv[] = { "/bin/sh", "-c", cmd, NULL }; - - return do_command_lines ((char **) argv); -} diff --git a/daemon/sh.c b/daemon/sh.c new file mode 100644 index 0000000..c4efa5b --- /dev/null +++ b/daemon/sh.c @@ -0,0 +1,319 @@ +/* libguestfs - the guestfsd daemon + * Copyright (C) 2009 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. + */ + +#include <config.h> + +#include <stdio.h> +#include <stdlib.h> +#include <stdbool.h> +#include <string.h> +#include <sys/stat.h> +#include <sys/types.h> +#include <fcntl.h> + +#include "guestfs_protocol.h" +#include "daemon.h" +#include "actions.h" + +#include "ignore-value.h" + +GUESTFSD_EXT_CMD(str_cp, cp); +GUESTFSD_EXT_CMD(str_mount, mount); +GUESTFSD_EXT_CMD(str_umount, umount); + +#ifdef HAVE_ATTRIBUTE_CLEANUP +#define CLEANUP_BIND_STATE __attribute__((cleanup(free_bind_state))) +#define CLEANUP_RESOLVER_STATE __attribute__((cleanup(free_resolver_state))) +#else +#define CLEANUP_BIND_STATE +#define CLEANUP_RESOLVER_STATE +#endif + +struct bind_state { + bool mounted; + char *sysroot_dev; + char *sysroot_dev_pts; + char *sysroot_proc; + char *sysroot_selinux; + char *sysroot_sys; + char *sysroot_sys_fs_selinux; + bool dev_ok, dev_pts_ok, proc_ok, selinux_ok, sys_ok, sys_fs_selinux_ok; +}; + +struct resolver_state { + bool mounted; + char *sysroot_etc_resolv_conf; + char *sysroot_etc_resolv_conf_old; +}; + +/* While running the command, bind-mount /dev, /proc, /sys + * into the chroot. However we must be careful to unmount them + * afterwards because otherwise they would interfere with + * future mount and unmount operations. + * + * We deliberately allow these commands to fail silently, BUT + * if a mount fails, don't unmount the corresponding mount. + */ +static int +bind_mount (struct bind_state *bs) +{ + int r; + + memset (bs, 0, sizeof *bs); + + bs->sysroot_dev = sysroot_path ("/dev"); + bs->sysroot_dev_pts = sysroot_path ("/dev/pts"); + bs->sysroot_proc = sysroot_path ("/proc"); + bs->sysroot_selinux = sysroot_path ("/selinux"); + bs->sysroot_sys = sysroot_path ("/sys"); + bs->sysroot_sys_fs_selinux = sysroot_path ("/sys/fs/selinux"); + + if (bs->sysroot_dev == NULL || bs->sysroot_dev_pts == NULL || + bs->sysroot_proc == NULL || bs->sysroot_selinux == NULL || + bs->sysroot_sys == NULL || bs->sysroot_sys_fs_selinux == NULL) { + reply_with_perror ("malloc"); + free (bs->sysroot_dev); + free (bs->sysroot_dev_pts); + free (bs->sysroot_proc); + free (bs->sysroot_selinux); + free (bs->sysroot_sys); + free (bs->sysroot_sys_fs_selinux); + return -1; + } + + /* Note it is tempting to use --rbind here (to bind submounts). + * However I have not found a reliable way to unmount the same set + * of directories (umount -R does NOT work). + */ + r = command (NULL, NULL, str_mount, "--bind", "/dev", bs->sysroot_dev, NULL); + bs->dev_ok = r != -1; + r = command (NULL, NULL, str_mount, "--bind", "/dev/pts", bs->sysroot_dev_pts, NULL); + bs->dev_pts_ok = r != -1; + r = command (NULL, NULL, str_mount, "--bind", "/proc", bs->sysroot_proc, NULL); + bs->proc_ok = r != -1; + /* Note on the next line we have to bind-mount /sys/fs/selinux (appliance + * kernel) on top of /selinux (where guest is expecting selinux). + */ + r = command (NULL, NULL, str_mount, "--bind", "/sys/fs/selinux", bs->sysroot_selinux, NULL); + bs->selinux_ok = r != -1; + r = command (NULL, NULL, str_mount, "--bind", "/sys", bs->sysroot_sys, NULL); + bs->sys_ok = r != -1; + r = command (NULL, NULL, str_mount, "--bind", "/sys/fs/selinux", bs->sysroot_sys_fs_selinux, NULL); + bs->sys_fs_selinux_ok = r != -1; + + bs->mounted = true; + + return 0; +} + +static inline void +umount_ignore_fail (const char *path) +{ + ignore_value (command (NULL, NULL, str_umount, path, NULL)); +} + +static void +free_bind_state (struct bind_state *bs) +{ + if (bs->mounted) { + if (bs->sys_fs_selinux_ok) umount_ignore_fail (bs->sysroot_sys_fs_selinux); + free (bs->sysroot_sys_fs_selinux); + if (bs->sys_ok) umount_ignore_fail (bs->sysroot_sys); + free (bs->sysroot_sys); + if (bs->selinux_ok) umount_ignore_fail (bs->sysroot_selinux); + free (bs->sysroot_selinux); + if (bs->proc_ok) umount_ignore_fail (bs->sysroot_proc); + free (bs->sysroot_proc); + if (bs->dev_pts_ok) umount_ignore_fail (bs->sysroot_dev_pts); + free (bs->sysroot_dev_pts); + if (bs->dev_ok) umount_ignore_fail (bs->sysroot_dev); + free (bs->sysroot_dev); + bs->mounted = false; + } +} + +/* If the network is enabled, we want <sysroot>/etc/resolv.conf to + * reflect the contents of /etc/resolv.conf so that name resolution + * works. It would be nice to bind-mount the file (single file bind + * mounts are possible). However annoyingly that doesn't work for + * Ubuntu guests where the guest resolv.conf is a dangling symlink, + * and for reasons unknown mount tries to follow the symlink and + * fails (likely a bug). So this is a hack. Note we only invoke + * this if the network is enabled. + */ +static int +set_up_etc_resolv_conf (struct resolver_state *rs) +{ + struct stat statbuf; + + rs->sysroot_etc_resolv_conf_old = NULL; + + rs->sysroot_etc_resolv_conf = sysroot_path ("/etc/resolv.conf"); + + if (!rs->sysroot_etc_resolv_conf) { + reply_with_perror ("malloc"); + goto error; + } + + /* If /etc/resolv.conf exists, rename it to the backup file. Note + * that on Ubuntu it's a dangling symlink. + */ + if (lstat (rs->sysroot_etc_resolv_conf, &statbuf) == 0) { + size_t len = sysroot_len + 32; + char buf[len]; + + /* Make a random name for the backup file. */ + snprintf (buf, len, "%s/etc/XXXXXXXX", sysroot); + if (random_name (buf) == -1) { + reply_with_perror ("random_name"); + goto error; + } + rs->sysroot_etc_resolv_conf_old = strdup (buf); + if (!rs->sysroot_etc_resolv_conf_old) { + reply_with_perror ("strdup"); + goto error; + } + + if (verbose) + fprintf (stderr, "renaming %s to %s\n", rs->sysroot_etc_resolv_conf, + rs->sysroot_etc_resolv_conf_old); + + if (rename (rs->sysroot_etc_resolv_conf, + rs->sysroot_etc_resolv_conf_old) == -1) { + reply_with_perror ("rename: %s to %s", rs->sysroot_etc_resolv_conf, + rs->sysroot_etc_resolv_conf_old); + goto error; + } + } + + /* Now that the guest's <sysroot>/etc/resolv.conf is out the way, we + * can create our own copy of the appliance /etc/resolv.conf. + */ + ignore_value (command (NULL, NULL, str_cp, "/etc/resolv.conf", + rs->sysroot_etc_resolv_conf, NULL)); + + rs->mounted = true; + return 0; + + error: + free (rs->sysroot_etc_resolv_conf); + free (rs->sysroot_etc_resolv_conf_old); + return -1; +} + +static void +free_resolver_state (struct resolver_state *rs) +{ + if (rs->mounted) { + unlink (rs->sysroot_etc_resolv_conf); + + if (rs->sysroot_etc_resolv_conf_old) { + if (verbose) + fprintf (stderr, "renaming %s to %s\n", rs->sysroot_etc_resolv_conf_old, + rs->sysroot_etc_resolv_conf); + + if (rename (rs->sysroot_etc_resolv_conf_old, + rs->sysroot_etc_resolv_conf) == -1) + perror ("error: could not restore /etc/resolv.conf"); + + free (rs->sysroot_etc_resolv_conf_old); + } + + free (rs->sysroot_etc_resolv_conf); + rs->mounted = false; + } +} + +char * +do_command (char *const *argv) +{ + char *out; + CLEANUP_FREE char *err = NULL; + int r, flags; + CLEANUP_BIND_STATE struct bind_state bind_state = { .mounted = false }; + CLEANUP_RESOLVER_STATE struct resolver_state resolver_state = + { .mounted = false }; + + /* We need a root filesystem mounted to do this. */ + NEED_ROOT (, return NULL); + + /* Conveniently, argv is already a NULL-terminated argv-style array + * of parameters, so we can pass it straight in to our internal + * commandv. We just have to check the list is non-empty. + */ + if (argv[0] == NULL) { + reply_with_error ("passed an empty list"); + return NULL; + } + + if (bind_mount (&bind_state) == -1) + return NULL; + if (enable_network) { + if (set_up_etc_resolv_conf (&resolver_state) == -1) + return NULL; + } + + flags = COMMAND_FLAG_DO_CHROOT; + + r = commandvf (&out, &err, flags, (const char * const *) argv); + + free_bind_state (&bind_state); + free_resolver_state (&resolver_state); + + if (r == -1) { + reply_with_error ("%s", err); + free (out); + return NULL; + } + + return out; /* Caller frees. */ +} + +char ** +do_command_lines (char *const *argv) +{ + CLEANUP_FREE char *out = NULL; + char **lines; + + out = do_command (argv); + if (out == NULL) + return NULL; + + lines = split_lines (out); + + if (lines == NULL) + return NULL; + + return lines; /* Caller frees. */ +} + +char * +do_sh (const char *cmd) +{ + const char *argv[] = { "/bin/sh", "-c", cmd, NULL }; + + return do_command ((char **) argv); +} + +char ** +do_sh_lines (const char *cmd) +{ + const char *argv[] = { "/bin/sh", "-c", cmd, NULL }; + + return do_command_lines ((char **) argv); +} diff --git a/po/POTFILES b/po/POTFILES index c6c277c..9719afd 100644 --- a/po/POTFILES +++ b/po/POTFILES @@ -26,7 +26,6 @@ daemon/btrfs.c daemon/cap.c daemon/checksum.c daemon/cmp.c -daemon/command.c daemon/compress.c daemon/copy.c daemon/cpio.c @@ -96,6 +95,7 @@ daemon/rsync.c daemon/scrub.c daemon/selinux.c daemon/sfdisk.c +daemon/sh.c daemon/sleep.c daemon/stat.c daemon/statvfs.c -- 2.5.0

Allows more sharing between the daemon and the inspection program. --- daemon/Makefile.am | 2 + daemon/cleanups.c | 80 ++++++++++ daemon/cleanups.h | 47 ++++++ daemon/command.c | 436 +++++++++++++++++++++++++++++++++++++++++++++++++++++ daemon/command.h | 41 +++++ daemon/daemon.h | 47 +----- daemon/guestfsd.c | 392 ----------------------------------------------- po/POTFILES | 2 + 8 files changed, 611 insertions(+), 436 deletions(-) create mode 100644 daemon/cleanups.c create mode 100644 daemon/cleanups.h create mode 100644 daemon/command.c create mode 100644 daemon/command.h diff --git a/daemon/Makefile.am b/daemon/Makefile.am index c1a33e3..a4e3df7 100644 --- a/daemon/Makefile.am +++ b/daemon/Makefile.am @@ -96,6 +96,8 @@ guestfsd_SOURCES = \ cap.c \ checksum.c \ cmp.c \ + command.c \ + command.h \ compress.c \ copy.c \ cpio.c \ diff --git a/daemon/cleanups.c b/daemon/cleanups.c new file mode 100644 index 0000000..5293ff2 --- /dev/null +++ b/daemon/cleanups.c @@ -0,0 +1,80 @@ +/* libguestfs - the guestfsd daemon + * Copyright (C) 2009-2015 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. + */ + +#include <config.h> + +#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> + +#include <augeas.h> + +#include "cleanups.h" + +/* Use by the CLEANUP_* macros. Do not call these directly. */ +void +cleanup_free (void *ptr) +{ + free (* (void **) ptr); +} + +extern void free_strings (char **argv); + +void +cleanup_free_string_list (void *ptr) +{ + free_strings (* (char ***) ptr); +} + +void +cleanup_unlink_free (void *ptr) +{ + char *filename = * (char **) ptr; + + if (filename) { + unlink (filename); + free (filename); + } +} + +void +cleanup_close (void *ptr) +{ + int fd = * (int *) ptr; + + if (fd >= 0) + close (fd); +} + +void +cleanup_aug_close (void *ptr) +{ + augeas *aug = * (augeas **) ptr; + + if (aug != NULL) + aug_close (aug); +} + +struct stringsbuf; +extern void free_stringsbuf (struct stringsbuf *sb); + +void +cleanup_free_stringsbuf (void *ptr) +{ + free_stringsbuf ((struct stringsbuf *) ptr); +} diff --git a/daemon/cleanups.h b/daemon/cleanups.h new file mode 100644 index 0000000..b6ef2ff --- /dev/null +++ b/daemon/cleanups.h @@ -0,0 +1,47 @@ +/* libguestfs - the guestfsd daemon + * Copyright (C) 2009-2015 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. + */ + +#ifndef GUESTFSD_CLEANUPS_H +#define GUESTFSD_CLEANUPS_H + +/* Use by the CLEANUP_* macros. */ +extern void cleanup_free (void *ptr); +extern void cleanup_free_string_list (void *ptr); +extern void cleanup_unlink_free (void *ptr); +extern void cleanup_close (void *ptr); +extern void cleanup_aug_close (void *ptr); +extern void cleanup_free_stringsbuf (void *ptr); + +#ifdef HAVE_ATTRIBUTE_CLEANUP +#define CLEANUP_FREE __attribute__((cleanup(cleanup_free))) +#define CLEANUP_FREE_STRING_LIST \ + __attribute__((cleanup(cleanup_free_string_list))) +#define CLEANUP_UNLINK_FREE __attribute__((cleanup(cleanup_unlink_free))) +#define CLEANUP_CLOSE __attribute__((cleanup(cleanup_close))) +#define CLEANUP_AUG_CLOSE __attribute__((cleanup(cleanup_aug_close))) +#define CLEANUP_FREE_STRINGSBUF __attribute__((cleanup(cleanup_free_stringsbuf))) +#else +#define CLEANUP_FREE +#define CLEANUP_FREE_STRING_LIST +#define CLEANUP_UNLINK_FREE +#define CLEANUP_CLOSE +#define CLEANUP_AUG_CLOSE +#define CLEANUP_FREE_STRINGSBUF +#endif + +#endif /* GUESTFSD_CLEANUPS_H */ diff --git a/daemon/command.c b/daemon/command.c new file mode 100644 index 0000000..3e757aa --- /dev/null +++ b/daemon/command.c @@ -0,0 +1,436 @@ +/* libguestfs - the guestfsd daemon + * Copyright (C) 2009-2015 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. + */ + +#include <config.h> + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> +#include <fcntl.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <sys/wait.h> +#include <error.h> +#include <errno.h> + +#include "ignore-value.h" + +#include "command.h" +#include "cleanups.h" + +extern int verbose; + +extern const char *sysroot; +extern size_t sysroot_len; + +#ifndef MAX +# define MAX(a,b) ((a)>(b)?(a):(b)) +#endif + +/* For improved readability dealing with pipe arrays */ +#define PIPE_READ 0 +#define PIPE_WRITE 1 + +/* Easy ways to run external commands. For full documentation, see + * 'commandrvf' below. + */ +int +commandf (char **stdoutput, char **stderror, unsigned flags, + const char *name, ...) +{ + va_list args; + /* NB: Mustn't free the strings which are on the stack. */ + CLEANUP_FREE const char **argv = NULL; + char *s; + size_t i; + int r; + + /* Collect the command line arguments into an array. */ + i = 2; + argv = malloc (sizeof (char *) * i); + if (argv == NULL) { + perror ("malloc"); + return -1; + } + argv[0] = (char *) name; + argv[1] = NULL; + + va_start (args, name); + + while ((s = va_arg (args, char *)) != NULL) { + const char **p = realloc (argv, sizeof (char *) * (++i)); + if (p == NULL) { + perror ("realloc"); + va_end (args); + return -1; + } + argv = p; + argv[i-2] = s; + argv[i-1] = NULL; + } + + va_end (args); + + r = commandvf (stdoutput, stderror, flags, (const char * const*) argv); + + return r; +} + +/* Same as 'command', but we allow the status code from the + * subcommand to be non-zero, and return that status code. + * We still return -1 if there was some other error. + */ +int +commandrf (char **stdoutput, char **stderror, unsigned flags, + const char *name, ...) +{ + va_list args; + CLEANUP_FREE const char **argv = NULL; + char *s; + int i, r; + + /* Collect the command line arguments into an array. */ + i = 2; + argv = malloc (sizeof (char *) * i); + if (argv == NULL) { + perror ("malloc"); + return -1; + } + argv[0] = (char *) name; + argv[1] = NULL; + + va_start (args, name); + + while ((s = va_arg (args, char *)) != NULL) { + const char **p = realloc (argv, sizeof (char *) * (++i)); + if (p == NULL) { + perror ("realloc"); + va_end (args); + return -1; + } + argv = p; + argv[i-2] = s; + argv[i-1] = NULL; + } + + va_end (args); + + r = commandrvf (stdoutput, stderror, flags, argv); + + return r; +} + +/* Same as 'command', but passing an argv. */ +int +commandvf (char **stdoutput, char **stderror, unsigned flags, + char const *const *argv) +{ + int r; + + r = commandrvf (stdoutput, stderror, flags, (void *) argv); + if (r == 0) + return 0; + else + return -1; +} + +/* This is a more sane version of 'system(3)' for running external + * commands. It uses fork/execvp, so we don't need to worry about + * quoting of parameters, and it allows us to capture any error + * messages in a buffer. + * + * If stdoutput is not NULL, then *stdoutput will return the stdout + * of the command. + * + * If stderror is not NULL, then *stderror will return the stderr + * of the command. If there is a final \n character, it is removed + * so you can use the error string directly in a call to + * reply_with_error. + * + * Flags: + * + * COMMAND_FLAG_FOLD_STDOUT_ON_STDERR: For broken external commands + * that send error messages to stdout (hello, parted) but that don't + * have any useful stdout information, use this flag to capture the + * error messages in the *stderror buffer. If using this flag, + * you should pass stdoutput as NULL because nothing could ever be + * captured in that buffer. + * + * COMMAND_FLAG_CHROOT_COPY_FILE_TO_STDIN: For running external + * commands on chrooted files correctly (see RHBZ#579608) specifying + * this flag causes another process to be forked which chroots into + * sysroot and just copies the input file to stdin of the specified + * command. The file descriptor is ORed with the flags, and that file + * descriptor is always closed by this function. See hexdump.c for an + * example of usage. + */ +int +commandrvf (char **stdoutput, char **stderror, unsigned flags, + char const* const *argv) +{ + size_t so_size = 0, se_size = 0; + int so_fd[2], se_fd[2]; + unsigned flag_copy_stdin = flags & COMMAND_FLAG_CHROOT_COPY_FILE_TO_STDIN; + int flag_copy_fd = (int) (flags & COMMAND_FLAG_FD_MASK); + pid_t pid; + int r, quit, i; + fd_set rset, rset2; + char buf[256]; + char *p; + + if (stdoutput) *stdoutput = NULL; + if (stderror) *stderror = NULL; + + if (verbose) { + printf ("commandrvf: stdout=%s stderr=%s flags=0x%x\n", + stdoutput ? "y" : "n", stderror ? "y" : "n", flags); + fputs ("commandrvf: ", stdout); + fputs (argv[0], stdout); + for (i = 1; argv[i] != NULL; ++i) { + char quote; + + /* Do simple (and incorrect) quoting of the debug output. Real + * quoting is not necessary because we use execvp to run the + * command below. + */ + if (strchr (argv[i], '\'')) + quote = '"'; + else if (strchr (argv[i], '"')) + quote = '\''; + else if (strchr (argv[i], ' ')) + quote = '"'; + else + quote = 0; + + putchar (' '); + if (quote) putchar (quote); + fputs (argv[i], stdout); + if (quote) putchar (quote); + } + putchar ('\n'); + } + + /* Note: abort is used in a few places along the error paths early + * in this function. This is because (a) cleaning up correctly is + * very complex at these places and (b) abort is used when a + * resource problems is indicated which would be due to much more + * serious issues - eg. memory or file descriptor leaks. We + * wouldn't expect fork(2) or pipe(2) to fail in normal + * circumstances. + */ + + if (pipe (so_fd) == -1 || pipe (se_fd) == -1) { + error (0, errno, "pipe"); + abort (); + } + + pid = fork (); + if (pid == -1) { + error (0, errno, "fork"); + abort (); + } + + if (pid == 0) { /* Child process running the command. */ + signal (SIGALRM, SIG_DFL); + signal (SIGPIPE, SIG_DFL); + close (0); + if (flag_copy_stdin) { + if (dup2 (flag_copy_fd, STDIN_FILENO) == -1) { + perror ("dup2/flag_copy_fd"); + _exit (EXIT_FAILURE); + } + } else { + /* Set stdin to /dev/null. */ + if (open ("/dev/null", O_RDONLY) == -1) { + perror ("open: /dev/null"); + _exit (EXIT_FAILURE); + } + } + close (so_fd[PIPE_READ]); + close (se_fd[PIPE_READ]); + if (!(flags & COMMAND_FLAG_FOLD_STDOUT_ON_STDERR)) { + if (dup2 (so_fd[PIPE_WRITE], STDOUT_FILENO) == -1) { + perror ("dup2/so_fd[PIPE_WRITE]"); + _exit (EXIT_FAILURE); + } + } else { + if (dup2 (se_fd[PIPE_WRITE], STDOUT_FILENO) == -1) { + perror ("dup2/se_fd[PIPE_WRITE]"); + _exit (EXIT_FAILURE); + } + } + if (dup2 (se_fd[PIPE_WRITE], STDERR_FILENO) == -1) { + perror ("dup2/se_fd[PIPE_WRITE]"); + _exit (EXIT_FAILURE); + } + close (so_fd[PIPE_WRITE]); + close (se_fd[PIPE_WRITE]); + + if (flags & COMMAND_FLAG_DO_CHROOT && sysroot_len > 0) { + if (chroot (sysroot) == -1) { + perror ("chroot in sysroot"); + _exit (EXIT_FAILURE); + } + } + + if (chdir ("/") == -1) { + perror ("chdir"); + _exit (EXIT_FAILURE); + } + + execvp (argv[0], (void *) argv); + perror (argv[0]); + _exit (EXIT_FAILURE); + } + + /* Parent process. */ + close (so_fd[PIPE_WRITE]); + close (se_fd[PIPE_WRITE]); + + FD_ZERO (&rset); + FD_SET (so_fd[PIPE_READ], &rset); + FD_SET (se_fd[PIPE_READ], &rset); + + quit = 0; + while (quit < 2) { + again: + rset2 = rset; + r = select (MAX (so_fd[PIPE_READ], se_fd[PIPE_READ]) + 1, &rset2, + NULL, NULL, NULL); + if (r == -1) { + if (errno == EINTR) + goto again; + + perror ("select"); + quit: + if (stdoutput) { + free (*stdoutput); + *stdoutput = NULL; + } + if (stderror) { + free (*stderror); + /* Need to return non-NULL *stderror here since most callers + * will try to print and then free the err string. + * Unfortunately recovery from strdup failure here is not + * possible. + */ + *stderror = strdup ("error running external command, " + "see debug output for details"); + } + close (so_fd[PIPE_READ]); + close (se_fd[PIPE_READ]); + if (flag_copy_stdin) close (flag_copy_fd); + waitpid (pid, NULL, 0); + return -1; + } + + if (FD_ISSET (so_fd[PIPE_READ], &rset2)) { /* something on stdout */ + r = read (so_fd[PIPE_READ], buf, sizeof buf); + if (r == -1) { + perror ("read"); + goto quit; + } + if (r == 0) { FD_CLR (so_fd[PIPE_READ], &rset); quit++; } + + if (r > 0 && stdoutput) { + so_size += r; + p = realloc (*stdoutput, so_size); + if (p == NULL) { + perror ("realloc"); + goto quit; + } + *stdoutput = p; + memcpy (*stdoutput + so_size - r, buf, r); + } + } + + if (FD_ISSET (se_fd[PIPE_READ], &rset2)) { /* something on stderr */ + r = read (se_fd[PIPE_READ], buf, sizeof buf); + if (r == -1) { + perror ("read"); + goto quit; + } + if (r == 0) { FD_CLR (se_fd[PIPE_READ], &rset); quit++; } + + if (r > 0) { + if (verbose) + ignore_value (write (STDERR_FILENO, buf, r)); + + if (stderror) { + se_size += r; + p = realloc (*stderror, se_size); + if (p == NULL) { + perror ("realloc"); + goto quit; + } + *stderror = p; + memcpy (*stderror + se_size - r, buf, r); + } + } + } + } + + close (so_fd[PIPE_READ]); + close (se_fd[PIPE_READ]); + + /* Make sure the output buffers are \0-terminated. Also remove any + * trailing \n characters from the error buffer (not from stdout). + */ + if (stdoutput) { + void *q = realloc (*stdoutput, so_size+1); + if (q == NULL) { + perror ("realloc"); + free (*stdoutput); + } + *stdoutput = q; + if (*stdoutput) + (*stdoutput)[so_size] = '\0'; + } + if (stderror) { + void *q = realloc (*stderror, se_size+1); + if (q == NULL) { + perror ("realloc"); + free (*stderror); + } + *stderror = q; + if (*stderror) { + (*stderror)[se_size] = '\0'; + while (se_size > 0 && (*stderror)[se_size-1] == '\n') { + se_size--; + (*stderror)[se_size] = '\0'; + } + } + } + + if (flag_copy_stdin && close (flag_copy_fd) == -1) { + perror ("close"); + return -1; + } + + /* Get the exit status of the command. */ + if (waitpid (pid, &r, 0) != pid) { + perror ("waitpid"); + return -1; + } + + if (WIFEXITED (r)) { + return WEXITSTATUS (r); + } else + return -1; +} diff --git a/daemon/command.h b/daemon/command.h new file mode 100644 index 0000000..60f32b8 --- /dev/null +++ b/daemon/command.h @@ -0,0 +1,41 @@ +/* libguestfs - the guestfsd daemon + * Copyright (C) 2009-2015 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. + */ + +#ifndef GUESTFSD_COMMAND_H +#define GUESTFSD_COMMAND_H + +#define command(out,err,name,...) commandf((out),(err),0,(name),__VA_ARGS__) +#define commandr(out,err,name,...) commandrf((out),(err),0,(name),__VA_ARGS__) +#define commandv(out,err,argv) commandvf((out),(err),0,(argv)) +#define commandrv(out,err,argv) commandrvf((out),(err),0,(argv)) + +#define COMMAND_FLAG_FD_MASK 0x0000ffff +#define COMMAND_FLAG_FOLD_STDOUT_ON_STDERR 0x00010000 +#define COMMAND_FLAG_CHROOT_COPY_FILE_TO_STDIN 0x00020000 +#define COMMAND_FLAG_DO_CHROOT 0x00040000 + +extern int commandf (char **stdoutput, char **stderror, unsigned flags, + const char *name, ...) __attribute__((sentinel)); +extern int commandrf (char **stdoutput, char **stderror, unsigned flags, + const char *name, ...) __attribute__((sentinel)); +extern int commandvf (char **stdoutput, char **stderror, unsigned flags, + char const *const *argv); +extern int commandrvf (char **stdoutput, char **stderror, unsigned flags, + char const* const *argv); + +#endif /* GUESTFSD_COMMAND_H */ diff --git a/daemon/daemon.h b/daemon/daemon.h index 7c90917..994b47a 100644 --- a/daemon/daemon.h +++ b/daemon/daemon.h @@ -32,6 +32,9 @@ #include "guestfs-internal-all.h" +#include "cleanups.h" +#include "command.h" + /* Mountables */ typedef struct { @@ -117,28 +120,9 @@ extern char **split_lines (char *str); extern char **empty_list (void); -#define command(out,err,name,...) commandf((out),(err),0,(name),__VA_ARGS__) -#define commandr(out,err,name,...) commandrf((out),(err),0,(name),__VA_ARGS__) -#define commandv(out,err,argv) commandvf((out),(err),0,(argv)) -#define commandrv(out,err,argv) commandrvf((out),(err),0,(argv)) - #define __external_command __attribute__((__section__(".guestfsd_ext_cmds"))) #define GUESTFSD_EXT_CMD(___ext_cmd_var, ___ext_cmd_str) static const char ___ext_cmd_var[] __external_command = #___ext_cmd_str -#define COMMAND_FLAG_FD_MASK 0x0000ffff -#define COMMAND_FLAG_FOLD_STDOUT_ON_STDERR 0x00010000 -#define COMMAND_FLAG_CHROOT_COPY_FILE_TO_STDIN 0x00020000 -#define COMMAND_FLAG_DO_CHROOT 0x00040000 - -extern int commandf (char **stdoutput, char **stderror, unsigned flags, - const char *name, ...) __attribute__((sentinel)); -extern int commandrf (char **stdoutput, char **stderror, unsigned flags, - const char *name, ...) __attribute__((sentinel)); -extern int commandvf (char **stdoutput, char **stderror, unsigned flags, - char const *const *argv); -extern int commandrvf (char **stdoutput, char **stderror, unsigned flags, - char const* const *argv); - extern int is_power_of_2 (unsigned long v); extern void trim (char *str); @@ -157,14 +141,6 @@ extern char *get_random_uuid (void); extern int asprintf_nowarn (char **strp, const char *fmt, ...); -/* Use by the CLEANUP_* macros. */ -extern void cleanup_free (void *ptr); -extern void cleanup_free_string_list (void *ptr); -extern void cleanup_unlink_free (void *ptr); -extern void cleanup_close (void *ptr); -extern void cleanup_aug_close (void *ptr); -extern void cleanup_free_stringsbuf (void *ptr); - /*-- in names.c (auto-generated) --*/ extern const char *function_names[]; @@ -452,21 +428,4 @@ is_zero (const char *buffer, size_t size) } \ } while (0) -#ifdef HAVE_ATTRIBUTE_CLEANUP -#define CLEANUP_FREE __attribute__((cleanup(cleanup_free))) -#define CLEANUP_FREE_STRING_LIST \ - __attribute__((cleanup(cleanup_free_string_list))) -#define CLEANUP_UNLINK_FREE __attribute__((cleanup(cleanup_unlink_free))) -#define CLEANUP_CLOSE __attribute__((cleanup(cleanup_close))) -#define CLEANUP_AUG_CLOSE __attribute__((cleanup(cleanup_aug_close))) -#define CLEANUP_FREE_STRINGSBUF __attribute__((cleanup(cleanup_free_stringsbuf))) -#else -#define CLEANUP_FREE -#define CLEANUP_FREE_STRING_LIST -#define CLEANUP_UNLINK_FREE -#define CLEANUP_CLOSE -#define CLEANUP_AUG_CLOSE -#define CLEANUP_FREE_STRINGSBUF -#endif - #endif /* GUESTFSD_DAEMON_H */ diff --git a/daemon/guestfsd.c b/daemon/guestfsd.c index b313534..00f53c6 100644 --- a/daemon/guestfsd.c +++ b/daemon/guestfsd.c @@ -68,10 +68,6 @@ GUESTFSD_EXT_CMD(str_uuidgen, uuidgen); # define O_CLOEXEC 0 #endif -/* For improved readability dealing with pipe arrays */ -#define PIPE_READ 0 -#define PIPE_WRITE 1 - /* If root device is an ext2 filesystem, this is the major and minor. * This is so we can ignore this device from the point of view of the * user, eg. in guestfs_list_devices and many other places. @@ -752,394 +748,6 @@ join_strings (const char *separator, char *const *argv) return r; } -/* Easy ways to run external commands. For full documentation, see - * 'commandrvf' below. - */ -int -commandf (char **stdoutput, char **stderror, unsigned flags, - const char *name, ...) -{ - va_list args; - /* NB: Mustn't free the strings which are on the stack. */ - CLEANUP_FREE const char **argv = NULL; - char *s; - size_t i; - int r; - - /* Collect the command line arguments into an array. */ - i = 2; - argv = malloc (sizeof (char *) * i); - if (argv == NULL) { - perror ("malloc"); - return -1; - } - argv[0] = (char *) name; - argv[1] = NULL; - - va_start (args, name); - - while ((s = va_arg (args, char *)) != NULL) { - const char **p = realloc (argv, sizeof (char *) * (++i)); - if (p == NULL) { - perror ("realloc"); - va_end (args); - return -1; - } - argv = p; - argv[i-2] = s; - argv[i-1] = NULL; - } - - va_end (args); - - r = commandvf (stdoutput, stderror, flags, (const char * const*) argv); - - return r; -} - -/* Same as 'command', but we allow the status code from the - * subcommand to be non-zero, and return that status code. - * We still return -1 if there was some other error. - */ -int -commandrf (char **stdoutput, char **stderror, unsigned flags, - const char *name, ...) -{ - va_list args; - CLEANUP_FREE const char **argv = NULL; - char *s; - int i, r; - - /* Collect the command line arguments into an array. */ - i = 2; - argv = malloc (sizeof (char *) * i); - if (argv == NULL) { - perror ("malloc"); - return -1; - } - argv[0] = (char *) name; - argv[1] = NULL; - - va_start (args, name); - - while ((s = va_arg (args, char *)) != NULL) { - const char **p = realloc (argv, sizeof (char *) * (++i)); - if (p == NULL) { - perror ("realloc"); - va_end (args); - return -1; - } - argv = p; - argv[i-2] = s; - argv[i-1] = NULL; - } - - va_end (args); - - r = commandrvf (stdoutput, stderror, flags, argv); - - return r; -} - -/* Same as 'command', but passing an argv. */ -int -commandvf (char **stdoutput, char **stderror, unsigned flags, - char const *const *argv) -{ - int r; - - r = commandrvf (stdoutput, stderror, flags, (void *) argv); - if (r == 0) - return 0; - else - return -1; -} - -/* This is a more sane version of 'system(3)' for running external - * commands. It uses fork/execvp, so we don't need to worry about - * quoting of parameters, and it allows us to capture any error - * messages in a buffer. - * - * If stdoutput is not NULL, then *stdoutput will return the stdout - * of the command. - * - * If stderror is not NULL, then *stderror will return the stderr - * of the command. If there is a final \n character, it is removed - * so you can use the error string directly in a call to - * reply_with_error. - * - * Flags: - * - * COMMAND_FLAG_FOLD_STDOUT_ON_STDERR: For broken external commands - * that send error messages to stdout (hello, parted) but that don't - * have any useful stdout information, use this flag to capture the - * error messages in the *stderror buffer. If using this flag, - * you should pass stdoutput as NULL because nothing could ever be - * captured in that buffer. - * - * COMMAND_FLAG_CHROOT_COPY_FILE_TO_STDIN: For running external - * commands on chrooted files correctly (see RHBZ#579608) specifying - * this flag causes another process to be forked which chroots into - * sysroot and just copies the input file to stdin of the specified - * command. The file descriptor is ORed with the flags, and that file - * descriptor is always closed by this function. See hexdump.c for an - * example of usage. - */ -int -commandrvf (char **stdoutput, char **stderror, unsigned flags, - char const* const *argv) -{ - size_t so_size = 0, se_size = 0; - int so_fd[2], se_fd[2]; - unsigned flag_copy_stdin = flags & COMMAND_FLAG_CHROOT_COPY_FILE_TO_STDIN; - int flag_copy_fd = (int) (flags & COMMAND_FLAG_FD_MASK); - pid_t pid; - int r, quit, i; - fd_set rset, rset2; - char buf[256]; - char *p; - - if (stdoutput) *stdoutput = NULL; - if (stderror) *stderror = NULL; - - if (verbose) { - printf ("commandrvf: stdout=%s stderr=%s flags=0x%x\n", - stdoutput ? "y" : "n", stderror ? "y" : "n", flags); - fputs ("commandrvf: ", stdout); - fputs (argv[0], stdout); - for (i = 1; argv[i] != NULL; ++i) { - char quote; - - /* Do simple (and incorrect) quoting of the debug output. Real - * quoting is not necessary because we use execvp to run the - * command below. - */ - if (strchr (argv[i], '\'')) - quote = '"'; - else if (strchr (argv[i], '"')) - quote = '\''; - else if (strchr (argv[i], ' ')) - quote = '"'; - else - quote = 0; - - putchar (' '); - if (quote) putchar (quote); - fputs (argv[i], stdout); - if (quote) putchar (quote); - } - putchar ('\n'); - } - - /* Note: abort is used in a few places along the error paths early - * in this function. This is because (a) cleaning up correctly is - * very complex at these places and (b) abort is used when a - * resource problems is indicated which would be due to much more - * serious issues - eg. memory or file descriptor leaks. We - * wouldn't expect fork(2) or pipe(2) to fail in normal - * circumstances. - */ - - if (pipe (so_fd) == -1 || pipe (se_fd) == -1) { - error (0, errno, "pipe"); - abort (); - } - - pid = fork (); - if (pid == -1) { - error (0, errno, "fork"); - abort (); - } - - if (pid == 0) { /* Child process running the command. */ - signal (SIGALRM, SIG_DFL); - signal (SIGPIPE, SIG_DFL); - close (0); - if (flag_copy_stdin) { - if (dup2 (flag_copy_fd, STDIN_FILENO) == -1) { - perror ("dup2/flag_copy_fd"); - _exit (EXIT_FAILURE); - } - } else { - /* Set stdin to /dev/null. */ - if (open ("/dev/null", O_RDONLY) == -1) { - perror ("open: /dev/null"); - _exit (EXIT_FAILURE); - } - } - close (so_fd[PIPE_READ]); - close (se_fd[PIPE_READ]); - if (!(flags & COMMAND_FLAG_FOLD_STDOUT_ON_STDERR)) { - if (dup2 (so_fd[PIPE_WRITE], STDOUT_FILENO) == -1) { - perror ("dup2/so_fd[PIPE_WRITE]"); - _exit (EXIT_FAILURE); - } - } else { - if (dup2 (se_fd[PIPE_WRITE], STDOUT_FILENO) == -1) { - perror ("dup2/se_fd[PIPE_WRITE]"); - _exit (EXIT_FAILURE); - } - } - if (dup2 (se_fd[PIPE_WRITE], STDERR_FILENO) == -1) { - perror ("dup2/se_fd[PIPE_WRITE]"); - _exit (EXIT_FAILURE); - } - close (so_fd[PIPE_WRITE]); - close (se_fd[PIPE_WRITE]); - - if (flags & COMMAND_FLAG_DO_CHROOT && sysroot_len > 0) { - if (chroot (sysroot) == -1) { - perror ("chroot in sysroot"); - _exit (EXIT_FAILURE); - } - } - - if (chdir ("/") == -1) { - perror ("chdir"); - _exit (EXIT_FAILURE); - } - - execvp (argv[0], (void *) argv); - perror (argv[0]); - _exit (EXIT_FAILURE); - } - - /* Parent process. */ - close (so_fd[PIPE_WRITE]); - close (se_fd[PIPE_WRITE]); - - FD_ZERO (&rset); - FD_SET (so_fd[PIPE_READ], &rset); - FD_SET (se_fd[PIPE_READ], &rset); - - quit = 0; - while (quit < 2) { - again: - rset2 = rset; - r = select (MAX (so_fd[PIPE_READ], se_fd[PIPE_READ]) + 1, &rset2, - NULL, NULL, NULL); - if (r == -1) { - if (errno == EINTR) - goto again; - - perror ("select"); - quit: - if (stdoutput) { - free (*stdoutput); - *stdoutput = NULL; - } - if (stderror) { - free (*stderror); - /* Need to return non-NULL *stderror here since most callers - * will try to print and then free the err string. - * Unfortunately recovery from strdup failure here is not - * possible. - */ - *stderror = strdup ("error running external command, " - "see debug output for details"); - } - close (so_fd[PIPE_READ]); - close (se_fd[PIPE_READ]); - if (flag_copy_stdin) close (flag_copy_fd); - waitpid (pid, NULL, 0); - return -1; - } - - if (FD_ISSET (so_fd[PIPE_READ], &rset2)) { /* something on stdout */ - r = read (so_fd[PIPE_READ], buf, sizeof buf); - if (r == -1) { - perror ("read"); - goto quit; - } - if (r == 0) { FD_CLR (so_fd[PIPE_READ], &rset); quit++; } - - if (r > 0 && stdoutput) { - so_size += r; - p = realloc (*stdoutput, so_size); - if (p == NULL) { - perror ("realloc"); - goto quit; - } - *stdoutput = p; - memcpy (*stdoutput + so_size - r, buf, r); - } - } - - if (FD_ISSET (se_fd[PIPE_READ], &rset2)) { /* something on stderr */ - r = read (se_fd[PIPE_READ], buf, sizeof buf); - if (r == -1) { - perror ("read"); - goto quit; - } - if (r == 0) { FD_CLR (se_fd[PIPE_READ], &rset); quit++; } - - if (r > 0) { - if (verbose) - ignore_value (write (STDERR_FILENO, buf, r)); - - if (stderror) { - se_size += r; - p = realloc (*stderror, se_size); - if (p == NULL) { - perror ("realloc"); - goto quit; - } - *stderror = p; - memcpy (*stderror + se_size - r, buf, r); - } - } - } - } - - close (so_fd[PIPE_READ]); - close (se_fd[PIPE_READ]); - - /* Make sure the output buffers are \0-terminated. Also remove any - * trailing \n characters from the error buffer (not from stdout). - */ - if (stdoutput) { - void *q = realloc (*stdoutput, so_size+1); - if (q == NULL) { - perror ("realloc"); - free (*stdoutput); - } - *stdoutput = q; - if (*stdoutput) - (*stdoutput)[so_size] = '\0'; - } - if (stderror) { - void *q = realloc (*stderror, se_size+1); - if (q == NULL) { - perror ("realloc"); - free (*stderror); - } - *stderror = q; - if (*stderror) { - (*stderror)[se_size] = '\0'; - while (se_size > 0 && (*stderror)[se_size-1] == '\n') { - se_size--; - (*stderror)[se_size] = '\0'; - } - } - } - - if (flag_copy_stdin && close (flag_copy_fd) == -1) { - perror ("close"); - return -1; - } - - /* Get the exit status of the command. */ - if (waitpid (pid, &r, 0) != pid) { - perror ("waitpid"); - return -1; - } - - if (WIFEXITED (r)) { - return WEXITSTATUS (r); - } else - return -1; -} - /* Split an output string into a NULL-terminated list of lines, * wrapped into a stringsbuf. * Typically this is used where we have run an external command diff --git a/po/POTFILES b/po/POTFILES index 9719afd..aca174d 100644 --- a/po/POTFILES +++ b/po/POTFILES @@ -25,7 +25,9 @@ daemon/blockdev.c daemon/btrfs.c daemon/cap.c daemon/checksum.c +daemon/cleanups.c daemon/cmp.c +daemon/command.c daemon/compress.c daemon/copy.c daemon/cpio.c -- 2.5.0

On Fri, Jan 22, 2016 at 11:03:28AM +0100, Pino Toscano wrote: I pushed this before reading your comments, but I'll push an updated commit with these fixes. Thanks, Rich. -- Richard Jones, Virtualization Group, Red Hat http://people.redhat.com/~rjones Read my programming and virtualization blog: http://rwmj.wordpress.com Fedora Windows cross-compiler. Compile Windows programs, test, and build Windows installers. Over 100 libraries supported. http://fedoraproject.org/wiki/MinGW

Using the rules compiler added in the previous commit, create an inspection program ("guestfs-inspection"). This will run inside the appliance. It is partly written in the Prolog-inspired language, with C supporting functions. For more details, read the guestfs-inspection(8) man page added in this commit. --- .gitignore | 4 + Makefile.am | 2 + appliance/Makefile.am | 3 +- configure.ac | 1 + docs/guestfs-hacking.pod | 6 + generator/Makefile.am | 2 +- generator/main.ml | 4 + inspection/Makefile.am | 92 ++++++ inspection/detect.c | 130 +++++++++ inspection/facts.c | 318 ++++++++++++++++++++ inspection/guestfs-inspection.pod | 450 +++++++++++++++++++++++++++++ inspection/inspection.c | 106 +++++++ inspection/inspection.h | 79 +++++ inspection/inspection.rules | 478 ++++++++++++++++++++++++++++++ inspection/mount.c | 591 ++++++++++++++++++++++++++++++++++++++ inspection/stringsbuf.c | 254 ++++++++++++++++ inspection/stringsbuf.h | 56 ++++ po/POTFILES | 5 + src/guestfs.pod | 1 + 19 files changed, 2580 insertions(+), 2 deletions(-) create mode 100644 inspection/Makefile.am create mode 100644 inspection/detect.c create mode 100644 inspection/facts.c create mode 100644 inspection/guestfs-inspection.pod create mode 100644 inspection/inspection.c create mode 100644 inspection/inspection.h create mode 100644 inspection/inspection.rules create mode 100644 inspection/mount.c create mode 100644 inspection/stringsbuf.c create mode 100644 inspection/stringsbuf.h diff --git a/.gitignore b/.gitignore index c035ca4..0106ec3 100644 --- a/.gitignore +++ b/.gitignore @@ -251,6 +251,10 @@ Makefile.in /haskell/Guestfs030Config /haskell/Guestfs050LVCreate /haskell/Guestfs.hs +/inspection/guestfs-inspection +/inspection/guestfs-inspection.8 +/inspection/rules.c +/inspection/stamp-guestfs-inspection.pod /inspector/actual-*.xml /inspector/stamp-virt-inspector.pod /inspector/test-xmllint.sh diff --git a/Makefile.am b/Makefile.am index ba99feb..11f5e78 100644 --- a/Makefile.am +++ b/Makefile.am @@ -42,6 +42,7 @@ SUBDIRS += src docs examples po # The daemon and the appliance. if ENABLE_DAEMON +SUBDIRS += inspection SUBDIRS += daemon SUBDIRS += tests/daemon endif @@ -290,6 +291,7 @@ all-local: find $(DIST_SUBDIRS) -name '*.c' -o -name '*.pl' -o -name '*.pm' | \ grep -v -E '^(examples|gnulib|gobject/docs|perl/(blib|examples)|po-docs|tests|test-data)/' | \ grep -v -E '/((guestfs|rc)_protocol\.c)$$' | \ + grep -v -E '^inspection/rules\.c$$' | \ grep -v -E '^python/utils\.c$$' | \ LC_ALL=C sort > po/POTFILES cd $(srcdir); \ diff --git a/appliance/Makefile.am b/appliance/Makefile.am index d8fb15b..eb1f4d3 100644 --- a/appliance/Makefile.am +++ b/appliance/Makefile.am @@ -72,11 +72,12 @@ packagelist: packagelist.in Makefile cmp -s $@ $@-t || mv $@-t $@ rm -f $@-t -supermin.d/daemon.tar.gz: ../daemon/guestfsd guestfs_lvm_conf.aug guestfs_shadow.aug +supermin.d/daemon.tar.gz: ../daemon/guestfsd ../inspection/guestfs-inspection guestfs_lvm_conf.aug guestfs_shadow.aug rm -f $@ $@-t rm -rf tmp-d mkdir -p tmp-d$(DAEMON_SUPERMIN_DIR) tmp-d/etc tmp-d/usr/share/guestfs ln ../daemon/guestfsd tmp-d$(DAEMON_SUPERMIN_DIR)/guestfsd + ln ../inspection/guestfs-inspection tmp-d$(DAEMON_SUPERMIN_DIR)/guestfs-inspection ln $(srcdir)/guestfs_lvm_conf.aug tmp-d/usr/share/guestfs/guestfs_lvm_conf.aug ln $(srcdir)/guestfs_shadow.aug tmp-d/usr/share/guestfs/guestfs_shadow.aug ( cd tmp-d && tar zcf - * ) > $@-t diff --git a/configure.ac b/configure.ac index 2bd1640..0915b83 100644 --- a/configure.ac +++ b/configure.ac @@ -205,6 +205,7 @@ AC_CONFIG_FILES([Makefile golang/Makefile golang/examples/Makefile haskell/Makefile + inspection/Makefile inspector/Makefile java/Makefile java/examples/Makefile diff --git a/docs/guestfs-hacking.pod b/docs/guestfs-hacking.pod index 3602180..974c0d6 100644 --- a/docs/guestfs-hacking.pod +++ b/docs/guestfs-hacking.pod @@ -560,6 +560,11 @@ L<virt-get-kernel(1)> command and documentation. Gnulib is used as a portability library. A copy of gnulib is included under here. +=item F<inspection> + +Inspection. See L<guestfs(3)/INSPECTION> and +L<guestfs-inspection(8)>. + =item F<inspector> L<virt-inspector(1)>, the virtual machine image inspector. @@ -838,6 +843,7 @@ Optionally do a full release of the development branch. L<guestfs(3)>, L<guestfs-examples(3)>, +L<guestfs-inspection(8)>, L<guestfs-internals(3)>, L<guestfs-performance(1)>, L<guestfs-release-notes(1)>, diff --git a/generator/Makefile.am b/generator/Makefile.am index bcdc20d..29712c0 100644 --- a/generator/Makefile.am +++ b/generator/Makefile.am @@ -170,7 +170,7 @@ noinst_DATA = stamp-generator # Git removes empty directories, so in cases where the # generator is creating the sole file in a directory, we # have to create the directory first. -stamp-generator: generator +stamp-generator: generator $(wildcard $(top_srcdir)/inspection/*.rules) mkdir -p $(top_srcdir)/perl/lib/Sys mkdir -p $(top_srcdir)/ruby/ext/guestfs mkdir -p $(top_srcdir)/java/com/redhat/et/libguestfs diff --git a/generator/main.ml b/generator/main.ml index 0230a2f..7625852 100644 --- a/generator/main.ml +++ b/generator/main.ml @@ -212,6 +212,10 @@ Run it from the top source directory using the command output_to "customize/customize-synopsis.pod" generate_customize_synopsis_pod; output_to "customize/customize-options.pod" generate_customize_options_pod; + (* Run the rules compiler to generate inspection rules. *) + output_to "inspection/rules.c" + (Rules_compiler.compile "inspection/inspection.rules"); + (* Generate the list of files generated -- last. *) printf "generated %d lines of code\n" (get_lines_generated ()); let files = List.sort compare (get_files_generated ()) in diff --git a/inspection/Makefile.am b/inspection/Makefile.am new file mode 100644 index 0000000..9227249 --- /dev/null +++ b/inspection/Makefile.am @@ -0,0 +1,92 @@ +# libguestfs +# Copyright (C) 2015 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. + +include $(top_srcdir)/subdir-rules.mk + +generator_built = \ + rules.c + +BUILT_SOURCES = \ + $(generator_built) + +CLEANFILES = \ + stamp-guestfs-inspection.pod \ + guestfs-inspection.8 + +# Build the inspection program. + +if INSTALL_DAEMON +sbin_PROGRAMS = guestfs-inspection +else +noinst_PROGRAMS = guestfs-inspection +endif + +SHARED_SOURCE_FILES = \ + ../daemon/cleanups.c \ + ../daemon/cleanups.h \ + ../daemon/command.c \ + ../daemon/command.h + +guestfs_inspection_SOURCES = \ + $(SHARED_SOURCE_FILES) \ + detect.c \ + facts.c \ + inspection.c \ + inspection.h \ + mount.c \ + rules.c \ + stringsbuf.c \ + stringsbuf.h + +guestfs_inspection_LDADD = \ + $(AUGEAS_LIBS) \ + $(HIVEX_LIBS) \ + $(PCRE_LIBS) \ + $(top_builddir)/gnulib/lib/.libs/libgnu.a + +guestfs_inspection_CPPFLAGS = \ + -I$(top_srcdir)/gnulib/lib \ + -I$(top_builddir)/gnulib/lib \ + -I$(top_srcdir)/daemon \ + -I$(top_builddir)/daemon \ + -I$(top_srcdir)/src \ + -I$(top_builddir)/src + +guestfs_inspection_CFLAGS = \ + $(WARN_CFLAGS) $(WERROR_CFLAGS) \ + $(AUGEAS_CFLAGS) \ + $(HIVEX_CFLAGS) \ + $(PCRE_CFLAGS) + +# Manual pages and HTML files for the website. +if INSTALL_DAEMON +man_MANS = guestfs-inspection.8 +else +noinst_MANS = guestfs-inspection.8 +endif +noinst_DATA = $(top_builddir)/website/guestfs-inspection.8.html + +guestfs-inspection.8 $(top_builddir)/website/guestfs-inspection.8.html: stamp-guestfs-inspection.pod + +stamp-guestfs-inspection.pod: guestfs-inspection.pod + $(PODWRAPPER) \ + --section 8 \ + --man guestfs-inspection.8 \ + --html $(top_builddir)/website/guestfs-inspection.8.html \ + --license GPLv2+ \ + $< + touch $@ diff --git a/inspection/detect.c b/inspection/detect.c new file mode 100644 index 0000000..46b7c9e --- /dev/null +++ b/inspection/detect.c @@ -0,0 +1,130 @@ +/* guestfs-inspection + * Copyright (C) 2009-2015 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. + */ + +#include <config.h> + +#include <stdio.h> +#include <stdlib.h> +#include <error.h> + +#include "inspection.h" + +int +get_distro_from_os_release (const char *fs, char **distro) +{ + error (EXIT_FAILURE, 0, "%s: not implemented", __func__); + return -1; +} + +int +get_version_from_os_release (const char *fs, char **major, char **minor) +{ + error (EXIT_FAILURE, 0, "%s: not implemented", __func__); + return -1; +} + +int +get_product_name_from_os_release (const char *fs, char **product_name) +{ + error (EXIT_FAILURE, 0, "%s: not implemented", __func__); + return -1; +} + +int +get_distro_from_lsb_release (const char *fs, char **distro) +{ + error (EXIT_FAILURE, 0, "%s: not implemented", __func__); + return -1; +} + +int +get_version_from_lsb_release (const char *fs, char **major, char **minor) +{ + error (EXIT_FAILURE, 0, "%s: not implemented", __func__); + return -1; +} + +int +get_product_name_from_lsb_release (const char *fs, char **product_name) +{ + error (EXIT_FAILURE, 0, "%s: not implemented", __func__); + return -1; +} + +int +get_version_from_oracle_release (const char *fs, char **major, char **minor) +{ + error (EXIT_FAILURE, 0, "%s: not implemented", __func__); + return -1; +} + +int +get_version_from_centos_release (const char *fs, char **major, char **minor) +{ + error (EXIT_FAILURE, 0, "%s: not implemented", __func__); + return -1; +} + +int +get_version_from_altlinux_release (const char *fs, char **major, char **minor) +{ + error (EXIT_FAILURE, 0, "%s: not implemented", __func__); + return -1; +} + +int +match_redhat_release_fedora (const char *fs) +{ + error (EXIT_FAILURE, 0, "%s: not implemented", __func__); + return -1; +} + +int +match_redhat_release_rhel (const char *fs) +{ + error (EXIT_FAILURE, 0, "%s: not implemented", __func__); + return -1; +} + +int +match_redhat_release_centos (const char *fs) +{ + error (EXIT_FAILURE, 0, "%s: not implemented", __func__); + return -1; +} + +int +match_redhat_release_scientific_linux (const char *fs) +{ + error (EXIT_FAILURE, 0, "%s: not implemented", __func__); + return -1; +} + +int +get_version_from_redhat_release (const char *fs, char **major, char **minor) +{ + error (EXIT_FAILURE, 0, "%s: not implemented", __func__); + return -1; +} + +int +get_product_name_from_release_file (const char *fs, const char *release_file, char **product_name) +{ + error (EXIT_FAILURE, 0, "%s: not implemented", __func__); + return -1; +} diff --git a/inspection/facts.c b/inspection/facts.c new file mode 100644 index 0000000..fc4ca8c --- /dev/null +++ b/inspection/facts.c @@ -0,0 +1,318 @@ +/* guestfs-inspection + * Copyright (C) 2009-2015 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. + */ + +/* Handle the true and false facts sets, and other helper functions. */ + +#include <config.h> + +#include <stdio.h> +#include <stdlib.h> +#include <stdarg.h> +#include <stdbool.h> +#include <string.h> +#include <inttypes.h> +#include <assert.h> +#include <error.h> +#include <errno.h> +#include <alloca.h> + +#include "gl_oset.h" +#include "gl_xoset.h" +#include "gl_array_oset.h" + +#include "inspection.h" + +/* True and false facts sets. See guestfs-inspection(8)/WRITING RULES + * to understand why these are used. + */ +static gl_oset_t true_facts = NULL; +static gl_oset_t false_facts = NULL; + +/* Used to store a single true or false fact. The only reason we know + * it's a false fact is because it would be stored in the false_facts + * set. + */ +struct fact { + char *term_name; + size_t nr_term_args; + char *term_arg[0]; +}; + +static int +compare_facts (const void *vf1, const void *vf2) +{ + size_t i; + int r; + const fact *f1 = vf1; + const fact *f2 = vf2; + + r = strcmp (f1->term_name, f2->term_name); + if (r != 0) return r; + + /* If term names are equal, they are supposed to have the same + * number of arguments. We type-checked that when reading the + * source. However, better check. + */ + assert (f1->nr_term_args == f2->nr_term_args); + + for (i = 0; i < f1->nr_term_args; ++i) { + r = strcmp (f1->term_arg[i], f2->term_arg[i]); + if (r != 0) return r; + } + + return 0; +} + +static void +free_fact (const void *vf) +{ + /* Why is the parameter const? + * See Bruno Haible's explanation here: + * https://www.mail-archive.com/bug-gnulib@gnu.org/msg08619.html + */ + fact *f = (fact *) vf; + size_t i; + + free (f->term_name); + for (i = 0; i < f->nr_term_args; ++i) + free (f->term_arg[i]); + free (f); +} + +static void init_facts (void) __attribute__((constructor)); + +static void +init_facts (void) +{ + true_facts = gl_oset_create_empty (GL_ARRAY_OSET, compare_facts, free_fact); + false_facts = gl_oset_create_empty (GL_ARRAY_OSET, compare_facts, free_fact); +} + +static void free_facts (void) __attribute__((destructor)); + +static void +free_facts (void) +{ + gl_oset_free (true_facts); + gl_oset_free (false_facts); +} + +static void +clear_set (gl_oset_t set) +{ + const void *f; + gl_oset_iterator_t iter = gl_oset_iterator (set); + + while (gl_oset_iterator_next (&iter, &f)) { + gl_oset_remove (set, (void *) f); + } + gl_oset_iterator_free (&iter); +} + +void +clear_true_facts (void) +{ + clear_set (true_facts); +} + +void +clear_false_facts (void) +{ + clear_set (false_facts); +} + +size_t +count_true_facts (void) +{ + return gl_oset_size (true_facts); +} + +/* This is just for debugging facts. */ +void +print_fact (bool is_true, fact *f, FILE *fp) +{ + size_t i; + + if (!is_true) + fputc ('!', fp); + fputs (f->term_name, fp); + if (f->nr_term_args > 0) + fputc ('(', fp); + for (i = 0; i < f->nr_term_args; ++i) { + fputc ('"', fp); + fputs (f->term_arg[i], fp); + fputc ('"', fp); + if (i+1 != f->nr_term_args) + fputs (", ", fp); + } + if (f->nr_term_args > 0) + fputc (')', fp); +} + +static void +print_set (bool is_true, gl_oset_t set) +{ + const void *vf; + gl_oset_iterator_t iter = gl_oset_iterator (set); + + while (gl_oset_iterator_next (&iter, &vf)) { + fact *f = (fact *) vf; + print_fact (is_true, f, stdout); + printf ("\n"); + } + gl_oset_iterator_free (&iter); +} + +void +print_true_facts (void) +{ + print_set (true, true_facts); +} + +void +print_false_facts (void) +{ + print_set (false, false_facts); +} + +/* Look for every string parameter of every fact we know about, and + * add all those strings to the set. + */ +void +add_all_fact_strings (gl_oset_t set) +{ + const void *vf; + fact *f; + gl_oset_iterator_t iter; + size_t i; + + iter = gl_oset_iterator (true_facts); + while (gl_oset_iterator_next (&iter, &vf)) { + f = (fact *) vf; + for (i = 0; i < f->nr_term_args; ++i) + gl_oset_add (set, f->term_arg[i]); + } + gl_oset_iterator_free (&iter); + + iter = gl_oset_iterator (false_facts); + while (gl_oset_iterator_next (&iter, &vf)) { + f = (fact *) vf; + for (i = 0; i < f->nr_term_args; ++i) + gl_oset_add (set, f->term_arg[i]); + } + gl_oset_iterator_free (&iter); +} + +/* Look for every string parameter in the specific argument position + * of the specific term name (both true and false), and add those + * strings only to the set. + */ +void +add_strings_from_facts (gl_oset_t set, const char *term_name, size_t arg_i) +{ + const void *vf; + fact *f; + gl_oset_iterator_t iter; + + iter = gl_oset_iterator (true_facts); + while (gl_oset_iterator_next (&iter, &vf)) { + f = (fact *) vf; + if (strcmp (f->term_name, term_name) == 0) + gl_oset_add (set, f->term_arg[arg_i]); + } + gl_oset_iterator_free (&iter); + + iter = gl_oset_iterator (false_facts); + while (gl_oset_iterator_next (&iter, &vf)) { + f = (fact *) vf; + if (strcmp (f->term_name, term_name) == 0) + gl_oset_add (set, f->term_arg[arg_i]); + } + gl_oset_iterator_free (&iter); +} + +/* NB: This does not make a deep copy of the strings. However before + * we add the fact to the true_facts or false_facts arrays, we do call + * deep_copy to copy the strings. + */ +fact * +create_fact (const char *term_name, size_t n, ...) +{ + fact *f; + size_t i; + va_list args; + + f = malloc (sizeof (*f) + n * sizeof (char *)); + if (f == NULL) + error (EXIT_FAILURE, errno, "malloc"); + va_start (args, term_name); + for (i = 0; i < n; ++i) { + const char *p = va_arg (args, const char *); + f->term_arg[i] = (char *) p; + } + va_end (args); + f->term_name = (char *) term_name; + f->nr_term_args = n; + return f; /* caller must free only the struct */ +} + +static fact * +deep_copy_fact (const fact *f) +{ + fact *ret; + size_t i; + + ret = malloc (sizeof (*ret) + f->nr_term_args * sizeof (char *)); + if (ret == NULL) + error (EXIT_FAILURE, errno, "malloc"); + + ret->term_name = strdup (f->term_name); + if (ret->term_name == NULL) + error (EXIT_FAILURE, errno, "strdup"); + + ret->nr_term_args = f->nr_term_args; + + for (i = 0; i < f->nr_term_args; ++i) { + ret->term_arg[i] = strdup (f->term_arg[i]); + if (ret->term_arg[i] == NULL) + error (EXIT_FAILURE, errno, "strdup"); + } + + return ret; +} + +bool +is_fact (bool is_true, const fact *f) +{ + return gl_oset_search (is_true ? true_facts : false_facts, f); +} + +bool +add_fact (bool is_true, const fact *f) +{ + fact *f2 = deep_copy_fact (f); + bool ret; + + ret = gl_oset_add (is_true ? true_facts : false_facts, f2); + + /* Didn't add it, so we must free the deep copy. */ + if (!ret) + free_fact (f2); + + return ret; +} diff --git a/inspection/guestfs-inspection.pod b/inspection/guestfs-inspection.pod new file mode 100644 index 0000000..6c4ce16 --- /dev/null +++ b/inspection/guestfs-inspection.pod @@ -0,0 +1,450 @@ +=head1 NAME + +guestfs-inspection - guestfs inspection program + +=head1 SYNOPSIS + + guestfs-inspection + +=head1 NOTE + +This man page documents the guestfs inspection program. If you want +to read about guestfs inspection then this is the wrong place. See +L<guestfs(3)/INSPECTION> instead. + +=head1 DESCRIPTION + +C<guestfs-inspection> is a standalone program that performs inspection +on the local disks, to find out what operating system(s) are +installed. It normally runs inside the libguestfs appliance, started +by L<guestfsd(8)>, when the caller uses the C<guestfs_inspect_os> API +(see L<guestfs-internals(1)> and L<guestfs(3)/guestfs_inspect_os>). +You should never need to run this program by hand. + +The program looks at all disks attached to the appliance, looking for +filesystems that might belong to operating systems. It may mount +these temporarily to examine them for Linux configuration files, +Windows Registries, and so on. It then tries to determine what +operating system(s) are installed on the disks. It is able to detect +many different Linux distributions, Windows, BSD, and others. The +currently mounted root filesystem is ignored, since when running under +libguestfs, that filesystem is part of the libguestfs appliance (this +is the main difference compared to programs like C<facter>). + +Guestfs-inpection is written in C, but most of the C is generated by a +rules compiler from a set of inspection rules written in a more +compact, declarative, Prolog-inspired language. If you want to write +or modify the rules, see L</WRITING RULES> below. + +=head1 OPTIONS + +=over 4 + +=item B<-?> + +=item B<--help> + +Display brief help. + +=item B<-v> + +=item B<--verbose> + +Enable verbose messages for debugging. + +=back + +=head1 WRITING RULES + +Inspection is performed according to a set of rules written in a +compact, declarative, Prolog-inspired language. This section explains +how this language works, so you can write your own rules to detect +other operating systems. + +The rules can be found starting in C<inspection/inspection.rules> (in +the libguestfs sources). The rules are compiled down to C and linked +into the guestfs-inspection program, together with a bit of extra C +code to provide runtime support. + +=head2 Facts + +Facts are what we try to determine about the operating system(s) we +are inspecting. They look like this: + + Filesystem("/dev/sda1") + +which means "F</dev/sda1> is a filesystem". + + File("/dev/sda1", "/etc/fstab") + +which means "there exists a file called F</etc/fstab> on the +F</dev/sda1> filesystem". + +Facts come in three flavours: true facts, false facts, and unknown +facts. False facts are written like this: + + ! File("/dev/sda1", "/etc/fstab") + +which means "either F</dev/sda1> is not a filesystem or there does not +exist a file called F</etc/fstab> on this filesystem". + +Unknown facts are facts that we don't know if they are true or false +yet. + +=head2 Rules + +Rules are used to generate more facts. A simple rule for generating +C<File> facts might look like this: + + File(fs, filename) :- + Filesystem(fs), + {{ + // some C code to mount 'fs' and check for 'filename' + }}. + +You can read this as: "For all C<fs> & C<filename>, if C<fs> is a +filesystem, and running the C code with parameters C<fs> and +C<filename> returns true, then C<File(fs, filename)> is a true fact". + +In the Prolog-inspired language, a comma (C<,>) is the AND operator. +A semicolon (C<;>) is the OR operator. C<:-> is a backwards +if-statement (the condition is on the right, the conclusion is on the +left). Also notice the dot (C<.>) which must follow each rule. + +Uppercase identifiers are facts. Lowercase identifiers are variables. +All identifiers are case-sensitive. + +Everything in C<{{ ... }}> is embedded C code. In this case the C +code returns a true/false/error indication, but embedded C code can +also do more complicated things and return strings and lists as we'll +see later. + +You can use parentheses C<(...)> for grouping expressions on the right +hand side of the C<:-> operator. + +=head2 Program evaluation + +Let's take a simple set of rules which you might use to detect a +Fedora root filesystem: + + File(fs, filename) :- + Filesystem(fs), + {{ + // some C code to mount 'fs' and check for 'filename' + }}. + + Fedora(rootfs) :- + Filesystem(rootfs), + File(rootfs, "/etc/fedora-release"). + +When evaluating this program, there are two sets of facts, the true +facts and the false facts. Let's start with the false facts set being +empty, and let's seed the true facts set with some C<Filesystem> +facts: + + true_facts = { Filesystem("/dev/sda1"), Filesystem("/dev/sda3") } + false_facts = { } // empty set + +Unknown facts are facts which don't appear in either set. + +Evaluating the program works like this: We consider each rule in turn, +and see if we can find new true or false facts from it. These new +facts are added to the true or false facts sets. After looking at +each rule in the program, as long as at least one new fact was added +to the true facts set, we go back to the start of the rules and repeat +over. We do this until we can no longer add any new true facts, and +then we're done. + +In the case of this program, we start with the C<File> rule, and we +substitute (theoretically) every possible string for C<fs> and +C<filename>. + +For example, this substitution: + + File("/dev/sda1", "/etc/fedora-release") :- + Filesystem("/dev/sda1"), + {{ // checks for file and returns false }}. + +turns out to be false (because the C code doesn't find F</etc/fstab> +in F</dev/sda1>), so that yields a new false fact: + + ! File("/dev/sda1", "/etc/fedora-release") + +But this substitution turns out to be true: + + File("/dev/sda3", "/etc/fedora-release") :- + Filesystem("/dev/sda3"), + {{ // checks for file and returns true }}. + +so that yields a new true fact: + + File("/dev/sda3", "/etc/fedora-release") + +In theory every possible string is tried, eg C<File("ardvark", "foo123654")>. +That would take literally forever to run, but luckily the rules +compiler is smarter. + +Looking now at the second rule, we try this substitution: + + Fedora("/dev/sda3") :- + Filesystem("/dev/sda3"), + File("/dev/sda3", "/etc/fedora-release"). + +which yields another new true fact: + + Fedora("/dev/sda3") + +Because we added several new true facts to the set, we go back and +repeat the whole process. But after trying all the rules for a second +time, no more true facts can be added, so now we're done. + +At the end, the set of true facts is: + + true_facts = { Filesystem("/dev/sda1"), Filesystem("/dev/sda3"), + File("/dev/sda3", "/etc/fedora-release"), + Fedora("/dev/sda3") } + +We don't care about the false facts -- they are discarded at the end +of the program. + +The summary of inspection is that F</dev/sda3> contains a Fedora root +filesystem. + +Of course real inspection is much more complicated than this, but the +same program evaluation order is followed. + +=head2 Some caveats with the language + +It's easy to look at an expression like: + + Fedora(rootfs) :- + Filesystem(rootfs), + File(rootfs, "/etc/fedora-release"). /* line 3 */ + +and think that line 3 is "calling" the "File function". This is +B<not> what is happening! Rules are not functions. Rules are +considered in isolation. Rules don't "call" other rules. Instead +when trying to find possible values that can be substituted into a +rule, we only look at the rule and the current sets of true and false +facts. + +When searching for values to subsitute, in theory the compiler would +have to look at every possible string. In practice of course it can't +and doesn't do that. Instead it looks at the current sets of true and +false facts to find strings to substitute. In the following rule: + + File(fs, filename) :- + Filesystem(fs), + {{ // C code }}. + +suitable choices for C<fs> are found by looking at any C<Filesystem> +facts in either the true or false sets. + +In some cases, this doesn't work, as in the example above where we +have no clues for the C<filename> variable. In that case the compiler +tries every string literal from every rule in the program. This can +be inefficient, but by modifying the rule slightly you can avoid this. +In the following program, only the strings F</etc/fstab> and +F</etc/fedora-release> would be tried: + + Filename("/etc/fstab"). + Filename("/etc/fedora-release"). + File(fs, filename) :- + Filesystem(fs), + Filename(filename), + {{ // C code }}. + +=head2 C expressions returning boolean + +Simple C code enclosed in C<{{ ... }}> as shown above should return a +true, false or error status only. It returns true by returning any +integer E<ge> 1. It should return C<0> to indicate false, and it +should return C<-1> to indicate an error (which stops the program and +causes inspection to fail with a user-visible error). + +Here is an example of a simple C expression returning a boolean: + + File(fs, filename) :- + Filesystem(fs), + {{ + int r; + char *relative_filename; + r = get_mount (fs, filename, &relative_filename); + if (r != 1) return r; + r = access (relative_filename, F_OK); + free (relative_filename); + if (r == -1) { + if (errno == ENOENT || errno == ENOTDIR) + return 0; + perror ("access"); + return -1; + } + return 1; + }}. + +Notice that C<fs> and C<filename> are passed into the C code as local +variables. + +You can see that dealing with errors is a bit involved, because we +want to fail hard if some error like C<EIO> is thrown. + +=head2 C expressions returning strings + +C expressions can also return strings or tuples of strings. This is +useful where you want to parse the content of external files. + +The syntax for this sort of C expression is: + + (var1, var2, ...)={{ ... }} + +where C<var1>, C<var2>, etc. are outputs from the C code. + +In the following example, a lot of error checking has been omitted +for clarity: + + ProductName(fs, product_name) :- + Unix_root(fs), + Distro(fs, "RHEL"), + (product_name)={{ + int r; + char *line = NULL; + size_t n; + char *relative_filename; + r = get_mount (fs, "/etc/redhat-release", &relative_filename); + FILE *fp = fopen (relative_filename, "r"); + free (relative_filename); + getline (&line, &n, fp); + fclose (fp); + set_product_name (line); + free (line); + return 0; + }}. + +The C code calls a function C<set_product_name> (that the compiler +generates). + +The return value from the C code should be C<0> if everything was OK, +or C<-1> if there is a error (which stops the whole program). + +=head2 C expressions returning multiple results + +Finally it is possible for C code to return multiple results. + +The syntax is: + + (var1, var2, ...)*={{ ... }} + + (var1, var2, ...)?={{ ... }} + + (var1, var2, ...)+={{ ... }} + +where C<var1>, C<var2>, etc. are outputs. Unlike the previous rules, +these rules may generate zero or multiple facts from a single string +substitution. + +For example, here is how we could populate a list of C<Filesystem> +facts: + + Filesystem(fs) :- + (fs)*={{ + int i; + extern char **fs; + for (i = 0; fs[i] != NULL; ++i) { + set_fs (fs[i]); + } + return 0; + }}. + +In this case, the C code repeatedly calls a function C<set_fs> (that +the compiler generates) for each new filesystem discovered. Multiple +C<Filesystem> facts can be generated as a result of one application of +this rule. + +As with regular expressions, C<*> means we expect zero or more rows of +results, C<?> means zero or one, and C<+> means one or more. The +generated target code checks that you call the C<set_*> function the +correct number of times. + +The return value from the C code should be C<0> if everything was OK, +or C<-1> if there is a error (which stops the whole program). + +=head2 Prologue and epilogue + +If you want to insert arbitrary chunks of C code into the output, for +example to C<#include> headers, then you can insert literal code +between C<{{ ... }}> at the top and bottom of the file (ie. before +all rules and after all rules). You cannot insert these chunks +between rules. + +=head2 C code memoization + +Although currently B<only partially implemented>, in future we will +implement memoization of C code. This means that for every input, the +C code will be called only once, making it less important that C code +is efficient: no matter how many times we need to evaluate if +F</etc/fstab> exists on F</dev/sda1>, the C code would only be called +once. + +This means that impure C functions returning different results for the +same input won't work in future, so don't do that. + +=head2 Type checking + +The current language treats every value as a string. Every expression +is a boolean. One possible future enhancement is to handle other +types. There is still some minimal type checking applied: + +=over 4 + +=item * + +A fact name which appears on a right hand side of any rule must also +appear on the left hand side of a rule. This is mainly for catching +typos. + +=item * + +A fact must have the same number of arguments ("arity") each time it +appears in the source. + +=back + +=head2 Debugging + +You can debug the evaluation of inspection programs by calling +C<guestfs_set_verbose> (or setting C<$LIBGUESTFS_DEBUG=1>) before +launching the handle. + +This causes L<guestfsd(8)> to pass the I<--verbose> parameter to this +inspection program, which in turn causes the inspection program to +print information about what rules it is trying and what true/false +facts it has found. These are passed back to libguestfs and printed +on C<stderr> (or sent to the event system if you are using that). + +You can also print debug messages from C code embedded in C<{{...}}> +expressions. These are similarly sent upwards through to libguestfs +and will appear on C<stderr>. + +Remember that C memoization [to be implemented in a future version] +can cause C code to run fewer times than expected. + +=head1 EXIT STATUS + +This program returns 0 if successful, or non-zero if there was an +error. + +=head1 SEE ALSO + +L<guestfsd(8)>, +L<guestfs-hacking(1)>, +L<guestfs-internals(1)>, +L<guestfs(3)/INSPECTION>, +L<http://libguestfs.org/>. + +=head1 AUTHOR + +Richard W.M. Jones L<http://people.redhat.com/~rjones/> + +=head1 COPYRIGHT + +Copyright (C) 2009-2015 Red Hat Inc. diff --git a/inspection/inspection.c b/inspection/inspection.c new file mode 100644 index 0000000..f74e028 --- /dev/null +++ b/inspection/inspection.c @@ -0,0 +1,106 @@ +/* guestfs-inspection + * Copyright (C) 2009-2015 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. + */ + +#include <config.h> + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <inttypes.h> +#include <getopt.h> +#include <unistd.h> + +#include "inspection.h" + +int verbose = 0; +const char *sysroot = NULL; +const size_t sysroot_len = 0; + +/* Required by the gnulib 'error' module. */ +const char *program_name = "guestfs-inspection"; + +static void __attribute__((noreturn)) +usage (int status) +{ + if (status != EXIT_SUCCESS) + fprintf (stderr, "Try `%s --help' for more information.\n", + program_name); + else { + printf ("%s: guestfs inspection\n" + "Copyright (C) 2009-2015 Red Hat Inc.\n" + "Usage:\n" + "Options:\n" + " --help Display brief help\n" + " -v|--verbose Verbose messages\n" + " -V|--version Display version and exit\n" + "For more information, see the manpage %s(8).\n", + program_name, program_name); + } + exit (status); +} + +int +main (int argc, char *argv[]) +{ + enum { HELP_OPTION = CHAR_MAX + 1 }; + + static const char *options = "vV"; + static const struct option long_options[] = { + { "help", 0, 0, HELP_OPTION }, + { "verbose", 0, 0, 'v' }, + { "version", 0, 0, 'V' }, + { 0, 0, 0, 0 } + }; + int c; + int option_index; + + for (;;) { + c = getopt_long (argc, argv, options, long_options, &option_index); + if (c == -1) break; + + switch (c) { + case 0: /* options which are long only */ + fprintf (stderr, "%s: unknown long option: %s (%d)\n", + program_name, + long_options[option_index].name, option_index); + exit (EXIT_FAILURE); + + case 'v': + verbose++; + break; + + case 'V': + printf ("%s %s\n", program_name, PACKAGE_VERSION_FULL); + exit (EXIT_SUCCESS); + + case HELP_OPTION: + usage (EXIT_SUCCESS); + + default: + usage (EXIT_FAILURE); + } + } + + /* Run the rules. */ + rules (); + + /* Print the true facts. XXX Output XXX */ + print_true_facts (); + + exit (EXIT_SUCCESS); +} diff --git a/inspection/inspection.h b/inspection/inspection.h new file mode 100644 index 0000000..c0feda0 --- /dev/null +++ b/inspection/inspection.h @@ -0,0 +1,79 @@ +/* guestfs-inspection + * Copyright (C) 2009-2015 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. + */ + +#ifndef GUESTFS_INSPECTION_H +#define GUESTFS_INSPECTION_H + +#include <stdbool.h> + +#include "gl_oset.h" + +#include "cleanups.h" +#include "command.h" + +extern int verbose; + +/* detect.c - used by rules */ +extern int get_distro_from_os_release (const char *fs, char **distro); +extern int get_version_from_os_release (const char *fs, char **major, char **minor); +extern int get_product_name_from_os_release (const char *fs, char **product_name); +extern int get_distro_from_lsb_release (const char *fs, char **distro); +extern int get_version_from_lsb_release (const char *fs, char **major, char **minor); +extern int get_product_name_from_lsb_release (const char *fs, char **product_name); +extern int get_version_from_oracle_release (const char *fs, char **major, char **minor); +extern int get_version_from_centos_release (const char *fs, char **major, char **minor); +extern int get_version_from_altlinux_release (const char *fs, char **major, char **minor); +extern int match_redhat_release_fedora (const char *fs); +extern int match_redhat_release_rhel (const char *fs); +extern int match_redhat_release_centos (const char *fs); +extern int match_redhat_release_scientific_linux (const char *fs); +extern int get_version_from_redhat_release (const char *fs, char **major, char **minor); +extern int get_product_name_from_release_file (const char *fs, const char *release_file, char **product_name); + +/* facts.c */ +typedef struct fact fact; +extern void clear_true_facts (void); +extern void clear_false_facts (void); +extern size_t count_true_facts (void); +extern void print_fact (bool is_true, fact *f, FILE *fp); +extern void print_true_facts (void); +extern void print_false_facts (void); +extern void add_all_fact_strings (gl_oset_t set); +extern void add_strings_from_facts (gl_oset_t set, const char *term_name, size_t arg_i); +extern fact *create_fact (const char *term_name, size_t n, ...); +extern bool is_fact (bool is_true, const fact *); +extern bool add_fact (bool is_true, const fact *); + +/* rules.c - generated code */ +extern const char *all_strings[]; +extern void rules (void); + +/* mount.c - used by rules */ +extern char **get_all_block_devices (void); +extern char **get_all_partitions (void); +extern char **get_all_mddevs (void); +extern char **get_all_lvs (void); +extern char **get_all_ldmvols (void); +extern char **get_all_ldmparts (void); +extern char **get_all_btrfs_subvolumes (const char *fs); +extern char *get_vfs_type (const char *fs); +extern int get_partition_mbr_id (const char *fs); +extern int is_mountable (const char *fs); +extern int get_mount (const char *fs, const char *filename, char **relative_filename); + +#endif /* GUESTFS_INSPECTION_H */ diff --git a/inspection/inspection.rules b/inspection/inspection.rules new file mode 100644 index 0000000..646d28f --- /dev/null +++ b/inspection/inspection.rules @@ -0,0 +1,478 @@ +/* Libguestfs inspection rules -*- prolog -*- + * Copyright (C) 2009-2016 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. + */ + +/* To understand what's going on here, it's recommended that you read + * guestfs-inspection(8) (inspection/guestfs-inspection.pod) first. + */ + +{{ +#include <sys/types.h> +#include <sys/stat.h> +#include <errno.h> +}} + +/* Whole block devices. */ +BlockDevice(dev) :- + (dev)*={{ + CLEANUP_FREE_STRING_LIST char **devs = get_all_block_devices (); + if (devs == NULL) return -1; + for (size_t i = 0; devs[i] != NULL; ++i) set_dev (devs[i]); + return 0; + }}. + +/* Partitions. */ +Partition(dev) :- + (dev)*={{ + CLEANUP_FREE_STRING_LIST char **devs = get_all_partitions (); + if (devs == NULL) return -1; + /* Ignore partitions with type byte 0x42 (RHBZ#887520). */ + for (size_t i = 0; devs[i] != NULL; ++i) { + int r = get_partition_mbr_id (devs[i]); + if (r == -1) return -1; + if (r != 0x42) set_dev (devs[i]); + } + return 0; + }}. + +/* LVM2 logical volumes. */ +LV(dev) :- + (dev)*={{ + CLEANUP_FREE_STRING_LIST char **devs = get_all_lvs (); + if (devs == NULL) return -1; + for (size_t i = 0; devs[i] != NULL; ++i) set_dev (devs[i]); + return 0; + }}. + +/* /dev/md* devices. */ +MDDev(dev) :- + (dev)*={{ + CLEANUP_FREE_STRING_LIST char **devs = get_all_mddevs (); + if (devs == NULL) return -1; + for (size_t i = 0; devs[i] != NULL; ++i) set_dev (devs[i]); + return 0; + }}. + +/* Windows LDM voumes. */ +LDMVol(dev) :- + (dev)*={{ + CLEANUP_FREE_STRING_LIST char **devs = get_all_ldmvols (); + if (devs == NULL) return -1; + for (size_t i = 0; devs[i] != NULL; ++i) set_dev (devs[i]); + return 0; + }}. + +/* Windows LDM partitions. */ +LDMPart(dev) :- + (dev)*={{ + CLEANUP_FREE_STRING_LIST char **devs = get_all_ldmparts (); + if (devs == NULL) return -1; + for (size_t i = 0; devs[i] != NULL; ++i) set_dev (devs[i]); + return 0; + }}. + +/* Device(dev) is just a group name for block devices, partitions etc. */ +Device(dev) :- + BlockDevice(dev); Partition(dev); LV(dev); + MDDev(dev); LDMVol(dev); LDMPart(dev). + +/* Map a filesystem to its VFS type (from blkid). */ +VFSType(fs, vfs_type) :- + Device(fs), + (vfs_type)?={{ + CLEANUP_FREE char *vfs_type = get_vfs_type (fs); + if (vfs_type != NULL) set_vfs_type (vfs_type); + return 0; + }}. + +/* A device contains a mountable filesystem (not swap, empty, etc). */ +Mountable(fs) :- + Device(fs), + {{ return is_mountable (fs); }}. + +/* Where a filesystem is btrfs and mountable, get the subvolumes. */ +BtrfsSubvolume(subvol) :- + Device(fs), + Mountable(fs), + VFSType(fs, "btrfs"), + (subvol)*={{ + size_t i; + CLEANUP_FREE_STRING_LIST char **paths = get_all_btrfs_subvolumes (fs); + if (paths == NULL) return -1; + for (i = 0; paths[i] != NULL; ++i) { + CLEANUP_FREE char *subvol; + if (asprintf (&subvol, "btrfsvol:%s/%s", fs, paths[i]) == -1) { + perror ("asprintf"); + exit (EXIT_FAILURE); + } + set_subvol (subvol); + } + return 0; + }}. +VFSType(subvol, "btrfs") :- BtrfsSubvolume(subvol). + +/* Ignore all *_member types. In libblkid these are returned + * for things which are members of some RAID or LVM set, most + * importantly "LVM2_member" which is a PV. Also ignore + * crypto_LUKS (LUKS encrypted partition). + */ +ContainerDevice(dev) :- + VFSType(dev, vfs_type), + {{ return STRSUFFIX (vfs_type, "_member"); }}. +ContainerDevice(dev) :- + VFSType(dev, "crypto_LUKS"). + +/* Ignore all swap devices. */ +SwapDevice(dev) :- VFSType(dev, "swap"). + +/* This rule generates one Filesystem(fs) fact per mountable + * filesystem found in the appliance. A filesystem could be + * a device, partition, LV, btrfs subvolume, etc. + */ +Filesystem(fs) :- + !ContainerDevice(fs), + !SwapDevice(fs), + (Device(fs), Mountable(fs); BtrfsSubvolume(fs)). + +/* File(fs, filename) is true if filename is a regular file in fs. + * It also follows symlinks. + */ +File(fs, filename) :- + Filesystem(fs), + {{ + int r; + CLEANUP_FREE char *relative_filename = NULL; + struct stat statbuf; + + if (filename[0] != '/') return 0; + r = get_mount (fs, filename, &relative_filename); + if (r != 1) return r; + r = stat (relative_filename, &statbuf); + if (r == -1) { + if (errno == ENOENT || errno == ENOTDIR || errno == ELOOP) + return 0; + perror (relative_filename); + return -1; + } + return S_ISREG (statbuf.st_mode); + }}. + +/* Directory(fs, dirname) is true if dirname is a directory in fs. + * It also follows symlinks. + */ +Directory(fs, dirname) :- + Filesystem(fs), + {{ + int r; + CLEANUP_FREE char *relative_dirname = NULL; + struct stat statbuf; + + if (dirname[0] != '/') return 0; + r = get_mount (fs, dirname, &relative_dirname); + if (r != 1) return r; + r = stat (relative_dirname, &statbuf); + if (r == -1) { + if (errno == ENOENT || errno == ENOTDIR || errno == ELOOP) + return 0; + perror (relative_dirname); + return -1; + } + return S_ISDIR (statbuf.st_mode); + }}. + +/* Symlink(fs, filename) is true if filename is a symlink. */ +Symlink(fs, filename) :- + Filesystem(fs), + {{ + int r; + CLEANUP_FREE char *relative_filename = NULL; + struct stat statbuf; + + if (filename[0] != '/') return 0; + r = get_mount (fs, filename, &relative_filename); + if (r != 1) return r; + r = stat (relative_filename, &statbuf); + if (r == -1) { + if (errno == ENOENT || errno == ENOTDIR || errno == ELOOP) + return 0; + perror (relative_filename); + return -1; + } + return S_ISLNK (statbuf.st_mode); + }}. + +/* grub or grub2 /boot */ +GrubBoot(fs) :- + Filesystem(fs), + File(fs, "/grub/menu.lst"), + File(fs, "/grub/grub.conf"), + File(fs, "/grub2/grub.cfg"). + +/* FreeBSD root. */ +FreeBSDRoot(fs) :- + Filesystem(fs), + Directory(fs, "/bin"), + Directory(fs, "/etc"), + File(fs, "/etc/freebsd-update.conf"), + File(fs, "/etc/fstab"). + +/* NetBSD root. */ +NetBSDRoot(fs) :- + Filesystem(fs), + Directory(fs, "/bin"), + Directory(fs, "/etc"), + File(fs, "/netbsd"), + File(fs, "/etc/fstab"), + File(fs, "/etc/release"). + +/* OpenBSD root. */ +OpenBSDRoot(fs) :- + Filesystem(fs), + Directory(fs, "/bin"), + Directory(fs, "/etc"), + File(fs, "/bsd"), + File(fs, "/etc/fstab"), + File(fs, "/etc/motd"). + +/* Hurd root. */ +HurdRoot(fs) :- + Filesystem(fs), + File(fs, "/hurd/console"), + File(fs, "/hurd/hello"), + File(fs, "/hurd/null"). + +/* Minix root. */ +MinixRoot(fs) :- + Filesystem(fs), + File(fs, "/service/vm"), + File(fs, "/etc/fstab"), + File(fs, "/etc/version"). + +/* Linux root (any distro). */ +LinuxRoot(fs) :- + Filesystem(fs), + Directory(fs, "/etc"), + File(fs, "/etc/fstab"), + (Directory(fs, "/bin"); Symlink(fs, "/bin")), + !FreeBSDRoot(fs), + !NetBSDRoot(fs), + !OpenBSDRoot(fs), + !HurdRoot(fs), + !MinixRoot(fs). + +/* Is it Linux using /etc/os-release? (Linux systemd). */ +LinuxRootWithOSRelease(fs) :- + LinuxRoot(fs), + File(fs, "/etc/os-release"). + +Distro(fs, distro) :- + LinuxRootWithOSRelease(fs), + (distro)?={{ + int r; + CLEANUP_FREE char *distro = NULL; + if ((r = get_distro_from_os_release (fs, &distro)) <= 0) + return r; + set_distro (distro); + return 0; + }}. + +Version(fs, major, minor) :- + LinuxRootWithOSRelease(fs), + (major, minor)?={{ + int r; + CLEANUP_FREE char *major = NULL, *minor = NULL; + if ((r = get_version_from_os_release (fs, &major, &minor)) <= 0) + return r; + set_major_minor (major, minor); + return 0; + }}. + +ProductName(fs, product_name) :- + LinuxRootWithOSRelease(fs), + (product_name)?={{ + int r; + CLEANUP_FREE char *product_name = NULL; + if ((r = get_product_name_from_os_release (fs, &product_name)) <= 0) + return r; + set_product_name (product_name); + return 0; + }}. + +/* Is it Linux using /etc/lsb-release? (Linux Standards Base). */ +LinuxRootWithLSBRelease(fs) :- + LinuxRoot(fs), + File(fs, "/etc/lsb-release"), + !LinuxRootWithOSRelease(fs). /* prefer /etc/os-release */ + +Distro(fs, distro) :- + LinuxRootWithLSBRelease(fs), + (distro)?={{ + int r; + CLEANUP_FREE char *distro = NULL; + if ((r = get_distro_from_lsb_release (fs, &distro)) <= 0) + return r; + set_distro (distro); + return 0; + }}. + +Version(fs, major, minor) :- + LinuxRootWithLSBRelease(fs), + (major, minor)?={{ + int r; + CLEANUP_FREE char *major = NULL, *minor = NULL; + if ((r = get_version_from_lsb_release (fs, &major, &minor)) <= 0) + return r; + set_major_minor (major, minor); + return 0; + }}. + +ProductName(fs, product_name) :- + LinuxRootWithLSBRelease(fs), + (product_name)?={{ + int r; + CLEANUP_FREE char *product_name = NULL; + if ((r = get_product_name_from_lsb_release (fs, &product_name)) <= 0) + return r; + set_product_name (product_name); + return 0; + }}. + +/* Fall back on /etc/*-release files to determine the distro, version and + * product name. + */ +LinuxRootWithReleaseFile(fs, "/etc/oracle-release") :- + LinuxRoot(fs), + !LinuxRootWithOSRelease(fs), !LinuxRootWithLSBRelease(fs), + File(fs, "/etc/oracle-release"). +Distro(fs, "oracle-linux") :- + LinuxRootWithReleaseFile(fs, "/etc/oracle-release"). +Version(fs, major, minor) :- + LinuxRootWithReleaseFile(fs, "/etc/oracle-release"), + (major, minor)={{ + CLEANUP_FREE char *major = NULL, *minor = NULL; + if (get_version_from_oracle_release (fs, &major, &minor) == -1) + return -1; + set_major_minor (major, minor); + return 0; + }}. + +LinuxRootWithReleaseFile(fs, "/etc/centos-release") :- + LinuxRoot(fs), + !LinuxRootWithOSRelease(fs), !LinuxRootWithLSBRelease(fs), + File(fs, "/etc/centos-release"). +Distro(fs, "centos") :- + LinuxRootWithReleaseFile(fs, "/etc/centos-release"). +Version(fs, major, minor) :- + LinuxRootWithReleaseFile(fs, "/etc/centos-release"), + (major, minor)={{ + CLEANUP_FREE char *major = NULL, *minor = NULL; + if (get_version_from_centos_release (fs, &major, &minor) == -1) + return -1; + set_major_minor (major, minor); + return 0; + }}. + +LinuxRootWithReleaseFile(fs, "/etc/altlinux-release") :- + LinuxRoot(fs), + !LinuxRootWithOSRelease(fs), !LinuxRootWithLSBRelease(fs), + File(fs, "/etc/altlinux-release"). +Distro(fs, "altlinux") :- + LinuxRootWithReleaseFile(fs, "/etc/altlinux-release"). +Version(fs, major, minor) :- + LinuxRootWithReleaseFile(fs, "/etc/altlinux-release"), + (major, minor)={{ + CLEANUP_FREE char *major = NULL, *minor = NULL; + if (get_version_from_altlinux_release (fs, &major, &minor) == -1) + return -1; + set_major_minor (major, minor); + return 0; + }}. + +/* Handle the fallback case of /etc/redhat-release. */ +LinuxRootWithReleaseFile(fs, "/etc/redhat-release") :- + LinuxRoot(fs), + !LinuxRootWithOSRelease(fs), !LinuxRootWithLSBRelease(fs), + !LinuxRootWithReleaseFile(fs, "/etc/oracle-release"), + !LinuxRootWithReleaseFile(fs, "/etc/centos-release"), + !LinuxRootWithReleaseFile(fs, "/etc/altlinux-release"), + File(fs, "/etc/redhat-release"). +Distro(fs, "fedora") :- + LinuxRootWithReleaseFile(fs, "/etc/redhat-release"), + {{ return match_redhat_release_fedora (fs); }}. +Distro(fs, "rhel") :- + LinuxRootWithReleaseFile(fs, "/etc/redhat-release"), + {{ return match_redhat_release_rhel (fs); }}. +Distro(fs, "centos") :- + LinuxRootWithReleaseFile(fs, "/etc/redhat-release"), + {{ return match_redhat_release_centos (fs); }}. +Distro(fs, "scientificlinux") :- + LinuxRootWithReleaseFile(fs, "/etc/redhat-release"), + {{ return match_redhat_release_scientific_linux (fs); }}. +Distro(fs, "redhat-based") :- + LinuxRootWithReleaseFile(fs, "/etc/redhat-release"), + !Distro(fs, "fedora"), + !Distro(fs, "rhel"), + !Distro(fs, "centos"), + !Distro(fs, "scientificlinux"). + +Version(fs, major, minor) :- + LinuxRootWithReleaseFile(fs, "/etc/redhat-release"), + (major, minor)={{ + CLEANUP_FREE char *major = NULL, *minor = NULL; + if (get_version_from_redhat_release (fs, &major, &minor) == -1) + return -1; + set_major_minor (major, minor); + return 0; + }}. + +/* Get the product name from a generic Linux release file. */ +ProductName(fs, product_name) :- + LinuxRootWithReleaseFile(fs, release_file), + (product_name)={{ + CLEANUP_FREE char *product_name = NULL; + if (get_product_name_from_release_file (fs, release_file, + &product_name) == -1) + return -1; + set_product_name (product_name); + return 0; + }}. + +/* XXX debian, arch-linux etc release files */ + +/* XXX Linux architecture, fstab, hostname */ + + + +/* XXX CoreOS etc. */ + + + + + + + + +/* +Has_fstab(rootfs) :- + Unix_root(fs), + File(rootfs, "/etc/fstab"). +Mount(rootfs, dev, mountpoint) :- + Has_fstab(rootfs), + (dev, mountpoint)*={{ + // code to return (dev, mountpoint) pairs from /etc/fstab + }}. +*/ diff --git a/inspection/mount.c b/inspection/mount.c new file mode 100644 index 0000000..2186bbd --- /dev/null +++ b/inspection/mount.c @@ -0,0 +1,591 @@ +/* guestfs-inspection + * Copyright (C) 2009-2015 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. + */ + +#include <config.h> + +#include <stdio.h> +#include <stdlib.h> +#include <stdbool.h> +#include <string.h> +#include <unistd.h> +#include <fcntl.h> +#include <dirent.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <sys/mount.h> +#include <errno.h> +#include <error.h> + +#include "c-ctype.h" + +#include "guestfs-internal-all.h" + +#include "inspection.h" +#include "stringsbuf.h" + +/* If root device is an ext2 filesystem, this is the major and minor. + * This is so we can ignore this device from the point of view of the + * user, eg. in guestfs_list_devices and many other places. + */ +static dev_t root_device = 0; + +/* A temporary directory where we place all the mountpoints. */ +static char mountpoints[] = "/tmp/mp.XXXXXX"; + +static void init_mount (void) __attribute__((constructor)); + +static void +init_mount (void) +{ + struct stat statbuf; + + if (stat ("/", &statbuf) == 0) + root_device = statbuf.st_dev; + + if (mkdtemp (mountpoints) == NULL) + perror ("mkdtemp"); +} + +static void free_mount (void) __attribute__((destructor)); + +static void +free_mount (void) +{ + DIR *dir; + struct dirent *d; + + /* Unmount all mountpoints in the temporary directory, then + * delete those directories and the parent. + */ + dir = opendir (mountpoints); + if (!dir) { + perror (mountpoints); + return; + } + + for (;;) { + errno = 0; + d = readdir (dir); + if (!d) break; + + if (d->d_name[0] != '.') { + CLEANUP_FREE char *mp; + + if (asprintf (&mp, "%s/%s", mountpoints, d->d_name) == -1) { + perror ("asprintf"); + continue; + } + + if (umount2 (mp, MNT_DETACH) == -1) /* lazy umount */ + perror (mp); + + if (rmdir (mp) == -1) + perror (mp); + } + } + + /* Check readdir didn't fail */ + if (errno != 0) { + perror ("readdir"); + return; + } + + /* Close the directory handle */ + if (closedir (dir) == -1) { + perror ("closedir"); + return; + } + + if (rmdir (mountpoints) == -1) + perror (mountpoints); +} + +/* Return true iff device is the root device (and therefore should be + * ignored from the point of view of user calls). + */ +static int +is_root_device_stat (struct stat *statbuf) +{ + if (statbuf->st_rdev == root_device) return 1; + return 0; +} + +static int +is_root_device (const char *device) +{ + struct stat statbuf; + + if (stat (device, &statbuf) == -1) { + perror (device); + return 0; + } + + return is_root_device_stat (&statbuf); +} + +typedef int (*block_dev_func_t) (const char *dev, struct stringsbuf *r); + +/* Execute a given function for each discovered block device */ +static char ** +foreach_block_device (block_dev_func_t func) +{ + DECLARE_STRINGSBUF (r); + DIR *dir; + struct dirent *d; + char dev_path[256]; + int fd; + bool err = false; + + dir = opendir ("/sys/block"); + if (!dir) { + perror ("opendir: /sys/block"); + return NULL; + } + + for (;;) { + errno = 0; + d = readdir (dir); + if (!d) break; + + if (STREQLEN (d->d_name, "sd", 2) || + STREQLEN (d->d_name, "hd", 2) || + STREQLEN (d->d_name, "ubd", 3) || + STREQLEN (d->d_name, "vd", 2) || + STREQLEN (d->d_name, "sr", 2)) { + snprintf (dev_path, sizeof dev_path, "/dev/%s", d->d_name); + + /* Ignore the root device. */ + if (is_root_device (dev_path)) + continue; + + /* RHBZ#514505: Some versions of qemu <= 0.10 add a + * CD-ROM device even though we didn't request it. Try to + * detect this by seeing if the device contains media. + */ + fd = open (dev_path, O_RDONLY|O_CLOEXEC); + if (fd == -1) { + perror (dev_path); + continue; + } + close (fd); + + /* Call the map function for this device */ + if ((*func)(d->d_name, &r) != 0) { + err = true; + break; + } + } + } + + /* Check readdir didn't fail */ + if (errno != 0) { + perror ("readdir: /sys/block"); + free_stringslen (r.argv, r.size); + closedir (dir); + return NULL; + } + + /* Close the directory handle */ + if (closedir (dir) == -1) { + perror ("closedir: /sys/block"); + free_stringslen (r.argv, r.size); + return NULL; + } + + /* Free the result list on error */ + if (err) { + free_stringslen (r.argv, r.size); + return NULL; + } + + /* Sort the devices. */ + if (r.size > 0) + sort_device_names (r.argv, r.size); + + /* NULL terminate the list */ + end_stringsbuf (&r); + + return r.argv; +} + +/* Add a device to the list of devices */ +static int +add_device (const char *device, struct stringsbuf *r) +{ + char dev_path[256]; + snprintf (dev_path, sizeof dev_path, "/dev/%s", device); + + add_string (r, dev_path); + + return 0; +} + +char ** +get_all_block_devices (void) +{ + return foreach_block_device (add_device); +} + +static int +add_partitions (const char *device, struct stringsbuf *r) +{ + char devdir[256]; + + /* Open the device's directory under /sys/block */ + snprintf (devdir, sizeof devdir, "/sys/block/%s", device); + + DIR *dir = opendir (devdir); + if (!dir) { + perror (devdir); + free_stringslen (r->argv, r->size); + return -1; + } + + /* Look in /sys/block/<device>/ for entries starting with <device> + * e.g. /sys/block/sda/sda1 + */ + errno = 0; + struct dirent *d; + while ((d = readdir (dir)) != NULL) { + if (STREQLEN (d->d_name, device, strlen (device))) { + char part[256]; + snprintf (part, sizeof part, "/dev/%s", d->d_name); + + add_string (r, part); + } + } + + /* Check if readdir failed */ + if (0 != errno) { + perror (devdir); + free_stringslen (r->argv, r->size); + closedir (dir); + return -1; + } + + /* Close the directory handle */ + if (closedir (dir) == -1) { + perror (device); + free_stringslen (r->argv, r->size); + return -1; + } + + return 0; +} + +char ** +get_all_partitions (void) +{ + return foreach_block_device (add_partitions); +} + +char ** +get_all_mddevs (void) +{ + error (EXIT_FAILURE, 0, "%s: not implemented", __func__); + return NULL; +} + +char ** +get_all_lvs (void) +{ + error (EXIT_FAILURE, 0, "%s: not implemented", __func__); + return NULL; +} + +char ** +get_all_ldmvols (void) +{ + error (EXIT_FAILURE, 0, "%s: not implemented", __func__); + return NULL; +} + +char ** +get_all_ldmparts (void) +{ + error (EXIT_FAILURE, 0, "%s: not implemented", __func__); + return NULL; +} + +char ** +get_all_btrfs_subvolumes (const char *fs) +{ + error (EXIT_FAILURE, 0, "%s: not implemented", __func__); + return NULL; +} + +static char * +get_blkid_tag (const char *device, const char *tag) +{ + char *out; + CLEANUP_FREE char *err = NULL; + int r; + size_t len; + + r = commandr (&out, &err, + "blkid", + /* Adding -c option kills all caching, even on RHEL 5. */ + "-c", "/dev/null", + "-o", "value", "-s", tag, device, NULL); + if (r != 0 && r != 2) { + if (r >= 0) + fprintf (stderr, "%s: %s (blkid returned %d)\n", device, err, r); + else + fprintf (stderr, "%s: %s\n", device, err); + free (out); + return NULL; + } + + if (r == 2) { /* means UUID etc not found */ + free (out); + out = strdup (""); + if (out == NULL) + perror ("strdup"); + return out; + } + + /* Trim trailing \n if present. */ + len = strlen (out); + if (len > 0 && out[len-1] == '\n') + out[len-1] = '\0'; + + return out; /* caller frees */ +} + +char * +get_vfs_type (const char *fs) +{ + return get_blkid_tag (fs, "TYPE"); +} + +/* Test if sfdisk is recent enough to have --part-type, to be used instead + * of --print-id and --change-id. + */ +static int +test_sfdisk_has_part_type (void) +{ + static int tested = -1; + int r; + CLEANUP_FREE char *out = NULL, *err = NULL; + + if (tested != -1) + return tested; + + r = command (&out, &err, "sfdisk", "--help", NULL); + if (r == -1) { + fprintf (stderr, "%s: %s\n", "sfdisk --help", err); + return -1; + } + + tested = strstr (out, "--part-type") != NULL; + return tested; +} + +static char * +part_to_dev (const char *part) +{ + int err = 1; + size_t n = strlen (part); + char *r; + + while (n >= 1 && c_isdigit (part[n-1])) { + err = 0; + n--; + } + + if (err) { + fprintf (stderr, "device name is not a partition\n"); + return NULL; + } + + r = strndup (part, n); + if (r == NULL) { + perror ("strdup"); + return NULL; + } + + return r; +} + +static int +part_to_partnum (const char *part) +{ + int err = 1; + size_t n = strlen (part); + int r; + + while (n >= 1 && c_isdigit (part[n-1])) { + err = 0; + n--; + } + + if (err) { + fprintf (stderr, "device name is not a partition\n"); + return -1; + } + + if (sscanf (&part[n], "%d", &r) != 1) { + fprintf (stderr, "could not parse number\n"); + return -1; + } + + return r; +} + +int +get_partition_mbr_id (const char *fs) +{ + CLEANUP_FREE char *device; + int partnum; + char partnum_str[16]; + const char *param = + test_sfdisk_has_part_type () ? "--part-type" : "--print-id"; + CLEANUP_FREE char *out = NULL, *err = NULL; + int r; + unsigned id; + + /* Get the block device and partition number from the filesystem + * string. + */ + device = part_to_dev (fs); + if (device == NULL) + return -1; + partnum = part_to_partnum (fs); + if (partnum == -1) + return -1; + snprintf (partnum_str, sizeof partnum_str, "%d", partnum); + + r = command (&out, &err, "sfdisk", param, device, partnum_str, NULL); + if (r == -1) { + fprintf (stderr, "sfdisk %s: %s\n", param, err); + return -1; + } + + /* It's printed in hex ... */ + if (sscanf (out, "%x", &id) != 1) { + fprintf (stderr, "sfdisk --print-id: cannot parse output: %s\n", out); + return -1; + } + + return id; +} + +/* When mounting filesystems, we place them in temporary directories + * under 'mountpoints'. We name the temporary directory after the + * device name, but since device names contain '/' characters, we have + * to mangle the name. + */ +static char * +get_mount_name (const char *fs) +{ + char *ret; + size_t i; + + if (asprintf (&ret, "%s/%s", mountpoints, fs) == -1) { + perror ("asprintf"); + return NULL; + } + + for (i = strlen (mountpoints) + 1; i < strlen (ret); ++i) { + if (ret[i] == '/') + ret[i] = '_'; + } + + return ret; /* caller frees */ +} + +int +is_mountable (const char *fs) +{ + CLEANUP_FREE char *mp = get_mount_name (fs); + struct stat statbuf; + int r; + CLEANUP_FREE char *err = NULL; + + if (stat (mp, &statbuf) == 0 && S_ISDIR (statbuf.st_mode)) + return 1; /* mountable, and mounted already */ + + /* Try to create the mountpoint. */ + if (mkdir (mp, 0700) == -1) { + perror (mp); + return -1; + } + + /* Try to mount the filesystem. */ + r = command (NULL, &err, + "mount", "-o", "ro", fs, mp, NULL); + if (r == -1) { + fprintf (stderr, "mount: %s: %s\n", fs, err); + + /* Now hack things for the *BSDs. */ + /* FreeBSD fs is a variant of ufs called ufs2 ... */ + free (err); err = NULL; + r = command (NULL, &err, + "mount", "-o", "ro,ufstype=ufs2", fs, mp, NULL); + if (r == -1) { + fprintf (stderr, "mount [ufs2]: %s: %s\n", fs, err); + + /* while NetBSD and OpenBSD use another variant labeled 44bsd */ + free (err); err = NULL; + r = command (NULL, &err, + "mount", "-o", "ro,ufstype=44bsd", fs, mp, NULL); + if (r == -1) { + fprintf (stderr, "mount [44bsd]: %s: %s\n", fs, err); + + /* Mount failed, so remove the mountpoint. */ + rmdir (mp); + return 0; + } + } + } + + /* Mount succeeded. */ + return 1; +} + +int +get_mount (const char *fs, const char *filename, char **relative_filename) +{ + CLEANUP_FREE char *mp = NULL; + int r; + + if (filename[0] != '/') { + fprintf (stderr, "get_mount: filename is not an absolute path: %s\n", + filename); + return -1; + } + + r = is_mountable (fs); + if (r == -1) + return -1; + if (r == 0) { + fprintf (stderr, "get_mount: called on non-mountable filesystem: %s\n", + fs); + return -1; + } + + mp = get_mount_name (fs); + + /* Construct the filename relative to the mountpoint. */ + if (asprintf (relative_filename, "%s%s", mp, filename) == -1) { + perror ("asprintf"); + return -1; + } + + return 0; +} diff --git a/inspection/stringsbuf.c b/inspection/stringsbuf.c new file mode 100644 index 0000000..338134e --- /dev/null +++ b/inspection/stringsbuf.c @@ -0,0 +1,254 @@ +/* libguestfs - the guestfsd daemon + * Copyright (C) 2009-2015 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. + */ + +#include <config.h> + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <errno.h> +#include <error.h> +#include <assert.h> + +#include "guestfs-internal-all.h" + +#include "stringsbuf.h" + +void +add_string_nodup (struct stringsbuf *sb, char *str) +{ + char **new_argv; + + if (sb->size >= sb->alloc) { + sb->alloc += 64; + new_argv = realloc (sb->argv, sb->alloc * sizeof (char *)); + if (new_argv == NULL) + error (EXIT_FAILURE, errno, "realloc"); + sb->argv = new_argv; + } + + sb->argv[sb->size] = str; + sb->size++; +} + +void +add_string (struct stringsbuf *sb, const char *str) +{ + char *new_str = NULL; + + if (str) { + new_str = strdup (str); + if (new_str == NULL) + error (EXIT_FAILURE, errno, "strdup"); + } + + add_string_nodup (sb, new_str); +} + +void +add_sprintf (struct stringsbuf *sb, const char *fs, ...) +{ + va_list args; + char *str; + int r; + + va_start (args, fs); + r = vasprintf (&str, fs, args); + va_end (args); + if (r == -1) + error (EXIT_FAILURE, errno, "vasprintf"); + + add_string_nodup (sb, str); +} + +void +end_stringsbuf (struct stringsbuf *sb) +{ + add_string_nodup (sb, NULL); +} + +void +free_stringsbuf (struct stringsbuf *sb) +{ + if (sb->argv != NULL) + free_stringslen (sb->argv, sb->size); +} + +size_t +count_strings (char *const *argv) +{ + size_t argc; + + for (argc = 0; argv[argc] != NULL; ++argc) + ; + return argc; +} + +static int +compare (const void *vp1, const void *vp2) +{ + char * const *p1 = (char * const *) vp1; + char * const *p2 = (char * const *) vp2; + return strcmp (*p1, *p2); +} + +void +sort_strings (char **argv, size_t len) +{ + qsort (argv, len, sizeof (char *), compare); +} + +void +free_strings (char **argv) +{ + size_t argc; + + if (!argv) + return; + + for (argc = 0; argv[argc] != NULL; ++argc) + free (argv[argc]); + free (argv); +} + +void +free_stringslen (char **argv, size_t len) +{ + size_t i; + + if (!argv) + return; + + for (i = 0; i < len; ++i) + free (argv[i]); + free (argv); +} + +/* Compare device names (including partition numbers if present). + * https://rwmj.wordpress.com/2011/01/09/how-are-linux-drives-named-beyond-d... + */ +int +compare_device_names (const char *a, const char *b) +{ + size_t alen, blen; + int r; + int a_partnum, b_partnum; + + /* Skip /dev/ prefix if present. */ + if (STRPREFIX (a, "/dev/")) + a += 5; + if (STRPREFIX (b, "/dev/")) + b += 5; + + /* Skip sd/hd/ubd/vd. */ + alen = strcspn (a, "d"); + blen = strcspn (b, "d"); + assert (alen > 0 && alen <= 2); + assert (blen > 0 && blen <= 2); + a += alen + 1; + b += blen + 1; + + /* Get device name part, that is, just 'a', 'ab' etc. */ + alen = strcspn (a, "0123456789"); + blen = strcspn (b, "0123456789"); + + /* If device name part is longer, it is always greater, eg. + * "/dev/sdz" < "/dev/sdaa". + */ + if (alen != blen) + return alen - blen; + + /* Device name parts are the same length, so do a regular compare. */ + r = strncmp (a, b, alen); + if (r != 0) + return r; + + /* Compare partitions numbers. */ + a += alen; + b += alen; + + /* If no partition numbers, bail -- the devices are the same. This + * can happen in one peculiar case: where you have a mix of devices + * with different interfaces (eg. /dev/sda and /dev/vda). + * (RHBZ#858128). + */ + if (!*a && !*b) + return 0; + + r = sscanf (a, "%d", &a_partnum); + assert (r == 1); + r = sscanf (b, "%d", &b_partnum); + assert (r == 1); + + return a_partnum - b_partnum; +} + +static int +compare_device_names_vp (const void *vp1, const void *vp2) +{ + char * const *p1 = (char * const *) vp1; + char * const *p2 = (char * const *) vp2; + return compare_device_names (*p1, *p2); +} + +void +sort_device_names (char **argv, size_t len) +{ + qsort (argv, len, sizeof (char *), compare_device_names_vp); +} + +char * +concat_strings (char *const *argv) +{ + return join_strings ("", argv); +} + +char * +join_strings (const char *separator, char *const *argv) +{ + size_t i, len, seplen, rlen; + char *r; + + seplen = strlen (separator); + + len = 0; + for (i = 0; argv[i] != NULL; ++i) { + if (i > 0) + len += seplen; + len += strlen (argv[i]); + } + len++; /* for final \0 */ + + r = malloc (len); + if (r == NULL) + error (EXIT_FAILURE, errno, "malloc"); + + rlen = 0; + for (i = 0; argv[i] != NULL; ++i) { + if (i > 0) { + memcpy (&r[rlen], separator, seplen); + rlen += seplen; + } + len = strlen (argv[i]); + memcpy (&r[rlen], argv[i], len); + rlen += len; + } + r[rlen] = '\0'; + + return r; +} diff --git a/inspection/stringsbuf.h b/inspection/stringsbuf.h new file mode 100644 index 0000000..4a26ffb --- /dev/null +++ b/inspection/stringsbuf.h @@ -0,0 +1,56 @@ +/* libguestfs - the guestfsd daemon + * Copyright (C) 2009-2015 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. + */ + +#ifndef GUESTFS_INSPECTION_STRINGSBUF_H +#define GUESTFS_INSPECTION_STRINGSBUF_H + +/* Growable strings buffer. */ +struct stringsbuf { + char **argv; + size_t size; + size_t alloc; +}; +#define DECLARE_STRINGSBUF(v) \ + struct stringsbuf (v) = { .argv = NULL, .size = 0, .alloc = 0 } + +/* Append a string to the strings buffer. + * + * add_string_nodup: don't copy the string. + * add_string: copy the string. + * end_stringsbuf: NULL-terminate the buffer. + */ +extern void add_string_nodup (struct stringsbuf *sb, char *str); +extern void add_string (struct stringsbuf *sb, const char *str); +extern void add_sprintf (struct stringsbuf *sb, const char *fs, ...) + __attribute__((format (printf,2,3))); +extern void end_stringsbuf (struct stringsbuf *sb); +extern void free_stringsbuf (struct stringsbuf *sb); + +extern size_t count_strings (char *const *argv); +extern void sort_strings (char **argv, size_t len); +extern void free_strings (char **argv); +extern void free_stringslen (char **argv, size_t len); + +extern void sort_device_names (char **argv, size_t len); +extern int compare_device_names (const char *a, const char *b); + +/* Concatenate strings, optionally with a separator string between each. */ +extern char *concat_strings (char *const *argv); +extern char *join_strings (const char *separator, char *const *argv); + +#endif /* GUESTFS_INSPECTION_STRINGSBUF_H */ diff --git a/po/POTFILES b/po/POTFILES index aca174d..b6332f6 100644 --- a/po/POTFILES +++ b/po/POTFILES @@ -258,6 +258,11 @@ gobject/src/struct-version.c gobject/src/struct-xattr.c gobject/src/struct-xfsinfo.c gobject/src/tristate.c +inspection/detect.c +inspection/facts.c +inspection/inspection.c +inspection/mount.c +inspection/stringsbuf.c inspector/inspector.c java/com_redhat_et_libguestfs_GuestFS.c lua/lua-guestfs.c diff --git a/src/guestfs.pod b/src/guestfs.pod index a4d7d57..dfa8fc1 100644 --- a/src/guestfs.pod +++ b/src/guestfs.pod @@ -3505,6 +3505,7 @@ Other libguestfs topics: L<guestfs-building(1)>, L<guestfs-faq(1)>, L<guestfs-hacking(1)>, +L<guestfs-inspection(8)>, L<guestfs-internals(1)>, L<guestfs-performance(1)>, L<guestfs-release-notes(1)>, -- 2.5.0

--- inspection/inspection.rules | 20 +++++++++++++++----- 1 file changed, 15 insertions(+), 5 deletions(-) diff --git a/inspection/inspection.rules b/inspection/inspection.rules index 646d28f..40c7400 100644 --- a/inspection/inspection.rules +++ b/inspection/inspection.rules @@ -50,40 +50,48 @@ Partition(dev) :- }}. /* LVM2 logical volumes. */ +/* LV(dev) :- (dev)*={{ CLEANUP_FREE_STRING_LIST char **devs = get_all_lvs (); if (devs == NULL) return -1; for (size_t i = 0; devs[i] != NULL; ++i) set_dev (devs[i]); return 0; - }}. + }}. */ +LV(dev) :- false. /* /dev/md* devices. */ +/* MDDev(dev) :- (dev)*={{ CLEANUP_FREE_STRING_LIST char **devs = get_all_mddevs (); if (devs == NULL) return -1; for (size_t i = 0; devs[i] != NULL; ++i) set_dev (devs[i]); return 0; - }}. + }}. */ +MDDev(dev) :- false. /* Windows LDM voumes. */ +/* LDMVol(dev) :- (dev)*={{ CLEANUP_FREE_STRING_LIST char **devs = get_all_ldmvols (); if (devs == NULL) return -1; for (size_t i = 0; devs[i] != NULL; ++i) set_dev (devs[i]); return 0; - }}. + }}. */ +LDMVol(dev) :- false. /* Windows LDM partitions. */ +/* LDMPart(dev) :- (dev)*={{ CLEANUP_FREE_STRING_LIST char **devs = get_all_ldmparts (); if (devs == NULL) return -1; for (size_t i = 0; devs[i] != NULL; ++i) set_dev (devs[i]); return 0; - }}. + }}. */ +LDMPart(dev) :- false. /* Device(dev) is just a group name for block devices, partitions etc. */ Device(dev) :- @@ -105,6 +113,7 @@ Mountable(fs) :- {{ return is_mountable (fs); }}. /* Where a filesystem is btrfs and mountable, get the subvolumes. */ +/* BtrfsSubvolume(subvol) :- Device(fs), Mountable(fs), @@ -123,7 +132,8 @@ BtrfsSubvolume(subvol) :- } return 0; }}. -VFSType(subvol, "btrfs") :- BtrfsSubvolume(subvol). +VFSType(subvol, "btrfs") :- BtrfsSubvolume(subvol). */ +BtrfsSubvolume(subvol) :- false. /* Ignore all *_member types. In libblkid these are returned * for things which are members of some RAID or LVM set, most -- 2.5.0