int main(int argc, char *argv[])
{
EvalContext *ctx = EvalContextNew();
GenericAgentConfig *config = CheckOpts(argc, argv);
GenericAgentConfigApply(ctx, config);
ReportContext *report_context = OpenReports(ctx, config->agent_type);
GenericAgentDiscoverContext(ctx, config, report_context);
if (SHOWHOSTS)
{
ShowLastSeenHosts();
return 0;
}
if (print_digest_arg)
{
return PrintDigest(print_digest_arg);
}
if (REMOVEKEYS)
{
return RemoveKeys(remove_keys_host);
}
if(LICENSE_INSTALL)
{
bool success = LicenseInstall(LICENSE_SOURCE);
return success ? 0 : 1;
}
if (trust_key_arg)
{
return TrustKey(trust_key_arg);
}
char *public_key_file, *private_key_file;
if (KEY_PATH)
{
xasprintf(&public_key_file, "%s.pub", KEY_PATH);
xasprintf(&private_key_file, "%s.priv", KEY_PATH);
}
else
{
public_key_file = xstrdup(PublicKeyFile());
private_key_file = xstrdup(PrivateKeyFile());
}
KeepKeyPromises(public_key_file, private_key_file);
free(public_key_file);
free(private_key_file);
ReportContextDestroy(report_context);
GenericAgentConfigDestroy(config);
EvalContextDestroy(ctx);
return 0;
}
static void test_match_region(void)
{
EvalContext *ctx =EvalContextNew();
Item *items = NULL;
Item *begin, *end;
PrependItem(&items, "third", NULL);
assert_true(MatchRegion(ctx, "third", items, NULL, false));
end = items;
PrependItem(&items, "second", NULL);
PrependItem(&items, "first", NULL);
begin = items;
assert_true(MatchRegion(ctx, "first", begin, end, false));
assert_false(MatchRegion(ctx, "second", begin, end, false));
assert_false(MatchRegion(ctx, "third", begin, end, false));
assert_true(MatchRegion(ctx, "first\nsecond", begin, end, false));
assert_false(MatchRegion(ctx, "first\nthird", begin, end, false));
assert_false(MatchRegion(ctx, "second\nthird", begin, end, false));
assert_false(MatchRegion(ctx, "first\nsecond\nthird", begin, end, false));
assert_true(MatchRegion(ctx, "first", begin, NULL, false));
assert_false(MatchRegion(ctx, "second", begin, NULL, false));
assert_false(MatchRegion(ctx, "third", begin, NULL, false));
assert_true(MatchRegion(ctx, "first\nsecond", begin, NULL, false));
assert_false(MatchRegion(ctx, "first\nthird", begin, NULL, false));
assert_false(MatchRegion(ctx, "second\nthird", begin, NULL, false));
assert_true(MatchRegion(ctx, "first\nsecond\nthird", begin, NULL, false));
}
static void test_failsafe(void)
{
char *tmp = tempnam(NULL, "cfengine_test");
WriteBuiltinFailsafePolicyToPath(tmp);
Policy *failsafe = ParserParseFile(tmp, PARSER_WARNING_ALL, PARSER_WARNING_ALL);
unlink(tmp);
free(tmp);
assert_true(failsafe);
Seq *errs = SeqNew(10, PolicyErrorDestroy);
PolicyCheckPartial(failsafe, errs);
DumpErrors(errs);
assert_int_equal(0, SeqLength(errs));
{
EvalContext *ctx = EvalContextNew();
PolicyCheckRunnable(ctx, failsafe, errs, false);
DumpErrors(errs);
assert_int_equal(0, SeqLength(errs));
EvalContextDestroy(ctx);
}
assert_int_equal(0, (SeqLength(errs)));
SeqDestroy(errs);
PolicyDestroy(failsafe);
}
static void test_block_text_match2(void)
{
EvalContext *ctx = EvalContextNew();
int start, end;
assert_int_not_equal(BlockTextMatch(ctx, "[a-z]+", "1234abcd6789", &start, &end), 0);
assert_int_equal(start, 4);
assert_int_equal(end, 8);
EvalContextDestroy(ctx);
}
static void test_block_text_match(void)
{
EvalContext *ctx = EvalContextNew();
int start, end;
assert_int_not_equal(BlockTextMatch(ctx, "#[^\n]*", "line 1:\nline2: # comment to end\nline 3: blablab", &start, &end),
0);
assert_int_equal(start, 15);
assert_int_equal(end, 31);
EvalContextDestroy(ctx);
}
int main(int argc, char *argv[])
{
EvalContext *ctx = EvalContextNew();
GenericAgentConfig *config = CheckOpts(ctx, argc, argv);
GenericAgentConfigApply(ctx, config);
GenericAgentDiscoverContext(ctx, config);
Policy *policy = GenericAgentLoadPolicy(ctx, config);
if (!policy)
{
Log(LOG_LEVEL_ERR, "Input files contain errors.");
exit(EXIT_FAILURE);
}
if (SHOWREPORTS)
{
ShowPromises(policy->bundles, policy->bodies);
}
switch (config->agent_specific.common.policy_output_format)
{
case GENERIC_AGENT_CONFIG_COMMON_POLICY_OUTPUT_FORMAT_CF:
{
Policy *output_policy = ParserParseFile(config->input_file, config->agent_specific.common.parser_warnings,
config->agent_specific.common.parser_warnings_error);
Writer *writer = FileWriter(stdout);
PolicyToString(policy, writer);
WriterClose(writer);
PolicyDestroy(output_policy);
}
break;
case GENERIC_AGENT_CONFIG_COMMON_POLICY_OUTPUT_FORMAT_JSON:
{
Policy *output_policy = ParserParseFile(config->input_file, config->agent_specific.common.parser_warnings,
config->agent_specific.common.parser_warnings_error);
JsonElement *json_policy = PolicyToJson(output_policy);
Writer *writer = FileWriter(stdout);
JsonWrite(writer, json_policy, 2);
WriterClose(writer);
JsonDestroy(json_policy);
PolicyDestroy(output_policy);
}
break;
case GENERIC_AGENT_CONFIG_COMMON_POLICY_OUTPUT_FORMAT_NONE:
break;
}
GenericAgentConfigDestroy(config);
EvalContextDestroy(ctx);
}
int main(int argc, char *argv[])
{
EvalContext *ctx = EvalContextNew();
GenericAgentConfig *config = CheckOpts(ctx, argc, argv);
GenericAgentConfigApply(ctx, config);
GenericAgentDiscoverContext(ctx, config);
Policy *policy = NULL;
if (GenericAgentCheckPolicy(ctx, config, false))
{
policy = GenericAgentLoadPolicy(ctx, config);
}
else if (config->tty_interactive)
{
exit(EXIT_FAILURE);
}
else
{
CfOut(OUTPUT_LEVEL_ERROR, "", "CFEngine was not able to get confirmation of promises from cf-promises, so going to failsafe\n");
EvalContextHeapAddHard(ctx, "failsafe_fallback");
GenericAgentConfigSetInputFile(config, "failsafe.cf");
policy = GenericAgentLoadPolicy(ctx, config);
}
WarnAboutDeprecatedFeatures(ctx);
CheckForPolicyHub(ctx);
ThisAgentInit();
ExecConfig *exec_config = ExecConfigNewDefault(!ONCE, VFQNAME, VIPADDRESS);
ExecConfigUpdate(ctx, policy, exec_config);
SetFacility(exec_config->log_facility);
#ifdef __MINGW32__
if (WINSERVICE)
{
NovaWin_StartExecService();
}
else
#endif /* __MINGW32__ */
{
StartServer(ctx, policy, config, exec_config);
}
ExecConfigDestroy(exec_config);
GenericAgentConfigDestroy(config);
return 0;
}
int main(int argc, char *argv[])
{
EvalContext *ctx = EvalContextNew();
GenericAgentConfig *config = CheckOpts(ctx, argc, argv);
GenericAgentConfigApply(ctx, config);
GenericAgentDiscoverContext(ctx, config);
Policy *policy = NULL;
if (GenericAgentCheckPolicy(config, false))
{
policy = GenericAgentLoadPolicy(ctx, config);
}
else if (config->tty_interactive)
{
exit(EXIT_FAILURE);
}
else
{
Log(LOG_LEVEL_ERR, "CFEngine was not able to get confirmation of promises from cf-promises, so going to failsafe");
EvalContextClassPut(ctx, NULL, "failsafe_fallback", false, CONTEXT_SCOPE_NAMESPACE, "goal=update,source=agent");
GenericAgentConfigSetInputFile(config, GetWorkDir(), "failsafe.cf");
policy = GenericAgentLoadPolicy(ctx, config);
}
ThisAgentInit();
ExecConfig *exec_config = ExecConfigNewDefault(!ONCE, VFQNAME, VIPADDRESS);
ExecConfigUpdate(ctx, policy, exec_config);
SetFacility(exec_config->log_facility);
#ifdef __MINGW32__
if (WINSERVICE)
{
NovaWin_StartExecService();
}
else
#endif /* __MINGW32__ */
{
StartServer(ctx, policy, config, exec_config);
}
ExecConfigDestroy(exec_config);
GenericAgentConfigDestroy(config);
return 0;
}
int main(int argc, char *argv[])
{
GenericAgentConfig *config = CheckOpts(argc, argv);
EvalContext *ctx = EvalContextNew();
GenericAgentConfigApply(ctx, config);
GenericAgentDiscoverContext(ctx, config);
Policy *policy = NULL;
if (GenericAgentCheckPolicy(config, false, false))
{
policy = LoadPolicy(ctx, config);
}
else if (config->tty_interactive)
{
exit(EXIT_FAILURE);
}
else
{
Log(LOG_LEVEL_ERR, "CFEngine was not able to get confirmation of promises from cf-promises, so going to failsafe");
EvalContextClassPutHard(ctx, "failsafe_fallback", "attribute_name=Errors,source=agent");
GenericAgentConfigSetInputFile(config, GetInputDir(), "failsafe.cf");
policy = LoadPolicy(ctx, config);
}
ThisAgentInit();
ExecConfig *exec_config = ExecConfigNew(!ONCE, ctx, policy);
ExecdConfig *execd_config = ExecdConfigNew(ctx, policy);
SetFacility(execd_config->log_facility);
#ifdef __MINGW32__
if (WINSERVICE)
{
NovaWin_StartExecService();
}
else
#endif /* __MINGW32__ */
{
StartServer(ctx, policy, config, &execd_config, &exec_config);
}
ExecConfigDestroy(exec_config);
ExecdConfigDestroy(execd_config);
GenericAgentConfigDestroy(config);
return 0;
}
int main(int argc, char *argv[])
{
/* Ensure that if fd 0,1,2 are closed, we reserve them to avoid opening
* the listening socket on them and closing it later when daemonising. */
int fd = -1;
do
{
fd = open(NULLFILE, O_RDWR, 0);
} while (fd == STDIN_FILENO ||
fd == STDOUT_FILENO ||
fd == STDERR_FILENO);
close(fd);
GenericAgentConfig *config = CheckOpts(argc, argv);
EvalContext *ctx = EvalContextNew();
GenericAgentConfigApply(ctx, config);
GenericAgentDiscoverContext(ctx, config);
Policy *policy = SelectAndLoadPolicy(config, ctx, false, false);
if (!policy)
{
Log(LOG_LEVEL_ERR, "Error reading CFEngine policy. Exiting...");
exit(EXIT_FAILURE);
}
GenericAgentPostLoadInit(ctx);
ThisAgentInit();
KeepPromises(ctx, policy, config);
Summarize();
int threads_left = StartServer(ctx, &policy, config);
if (threads_left <= 0)
{
PolicyDestroy(policy);
GenericAgentFinalize(ctx, config);
CleanReportBookFilterSet();
}
return 0;
}
static void test_set_names(void **state)
{
int i = 0;
EvalContext *ctx = EvalContextNew();
DetectDomainName(ctx, "laptop.intra");
for (i = 0; i < sizeof(expected_classes) / sizeof(expected_classes[0]); ++i)
{
assert_int_equal(expected_classes[i].found, true);
}
for (i = 0; i < sizeof(expected_vars) / sizeof(expected_vars[0]); ++i)
{
assert_int_equal(expected_vars[i].found, true);
}
EvalContextDestroy(ctx);
}
static void test_list_select_last_matching_not_found(void)
{
EvalContext *ctx = EvalContextNew();
Item *list = NULL, *match = NULL, *prev = NULL;
bool result;
AppendItem(&list, "abc", NULL);
AppendItem(&list, "def", NULL);
AppendItem(&list, "ghi", NULL);
AppendItem(&list, "abc", NULL);
result = SelectLastItemMatching(ctx, "xyz", list, NULL, &match, &prev);
assert_false(result);
assert_int_equal(match, CF_UNDEFINED_ITEM);
assert_int_equal(prev, CF_UNDEFINED_ITEM);
DeleteItemList(list);
EvalContextDestroy(ctx);
}
int main(int argc, char *argv[])
{
GenericAgentConfig *config = CheckOpts(argc, argv);
EvalContext *ctx = EvalContextNew();
GenericAgentConfigApply(ctx, config);
GenericAgentDiscoverContext(ctx, config);
Policy *policy = LoadPolicy(ctx, config);
ThisAgentInit(ctx);
KeepPromises(ctx, policy);
MonitorStartServer(ctx, policy);
PolicyDestroy(policy);
GenericAgentFinalize(ctx, config);
return 0;
}
static void test_list_select_last_matching_finds_last(void)
{
EvalContext *ctx = EvalContextNew();
Item *list = NULL, *match = NULL, *prev = NULL;
bool result;
AppendItem(&list, "abc", NULL);
AppendItem(&list, "def", NULL);
AppendItem(&list, "ghi", NULL);
AppendItem(&list, "abc", NULL);
result = SelectLastItemMatching(ctx, "abc", list, NULL, &match, &prev);
assert_true(result);
assert_int_equal(match, list->next->next->next);
assert_int_equal(prev, list->next->next);
DeleteItemList(list);
EvalContextDestroy(ctx);
}
static void test_set_names(void)
{
EvalContext *ctx = EvalContextNew();
DetectDomainName(ctx, "laptop.intra");
assert_true(!EvalContextClassGet(ctx, NULL, "laptop_intra_cfengine_com")->is_soft);
assert_true(!EvalContextClassGet(ctx, NULL, "intra_cfengine_com")->is_soft);
assert_true(!EvalContextClassGet(ctx, NULL, "cfengine_com")->is_soft);
assert_true(!EvalContextClassGet(ctx, NULL, "com")->is_soft);
assert_true(!EvalContextClassGet(ctx, NULL, "laptop_intra")->is_soft);
TestSysVar(ctx, "host", "laptop.intra");
TestSysVar(ctx, "fqhost", "laptop.intra.cfengine.com");
TestSysVar(ctx, "uqhost", "laptop.intra");
TestSysVar(ctx, "domain", "cfengine.com");
EvalContextDestroy(ctx);
}
static void run_test_in_policy(const char *policy_filename, TestFn fn)
{
GenericAgentConfig *agent_config = GenericAgentConfigNewDefault(
AGENT_TYPE_EXECUTOR);
EvalContext *ctx = EvalContextNew();
Policy *policy = TestParsePolicy(policy_filename);
PolicyResolve(ctx, policy, agent_config);
/* Setup global environment */
strcpy(VFQNAME, "localhost.localdomain");
strcpy(VIPADDRESS, "127.0.0.100");
EvalContextAddIpAddress(ctx, "127.0.0.100");
EvalContextAddIpAddress(ctx, "127.0.0.101");
fn(ctx, policy);
PolicyDestroy(policy);
GenericAgentFinalize(ctx, agent_config);
}
int main(int argc, char *argv[])
{
EvalContext *ctx = EvalContextNew();
GenericAgentConfig *config = CheckOpts(argc, argv);
GenericAgentConfigApply(ctx, config);
GenericAgentDiscoverContext(ctx, config);
Policy *policy = NULL;
if (GenericAgentCheckPolicy(config, false))
{
policy = GenericAgentLoadPolicy(ctx, config);
}
else if (config->tty_interactive)
{
exit(EXIT_FAILURE);
}
else
{
Log(LOG_LEVEL_ERR, "CFEngine was not able to get confirmation of promises from cf-promises, so going to failsafe");
EvalContextHeapAddHard(ctx, "failsafe_fallback");
GenericAgentConfigSetInputFile(config, GetWorkDir(), "failsafe.cf");
policy = GenericAgentLoadPolicy(ctx, config);
}
ThisAgentInit();
KeepPromises(ctx, policy, config);
Summarize();
Log(LOG_LEVEL_NOTICE, "Server is starting...");
StartServer(ctx, &policy, config);
Log(LOG_LEVEL_NOTICE, "Cleaning up and exiting...");
GenericAgentConfigDestroy(config);
PolicyDestroy(policy);
EvalContextDestroy(ctx);
return 0;
}
int main(int argc, char *argv[])
{
GenericAgentConfig *config = CheckOpts(argc, argv);
EvalContext *ctx = EvalContextNew();
GenericAgentConfigApply(ctx, config);
GenericAgentDiscoverContext(ctx, config);
Policy *policy = SelectAndLoadPolicy(config, ctx, false, false);
if (!policy)
{
Log(LOG_LEVEL_ERR, "Error reading CFEngine policy. Exiting...");
exit(EXIT_FAILURE);
}
GenericAgentPostLoadInit(ctx);
ThisAgentInit();
ExecConfig *exec_config = ExecConfigNew(!ONCE, ctx, policy);
ExecdConfig *execd_config = ExecdConfigNew(ctx, policy);
SetFacility(execd_config->log_facility);
#ifdef __MINGW32__
if (WINSERVICE)
{
NovaWin_StartExecService();
}
else
#endif /* __MINGW32__ */
{
StartServer(ctx, policy, config, &execd_config, &exec_config);
}
GenericAgentFinalize(ctx, config);
ExecConfigDestroy(exec_config);
ExecdConfigDestroy(execd_config);
return 0;
}
int main(int argc, char *argv[])
{
EvalContext *ctx = EvalContextNew();
GenericAgentConfig *config = CheckOpts(argc, argv);
GenericAgentConfigApply(ctx, config);
ReportContext *report_context = OpenReports(ctx, config->agent_type);
GenericAgentDiscoverContext(ctx, config, report_context);
Policy *policy = GenericAgentLoadPolicy(ctx, config->agent_type, config, report_context);
CheckLicenses(ctx);
ThisAgentInit(ctx);
KeepPromises(ctx, policy);
MonitorStartServer(ctx, policy, report_context);
ReportContextDestroy(report_context);
GenericAgentConfigDestroy(config);
EvalContextDestroy(ctx);
return 0;
}
int main(int argc, char *argv[])
{
EvalContext *ctx = EvalContextNew();
GenericAgentConfig *config = CheckOpts(argc, argv);
GenericAgentConfigApply(ctx, config);
ReportContext *report_context = OpenReports(config->agent_type);
GenericAgentDiscoverContext(ctx, config, report_context);
if (GENERATE_XML)
{
GenerateXml();
}
else
{
GenerateManual();
}
ReportContextDestroy(report_context);
GenericAgentConfigDestroy(config);
EvalContextDestroy(ctx);
return 0;
}
static void test_class_persistence(void)
{
EvalContext *ctx = EvalContextNew();
// simulate old version
{
CF_DB *dbp;
PersistentClassInfo i;
assert_true(OpenDB(&dbp, dbid_state));
i.expires = UINT_MAX;
i.policy = CONTEXT_STATE_POLICY_RESET;
WriteDB(dbp, "old", &i, sizeof(PersistentClassInfo));
CloseDB(dbp);
}
// e.g. by monitoring
EvalContextHeapPersistentSave(ctx, "class1", 3, CONTEXT_STATE_POLICY_PRESERVE, "a,b");
// e.g. by a class promise in a bundle with a namespace
{
Policy *p = PolicyNew();
Bundle *bp = PolicyAppendBundle(p, "ns1", "bundle1", "agent", NULL, NULL);
EvalContextStackPushBundleFrame(ctx, bp, NULL, false);
EvalContextHeapPersistentSave(ctx, "class2", 5, CONTEXT_STATE_POLICY_PRESERVE, "x");
EvalContextStackPopFrame(ctx);
PolicyDestroy(p);
}
EvalContextHeapPersistentLoadAll(ctx);
{
const Class *cls = EvalContextClassGet(ctx, "default", "old");
assert_true(cls != NULL);
assert_string_equal("old", cls->name);
assert_true(cls->tags != NULL);
assert_int_equal(1, StringSetSize(cls->tags));
assert_true(StringSetContains(cls->tags, "source=persistent"));
}
{
const Class *cls = EvalContextClassGet(ctx, "default", "class1");
assert_true(cls != NULL);
assert_string_equal("class1", cls->name);
assert_true(cls->tags != NULL);
assert_int_equal(3, StringSetSize(cls->tags));
assert_true(StringSetContains(cls->tags, "source=persistent"));
assert_true(StringSetContains(cls->tags, "a"));
assert_true(StringSetContains(cls->tags, "b"));
}
{
const Class *cls = EvalContextClassGet(ctx, "ns1", "class2");
assert_true(cls != NULL);
assert_string_equal("ns1", cls->ns);
assert_string_equal("class2", cls->name);
assert_true(cls->tags != NULL);
assert_int_equal(2, StringSetSize(cls->tags));
assert_true(StringSetContains(cls->tags, "source=persistent"));
assert_true(StringSetContains(cls->tags, "x"));
}
EvalContextDestroy(ctx);
}
static void test_load(void)
{
GenericAgentConfig *agent_config = GenericAgentConfigNewDefault(AGENT_TYPE_EXECUTOR);
ExecConfig *c = ExecConfigNewDefault(true, "host", "ip");
assert_true(c->scheduled_run);
assert_string_equal("host", c->fq_name);
assert_string_equal("ip", c->ip_address);
TestCheckConfigIsDefault(c);
EvalContext *ctx = EvalContextNew();
{
VarRef *lval = VarRefParse("g.host");
EvalContextVariablePut(ctx, lval, "snookie", DATA_TYPE_STRING, NULL);
VarRefDestroy(lval);
}
// provide a full body executor control and check that all options are collected
{
Policy *p = LoadPolicy("body_executor_control_full.cf");
PolicyResolve(ctx, p, agent_config);
ExecConfigUpdate(ctx, p, c);
assert_true(c->scheduled_run);
assert_string_equal("host", c->fq_name);
assert_string_equal("ip", c->ip_address);
assert_int_equal(120, c->agent_expireafter);
assert_string_equal("/bin/echo", c->exec_command);
assert_string_equal("LOG_LOCAL6",c->log_facility);
assert_string_equal("*****@*****.**",c->mail_from_address);
assert_int_equal(50, c->mail_max_lines);
assert_string_equal("localhost", c->mail_server);
assert_string_equal("*****@*****.**",c->mail_to_address);
assert_string_equal("Test [localhost/127.0.0.1]",c->mail_subject);
// splay time hard to test (pseudo random)
assert_int_equal(2, StringSetSize(c->schedule));
assert_true(StringSetContains(c->schedule, "Min00_05"));
assert_true(StringSetContains(c->schedule, "Min05_10"));
PolicyDestroy(p);
}
// provide a small policy and check that missing settings are being reverted to default
{
{
Policy *p = LoadPolicy("body_executor_control_agent_expireafter_only.cf");
PolicyResolve(ctx, p, agent_config);
ExecConfigUpdate(ctx, p, c);
assert_true(c->scheduled_run);
assert_string_equal("host", c->fq_name);
assert_string_equal("ip", c->ip_address);
assert_int_equal(121, c->agent_expireafter);
// rest should be default
assert_string_equal("", c->exec_command);
assert_string_equal("LOG_USER",c->log_facility);
assert_string_equal("",c->mail_from_address);
assert_int_equal(30, c->mail_max_lines);
assert_string_equal("", c->mail_server);
assert_string_equal("",c->mail_to_address);
assert_string_equal("",c->mail_subject);
assert_int_equal(0, c->splay_time);
assert_int_equal(12, StringSetSize(c->schedule));
PolicyDestroy(p);
}
}
EvalContextDestroy(ctx);
GenericAgentConfigDestroy(agent_config);
}
void test_different_name(void)
{
EvalContext *ctx = EvalContextNew();
PromiseResult result;
PackageItem pi = {
.name = "pkgone",
.version = "1",
.arch = "arch"
};
Attributes attr = {
.packages = {
.package_select = PACKAGE_VERSION_COMPARATOR_EQ
}
};
assert_int_equal(ComparePackages(ctx, "pkgtwo", "1", "arch", &pi, attr, NULL, "test", &result), VERCMP_NO_MATCH);
EvalContextDestroy(ctx);
}
void test_wildcard_arch(void)
{
EvalContext *ctx = EvalContextNew();
PromiseResult result;
PackageItem pi = {
.name = "foobar",
.version = "1",
.arch = "arch"
};
Attributes attr = {
.packages = {
.package_select = PACKAGE_VERSION_COMPARATOR_EQ
}
};
assert_int_equal(ComparePackages(ctx, "foobar", "1", "*", &pi, attr, NULL, "test", &result), VERCMP_MATCH);
EvalContextDestroy(ctx);
}
void test_non_matching_arch(void)
{
EvalContext *ctx = EvalContextNew();
PromiseResult result;
PackageItem pi = {
.name = "foobar",
.version = "1",
.arch = "s390x"
};
Attributes attr = {
.packages = {
.package_select = PACKAGE_VERSION_COMPARATOR_EQ
}
};
assert_int_equal(ComparePackages(ctx, "foobar", "1", "s390", &pi, attr, NULL, "test", &result), VERCMP_NO_MATCH);
EvalContextDestroy(ctx);
}
VersionCmpResult DoCompare(const char *lhs, const char *rhs, PackageVersionComparator cmp)
{
EvalContext *ctx = EvalContextNew();
PromiseResult result;
PackageItem pi = {
.name = "foobar",
.version = (char*)lhs,
.arch = "somearch"
};
Attributes a = {
.packages = {
.package_select = cmp,
}
};
VersionCmpResult cmp_result = ComparePackages(ctx, "foobar", rhs, "somearch", &pi, a, NULL, "test", &result);
EvalContextDestroy(ctx);
return cmp_result;
}
void test_wildcard_version(void)
{
assert_int_equal(DoCompare("1.0-1", "*", PACKAGE_VERSION_COMPARATOR_EQ), VERCMP_MATCH);
}
int main(int argc, char *argv[])
{
GenericAgentConfig *config = CheckOpts(argc, argv);
EvalContext *ctx = EvalContextNew();
GenericAgentConfigApply(ctx, config);
GenericAgentDiscoverContext(ctx, config);
Policy *policy = LoadPolicy(ctx, config);
if (!policy)
{
Log(LOG_LEVEL_ERR, "Input files contain errors.");
exit(EXIT_FAILURE);
}
if (NULL != config->tag_release_dir)
{
// write the validated file and the release ID
bool tagged = GenericAgentTagReleaseDirectory(config, config->tag_release_dir, true, true);
if (tagged)
{
Log(LOG_LEVEL_VERBOSE, "Release tagging done!");
}
else
{
Log(LOG_LEVEL_ERR, "The given directory could not be tagged, sorry.");
exit(EXIT_FAILURE);
}
}
if (SHOWREPORTS)
{
ShowPromises(policy->bundles, policy->bodies);
}
switch (config->agent_specific.common.policy_output_format)
{
case GENERIC_AGENT_CONFIG_COMMON_POLICY_OUTPUT_FORMAT_CF:
{
Policy *output_policy = ParserParseFile(AGENT_TYPE_COMMON, config->input_file,
config->agent_specific.common.parser_warnings,
config->agent_specific.common.parser_warnings_error);
Writer *writer = FileWriter(stdout);
PolicyToString(policy, writer);
WriterClose(writer);
PolicyDestroy(output_policy);
}
break;
case GENERIC_AGENT_CONFIG_COMMON_POLICY_OUTPUT_FORMAT_JSON:
{
Policy *output_policy = ParserParseFile(AGENT_TYPE_COMMON, config->input_file,
config->agent_specific.common.parser_warnings,
config->agent_specific.common.parser_warnings_error);
JsonElement *json_policy = PolicyToJson(output_policy);
Writer *writer = FileWriter(stdout);
JsonWrite(writer, json_policy, 2);
WriterClose(writer);
JsonDestroy(json_policy);
PolicyDestroy(output_policy);
}
break;
case GENERIC_AGENT_CONFIG_COMMON_POLICY_OUTPUT_FORMAT_NONE:
break;
}
if(config->agent_specific.common.show_classes)
{
ShowContextsFormatted(ctx);
}
if(config->agent_specific.common.show_variables)
{
ShowVariablesFormatted(ctx);
}
PolicyDestroy(policy);
GenericAgentFinalize(ctx, config);
}
static void test_policy_json_to_from(void)
{
EvalContext *ctx = EvalContextNew();
Policy *policy = NULL;
{
Policy *original = LoadPolicy("benchmark.cf");
JsonElement *json = PolicyToJson(original);
PolicyDestroy(original);
policy = PolicyFromJson(json);
JsonDestroy(json);
}
assert_true(policy);
assert_int_equal(1, SeqLength(policy->bundles));
assert_int_equal(2, SeqLength(policy->bodies));
{
Bundle *main_bundle = PolicyGetBundle(policy, NULL, "agent", "main");
assert_true(main_bundle);
{
{
PromiseType *files = BundleGetPromiseType(main_bundle, "files");
assert_true(files);
assert_int_equal(1, SeqLength(files->promises));
for (size_t i = 0; i < SeqLength(files->promises); i++)
{
Promise *promise = SeqAt(files->promises, i);
if (strcmp("/tmp/stuff", promise->promiser) == 0)
{
assert_string_equal("any", promise->classes);
assert_int_equal(2, SeqLength(promise->conlist));
{
Constraint *create = PromiseGetConstraint(ctx, promise, "create");
assert_true(create);
assert_string_equal("create", create->lval);
assert_string_equal("true", RvalScalarValue(create->rval));
}
{
Constraint *create = PromiseGetConstraint(ctx, promise, "perms");
assert_true(create);
assert_string_equal("perms", create->lval);
assert_string_equal("myperms", RvalScalarValue(create->rval));
}
}
else
{
fprintf(stderr, "Found unknown promise");
fail();
}
}
}
{
const char* reportOutput[2] = { "Hello, CFEngine", "Hello, world" };
const char* reportClass[2] = { "cfengine", "any" };
PromiseType *reports = BundleGetPromiseType(main_bundle, "reports");
assert_true(reports);
assert_int_equal(2, SeqLength(reports->promises));
for (size_t i = 0; i < SeqLength(reports->promises); i++)
{
Promise *promise = SeqAt(reports->promises, i);
if (strcmp(reportOutput[i], promise->promiser) == 0)
{
assert_string_equal(reportClass[i], promise->classes);
assert_int_equal(1, SeqLength(promise->conlist));
{
Constraint *friend_pattern = SeqAt(promise->conlist, 0);
assert_true(friend_pattern);
assert_string_equal("friend_pattern", friend_pattern->lval);
assert_int_equal(RVAL_TYPE_FNCALL, friend_pattern->rval.type);
FnCall *fn = RvalFnCallValue(friend_pattern->rval);
assert_string_equal("hash", fn->name);
assert_int_equal(2, RlistLen(fn->args));
}
}
else
{
fprintf(stderr, "Found unknown promise");
fail();
}
}
}
}
}
{
Body *myperms = PolicyGetBody(policy, NULL, "perms", "myperms");
assert_true(myperms);
{
Seq *mode_cps = BodyGetConstraint(myperms, "mode");
assert_int_equal(1, SeqLength(mode_cps));
Constraint *mode = SeqAt(mode_cps, 0);
assert_string_equal("mode", mode->lval);
assert_string_equal("555", RvalScalarValue(mode->rval));
}
}
PolicyDestroy(policy);
EvalContextDestroy(ctx);
}
int main(int argc, char *argv[])
{
EvalContext *ctx = EvalContextNew();
GenericAgentConfig *config = CheckOpts(ctx, argc, argv);
GenericAgentConfigApply(ctx, config);
ReportContext *report_context = OpenReports(config->agent_type);
GenericAgentDiscoverContext(ctx, config, report_context);
Policy *policy = GenericAgentLoadPolicy(ctx, config->agent_type, config, report_context);
if (SHOWREPORTS)
{
ShowPromises(ctx, policy->bundles, policy->bodies);
}
CheckLicenses(ctx);
switch (config->agent_specific.common.policy_output_format)
{
case GENERIC_AGENT_CONFIG_COMMON_POLICY_OUTPUT_FORMAT_CF:
{
Policy *output_policy = ParserParseFile(GenericAgentResolveInputPath(config->input_file, config->input_file));
Writer *writer = FileWriter(stdout);
PolicyToString(policy, writer);
WriterClose(writer);
PolicyDestroy(output_policy);
}
break;
case GENERIC_AGENT_CONFIG_COMMON_POLICY_OUTPUT_FORMAT_JSON:
{
Policy *output_policy = ParserParseFile(GenericAgentResolveInputPath(config->input_file, config->input_file));
JsonElement *json_policy = PolicyToJson(output_policy);
Writer *writer = FileWriter(stdout);
JsonElementPrint(writer, json_policy, 2);
WriterClose(writer);
JsonElementDestroy(json_policy);
PolicyDestroy(output_policy);
}
break;
case GENERIC_AGENT_CONFIG_COMMON_POLICY_OUTPUT_FORMAT_NONE:
break;
}
GenericAgentConfigDestroy(config);
CloseReports("commmon", report_context);
EvalContextDestroy(ctx);
if (ERRORCOUNT > 0)
{
CfOut(OUTPUT_LEVEL_VERBOSE, "", " !! Inputs are invalid\n");
exit(1);
}
else
{
CfOut(OUTPUT_LEVEL_VERBOSE, "", " -> Inputs are valid\n");
exit(0);
}
}
int main(int argc, char *argv[])
{
#if !defined(__MINGW32__)
int count = 0;
int status;
int pid;
#endif
GenericAgentConfig *config = CheckOpts(argc, argv);
EvalContext *ctx = EvalContextNew();
GenericAgentConfigApply(ctx, config);
GenericAgentDiscoverContext(ctx, config);
Policy *policy = LoadPolicy(ctx, config);
ThisAgentInit();
KeepControlPromises(ctx, policy); // Set RUNATTR using copy
if (BACKGROUND && INTERACTIVE)
{
Log(LOG_LEVEL_ERR, "You cannot specify background mode and interactive mode together");
exit(EXIT_FAILURE);
}
/* HvB */
if (HOSTLIST)
{
const Rlist *rp = HOSTLIST;
while (rp != NULL)
{
#ifdef __MINGW32__
if (BACKGROUND)
{
Log(LOG_LEVEL_VERBOSE,
"Windows does not support starting processes in the background - starting in foreground");
BACKGROUND = false;
}
#else
if (BACKGROUND) /* parallel */
{
if (count <= MAXCHILD)
{
if (fork() == 0) /* child process */
{
HailServer(ctx, config, RlistScalarValue(rp));
exit(EXIT_SUCCESS);
}
else /* parent process */
{
rp = rp->next;
count++;
}
}
else
{
pid = wait(&status);
Log(LOG_LEVEL_DEBUG, "child = %d, child number = %d", pid, count);
count--;
}
}
else /* serial */
#endif /* __MINGW32__ */
{
HailServer(ctx, config, RlistScalarValue(rp));
rp = rp->next;
}
} /* end while */
} /* end if HOSTLIST */
#ifndef __MINGW32__
if (BACKGROUND)
{
Log(LOG_LEVEL_NOTICE, "Waiting for child processes to finish");
while (count > 1)
{
pid = wait(&status);
Log(LOG_LEVEL_VERBOSE, "Child %d ended, number %d", pid, count);
count--;
}
}
#endif
PolicyDestroy(policy);
GenericAgentFinalize(ctx, config);
return 0;
}
static void test_setup(void **state)
{
*state = EvalContextNew();
}
static void test_full_text_match(void)
{
EvalContext *ctx = EvalContextNew();
assert_int_equal(FullTextMatch(ctx, "[a-z]*", "1234abcd6789"), 0);
EvalContextDestroy(ctx);
}
int main(int argc, char *argv[])
{
Rlist *rp;
#if !defined(__MINGW32__)
int count = 0;
int status;
int pid;
#endif
EvalContext *ctx = EvalContextNew();
GenericAgentConfig *config = CheckOpts(ctx, argc, argv);
GenericAgentConfigApply(ctx, config);
GenericAgentDiscoverContext(ctx, config);
Policy *policy = GenericAgentLoadPolicy(ctx, config);
WarnAboutDeprecatedFeatures(ctx);
CheckForPolicyHub(ctx);
ThisAgentInit();
KeepControlPromises(ctx, policy); // Set RUNATTR using copy
if (BACKGROUND && INTERACTIVE)
{
CfOut(OUTPUT_LEVEL_ERROR, "", " !! You cannot specify background mode and interactive mode together");
exit(1);
}
/* HvB */
if (HOSTLIST)
{
rp = HOSTLIST;
while (rp != NULL)
{
#ifdef __MINGW32__
if (BACKGROUND)
{
CfOut(OUTPUT_LEVEL_VERBOSE, "",
"Windows does not support starting processes in the background - starting in foreground");
BACKGROUND = false;
}
#else
if (BACKGROUND) /* parallel */
{
if (count <= MAXCHILD)
{
if (fork() == 0) /* child process */
{
HailServer(ctx, rp->item);
exit(0);
}
else /* parent process */
{
rp = rp->next;
count++;
}
}
else
{
pid = wait(&status);
CfDebug("child = %d, child number = %d\n", pid, count);
count--;
}
}
else /* serial */
#endif /* __MINGW32__ */
{
HailServer(ctx, rp->item);
rp = rp->next;
}
} /* end while */
} /* end if HOSTLIST */
#ifndef __MINGW32__
if (BACKGROUND)
{
printf("Waiting for child processes to finish\n");
while (count > 1)
{
pid = wait(&status);
CfOut(OUTPUT_LEVEL_VERBOSE, "", "Child = %d ended, number = %d\n", pid, count);
count--;
}
}
#endif
GenericAgentConfigDestroy(config);
return 0;
}
