[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_TCPWRAP:
                        return "TCPWRAP";

                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";
                }
        }

        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->code, 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);
}
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
116	case EXIT_TCPWRAP:
117	return "TCPWRAP";
118
119	case EXIT_PAM:
120	return "PAM";
ff01d048 LP	121
	122	case EXIT_NETWORK:
	123	return "NETWORK";
4c2630eb MS	124
	125	case EXIT_NAMESPACE:
	126	return "NAMESPACE";
8351ceae LP	127
	128	case EXIT_NO_NEW_PRIVILEGES:
	129	return "NO_NEW_PRIVILEGES";
	130
	131	case EXIT_SECCOMP:
	132	return "SECCOMP";
1afbdcb0 LP	133	}
	134	}
	135
	136	if (level == EXIT_STATUS_LSB) {
	137	switch ((int) status) {
	138
	139	case EXIT_INVALIDARGUMENT:
	140	return "INVALIDARGUMENT";
	141
	142	case EXIT_NOTIMPLEMENTED:
	143	return "NOTIMPLEMENTED";
	144
	145	case EXIT_NOPERMISSION:
	146	return "NOPERMISSION";
	147
	148	case EXIT_NOTINSTALLED:
	149	return "NOTINSSTALLED";
	150
	151	case EXIT_NOTCONFIGURED:
	152	return "NOTCONFIGURED";
	153
	154	case EXIT_NOTRUNNING:
	155	return "NOTRUNNING";
	156	}
	157	}
	158
	159	return NULL;
	160	}
9a57c629 LP	161
9a57c629 LP	162
96342de6	163	bool is_clean_exit(int code, int status, ExitStatusSet *success_status) {
9a57c629 LP	164
9a57c629 LP	165	if (code == CLD_EXITED)
96342de6 LN	166	return status == 0 \|\|
	167	(success_status &&
	168	set_contains(success_status->code, INT_TO_PTR(status)));
9a57c629 LP	169
	170	/* If a daemon does not implement handlers for some of the
	171	* signals that's not considered an unclean shutdown */
	172	if (code == CLD_KILLED)
	173	return
	174	status == SIGHUP \|\|
	175	status == SIGINT \|\|
	176	status == SIGTERM \|\|
96342de6 LN	177	status == SIGPIPE \|\|
	178	(success_status &&
	179	set_contains(success_status->signal, INT_TO_PTR(status)));
9a57c629 LP	180
	181	return false;
	182	}
	183
96342de6	184	bool is_clean_exit_lsb(int code, int status, ExitStatusSet *success_status) {
9a57c629	185
96342de6	186	if (is_clean_exit(code, status, success_status))
9a57c629 LP	187	return true;
	188
	189	return
	190	code == CLD_EXITED &&
	191	(status == EXIT_NOTINSTALLED \|\| status == EXIT_NOTCONFIGURED);
	192	}