[thirdparty/systemd.git] / src / test / test-condition.c

/***
  This file is part of systemd

  Copyright 2014 Ronny Chevalier

  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 "sd-id128.h"

#include "apparmor-util.h"
#include "architecture.h"
#include "audit.h"
#include "condition.h"
#include "hostname-util.h"
#include "ima-util.h"
#include "log.h"
#include "macro.h"
#include "selinux-util.h"
#include "smack-util.h"
#include "util.h"

static void test_condition_test_path(void) {
        Condition *condition;

        condition = condition_new(CONDITION_PATH_EXISTS, "/bin/sh", false, false);
        assert_se(condition_test(condition));
        condition_free(condition);

        condition = condition_new(CONDITION_PATH_EXISTS, "/bin/s?", false, false);
        assert_se(!condition_test(condition));
        condition_free(condition);

        condition = condition_new(CONDITION_PATH_EXISTS_GLOB, "/bin/s?", false, false);
        assert_se(condition_test(condition));
        condition_free(condition);

        condition = condition_new(CONDITION_PATH_EXISTS_GLOB, "/bin/s?", false, true);
        assert_se(!condition_test(condition));
        condition_free(condition);

        condition = condition_new(CONDITION_PATH_EXISTS, "/thiscertainlywontexist", false, false);
        assert_se(!condition_test(condition));
        condition_free(condition);

        condition = condition_new(CONDITION_PATH_EXISTS, "/thiscertainlywontexist", false, true);
        assert_se(condition_test(condition));
        condition_free(condition);

        condition = condition_new(CONDITION_PATH_IS_DIRECTORY, "/bin", false, false);
        assert_se(condition_test(condition));
        condition_free(condition);

        condition = condition_new(CONDITION_DIRECTORY_NOT_EMPTY, "/bin", false, false);
        assert_se(condition_test(condition));
        condition_free(condition);

        condition = condition_new(CONDITION_FILE_NOT_EMPTY, "/bin/sh", false, false);
        assert_se(condition_test(condition));
        condition_free(condition);

        condition = condition_new(CONDITION_FILE_IS_EXECUTABLE, "/bin/sh", false, false);
        assert_se(condition_test(condition));
        condition_free(condition);

        condition = condition_new(CONDITION_FILE_IS_EXECUTABLE, "/etc/passwd", false, false);
        assert_se(!condition_test(condition));
        condition_free(condition);

        condition = condition_new(CONDITION_PATH_IS_MOUNT_POINT, "/proc", false, false);
        assert_se(condition_test(condition));
        condition_free(condition);

        condition = condition_new(CONDITION_PATH_IS_MOUNT_POINT, "/", false, false);
        assert_se(condition_test(condition));
        condition_free(condition);

        condition = condition_new(CONDITION_PATH_IS_MOUNT_POINT, "/bin", false, false);
        assert_se(!condition_test(condition));
        condition_free(condition);

        condition = condition_new(CONDITION_PATH_IS_READ_WRITE, "/tmp", false, false);
        assert_se(condition_test(condition));
        condition_free(condition);

        condition = condition_new(CONDITION_PATH_IS_SYMBOLIC_LINK, "/dev/stdout", false, false);
        assert_se(condition_test(condition));
        condition_free(condition);
}

static void test_condition_test_ac_power(void) {
        Condition *condition;

        condition = condition_new(CONDITION_AC_POWER, "true", false, false);
        assert_se(condition_test(condition) == on_ac_power());
        condition_free(condition);

        condition = condition_new(CONDITION_AC_POWER, "false", false, false);
        assert_se(condition_test(condition) != on_ac_power());
        condition_free(condition);

        condition = condition_new(CONDITION_AC_POWER, "false", false, true);
        assert_se(condition_test(condition) == on_ac_power());
        condition_free(condition);
}

static void test_condition_test_host(void) {
        Condition *condition;
        sd_id128_t id;
        int r;
        char sid[SD_ID128_STRING_MAX];
        _cleanup_free_ char *hostname = NULL;

        r = sd_id128_get_machine(&id);
        assert_se(r >= 0);
        assert_se(sd_id128_to_string(id, sid));

        condition = condition_new(CONDITION_HOST, sid, false, false);
        assert_se(condition_test(condition));
        condition_free(condition);

        condition = condition_new(CONDITION_HOST, "garbage value jjjjjjjjjjjjjj", false, false);
        assert_se(!condition_test(condition));
        condition_free(condition);

        condition = condition_new(CONDITION_HOST, sid, false, true);
        assert_se(!condition_test(condition));
        condition_free(condition);

        hostname = gethostname_malloc();
        assert_se(hostname);

        condition = condition_new(CONDITION_HOST, hostname, false, false);
        assert_se(condition_test(condition));
        condition_free(condition);
}

static void test_condition_test_architecture(void) {
        Condition *condition;
        const char *sa;
        int a;

        a = uname_architecture();
        assert_se(a >= 0);

        sa = architecture_to_string(a);
        assert_se(sa);

        condition = condition_new(CONDITION_ARCHITECTURE, sa, false, false);
        assert_se(condition_test(condition));
        condition_free(condition);

        condition = condition_new(CONDITION_ARCHITECTURE, "garbage value", false, false);
        assert_se(condition_test(condition) < 0);
        condition_free(condition);

        condition = condition_new(CONDITION_ARCHITECTURE, sa, false, true);
        assert_se(!condition_test(condition));
        condition_free(condition);
}

static void test_condition_test_kernel_command_line(void) {
        Condition *condition;

        condition = condition_new(CONDITION_KERNEL_COMMAND_LINE, "thisreallyshouldntbeonthekernelcommandline", false, false);
        assert_se(!condition_test(condition));
        condition_free(condition);

        condition = condition_new(CONDITION_KERNEL_COMMAND_LINE, "andthis=neither", false, false);
        assert_se(!condition_test(condition));
        condition_free(condition);
}

static void test_condition_test_null(void) {
        Condition *condition;

        condition = condition_new(CONDITION_NULL, NULL, false, false);
        assert_se(condition_test(condition));
        condition_free(condition);

        condition = condition_new(CONDITION_NULL, NULL, false, true);
        assert_se(!condition_test(condition));
        condition_free(condition);
}

static void test_condition_test_security(void) {
        Condition *condition;

        condition = condition_new(CONDITION_SECURITY, "garbage oifdsjfoidsjoj", false, false);
        assert_se(!condition_test(condition));
        condition_free(condition);

        condition = condition_new(CONDITION_SECURITY, "selinux", false, true);
        assert_se(condition_test(condition) != mac_selinux_use());
        condition_free(condition);

        condition = condition_new(CONDITION_SECURITY, "ima", false, false);
        assert_se(condition_test(condition) == use_ima());
        condition_free(condition);

        condition = condition_new(CONDITION_SECURITY, "apparmor", false, false);
        assert_se(condition_test(condition) == mac_apparmor_use());
        condition_free(condition);

        condition = condition_new(CONDITION_SECURITY, "smack", false, false);
        assert_se(condition_test(condition) == mac_smack_use());
        condition_free(condition);

        condition = condition_new(CONDITION_SECURITY, "audit", false, false);
        assert_se(condition_test(condition) == use_audit());
        condition_free(condition);
}


int main(int argc, char *argv[]) {
        log_parse_environment();
        log_open();

        test_condition_test_path();
        test_condition_test_ac_power();
        test_condition_test_host();
        test_condition_test_architecture();
        test_condition_test_kernel_command_line();
        test_condition_test_null();
        test_condition_test_security();

        return 0;
}
Commit	Line	Data
b08f2be6 RC	1	/***
	2	This file is part of systemd
	3
	4	Copyright 2014 Ronny Chevalier
	5
	6	systemd is free software; you can redistribute it and/or modify it
	7	under the terms of the GNU Lesser General Public License as published by
	8	the Free Software Foundation; either version 2.1 of the License, or
	9	(at your option) any later version.
	10
	11	systemd is distributed in the hope that it will be useful, but
	12	WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	14	Lesser General Public License for more details.
	15
	16	You should have received a copy of the GNU Lesser General Public License
	17	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	18	***/
	19
