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);
}
GenericAgentFinalize(ctx, config);
ExecConfigDestroy(exec_config);
ExecdConfigDestroy(execd_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;
}
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 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[])
{
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[])
{
#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;
}
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);
}
int main(int argc, char *argv[])
{
SetupSignalsForCfKey(HandleSignalsForAgent);
GenericAgentConfig *config = CheckOpts(argc, argv);
EvalContext *ctx = EvalContextNew();
GenericAgentConfigApply(ctx, config);
GenericAgentDiscoverContext(ctx, config);
if (SHOWHOSTS)
{
SetupSignalsForCfKey(handleShowKeysSignal);
ShowLastSeenHosts();
return 0;
}
if (print_digest_arg)
{
return PrintDigest(print_digest_arg);
}
GenericAgentPostLoadInit(ctx);
if (REMOVEKEYS)
{
int status;
if (FORCEREMOVAL)
{
if (!strncmp(remove_keys_host, "SHA=", 3) ||
!strncmp(remove_keys_host, "MD5=", 3))
{
status = ForceKeyRemoval(remove_keys_host);
}
else
{
status = ForceIpAddressRemoval(remove_keys_host);
}
}
else
{
status = RemoveKeys(remove_keys_host, true);
if (status == 0 || status == 1)
{
Log (LOG_LEVEL_VERBOSE,
"Forced removal of entry '%s' was successful",
remove_keys_host);
return 0;
}
}
return status;
}
if(LICENSE_INSTALL)
{
bool success = LicenseInstall(LICENSE_SOURCE);
return success ? 0 : 1;
}
if (trust_key_arg != NULL)
{
char *filename, *ipaddr, *username;
/* We will modify the argument to --trust-key. */
char *arg = xstrdup(trust_key_arg);
ParseKeyArg(arg, &filename, &ipaddr, &username);
/* Server IP address required to trust key on the client side. */
if (ipaddr == NULL)
{
Log(LOG_LEVEL_NOTICE, "Establishing trust might be incomplete. "
"For completeness, use --trust-key IPADDR:filename");
}
bool ret = TrustKey(filename, ipaddr, username);
free(arg);
return ret ? EXIT_SUCCESS : EXIT_FAILURE;
}
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 = PublicKeyFile(GetWorkDir());
private_key_file = PrivateKeyFile(GetWorkDir());
}
bool ret = KeepKeyPromises(public_key_file, private_key_file, KEY_SIZE);
free(public_key_file);
free(private_key_file);
GenericAgentFinalize(ctx, config);
return ret ? EXIT_SUCCESS : EXIT_FAILURE;
}
int main(int argc, char *argv[])
{
SetupSignalsForAgent();
GenericAgentConfig *config = CheckOpts(argc, argv);
enum generic_agent_config_common_policy_output_format format = config->agent_specific.common.policy_output_format;
if (format == GENERIC_AGENT_CONFIG_COMMON_POLICY_OUTPUT_FORMAT_CF ||
format == GENERIC_AGENT_CONFIG_COMMON_POLICY_OUTPUT_FORMAT_JSON)
{
// Just parse and write content to output
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);
if (format == GENERIC_AGENT_CONFIG_COMMON_POLICY_OUTPUT_FORMAT_CF)
{
PolicyToString(output_policy, writer);
}
else
{
JsonElement *json_policy = PolicyToJson(output_policy);
JsonWrite(writer, json_policy, 2);
JsonDestroy(json_policy);
}
WriterClose(writer);
PolicyDestroy(output_policy);
return EXIT_SUCCESS;
}
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);
}
GenericAgentPostLoadInit(ctx);
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);
}
}
switch (config->agent_specific.common.policy_output_format)
{
case GENERIC_AGENT_CONFIG_COMMON_POLICY_OUTPUT_FORMAT_CF_FULL:
{
Writer *writer = FileWriter(stdout);
PolicyToString(policy, writer);
WriterClose(writer);
}
break;
case GENERIC_AGENT_CONFIG_COMMON_POLICY_OUTPUT_FORMAT_JSON_FULL:
{
Writer *writer = FileWriter(stdout);
JsonElement *json_policy = PolicyToJson(policy);
JsonWrite(writer, json_policy, 2);
JsonDestroy(json_policy);
WriterClose(writer);
}
break;
// already handled, but avoids compiler warnings
case GENERIC_AGENT_CONFIG_COMMON_POLICY_OUTPUT_FORMAT_CF:
case GENERIC_AGENT_CONFIG_COMMON_POLICY_OUTPUT_FORMAT_JSON:
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);
}