src/shared/exit-status.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include <signal.h>
   4 #include <stdlib.h>
   5 #include <sysexits.h>
   6
   7 #include "exit-status.h"
   8 #include "macro.h"
   9 #include "set.h"
  10
  11 const ExitStatusMapping exit_status_mappings[256] = {
  12         /* Exit status ranges:
  13          *
  14          *   0…1   │ ISO C, EXIT_SUCCESS + EXIT_FAILURE
  15          *   2…7   │ LSB exit codes for init scripts
  16          *   8…63  │ (Currently unmapped)
  17          *  64…78  │ BSD defined exit codes
  18          *  79…199 │ (Currently unmapped)
  19          * 200…241 │ systemd's private error codes (might be extended to 254 in future development)
  20          * 242…254 │ (Currently unmapped, but see above)
  21          *
  22          *   255   │ EXIT_EXCEPTION (We use this to propagate exit-by-signal events. It's frequently used by others apps (like bash)
  23          *         │ to indicate exit reason that cannot really be expressed in a single exit status value — such as a propagated
  24          *         │ signal or such, and we follow that logic here.)
  25          */
  26
  27         [EXIT_SUCCESS] =                 { "SUCCESS",                 EXIT_STATUS_GLIBC },
  28         [EXIT_FAILURE] =                 { "FAILURE",                 EXIT_STATUS_GLIBC },
  29
  30         [EXIT_CHDIR] =                   { "CHDIR",                   EXIT_STATUS_SYSTEMD },
  31         [EXIT_NICE] =                    { "NICE",                    EXIT_STATUS_SYSTEMD },
  32         [EXIT_FDS] =                     { "FDS",                     EXIT_STATUS_SYSTEMD },
  33         [EXIT_EXEC] =                    { "EXEC",                    EXIT_STATUS_SYSTEMD },
  34         [EXIT_MEMORY] =                  { "MEMORY",                  EXIT_STATUS_SYSTEMD },
  35         [EXIT_LIMITS] =                  { "LIMITS",                  EXIT_STATUS_SYSTEMD },
  36         [EXIT_OOM_ADJUST] =              { "OOM_ADJUST",              EXIT_STATUS_SYSTEMD },
  37         [EXIT_SIGNAL_MASK] =             { "SIGNAL_MASK",             EXIT_STATUS_SYSTEMD },
  38         [EXIT_STDIN] =                   { "STDIN",                   EXIT_STATUS_SYSTEMD },
  39         [EXIT_STDOUT] =                  { "STDOUT",                  EXIT_STATUS_SYSTEMD },
  40         [EXIT_CHROOT] =                  { "CHROOT",                  EXIT_STATUS_SYSTEMD },
  41         [EXIT_IOPRIO] =                  { "IOPRIO",                  EXIT_STATUS_SYSTEMD },
  42         [EXIT_TIMERSLACK] =              { "TIMERSLACK",              EXIT_STATUS_SYSTEMD },
  43         [EXIT_SECUREBITS] =              { "SECUREBITS",              EXIT_STATUS_SYSTEMD },
  44         [EXIT_SETSCHEDULER] =            { "SETSCHEDULER",            EXIT_STATUS_SYSTEMD },
  45         [EXIT_CPUAFFINITY] =             { "CPUAFFINITY",             EXIT_STATUS_SYSTEMD },
  46         [EXIT_GROUP] =                   { "GROUP",                   EXIT_STATUS_SYSTEMD },
  47         [EXIT_USER] =                    { "USER",                    EXIT_STATUS_SYSTEMD },
  48         [EXIT_CAPABILITIES] =            { "CAPABILITIES",            EXIT_STATUS_SYSTEMD },
  49         [EXIT_CGROUP] =                  { "CGROUP",                  EXIT_STATUS_SYSTEMD },
  50         [EXIT_SETSID] =                  { "SETSID",                  EXIT_STATUS_SYSTEMD },
  51         [EXIT_CONFIRM] =                 { "CONFIRM",                 EXIT_STATUS_SYSTEMD },
  52         [EXIT_STDERR] =                  { "STDERR",                  EXIT_STATUS_SYSTEMD },
  53         [EXIT_PAM] =                     { "PAM",                     EXIT_STATUS_SYSTEMD },
  54         [EXIT_NETWORK] =                 { "NETWORK",                 EXIT_STATUS_SYSTEMD },
  55         [EXIT_NAMESPACE] =               { "NAMESPACE",               EXIT_STATUS_SYSTEMD },
  56         [EXIT_NO_NEW_PRIVILEGES] =       { "NO_NEW_PRIVILEGES",       EXIT_STATUS_SYSTEMD },
  57         [EXIT_SECCOMP] =                 { "SECCOMP",                 EXIT_STATUS_SYSTEMD },
  58         [EXIT_SELINUX_CONTEXT] =         { "SELINUX_CONTEXT",         EXIT_STATUS_SYSTEMD },
  59         [EXIT_PERSONALITY] =             { "PERSONALITY",             EXIT_STATUS_SYSTEMD },
  60         [EXIT_APPARMOR_PROFILE] =        { "APPARMOR",                EXIT_STATUS_SYSTEMD },
  61         [EXIT_ADDRESS_FAMILIES] =        { "ADDRESS_FAMILIES",        EXIT_STATUS_SYSTEMD },
  62         [EXIT_RUNTIME_DIRECTORY] =       { "RUNTIME_DIRECTORY",       EXIT_STATUS_SYSTEMD },
  63         [EXIT_CHOWN] =                   { "CHOWN",                   EXIT_STATUS_SYSTEMD },
  64         [EXIT_SMACK_PROCESS_LABEL] =     { "SMACK_PROCESS_LABEL",     EXIT_STATUS_SYSTEMD },
  65         [EXIT_KEYRING] =                 { "KEYRING",                 EXIT_STATUS_SYSTEMD },
  66         [EXIT_STATE_DIRECTORY] =         { "STATE_DIRECTORY",         EXIT_STATUS_SYSTEMD },
  67         [EXIT_CACHE_DIRECTORY] =         { "CACHE_DIRECTORY",         EXIT_STATUS_SYSTEMD },
  68         [EXIT_LOGS_DIRECTORY] =          { "LOGS_DIRECTORY",          EXIT_STATUS_SYSTEMD },
  69         [EXIT_CONFIGURATION_DIRECTORY] = { "CONFIGURATION_DIRECTORY", EXIT_STATUS_SYSTEMD },
  70         [EXIT_NUMA_POLICY] =             { "NUMA_POLICY",             EXIT_STATUS_SYSTEMD },
  71         [EXIT_EXCEPTION] =               { "EXCEPTION",               EXIT_STATUS_SYSTEMD },
  72
  73         [EXIT_INVALIDARGUMENT] =         { "INVALIDARGUMENT",         EXIT_STATUS_LSB },
  74         [EXIT_NOTIMPLEMENTED] =          { "NOTIMPLEMENTED",          EXIT_STATUS_LSB },
  75         [EXIT_NOPERMISSION] =            { "NOPERMISSION",            EXIT_STATUS_LSB },
  76         [EXIT_NOTINSTALLED] =            { "NOTINSTALLED",            EXIT_STATUS_LSB },
  77         [EXIT_NOTCONFIGURED] =           { "NOTCONFIGURED",           EXIT_STATUS_LSB },
  78         [EXIT_NOTRUNNING] =              { "NOTRUNNING",              EXIT_STATUS_LSB },
  79
  80         [EX_USAGE] =                     { "USAGE",                   EXIT_STATUS_BSD },
  81         [EX_DATAERR] =                   { "DATAERR",                 EXIT_STATUS_BSD },
  82         [EX_NOINPUT] =                   { "NOINPUT",                 EXIT_STATUS_BSD },
  83         [EX_NOUSER] =                    { "NOUSER",                  EXIT_STATUS_BSD },
  84         [EX_NOHOST] =                    { "NOHOST",                  EXIT_STATUS_BSD },
  85         [EX_UNAVAILABLE] =               { "UNAVAILABLE",             EXIT_STATUS_BSD },
  86         [EX_SOFTWARE] =                  { "SOFTWARE",                EXIT_STATUS_BSD },
  87         [EX_OSERR] =                     { "OSERR",                   EXIT_STATUS_BSD },
  88         [EX_OSFILE] =                    { "OSFILE",                  EXIT_STATUS_BSD },
  89         [EX_CANTCREAT] =                 { "CANTCREAT",               EXIT_STATUS_BSD },
  90         [EX_IOERR] =                     { "IOERR",                   EXIT_STATUS_BSD },
  91         [EX_TEMPFAIL] =                  { "TEMPFAIL",                EXIT_STATUS_BSD },
  92         [EX_PROTOCOL] =                  { "PROTOCOL",                EXIT_STATUS_BSD },
  93         [EX_NOPERM] =                    { "NOPERM",                  EXIT_STATUS_BSD },
  94         [EX_CONFIG] =                    { "CONFIG",                  EXIT_STATUS_BSD },
  95 };
  96
  97 const char* exit_status_to_string(int code, ExitStatusClass class) {
  98         if (code < 0 || (size_t) code >= ELEMENTSOF(exit_status_mappings))
  99                 return NULL;
 100         return FLAGS_SET(exit_status_mappings[code].class, class) ? exit_status_mappings[code].name : NULL;
 101 }
 102
 103 const char* exit_status_class(int code) {
 104         if (code < 0 || (size_t) code >= ELEMENTSOF(exit_status_mappings))
 105                 return NULL;
 106
 107         switch (exit_status_mappings[code].class) {
 108         case EXIT_STATUS_GLIBC:
 109                 return "glibc";
 110         case EXIT_STATUS_SYSTEMD:
 111                 return "systemd";
 112         case EXIT_STATUS_LSB:
 113                 return "LSB";
 114         case EXIT_STATUS_BSD:
 115                 return "BSD";
 116         default: return NULL;
 117         }
 118 }
 119
 120 bool is_clean_exit(int code, int status, ExitClean clean, ExitStatusSet *success_status) {
 121         if (code == CLD_EXITED)
 122                 return status == 0 ||
 123                        (success_status &&
 124                         set_contains(success_status->status, INT_TO_PTR(status)));
 125
 126         /* If a daemon does not implement handlers for some of the signals that's not considered an unclean shutdown */
 127         if (code == CLD_KILLED)
 128                 return
 129                         (clean == EXIT_CLEAN_DAEMON && IN_SET(status, SIGHUP, SIGINT, SIGTERM, SIGPIPE)) ||
 130                         (success_status &&
 131                          set_contains(success_status->signal, INT_TO_PTR(status)));
 132
 133         return false;
 134 }
 135
 136 void exit_status_set_free(ExitStatusSet *x) {
 137         assert(x);
 138
 139         x->status = set_free(x->status);
 140         x->signal = set_free(x->signal);
 141 }
 142
 143 bool exit_status_set_is_empty(ExitStatusSet *x) {
 144         if (!x)
 145                 return true;
 146
 147         return set_isempty(x->status) && set_isempty(x->signal);
 148 }
 149
 150 bool exit_status_set_test(ExitStatusSet *x, int code, int status) {
 151
 152         if (exit_status_set_is_empty(x))
 153                 return false;
 154
 155         if (code == CLD_EXITED && set_contains(x->status, INT_TO_PTR(status)))
 156                 return true;
 157
 158         if (IN_SET(code, CLD_KILLED, CLD_DUMPED) && set_contains(x->signal, INT_TO_PTR(status)))
 159                 return true;
 160
 161         return false;
 162 }