src/login/inhibit.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   This file is part of systemd.
   4
   5   Copyright 2012 Lennart Poettering
   6
   7   systemd is free software; you can redistribute it and/or modify it
   8   under the terms of the GNU Lesser General Public License as published by
   9   the Free Software Foundation; either version 2.1 of the License, or
  10   (at your option) any later version.
  11
  12   systemd is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   Lesser General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  19 ***/
  20
  21 #include <fcntl.h>
  22 #include <getopt.h>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <unistd.h>
  26
  27 #include "sd-bus.h"
  28
  29 #include "alloc-util.h"
  30 #include "bus-error.h"
  31 #include "bus-util.h"
  32 #include "fd-util.h"
  33 #include "format-util.h"
  34 #include "process-util.h"
  35 #include "signal-util.h"
  36 #include "strv.h"
  37 #include "user-util.h"
  38 #include "util.h"
  39
  40 static const char* arg_what = "idle:sleep:shutdown";
  41 static const char* arg_who = NULL;
  42 static const char* arg_why = "Unknown reason";
  43 static const char* arg_mode = NULL;
  44
  45 static enum {
  46         ACTION_INHIBIT,
  47         ACTION_LIST
  48 } arg_action = ACTION_INHIBIT;
  49
  50 static int inhibit(sd_bus *bus, sd_bus_error *error) {
  51         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
  52         int r;
  53         int fd;
  54
  55         r = sd_bus_call_method(
  56                         bus,
  57                         "org.freedesktop.login1",
  58                         "/org/freedesktop/login1",
  59                         "org.freedesktop.login1.Manager",
  60                         "Inhibit",
  61                         error,
  62                         &reply,
  63                         "ssss", arg_what, arg_who, arg_why, arg_mode);
  64         if (r < 0)
  65                 return r;
  66
  67         r = sd_bus_message_read_basic(reply, SD_BUS_TYPE_UNIX_FD, &fd);
  68         if (r < 0)
  69                 return r;
  70
  71         r = fcntl(fd, F_DUPFD_CLOEXEC, 3);
  72         if (r < 0)
  73                 return -errno;
  74
  75         return r;
  76 }
  77
  78 static int print_inhibitors(sd_bus *bus, sd_bus_error *error) {
  79         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
  80         const char *what, *who, *why, *mode;
  81         unsigned int uid, pid;
  82         unsigned n = 0;
  83         int r;
  84
  85         r = sd_bus_call_method(
  86                         bus,
  87                         "org.freedesktop.login1",
  88                         "/org/freedesktop/login1",
  89                         "org.freedesktop.login1.Manager",
  90                         "ListInhibitors",
  91                         error,
  92                         &reply,
  93                         "");
  94         if (r < 0)
  95                 return r;
  96
  97         r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(ssssuu)");
  98         if (r < 0)
  99                 return bus_log_parse_error(r);
 100
 101         while ((r = sd_bus_message_read(reply, "(ssssuu)", &what, &who, &why, &mode, &uid, &pid)) > 0) {
 102                 _cleanup_free_ char *comm = NULL, *u = NULL;
 103
 104                 if (arg_mode && !streq(mode, arg_mode))
 105                         continue;
 106
 107                 get_process_comm(pid, &comm);
 108                 u = uid_to_name(uid);
 109
 110                 printf("     Who: %s (UID "UID_FMT"/%s, PID "PID_FMT"/%s)\n"
 111                        "    What: %s\n"
 112                        "     Why: %s\n"
 113                        "    Mode: %s\n\n",
 114                        who, uid, strna(u), pid, strna(comm),
 115                        what,
 116                        why,
 117                        mode);
 118
 119                 n++;
 120         }
 121         if (r < 0)
 122                 return bus_log_parse_error(r);
 123
 124         r = sd_bus_message_exit_container(reply);
 125         if (r < 0)
 126                 return bus_log_parse_error(r);
 127
 128         printf("%u inhibitors listed.\n", n);
 129         return 0;
 130 }
 131
 132 static void help(void) {
 133         printf("%s [OPTIONS...] {COMMAND} ...\n\n"
 134                "Execute a process while inhibiting shutdown/sleep/idle.\n\n"
 135                "  -h --help               Show this help\n"
 136                "     --version            Show package version\n"
 137                "     --what=WHAT          Operations to inhibit, colon separated list of:\n"
 138                "                          shutdown, sleep, idle, handle-power-key,\n"
 139                "                          handle-suspend-key, handle-hibernate-key,\n"
 140                "                          handle-lid-switch\n"
 141                "     --who=STRING         A descriptive string who is inhibiting\n"
 142                "     --why=STRING         A descriptive string why is being inhibited\n"
 143                "     --mode=MODE          One of block or delay\n"
 144                "     --list               List active inhibitors\n"
 145                , program_invocation_short_name);
 146 }
 147
 148 static int parse_argv(int argc, char *argv[]) {
 149
 150         enum {
 151                 ARG_VERSION = 0x100,
 152                 ARG_WHAT,
 153                 ARG_WHO,
 154                 ARG_WHY,
 155                 ARG_MODE,
 156                 ARG_LIST,
 157         };
 158
 159         static const struct option options[] = {
 160                 { "help",         no_argument,       NULL, 'h'              },
 161                 { "version",      no_argument,       NULL, ARG_VERSION      },
 162                 { "what",         required_argument, NULL, ARG_WHAT         },
 163                 { "who",          required_argument, NULL, ARG_WHO          },
 164                 { "why",          required_argument, NULL, ARG_WHY          },
 165                 { "mode",         required_argument, NULL, ARG_MODE         },
 166                 { "list",         no_argument,       NULL, ARG_LIST         },
 167                 {}
 168         };
 169
 170         int c;
 171
 172         assert(argc >= 0);
 173         assert(argv);
 174
 175         while ((c = getopt_long(argc, argv, "+h", options, NULL)) >= 0)
 176
 177                 switch (c) {
 178
 179                 case 'h':
 180                         help();
 181                         return 0;
 182
 183                 case ARG_VERSION:
 184                         return version();
 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_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
 226         _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
 227         int r;
 228
 229         log_parse_environment();
 230         log_open();
 231
 232         r = parse_argv(argc, argv);
 233         if (r < 0)
 234                 return EXIT_FAILURE;
 235         if (r == 0)
 236                 return EXIT_SUCCESS;
 237
 238         r = sd_bus_default_system(&bus);
 239         if (r < 0) {
 240                 log_error_errno(r, "Failed to connect to bus: %m");
 241                 return EXIT_FAILURE;
 242         }
 243
 244         if (arg_action == ACTION_LIST) {
 245
 246                 r = print_inhibitors(bus, &error);
 247                 if (r < 0) {
 248                         log_error("Failed to list inhibitors: %s", bus_error_message(&error, -r));
 249                         return EXIT_FAILURE;
 250                 }
 251
 252         } else {
 253                 _cleanup_close_ int fd = -1;
 254                 _cleanup_free_ char *w = NULL;
 255                 pid_t pid;
 256
 257                 if (!arg_who)
 258                         arg_who = w = strv_join(argv + optind, " ");
 259
 260                 if (!arg_mode)
 261                         arg_mode = "block";
 262
 263                 fd = inhibit(bus, &error);
 264                 if (fd < 0) {
 265                         log_error("Failed to inhibit: %s", bus_error_message(&error, fd));
 266                         return EXIT_FAILURE;
 267                 }
 268
 269                 pid = fork();
 270                 if (pid < 0) {
 271                         log_error_errno(errno, "Failed to fork: %m");
 272                         return EXIT_FAILURE;
 273                 }
 274
 275                 if (pid == 0) {
 276                         /* Child */
 277
 278                         (void) reset_all_signal_handlers();
 279                         (void) reset_signal_mask();
 280
 281                         close_all_fds(NULL, 0);
 282
 283                         execvp(argv[optind], argv + optind);
 284                         log_error_errno(errno, "Failed to execute %s: %m", argv[optind]);
 285                         _exit(EXIT_FAILURE);
 286                 }
 287
 288                 r = wait_for_terminate_and_warn(argv[optind], pid, true);
 289                 return r < 0 ? EXIT_FAILURE : r;
 290         }
 291
 292         return 0;
 293 }