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