[thirdparty/systemd.git] / src / shared / exit-status.c

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
  This file is part of systemd.

  Copyright 2010 Lennart Poettering

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include <stdlib.h>
#include <sys/wait.h>

#include "exit-status.h"
#include "set.h"
#include "macro.h"

const char* exit_status_to_string(ExitStatus status, ExitStatusLevel level) {

        /* We cast to int here, so that -Wenum doesn't complain that
         * EXIT_SUCCESS/EXIT_FAILURE aren't in the enum */

        switch ((int) status) {

        case EXIT_SUCCESS:
                return "SUCCESS";

        case EXIT_FAILURE:
                return "FAILURE";
        }


        if (level == EXIT_STATUS_SYSTEMD || level == EXIT_STATUS_LSB) {
                switch ((int) status) {

                case EXIT_CHDIR:
                        return "CHDIR";

                case EXIT_NICE:
                        return "NICE";

                case EXIT_FDS:
                        return "FDS";

                case EXIT_EXEC:
                        return "EXEC";

                case EXIT_MEMORY:
                        return "MEMORY";

                case EXIT_LIMITS:
                        return "LIMITS";

                case EXIT_OOM_ADJUST:
                        return "OOM_ADJUST";

                case EXIT_SIGNAL_MASK:
                        return "SIGNAL_MASK";

                case EXIT_STDIN:
                        return "STDIN";

                case EXIT_STDOUT:
                        return "STDOUT";

                case EXIT_CHROOT:
                        return "CHROOT";

                case EXIT_IOPRIO:
                        return "IOPRIO";

                case EXIT_TIMERSLACK:
                        return "TIMERSLACK";

                case EXIT_SECUREBITS:
                        return "SECUREBITS";

                case EXIT_SETSCHEDULER:
                        return "SETSCHEDULER";

                case EXIT_CPUAFFINITY:
                        return "CPUAFFINITY";

                case EXIT_GROUP:
                        return "GROUP";

                case EXIT_USER:
                        return "USER";

                case EXIT_CAPABILITIES:
                        return "CAPABILITIES";

                case EXIT_CGROUP:
                        return "CGROUP";

                case EXIT_SETSID:
                        return "SETSID";

                case EXIT_CONFIRM:
                        return "CONFIRM";

                case EXIT_STDERR:
                        return "STDERR";

                case EXIT_PAM:
                        return "PAM";

                case EXIT_NETWORK:
                        return "NETWORK";

                case EXIT_NAMESPACE:
                        return "NAMESPACE";

                case EXIT_NO_NEW_PRIVILEGES:
                        return "NO_NEW_PRIVILEGES";

                case EXIT_SECCOMP:
                        return "SECCOMP";

                case EXIT_SELINUX_CONTEXT:
                        return "SELINUX_CONTEXT";

                case EXIT_PERSONALITY:
                        return "PERSONALITY";

                case EXIT_APPARMOR_PROFILE:
                        return "APPARMOR";

                case EXIT_ADDRESS_FAMILIES:
                        return "ADDRESS_FAMILIES";

                case EXIT_RUNTIME_DIRECTORY:
                        return "RUNTIME_DIRECTORY";

                case EXIT_CHOWN:
                        return "CHOWN";

                case EXIT_MAKE_STARTER:
                        return "MAKE_STARTER";
                }
        }

        if (level == EXIT_STATUS_LSB) {
                switch ((int) status) {

                case EXIT_INVALIDARGUMENT:
                        return "INVALIDARGUMENT";

                case EXIT_NOTIMPLEMENTED:
                        return "NOTIMPLEMENTED";

                case EXIT_NOPERMISSION:
                        return "NOPERMISSION";

                case EXIT_NOTINSTALLED:
                        return "NOTINSSTALLED";

                case EXIT_NOTCONFIGURED:
                        return "NOTCONFIGURED";

                case EXIT_NOTRUNNING:
                        return "NOTRUNNING";
                }
        }

        return NULL;
}