d1bddcec	20	#include "sd-id128.h"
07630cea LP	21
	22	#include "apparmor-util.h"
	23	#include "architecture.h"
015df1f7	24	#include "audit.h"
07630cea LP	25	#include "condition.h"
07630cea LP	26	#include "hostname-util.h"
015df1f7	27	#include "ima-util.h"
07630cea LP	28	#include "log.h"
	29	#include "macro.h"
	30	#include "selinux-util.h"
015df1f7	31	#include "smack-util.h"
07630cea	32	#include "util.h"
d1bddcec	33
015df1f7	34	static void test_condition_test_path(void) {
d1bddcec LP	35	Condition *condition;
	36
	37	condition = condition_new(CONDITION_PATH_EXISTS, "/bin/sh", false, false);
	38	assert_se(condition_test(condition));
	39	condition_free(condition);
	40
b80ba1da LP	41	condition = condition_new(CONDITION_PATH_EXISTS, "/bin/s?", false, false);
	42	assert_se(!condition_test(condition));
	43	condition_free(condition);
	44
	45	condition = condition_new(CONDITION_PATH_EXISTS_GLOB, "/bin/s?", false, false);
	46	assert_se(condition_test(condition));
	47	condition_free(condition);
	48
	49	condition = condition_new(CONDITION_PATH_EXISTS_GLOB, "/bin/s?", false, true);
	50	assert_se(!condition_test(condition));
	51	condition_free(condition);
	52
d1bddcec LP	53	condition = condition_new(CONDITION_PATH_EXISTS, "/thiscertainlywontexist", false, false);
	54	assert_se(!condition_test(condition));
	55	condition_free(condition);
	56
	57	condition = condition_new(CONDITION_PATH_EXISTS, "/thiscertainlywontexist", false, true);
	58	assert_se(condition_test(condition));
	59	condition_free(condition);
b80ba1da LP	60
	61	condition = condition_new(CONDITION_PATH_IS_DIRECTORY, "/bin", false, false);
	62	assert_se(condition_test(condition));
	63	condition_free(condition);
	64
	65	condition = condition_new(CONDITION_DIRECTORY_NOT_EMPTY, "/bin", false, false);
	66	assert_se(condition_test(condition));
	67	condition_free(condition);
	68
	69	condition = condition_new(CONDITION_FILE_NOT_EMPTY, "/bin/sh", false, false);
	70	assert_se(condition_test(condition));
	71	condition_free(condition);
	72
	73	condition = condition_new(CONDITION_FILE_IS_EXECUTABLE, "/bin/sh", false, false);
	74	assert_se(condition_test(condition));
	75	condition_free(condition);
	76
	77	condition = condition_new(CONDITION_FILE_IS_EXECUTABLE, "/etc/passwd", false, false);
	78	assert_se(!condition_test(condition));
	79	condition_free(condition);
	80
	81	condition = condition_new(CONDITION_PATH_IS_MOUNT_POINT, "/proc", false, false);
	82	assert_se(condition_test(condition));
	83	condition_free(condition);
	84
	85	condition = condition_new(CONDITION_PATH_IS_MOUNT_POINT, "/", false, false);
	86	assert_se(condition_test(condition));
	87	condition_free(condition);
	88
	89	condition = condition_new(CONDITION_PATH_IS_MOUNT_POINT, "/bin", false, false);
	90	assert_se(!condition_test(condition));
	91	condition_free(condition);
015df1f7 RC	92
	93	condition = condition_new(CONDITION_PATH_IS_READ_WRITE, "/tmp", false, false);
	94	assert_se(condition_test(condition));
	95	condition_free(condition);
	96
	97	condition = condition_new(CONDITION_PATH_IS_SYMBOLIC_LINK, "/dev/stdout", false, false);
	98	assert_se(condition_test(condition));
	99	condition_free(condition);
d1bddcec	100	}
b08f2be6 RC	101
	102	static void test_condition_test_ac_power(void) {
	103	Condition *condition;
	104
	105	condition = condition_new(CONDITION_AC_POWER, "true", false, false);
d1bddcec	106	assert_se(condition_test(condition) == on_ac_power());
b08f2be6 RC	107	condition_free(condition);
	108
	109	condition = condition_new(CONDITION_AC_POWER, "false", false, false);
d1bddcec	110	assert_se(condition_test(condition) != on_ac_power());
b08f2be6 RC	111	condition_free(condition);
	112
	113	condition = condition_new(CONDITION_AC_POWER, "false", false, true);
d1bddcec	114	assert_se(condition_test(condition) == on_ac_power());
b08f2be6 RC	115	condition_free(condition);
	116	}
	117
	118	static void test_condition_test_host(void) {
	119	Condition *condition;
	120	sd_id128_t id;
	121	int r;
	122	char sid[SD_ID128_STRING_MAX];
76082570	123	_cleanup_free_ char *hostname = NULL;
b08f2be6 RC	124
	125	r = sd_id128_get_machine(&id);
	126	assert_se(r >= 0);
	127	assert_se(sd_id128_to_string(id, sid));
	128
	129	condition = condition_new(CONDITION_HOST, sid, false, false);
d1bddcec	130	assert_se(condition_test(condition));
b08f2be6 RC	131	condition_free(condition);
	132
	133	condition = condition_new(CONDITION_HOST, "garbage value jjjjjjjjjjjjjj", false, false);
d1bddcec	134	assert_se(!condition_test(condition));
b08f2be6 RC	135	condition_free(condition);
	136
	137	condition = condition_new(CONDITION_HOST, sid, false, true);
d1bddcec	138	assert_se(!condition_test(condition));
b08f2be6 RC	139	condition_free(condition);
	140
	141	hostname = gethostname_malloc();
	142	assert_se(hostname);
	143
	144	condition = condition_new(CONDITION_HOST, hostname, false, false);
d1bddcec	145	assert_se(condition_test(condition));
b08f2be6 RC	146	condition_free(condition);
	147	}
	148
	149	static void test_condition_test_architecture(void) {
	150	Condition *condition;
b08f2be6	151	const char *sa;
592fd144	152	int a;
b08f2be6 RC	153
	154	a = uname_architecture();
	155	assert_se(a >= 0);
	156
	157	sa = architecture_to_string(a);
	158	assert_se(sa);
	159
	160	condition = condition_new(CONDITION_ARCHITECTURE, sa, false, false);
d1bddcec	161	assert_se(condition_test(condition));
b08f2be6 RC	162	condition_free(condition);
	163
	164	condition = condition_new(CONDITION_ARCHITECTURE, "garbage value", false, false);
d1bddcec	165	assert_se(condition_test(condition) < 0);
b08f2be6 RC	166	condition_free(condition);
	167
	168	condition = condition_new(CONDITION_ARCHITECTURE, sa, false, true);
d1bddcec	169	assert_se(!condition_test(condition));
b08f2be6 RC	170	condition_free(condition);
	171	}
	172
