src/login/inhibit.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2012 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 <getopt.h>
  23 #include <stdlib.h>
  24 #include <stdio.h>
  25 #include <unistd.h>
  26 #include <fcntl.h>
  27
  28 #include "sd-bus.h"
  29 #include "bus-util.h"
  30 #include "bus-error.h"
  31 #include "util.h"
  32 #include "build.h"
  33 #include "strv.h"
  34 #include "formats-util.h"
  35 #include "process-util.h"
  36 #include "signal-util.h"
  37
  38 static const char* arg_what = "idle:sleep:shutdown";
  39 static const char* arg_who = NULL;
  40 static const char* arg_why = "Unknown reason";
  41 static const char* arg_mode = NULL;
  42
  43 static enum {
  44         ACTION_INHIBIT,
  45         ACTION_LIST
  46 } arg_action = ACTION_INHIBIT;
  47
  48 static int inhibit(sd_bus *bus, sd_bus_error *error) {
  49         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
  50         int r;
  51         int fd;
  52
  53         r = sd_bus_call_method(
  54                         bus,
  55                         "org.freedesktop.login1",
  56                         "/org/freedesktop/login1",
  57                         "org.freedesktop.login1.Manager",
  58                         "Inhibit",
  59                         error,
  60                         &reply,
  61                         "ssss", arg_what, arg_who, arg_why, arg_mode);
  62         if (r < 0)
  63                 return r;
  64
  65         r = sd_bus_message_read_basic(reply, SD_BUS_TYPE_UNIX_FD, &fd);
  66         if (r < 0)
  67                 return r;
  68
  69         r = fcntl(fd, F_DUPFD_CLOEXEC, 3);
  70         if (r < 0)
  71                 return -errno;
  72
  73         return r;
  74 }
  75
  76 static int print_inhibitors(sd_bus *bus, sd_bus_error *error) {
  77         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
  78         const char *what, *who, *why, *mode;
  79         unsigned int uid, pid;
  80         unsigned n = 0;
  81         int r;
  82
  83         r = sd_bus_call_method(
  84                         bus,
  85                         "org.freedesktop.login1",
  86                         "/org/freedesktop/login1",
  87                         "org.freedesktop.login1.Manager",
  88                         "ListInhibitors",
  89                         error,
  90                         &reply,
  91                         "");
  92         if (r < 0)
  93                 return r;
  94
  95         r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(ssssuu)");
  96         if (r < 0)
  97                 return bus_log_parse_error(r);
  98
  99         while ((r = sd_bus_message_read(reply, "(ssssuu)", &what, &who, &why, &mode, &uid, &pid)) > 0) {
 100                 _cleanup_free_ char *comm = NULL, *u = NULL;
 101
 102                 if (arg_mode && !streq(mode, arg_mode))
 103                         continue;
 104
 105                 get_process_comm(pid, &comm);
 106                 u = uid_to_name(uid);
 107
 108                 printf("     Who: %s (UID "UID_FMT"/%s, PID "PID_FMT"/%s)\n"
 109                        "    What: %s\n"
 110                        "     Why: %s\n"
 111                        "    Mode: %s\n\n",
 112                        who, uid, strna(u), pid, strna(comm),
 113                        what,
 114                        why,
 115                        mode);
 116
 117                 n++;
 118         }
 119         if (r < 0)
 120                 return bus_log_parse_error(r);
 121
 122         r = sd_bus_message_exit_container(reply);
 123         if (r < 0)
 124                 return bus_log_parse_error(r);
 125
 126         printf("%u inhibitors listed.\n", n);
 127         return 0;
 128 }
 129
 130 static void help(void) {
 131         printf("%s [OPTIONS...] {COMMAND} ...\n\n"
 132                "Execute a process while inhibiting shutdown/sleep/idle.\n\n"
 133                "  -h --help               Show this help\n"
 134                "     --version            Show package version\n"
 135                "     --what=WHAT          Operations to inhibit, colon separated list of:\n"
 136                "                          shutdown, sleep, idle, handle-power-key,\n"
 137                "                          handle-suspend-key, handle-hibernate-key,\n"
 138                "                          handle-lid-switch\n"
 139                "     --who=STRING         A descriptive string who is inhibiting\n"
 140                "     --why=STRING         A descriptive string why is being inhibited\n"
 141                "     --mode=MODE          One of block or delay\n"
 142                "     --list               List active inhibitors\n"
 143                , program_invocation_short_name);
 144 }
 145
 146 static int parse_argv(int argc, char *argv[]) {
 147
 148         enum {
 149                 ARG_VERSION = 0x100,
 150                 ARG_WHAT,
 151                 ARG_WHO,
 152                 ARG_WHY,
 153                 ARG_MODE,
 154                 ARG_LIST,
 155         };
 156
 157         static const struct option options[] = {
 158                 { "help",         no_argument,       NULL, 'h'              },
 159                 { "version",      no_argument,       NULL, ARG_VERSION      },
 160                 { "what",         required_argument, NULL, ARG_WHAT         },
 161                 { "who",          required_argument, NULL, ARG_WHO          },
 162                 { "why",          required_argument, NULL, ARG_WHY          },
 163                 { "mode",         required_argument, NULL, ARG_MODE         },
 164                 { "list",         no_argument,       NULL, ARG_LIST         },
 165                 {}
 166         };
 167
 168         int c;
 169
 170         assert(argc >= 0);
 171         assert(argv);
 172
 173         while ((c = getopt_long(argc, argv, "+h", options, NULL)) >= 0)
 174
 175                 switch (c) {
 176
 177                 case 'h':
 178                         help();
 179                         return 0;
 180
 181                 case ARG_VERSION:
 182                         puts(PACKAGE_STRING);
 183                         puts(SYSTEMD_FEATURES);
 184                         return 0;
 185
 186                 case ARG_WHAT:
 187                         arg_what = optarg;
 188                         break;
 189
 190                 case ARG_WHO:
 191                         arg_who = optarg;
 192                         break;
 193
 194                 case ARG_WHY:
 195                         arg_why = optarg;
 196                         break;
 197
 198                 case ARG_MODE:
 199                         arg_mode = optarg;
 200                         break;
 201
 202                 case ARG_LIST:
 203                         arg_action = ACTION_LIST;
 204                         break;
 205
 206                 case '?':
 207                         return -EINVAL;
 208
 209                 default:
 210                         assert_not_reached("Unhandled option");
 211                 }
 212
 213         if (arg_action == ACTION_INHIBIT && optind == argc)
 214                 arg_action = ACTION_LIST;
 215
 216         else if (arg_action == ACTION_INHIBIT && optind >= argc) {
 217                 log_error("Missing command line to execute.");
 218                 return -EINVAL;
 219         }
 220
 221         return 1;
 222 }
 223
 224 int main(int argc, char *argv[]) {
 225         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
 226         _cleanup_bus_flush_close_unref_ sd_bus *bus = NULL;
 227         int r;
 228
 229         elogind_set_program_name(argv[0]);
 230         log_parse_environment();
 231         log_open();
 232
 233         r = parse_argv(argc, argv);
 234         if (r < 0)
 235                 return EXIT_FAILURE;
 236         if (r == 0)
 237                 return EXIT_SUCCESS;
 238
 239         r = sd_bus_default_system(&bus);
 240         if (r < 0) {
 241                 log_error_errno(r, "Failed to connect to bus: %m");
 242                 return EXIT_FAILURE;
 243         }
 244
 245         if (arg_action == ACTION_LIST) {
 246
 247                 r = print_inhibitors(bus, &error);
 248                 if (r < 0) {
 249                         log_error("Failed to list inhibitors: %s", bus_error_message(&error, -r));
 250                         return EXIT_FAILURE;
 251                 }
 252
 253         } else {
 254                 _cleanup_close_ int fd = -1;
 255                 _cleanup_free_ char *w = NULL;
 256                 pid_t pid;
 257
 258                 if (!arg_who)
 259                         arg_who = w = strv_join(argv + optind, " ");
 260
 261                 if (!arg_mode)
 262                         arg_mode = "block";
 263
 264                 fd = inhibit(bus, &error);
 265                 if (fd < 0) {
 266                         log_error("Failed to inhibit: %s", bus_error_message(&error, fd));
 267                         return EXIT_FAILURE;
 268                 }
 269
 270                 pid = fork();
 271                 if (pid < 0) {
 272                         log_error_errno(errno, "Failed to fork: %m");
 273                         return EXIT_FAILURE;
 274                 }
 275
 276                 if (pid == 0) {
 277                         /* Child */
 278
 279                         (void) reset_all_signal_handlers();
 280                         (void) reset_signal_mask();
 281
 282                         close_all_fds(NULL, 0);
 283
 284                         execvp(argv[optind], argv + optind);
 285                         log_error_errno(errno, "Failed to execute %s: %m", argv[optind]);
 286                         _exit(EXIT_FAILURE);
 287                 }
 288
 289                 r = wait_for_terminate_and_warn(argv[optind], pid, true);
 290                 return r < 0 ? EXIT_FAILURE : r;
 291         }
 292
 293         return 0;
 294 }