src/login/logind-action.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 <unistd.h>
  23
  24 #include "conf-parser.h"
  25 #include "special.h"
  26 #include "sleep-config.h"
  27 #include "bus-util.h"
  28 #include "bus-error.h"
  29 #include "logind-action.h"
  30
  31 int manager_handle_action(
  32                 Manager *m,
  33                 InhibitWhat inhibit_key,
  34                 HandleAction handle,
  35                 bool ignore_inhibited,
  36                 bool is_edge) {
  37
  38         static const char * const message_table[_HANDLE_ACTION_MAX] = {
  39                 [HANDLE_POWEROFF] = "Powering Off...",
  40                 [HANDLE_REBOOT] = "Rebooting...",
  41                 [HANDLE_HALT] = "Halting...",
  42                 [HANDLE_KEXEC] = "Rebooting via kexec...",
  43                 [HANDLE_SUSPEND] = "Suspending...",
  44                 [HANDLE_HIBERNATE] = "Hibernating...",
  45                 [HANDLE_HYBRID_SLEEP] = "Hibernating and suspending..."
  46         };
  47
  48         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
  49         InhibitWhat inhibit_operation;
  50         Inhibitor *offending = NULL;
  51         bool supported;
  52         int r;
  53
  54         assert(m);
  55
  56         /* If the key handling is turned off, don't do anything */
  57         if (handle == HANDLE_IGNORE) {
  58                 log_debug("Refusing operation, as it is turned off.");
  59                 return 0;
  60         }
  61
  62         if (inhibit_key == INHIBIT_HANDLE_LID_SWITCH) {
  63                 /* If the last system suspend or startup is too close,
  64                  * let's not suspend for now, to give USB docking
  65                  * stations some time to settle so that we can
  66                  * properly watch its displays. */
  67                 if (m->lid_switch_ignore_event_source) {
  68                         log_debug("Ignoring lid switch request, system startup or resume too close.");
  69                         return 0;
  70                 }
  71         }
  72
  73         /* If the key handling is inhibited, don't do anything */
  74         if (inhibit_key > 0) {
  75                 if (manager_is_inhibited(m, inhibit_key, INHIBIT_BLOCK, NULL, true, false, 0, NULL)) {
  76                         log_debug("Refusing operation, %s is inhibited.", inhibit_what_to_string(inhibit_key));
  77                         return 0;
  78                 }
  79         }
  80
  81         /* Locking is handled differently from the rest. */
  82         if (handle == HANDLE_LOCK) {
  83
  84                 if (!is_edge)
  85                         return 0;
  86
  87                 log_info("Locking sessions...");
  88                 session_send_lock_all(m, true);
  89                 return 1;
  90         }
  91
  92         if (handle == HANDLE_SUSPEND)
  93                 supported = can_sleep("suspend") > 0;
  94         else if (handle == HANDLE_HIBERNATE)
  95                 supported = can_sleep("hibernate") > 0;
  96         else if (handle == HANDLE_HYBRID_SLEEP)
  97                 supported = can_sleep("hybrid-sleep") > 0;
  98         else if (handle == HANDLE_KEXEC)
  99                 supported = access(KEXEC, X_OK) >= 0;
 100         else
 101                 supported = true;
 102
 103         if (!supported) {
 104                 log_warning("Requested operation not supported, ignoring.");
 105                 return -EOPNOTSUPP;
 106         }
 107
 108         if (m->action_what) {
 109                 log_debug("Action already in progress, ignoring.");
 110                 return -EALREADY;
 111         }
 112
 113         inhibit_operation = handle == HANDLE_SUSPEND || handle == HANDLE_HIBERNATE || handle == HANDLE_HYBRID_SLEEP ? INHIBIT_SLEEP : INHIBIT_SHUTDOWN;
 114
 115         /* If the actual operation is inhibited, warn and fail */
 116         if (!ignore_inhibited &&
 117             manager_is_inhibited(m, inhibit_operation, INHIBIT_BLOCK, NULL, false, false, 0, &offending)) {
 118                 _cleanup_free_ char *comm = NULL, *u = NULL;
 119
 120                 get_process_comm(offending->pid, &comm);
 121                 u = uid_to_name(offending->uid);
 122
 123                 /* If this is just a recheck of the lid switch then don't warn about anything */
 124                 if (!is_edge) {
 125                         log_debug("Refusing operation, %s is inhibited by UID "UID_FMT"/%s, PID "PID_FMT"/%s.",
 126                                   inhibit_what_to_string(inhibit_operation),
 127                                   offending->uid, strna(u),
 128                                   offending->pid, strna(comm));
 129                         return 0;
 130                 }
 131
 132                 log_error("Refusing operation, %s is inhibited by UID "UID_FMT"/%s, PID "PID_FMT"/%s.",
 133                           inhibit_what_to_string(inhibit_operation),
 134                           offending->uid, strna(u),
 135                           offending->pid, strna(comm));
 136
 137                 warn_melody();
 138                 return -EPERM;
 139         }
 140
 141         log_info("%s", message_table[handle]);
 142
 143         r = bus_manager_shutdown_or_sleep_now_or_later(m, handle, inhibit_operation, &error);
 144         if (r < 0) {
 145                 log_error("Failed to execute operation: %s", bus_error_message(&error, r));
 146                 return r;
 147         }
 148
 149         return 1;
 150 }
 151
 152 static const char* const handle_action_table[_HANDLE_ACTION_MAX] = {
 153         [HANDLE_IGNORE] = "ignore",
 154         [HANDLE_POWEROFF] = "poweroff",
 155         [HANDLE_REBOOT] = "reboot",
 156         [HANDLE_HALT] = "halt",
 157         [HANDLE_KEXEC] = "kexec",
 158         [HANDLE_SUSPEND] = "suspend",
 159         [HANDLE_HIBERNATE] = "hibernate",
 160         [HANDLE_HYBRID_SLEEP] = "hybrid-sleep",
 161         [HANDLE_LOCK] = "lock"
 162 };
 163
 164 DEFINE_STRING_TABLE_LOOKUP(handle_action, HandleAction);
 165 DEFINE_CONFIG_PARSE_ENUM(config_parse_handle_action, handle_action, HandleAction, "Failed to parse handle action setting");