07318c29 LP	173	static void test_condition_test_kernel_command_line(void) {
	174	Condition *condition;
	175
	176	condition = condition_new(CONDITION_KERNEL_COMMAND_LINE, "thisreallyshouldntbeonthekernelcommandline", false, false);
d1bddcec	177	assert_se(!condition_test(condition));
07318c29 LP	178	condition_free(condition);
	179
	180	condition = condition_new(CONDITION_KERNEL_COMMAND_LINE, "andthis=neither", false, false);
d1bddcec	181	assert_se(!condition_test(condition));
07318c29 LP	182	condition_free(condition);
	183	}
	184
b80ba1da LP	185	static void test_condition_test_null(void) {
	186	Condition *condition;
	187
	188	condition = condition_new(CONDITION_NULL, NULL, false, false);
	189	assert_se(condition_test(condition));
	190	condition_free(condition);
	191
	192	condition = condition_new(CONDITION_NULL, NULL, false, true);
	193	assert_se(!condition_test(condition));
	194	condition_free(condition);
	195	}
	196
015df1f7 RC	197	static void test_condition_test_security(void) {
	198	Condition *condition;
	199
	200	condition = condition_new(CONDITION_SECURITY, "garbage oifdsjfoidsjoj", false, false);
	201	assert_se(!condition_test(condition));
	202	condition_free(condition);
	203
	204	condition = condition_new(CONDITION_SECURITY, "selinux", false, true);
	205	assert_se(condition_test(condition) != mac_selinux_use());
	206	condition_free(condition);
	207
	208	condition = condition_new(CONDITION_SECURITY, "ima", false, false);
	209	assert_se(condition_test(condition) == use_ima());
	210	condition_free(condition);
	211
	212	condition = condition_new(CONDITION_SECURITY, "apparmor", false, false);
	213	assert_se(condition_test(condition) == mac_apparmor_use());
	214	condition_free(condition);
	215
	216	condition = condition_new(CONDITION_SECURITY, "smack", false, false);
	217	assert_se(condition_test(condition) == mac_smack_use());
	218	condition_free(condition);
	219
	220	condition = condition_new(CONDITION_SECURITY, "audit", false, false);
	221	assert_se(condition_test(condition) == use_audit());
	222	condition_free(condition);
	223	}
	224
	225
b08f2be6 RC	226	int main(int argc, char *argv[]) {
	227	log_parse_environment();
	228	log_open();
	229
015df1f7	230	test_condition_test_path();
b08f2be6 RC	231	test_condition_test_ac_power();
	232	test_condition_test_host();
	233	test_condition_test_architecture();
07318c29	234	test_condition_test_kernel_command_line();
b80ba1da	235	test_condition_test_null();
015df1f7	236	test_condition_test_security();
b08f2be6 RC	237
	238	return 0;
	239	}