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",     required_argument, NULL, 'q'           },
  65                 { NULL,        0,                 NULL, 0             }
  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                         help();
  79                         return 0;
  80
  81                 case ARG_VERSION:
  82                         puts(PACKAGE_STRING);
  83                         puts(DISTRIBUTION);
  84                         puts(SYSTEMD_FEATURES);
  85                         return 0;
  86
  87                 case 'q':
  88                         arg_quiet = true;
  89                         break;
  90
  91                 case 'c':
  92                         arg_mode = ONLY_CONTAINER;
  93                         break;
  94
  95                 case 'v':
  96                         arg_mode = ONLY_VM;
  97                         break;
  98
  99                 case '?':
 100                         return -EINVAL;
 101
 102                 default:
 103                         log_error("Unknown option code %c", c);
 104                         return -EINVAL;
 105                 }
 106         }
 107
 108         if (optind < argc) {
 109                 help();
 110                 return -EINVAL;
 111         }
 112
 113         return 1;
 114 }
 115
 116 int main(int argc, char *argv[]) {
 117         const char *id = NULL;
 118         int retval, r;
 119
 120         /* This is mostly intended to be used for scripts which want
 121          * to detect whether we are being run in a virtualized
 122          * environment or not */
 123
 124         log_parse_environment();
 125         log_open();
 126
 127         r = parse_argv(argc, argv);
 128         if (r <= 0)
 129                 return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
 130
 131         switch (arg_mode) {
 132
 133         case ANY_VIRTUALIZATION: {
 134                 Virtualization v;
 135
 136                 v = detect_virtualization(&id);
 137                 if (v < 0) {
 138                         log_error("Failed to check for virtualization: %s", strerror(-v));
 139                         return EXIT_FAILURE;
 140                 }
 141
 142                 retval = v != VIRTUALIZATION_NONE ? EXIT_SUCCESS : EXIT_FAILURE;
 143                 break;
 144         }
 145
 146         case ONLY_CONTAINER:
 147                 r = detect_container(&id);
 148                 if (r < 0) {
 149                         log_error("Failed to check for container: %s", strerror(-r));
 150                         return EXIT_FAILURE;
 151                 }
 152
 153                 retval = r > 0 ? EXIT_SUCCESS : EXIT_FAILURE;
 154                 break;
 155
 156         case ONLY_VM:
 157                 r = detect_vm(&id);
 158                 if (r < 0) {
 159                         log_error("Failed to check for vm: %s", strerror(-r));
 160                         return EXIT_FAILURE;
 161                 }
 162
 163                 retval = r > 0 ? EXIT_SUCCESS : EXIT_FAILURE;
 164                 break;
 165         }
 166
 167         if (!arg_quiet)
 168                 puts(id ? id : "none");
 169
 170         return retval;
 171 }