bool is_clean_exit(int code, int status, ExitStatusSet *success_status) {

        if (code == CLD_EXITED)
                return status == 0 ||
                       (success_status &&
                       set_contains(success_status->status, INT_TO_PTR(status)));

        /* If a daemon does not implement handlers for some of the
         * signals that's not considered an unclean shutdown */
        if (code == CLD_KILLED)
                return
                        status == SIGHUP ||
                        status == SIGINT ||
                        status == SIGTERM ||
                        status == SIGPIPE ||
                        (success_status &&
                        set_contains(success_status->signal, INT_TO_PTR(status)));

        return false;
}

bool is_clean_exit_lsb(int code, int status, ExitStatusSet *success_status) {

        if (is_clean_exit(code, status, success_status))
                return true;

        return
                code == CLD_EXITED &&
                (status == EXIT_NOTINSTALLED || status == EXIT_NOTCONFIGURED);
}

void exit_status_set_free(ExitStatusSet *x) {
        assert(x);

        set_free(x->status);
        set_free(x->signal);
        x->status = x->signal = NULL;
}

bool exit_status_set_is_empty(ExitStatusSet *x) {
        if (!x)
                return true;

        return set_isempty(x->status) && set_isempty(x->signal);
}
Commit	Line	Data
1afbdcb0 LP	1	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/
	2
	3	/***
	4	This file is part of systemd.
	5
	6	Copyright 2010 Lennart Poettering
	7
	8	systemd is free software; you can redistribute it and/or modify it
5430f7f2 LP	9	under the terms of the GNU Lesser General Public License as published by
5430f7f2 LP	10	the Free Software Foundation; either version 2.1 of the License, or
1afbdcb0 LP	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
5430f7f2	16	Lesser General Public License for more details.
1afbdcb0	17
5430f7f2	18	You should have received a copy of the GNU Lesser General Public License
1afbdcb0 LP	19	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	20	***/
	21
	22	#include <stdlib.h>
9a57c629	23	#include <sys/wait.h>
1afbdcb0 LP	24
1afbdcb0 LP	25	#include "exit-status.h"
96342de6 LN	26	#include "set.h"
96342de6 LN	27	#include "macro.h"
1afbdcb0 LP	28
	29	const char* exit_status_to_string(ExitStatus status, ExitStatusLevel level) {
	30
	31	/* We cast to int here, so that -Wenum doesn't complain that
	32	* EXIT_SUCCESS/EXIT_FAILURE aren't in the enum */
	33
	34	switch ((int) status) {
	35
	36	case EXIT_SUCCESS:
	37	return "SUCCESS";
	38
	39	case EXIT_FAILURE:
	40	return "FAILURE";
	41	}
	42
	43
	44	if (level == EXIT_STATUS_SYSTEMD \|\| level == EXIT_STATUS_LSB) {
	45	switch ((int) status) {
	46
	47	case EXIT_CHDIR:
	48	return "CHDIR";
	49
	50	case EXIT_NICE:
	51	return "NICE";
	52
	53	case EXIT_FDS:
	54	return "FDS";
	55
	56	case EXIT_EXEC:
	57	return "EXEC";
	58
	59	case EXIT_MEMORY:
	60	return "MEMORY";
	61
	62	case EXIT_LIMITS:
	63	return "LIMITS";
	64
	65	case EXIT_OOM_ADJUST:
	66	return "OOM_ADJUST";
	67
	68	case EXIT_SIGNAL_MASK:
	69	return "SIGNAL_MASK";
	70
	71	case EXIT_STDIN:
	72	return "STDIN";
	73
	74	case EXIT_STDOUT:
	75	return "STDOUT";
	76
	77	case EXIT_CHROOT:
	78	return "CHROOT";
	79
	80	case EXIT_IOPRIO:
	81	return "IOPRIO";
	82
	83	case EXIT_TIMERSLACK:
	84	return "TIMERSLACK";
	85
	86	case EXIT_SECUREBITS:
	87	return "SECUREBITS";
	88
	89	case EXIT_SETSCHEDULER:
	90	return "SETSCHEDULER";
	91
92	case EXIT_CPUAFFINITY:
93	return "CPUAFFINITY";
94
95	case EXIT_GROUP:
96	return "GROUP";
97
98	case EXIT_USER:
99	return "USER";
100
101	case EXIT_CAPABILITIES:
102	return "CAPABILITIES";
103
104	case EXIT_CGROUP:
105	return "CGROUP";
106
107	case EXIT_SETSID:
108	return "SETSID";
109
110	case EXIT_CONFIRM:
111	return "CONFIRM";
112
113	case EXIT_STDERR:
114	return "STDERR";
115
1afbdcb0 LP	116	case EXIT_PAM:
1afbdcb0 LP	117	return "PAM";
ff01d048 LP	118
	119	case EXIT_NETWORK:
	120	return "NETWORK";
4c2630eb MS	121
	122	case EXIT_NAMESPACE:
	123	return "NAMESPACE";
8351ceae LP	124
	125	case EXIT_NO_NEW_PRIVILEGES:
	126	return "NO_NEW_PRIVILEGES";
	127
	128	case EXIT_SECCOMP:
	129	return "SECCOMP";
7b52a628 MS	130
	131	case EXIT_SELINUX_CONTEXT:
	132	return "SELINUX_CONTEXT";
ac45f971 LP	133
	134	case EXIT_PERSONALITY:
	135	return "PERSONALITY";
eef65bf3 MS	136
	137	case EXIT_APPARMOR_PROFILE:
	138	return "APPARMOR";
4298d0b5 LP	139
	140	case EXIT_ADDRESS_FAMILIES:
	141	return "ADDRESS_FAMILIES";
e66cf1a3 LP	142
	143	case EXIT_RUNTIME_DIRECTORY:
	144	return "RUNTIME_DIRECTORY";
3900e5fd LP	145
	146	case EXIT_CHOWN:
	147	return "CHOWN";
a4152e3f LP	148
	149	case EXIT_MAKE_STARTER:
	150	return "MAKE_STARTER";
1afbdcb0 LP	151	}
	152	}
	153
	154	if (level == EXIT_STATUS_LSB) {
	155	switch ((int) status) {
	156
	157	case EXIT_INVALIDARGUMENT:
	158	return "INVALIDARGUMENT";
	159
	160	case EXIT_NOTIMPLEMENTED:
	161	return "NOTIMPLEMENTED";
	162
	163	case EXIT_NOPERMISSION:
	164	return "NOPERMISSION";
	165
	166	case EXIT_NOTINSTALLED:
	167	return "NOTINSSTALLED";
	168
	169	case EXIT_NOTCONFIGURED:
	170	return "NOTCONFIGURED";
	171
	172	case EXIT_NOTRUNNING:
	173	return "NOTRUNNING";
	174	}
	175	}
	176
	177	return NULL;
	178	}
