src/basic/exit-status.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   This file is part of systemd.
   4
   5   Copyright 2010 Lennart Poettering
   6 ***/
   7
   8 #include <signal.h>
   9 #include <stdlib.h>
  10 #include <sysexits.h>
  11
  12 #include "exit-status.h"
  13 #include "macro.h"
  14 #include "set.h"
  15
  16 const char* exit_status_to_string(int status, ExitStatusLevel level) {
  17
  18         /* Exit status ranges:
  19          *
  20          *   0…1   │ ISO C, EXIT_SUCCESS + EXIT_FAILURE
  21          *   2…7   │ LSB exit codes for init scripts
  22          *   8…63  │ (Currently unmapped)
  23          *  64…78  │ BSD defined exit codes
  24          *  79…199 │ (Currently unmapped)
  25          * 200…241 │ systemd's private error codes (might be extended to 254 in future development)
  26          * 242…254 │ (Currently unmapped, but see above)
  27          *   255   │ (We should probably stay away from that one, it's frequently used by applications to indicate an
  28          *         │ exit reason that cannot really be expressed in a single exit status value — such as a propagated
  29          *         │ signal or such)
  30          */
  31
  32         switch (status) {  /* We always cover the ISO C ones */
  33
  34         case EXIT_SUCCESS:
  35                 return "SUCCESS";
  36
  37         case EXIT_FAILURE:
  38                 return "FAILURE";
  39         }
  40
  41         if (IN_SET(level, EXIT_STATUS_SYSTEMD, EXIT_STATUS_LSB, EXIT_STATUS_FULL)) {
  42                 switch (status) { /* Optionally we cover our own ones */
  43
  44                 case EXIT_CHDIR:
  45                         return "CHDIR";
  46
  47                 case EXIT_NICE:
  48                         return "NICE";
  49
  50                 case EXIT_FDS:
  51                         return "FDS";
  52
  53                 case EXIT_EXEC:
  54                         return "EXEC";
  55
  56                 case EXIT_MEMORY:
  57                         return "MEMORY";
  58
  59                 case EXIT_LIMITS:
  60                         return "LIMITS";
  61
  62                 case EXIT_OOM_ADJUST:
  63                         return "OOM_ADJUST";
  64
  65                 case EXIT_SIGNAL_MASK:
  66                         return "SIGNAL_MASK";
  67
  68                 case EXIT_STDIN:
  69                         return "STDIN";
  70
  71                 case EXIT_STDOUT:
  72                         return "STDOUT";
  73
  74                 case EXIT_CHROOT:
  75                         return "CHROOT";
  76
  77                 case EXIT_IOPRIO:
  78                         return "IOPRIO";
  79
  80                 case EXIT_TIMERSLACK:
  81                         return "TIMERSLACK";
  82
  83                 case EXIT_SECUREBITS:
  84                         return "SECUREBITS";
  85
  86                 case EXIT_SETSCHEDULER:
  87                         return "SETSCHEDULER";
  88
  89                 case EXIT_CPUAFFINITY:
  90                         return "CPUAFFINITY";
  91
  92                 case EXIT_GROUP:
  93                         return "GROUP";
  94
  95                 case EXIT_USER:
  96                         return "USER";
  97
  98                 case EXIT_CAPABILITIES:
  99                         return "CAPABILITIES";
 100
 101                 case EXIT_CGROUP:
 102                         return "CGROUP";
 103
 104                 case EXIT_SETSID:
 105                         return "SETSID";
 106
 107                 case EXIT_CONFIRM:
 108                         return "CONFIRM";
 109
 110                 case EXIT_STDERR:
 111                         return "STDERR";
 112
 113                 case EXIT_PAM:
 114                         return "PAM";
 115
 116                 case EXIT_NETWORK:
 117                         return "NETWORK";
 118
 119                 case EXIT_NAMESPACE:
 120                         return "NAMESPACE";
 121
 122                 case EXIT_NO_NEW_PRIVILEGES:
 123                         return "NO_NEW_PRIVILEGES";
 124
 125                 case EXIT_SECCOMP:
 126                         return "SECCOMP";
 127
 128                 case EXIT_SELINUX_CONTEXT:
 129                         return "SELINUX_CONTEXT";
 130
 131                 case EXIT_PERSONALITY:
 132                         return "PERSONALITY";
 133
 134                 case EXIT_APPARMOR_PROFILE:
 135                         return "APPARMOR";
 136
 137                 case EXIT_ADDRESS_FAMILIES:
 138                         return "ADDRESS_FAMILIES";
 139
 140                 case EXIT_RUNTIME_DIRECTORY:
 141                         return "RUNTIME_DIRECTORY";
 142
 143                 case EXIT_CHOWN:
 144                         return "CHOWN";
 145
 146                 case EXIT_SMACK_PROCESS_LABEL:
 147                         return "SMACK_PROCESS_LABEL";
 148
 149                 case EXIT_KEYRING:
 150                         return "KEYRING";
 151
 152                 case EXIT_STATE_DIRECTORY:
 153                         return "STATE_DIRECTORY";
 154
 155                 case EXIT_CACHE_DIRECTORY:
 156                         return "CACHE_DIRECTORY";
 157
 158                 case EXIT_LOGS_DIRECTORY:
 159                         return "LOGS_DIRECTORY";
 160
 161                 case EXIT_CONFIGURATION_DIRECTORY:
 162                         return "CONFIGURATION_DIRECTORY";
 163                 }
 164         }
 165
 166         if (IN_SET(level, EXIT_STATUS_LSB, EXIT_STATUS_FULL)) {
 167                 switch (status) { /* Optionally we support LSB ones */
 168
 169                 case EXIT_INVALIDARGUMENT:
 170                         return "INVALIDARGUMENT";
 171
 172                 case EXIT_NOTIMPLEMENTED:
 173                         return "NOTIMPLEMENTED";
 174
 175                 case EXIT_NOPERMISSION:
 176                         return "NOPERMISSION";
 177
 178                 case EXIT_NOTINSTALLED:
 179                         return "NOTINSTALLED";
 180
 181                 case EXIT_NOTCONFIGURED:
 182                         return "NOTCONFIGURED";
 183
 184                 case EXIT_NOTRUNNING:
 185                         return "NOTRUNNING";
 186                 }
 187         }
 188
 189         if (level == EXIT_STATUS_FULL) {
 190                 switch (status) { /* Optionally, we support BSD exit statusses */
 191
 192                 case EX_USAGE:
 193                         return "USAGE";
 194
 195                 case EX_DATAERR:
 196                         return "DATAERR";
 197
 198                 case EX_NOINPUT:
 199                         return "NOINPUT";
 200
 201                 case EX_NOUSER:
 202                         return "NOUSER";
 203
 204                 case EX_NOHOST:
 205                         return "NOHOST";
 206
 207                 case EX_UNAVAILABLE:
 208                         return "UNAVAILABLE";
 209
 210                 case EX_SOFTWARE:
 211                         return "SOFTWARE";
 212
 213                 case EX_OSERR:
 214                         return "OSERR";
 215
 216                 case EX_OSFILE:
 217                         return "OSFILE";
 218
 219                 case EX_CANTCREAT:
 220                         return "CANTCREAT";
 221
 222                 case EX_IOERR:
 223                         return "IOERR";
 224
 225                 case EX_TEMPFAIL:
 226                         return "TEMPFAIL";
 227
 228                 case EX_PROTOCOL:
 229                         return "PROTOCOL";
 230
 231                 case EX_NOPERM:
 232                         return "NOPERM";
 233
 234                 case EX_CONFIG:
 235                         return "CONFIG";
 236                 }
 237         }
 238
 239         return NULL;
 240 }
 241
 242 bool is_clean_exit(int code, int status, ExitClean clean, ExitStatusSet *success_status) {
 243
 244         if (code == CLD_EXITED)
 245                 return status == 0 ||
 246                        (success_status &&
 247                         set_contains(success_status->status, INT_TO_PTR(status)));
 248
 249         /* If a daemon does not implement handlers for some of the signals that's not considered an unclean shutdown */
 250         if (code == CLD_KILLED)
 251                 return
 252                         (clean == EXIT_CLEAN_DAEMON && IN_SET(status, SIGHUP, SIGINT, SIGTERM, SIGPIPE)) ||
 253                         (success_status &&
 254                          set_contains(success_status->signal, INT_TO_PTR(status)));
 255
 256         return false;
 257 }
 258
 259 void exit_status_set_free(ExitStatusSet *x) {
 260         assert(x);
 261
 262         x->status = set_free(x->status);
 263         x->signal = set_free(x->signal);
 264 }
 265
 266 bool exit_status_set_is_empty(ExitStatusSet *x) {
 267         if (!x)
 268                 return true;
 269
 270         return set_isempty(x->status) && set_isempty(x->signal);
 271 }
 272
 273 bool exit_status_set_test(ExitStatusSet *x, int code, int status) {
 274
 275         if (exit_status_set_is_empty(x))
 276                 return false;
 277
 278         if (code == CLD_EXITED && set_contains(x->status, INT_TO_PTR(status)))
 279                 return true;
 280
 281         if (IN_SET(code, CLD_KILLED, CLD_DUMPED) && set_contains(x->signal, INT_TO_PTR(status)))
 282                 return true;
 283
 284         return false;
 285 }