src/detect-virt/detect-virt.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2010 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <stdlib.h>
  23 #include <stdbool.h>
  24 #include <errno.h>
  25 #include <string.h>
  26 #include <getopt.h>
  27
  28 #include "util.h"
  29 #include "virt.h"
  30 #include "build.h"
  31
  32 static bool arg_quiet = false;
  33 static enum {
  34         ANY_VIRTUALIZATION,
  35         ONLY_VM,
  36         ONLY_CONTAINER
  37 } arg_mode = ANY_VIRTUALIZATION;
  38
  39 static int help(void) {
  40
  41         printf("%s [OPTIONS...]\n\n"
  42                "Detect execution in a virtualized environment.\n\n"
  43                "  -h --help             Show this help\n"
  44                "     --version          Show package version\n"
  45                "  -c --container        Only detect whether we are run in a container\n"
  46                "  -v --vm               Only detect whether we are run in a VM\n"
  47                "  -q --quiet            Don't output anything, just set return value\n",
  48                program_invocation_short_name);
  49
  50         return 0;
  51 }
  52
  53 static int parse_argv(int argc, char *argv[]) {
  54
  55         enum {
  56                 ARG_VERSION = 0x100
  57         };
  58
  59         static const struct option options[] = {
  60                 { "help",      no_argument,       NULL, 'h'           },
  61                 { "version",   no_argument,       NULL, ARG_VERSION   },
  62                 { "container", no_argument,       NULL, 'c'           },
  63                 { "vm",        optional_argument, NULL, 'v'           },
  64                 { "quiet",     no_argument,       NULL, 'q'           },
  65                 {}
  66         };
  67
  68         int c;
  69
  70         assert(argc >= 0);
  71         assert(argv);
  72
  73         while ((c = getopt_long(argc, argv, "hqcv", options, NULL)) >= 0) {
  74
  75                 switch (c) {
  76
  77                 case 'h':
  78                         return help();
  79
  80                 case ARG_VERSION:
  81                         puts(PACKAGE_STRING);
  82                         puts(SYSTEMD_FEATURES);
  83                         return 0;
  84
  85                 case 'q':
  86                         arg_quiet = true;
  87                         break;
  88
  89                 case 'c':
  90                         arg_mode = ONLY_CONTAINER;
  91                         break;
  92
  93                 case 'v':
  94                         arg_mode = ONLY_VM;
  95                         break;
  96
  97                 case '?':
  98                         return -EINVAL;
  99
 100                 default:
 101                         assert_not_reached("Unhandled option");
 102                 }
 103         }
 104
 105         if (optind < argc) {
 106                 help();
 107                 return -EINVAL;
 108         }
 109
 110         return 1;
 111 }
 112
 113 int main(int argc, char *argv[]) {
 114         const char *id = NULL;
 115         int retval = EXIT_SUCCESS;
 116         int r;
 117
 118         /* This is mostly intended to be used for scripts which want
 119          * to detect whether we are being run in a virtualized
 120          * environment or not */
 121
 122         log_parse_environment();
 123         log_open();
 124
 125         r = parse_argv(argc, argv);
 126         if (r <= 0)
 127                 return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
 128
 129         switch (arg_mode) {
 130
 131         case ANY_VIRTUALIZATION: {
 132                 Virtualization v;
 133
 134                 v = detect_virtualization(&id);
 135                 if (v < 0) {
 136                         log_error("Failed to check for virtualization: %s", strerror(-v));
 137                         return EXIT_FAILURE;
 138                 }
 139
 140                 retval = v != VIRTUALIZATION_NONE ? EXIT_SUCCESS : EXIT_FAILURE;
 141                 break;
 142         }
 143
 144         case ONLY_CONTAINER:
 145                 r = detect_container(&id);
 146                 if (r < 0) {
 147                         log_error("Failed to check for container: %s", strerror(-r));
 148                         return EXIT_FAILURE;
 149                 }
 150
 151                 retval = r > 0 ? EXIT_SUCCESS : EXIT_FAILURE;
 152                 break;
 153
 154         case ONLY_VM:
 155                 r = detect_vm(&id);
 156                 if (r < 0) {
 157                         log_error("Failed to check for vm: %s", strerror(-r));
 158                         return EXIT_FAILURE;
 159                 }
 160
 161                 retval = r > 0 ? EXIT_SUCCESS : EXIT_FAILURE;
 162                 break;
 163         }
 164
 165         if (!arg_quiet)
 166                 puts(id ? id : "none");
 167
 168         return retval;
 169 }