9a57c629 LP	179
9a57c629 LP	180
96342de6	181	bool is_clean_exit(int code, int status, ExitStatusSet *success_status) {
9a57c629 LP	182
9a57c629 LP	183	if (code == CLD_EXITED)
96342de6 LN	184	return status == 0 \|\|
96342de6 LN	185	(success_status &&
3e2d435b	186	set_contains(success_status->status, INT_TO_PTR(status)));
9a57c629 LP	187
	188	/* If a daemon does not implement handlers for some of the
	189	* signals that's not considered an unclean shutdown */
	190	if (code == CLD_KILLED)
	191	return
	192	status == SIGHUP \|\|
	193	status == SIGINT \|\|
	194	status == SIGTERM \|\|
96342de6 LN	195	status == SIGPIPE \|\|
	196	(success_status &&
	197	set_contains(success_status->signal, INT_TO_PTR(status)));
9a57c629 LP	198
	199	return false;
	200	}
	201
96342de6	202	bool is_clean_exit_lsb(int code, int status, ExitStatusSet *success_status) {
9a57c629	203
96342de6	204	if (is_clean_exit(code, status, success_status))
9a57c629 LP	205	return true;
	206
	207	return
	208	code == CLD_EXITED &&
	209	(status == EXIT_NOTINSTALLED \|\| status == EXIT_NOTCONFIGURED);
	210	}
37520c1b LP	211
	212	void exit_status_set_free(ExitStatusSet *x) {
	213	assert(x);
	214
3e2d435b	215	set_free(x->status);
37520c1b	216	set_free(x->signal);
3e2d435b	217	x->status = x->signal = NULL;
37520c1b	218	}
55ebf98c LP	219
	220	bool exit_status_set_is_empty(ExitStatusSet *x) {
	221	if (!x)
	222	return true;
	223
	224	return set_isempty(x->status) && set_isempty(x->signal);
	225	}