chiark / gitweb /
detect-virt: beef up tool considerably
authorLennart Poettering <lennart@poettering.net>
Thu, 12 Apr 2012 12:45:50 +0000 (14:45 +0200)
committerLennart Poettering <lennart@poettering.net>
Thu, 12 Apr 2012 12:46:41 +0000 (14:46 +0200)
src/detect-virt.c

index b3d8fb5..bdcd27d 100644 (file)
 #include <stdbool.h>
 #include <errno.h>
 #include <string.h>
+#include <getopt.h>
 
 #include "util.h"
 #include "virt.h"
+#include "build.h"
+
+static bool arg_quiet = false;
+static enum {
+        ANY_VIRTUALIZATION,
+        ONLY_VM,
+        ONLY_CONTAINER
+} arg_mode = ANY_VIRTUALIZATION;
+
+static int help(void) {
+
+        printf("%s [OPTIONS...]\n\n"
+               "Detect execution in a virtualized environment.\n\n"
+               "  -h --help             Show this help\n"
+               "     --version          Show package version\n"
+               "  -c --container        Only detect whether we are run in a container\n"
+               "  -v --vm               Only detect whether we are run in a VM\n"
+               "  -q --quiet            Don't output anything, just set return value\n",
+               program_invocation_short_name);
+
+        return 0;
+}
+
+static int parse_argv(int argc, char *argv[]) {
+
+        enum {
+                ARG_VERSION = 0x100
+        };
+
+        static const struct option options[] = {
+                { "help",      no_argument,       NULL, 'h'           },
+                { "version",   no_argument,       NULL, ARG_VERSION   },
+                { "container", no_argument,       NULL, 'c'           },
+                { "vm",        optional_argument, NULL, 'v'           },
+                { "quiet",     required_argument, NULL, 'q'           },
+                { NULL,        0,                 NULL, 0             }
+        };
+
+        int c;
+
+        assert(argc >= 0);
+        assert(argv);
+
+        while ((c = getopt_long(argc, argv, "hqcv", options, NULL)) >= 0) {
+
+                switch (c) {
+
+                case 'h':
+                        help();
+                        return 0;
+
+                case ARG_VERSION:
+                        puts(PACKAGE_STRING);
+                        puts(DISTRIBUTION);
+                        puts(SYSTEMD_FEATURES);
+                        return 0;
+
+                case 'q':
+                        arg_quiet = true;
+                        break;
+
+                case 'c':
+                        arg_mode = ONLY_CONTAINER;
+                        break;
+
+                case 'v':
+                        arg_mode = ONLY_VM;
+                        break;
+
+                case '?':
+                        return -EINVAL;
+
+                default:
+                        log_error("Unknown option code %c", c);
+                        return -EINVAL;
+                }
+        }
+
+        if (optind < argc) {
+                help();
+                return -EINVAL;
+        }
+
+        return 1;
+}
 
 int main(int argc, char *argv[]) {
-        Virtualization r;
-        const char *id;
+        const char *id = NULL;
+        int retval, r;
 
         /* This is mostly intended to be used for scripts which want
          * to detect whether we are being run in a virtualized
          * environment or not */
 
-        r = detect_virtualization(&id);
-        if (r < 0) {
-                log_error("Failed to check for virtualization: %s", strerror(-r));
-                return EXIT_FAILURE;
+        log_parse_environment();
+        log_open();
+
+        r = parse_argv(argc, argv);
+        if (r <= 0)
+                return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
+
+        switch (arg_mode) {
+
+        case ANY_VIRTUALIZATION: {
+                Virtualization v;
+
+                v = detect_virtualization(&id);
+                if (v < 0) {
+                        log_error("Failed to check for virtualization: %s", strerror(-v));
+                        return EXIT_FAILURE;
+                }
+
+                retval = v != VIRTUALIZATION_NONE ? EXIT_SUCCESS : EXIT_FAILURE;
+                break;
+        }
+
+        case ONLY_CONTAINER:
+                r = detect_container(&id);
+                if (r < 0) {
+                        log_error("Failed to check for container: %s", strerror(-r));
+                        return EXIT_FAILURE;
+                }
+
+                retval = r > 0 ? EXIT_SUCCESS : EXIT_FAILURE;
+                break;
+
+        case ONLY_VM:
+                r = detect_vm(&id);
+                if (r < 0) {
+                        log_error("Failed to check for vm: %s", strerror(-r));
+                        return EXIT_FAILURE;
+                }
+
+                retval = r > 0 ? EXIT_SUCCESS : EXIT_FAILURE;
+                break;
         }
 
-        if (r > 0)
+        if (id && !arg_quiet)
                 puts(id);
 
-        return r > 0 ? EXIT_SUCCESS : EXIT_FAILURE;
+        return retval;
 }