int main(int argc, char *argv[])
{
int ret = 0;
GenericAgentConfig *config = CheckOpts(argc, argv);
#ifdef HAVE_AVAHI_CLIENT_CLIENT_H
#ifdef HAVE_AVAHI_COMMON_ADDRESS_H
if (NULL_OR_EMPTY(POLICY_SERVER) && BOOTSTRAP)
{
int ret = AutomaticBootstrap();
if (ret < 0)
{
return 1;
}
}
#endif
#endif
ReportContext *report_context = OpenReports(config->agent_type);
GenericAgentDiscoverContext(config, report_context);
Policy *policy = GenericAgentLoadPolicy(config, report_context, ALWAYS_VALIDATE);
CheckLicenses();
ThisAgentInit();
BeginAudit();
KeepPromises(policy, config, report_context);
CloseReports("agent", report_context);
// only note class usage when default policy is run
if (!config->input_file)
{
NoteClassUsage(VHEAP, true);
NoteClassUsage(VHARDHEAP, true);
}
#ifdef HAVE_NOVA
Nova_NoteVarUsageDB();
Nova_TrackExecution(config->input_file);
#endif
PurgeLocks();
if (BOOTSTRAP && !VerifyBootstrap())
{
ret = 1;
}
EndAudit(CFA_BACKGROUND);
GenericAgentConfigDestroy(config);
return ret;
}
int main(int argc, char *argv[])
{
GenericAgentConfig *config = CheckOpts(argc, argv);
ReportContext *report_context = OpenReports(config->agent_type);
GenericAgentDiscoverContext(config, report_context);
Policy *policy = GenericAgentLoadPolicy(config, report_context, false);
CheckLicenses();
ThisAgentInit();
KeepPromises(policy, config, report_context);
Summarize();
StartServer(policy, config, report_context);
ReportContextDestroy(report_context);
GenericAgentConfigDestroy(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[])
{
GenericAgentConfig *config = CheckOpts(argc, argv);
ReportContext *report_context = OpenReports(config->agent_type);
GenericAgentDiscoverContext(config, report_context);
Policy *policy = NULL;
if (GenericAgentCheckPolicy(config, report_context, false))
{
policy = GenericAgentLoadPolicy(config->agent_type, config, report_context);
}
else if (config->tty_interactive)
{
FatalError("CFEngine was not able to get confirmation of promises from cf-promises, please verify input file\n");
}
else
{
CfOut(OUTPUT_LEVEL_ERROR, "", "CFEngine was not able to get confirmation of promises from cf-promises, so going to failsafe\n");
HardClass("failsafe_fallback");
GenericAgentConfigSetInputFile(config, "failsafe.cf");
policy = GenericAgentLoadPolicy(config->agent_type, config, report_context);
}
CheckLicenses();
ThisAgentInit();
ExecConfig exec_config = {
.scheduled_run = !ONCE,
.exec_command = SafeStringDuplicate(""),
.mail_server = SafeStringDuplicate(""),
.mail_from_address = SafeStringDuplicate(""),
.mail_to_address = SafeStringDuplicate(""),
.mail_max_lines = 30,
.fq_name = VFQNAME,
.ip_address = VIPADDRESS,
.agent_expireafter = 10080,
};
KeepPromises(policy, &exec_config);
#ifdef __MINGW32__
if (WINSERVICE)
{
NovaWin_StartExecService();
}
else
#endif /* __MINGW32__ */
{
StartServer(policy, config, &exec_config, report_context);
}
ReportContextDestroy(report_context);
GenericAgentConfigDestroy(config);
return 0;
}
/*****************************************************************************/
/* Level 1 */
/*****************************************************************************/
static GenericAgentConfig *CheckOpts(int argc, char **argv)
{
extern char *optarg;
int optindex = 0;
int c;
char ld_library_path[CF_BUFSIZE];
GenericAgentConfig *config = GenericAgentConfigNewDefault(AGENT_TYPE_EXECUTOR);
while ((c = getopt_long(argc, argv, "dvnKIf:D:N:VxL:hFOV1gMW", OPTIONS, &optindex)) != EOF)
{
switch ((char) c)
{
case 'f':
if (optarg && strlen(optarg) < 5)
{
FatalError(" -f used but argument \"%s\" incorrect", optarg);
}
GenericAgentConfigSetInputFile(config, optarg);
MINUSF = true;
break;
case 'd':
HardClass("opt_debug");
DEBUG = true;
break;
case 'K':
IGNORELOCK = true;
break;
case 'D':
NewClassesFromString(optarg);
break;
case 'N':
NegateClassesFromString(optarg);
break;
case 'I':
INFORM = true;
break;
case 'v':
VERBOSE = true;
NO_FORK = true;
break;
case 'n':
DONTDO = true;
IGNORELOCK = true;
HardClass("opt_dry_run");
break;
case 'L':
snprintf(ld_library_path, CF_BUFSIZE - 1, "LD_LIBRARY_PATH=%s", optarg);
if (putenv(xstrdup(ld_library_path)) != 0)
{
}
break;
case 'W':
WINSERVICE = false;
break;
case 'F':
NO_FORK = true;
break;
case 'O':
ONCE = true;
break;
case 'V':
PrintVersionBanner("cf-execd");
exit(0);
case 'h':
Syntax("cf-execd - cfengine's execution agent", OPTIONS, HINTS, ID);
exit(0);
case 'M':
ManPage("cf-execd - cfengine's execution agent", OPTIONS, HINTS, ID);
exit(0);
case 'x':
CfOut(OUTPUT_LEVEL_ERROR, "", "Self-diagnostic functionality is retired.");
exit(0);
default:
Syntax("cf-execd - cfengine's execution agent", OPTIONS, HINTS, ID);
exit(1);
}
}
if (argv[optind] != NULL)
{
CfOut(OUTPUT_LEVEL_ERROR, "", "Unexpected argument with no preceding option: %s\n", argv[optind]);
}
return config;
}
/*****************************************************************************/
static void LoadDefaultSchedule(void)
{
CfDebug("Loading default schedule...\n");
DeleteItemList(SCHEDULE);
SCHEDULE = NULL;
AppendItem(&SCHEDULE, "Min00", NULL);
AppendItem(&SCHEDULE, "Min05", NULL);
AppendItem(&SCHEDULE, "Min10", NULL);
AppendItem(&SCHEDULE, "Min15", NULL);
AppendItem(&SCHEDULE, "Min20", NULL);
AppendItem(&SCHEDULE, "Min25", NULL);
AppendItem(&SCHEDULE, "Min30", NULL);
AppendItem(&SCHEDULE, "Min35", NULL);
AppendItem(&SCHEDULE, "Min40", NULL);
AppendItem(&SCHEDULE, "Min45", NULL);
AppendItem(&SCHEDULE, "Min50", NULL);
AppendItem(&SCHEDULE, "Min55", NULL);
}
int main(int argc, char *argv[])
{
int ret = 0;
GenericAgentConfig *config = CheckOpts(argc, argv);
#ifdef HAVE_AVAHI_CLIENT_CLIENT_H
#ifdef HAVE_AVAHI_COMMON_ADDRESS_H
if (NULL_OR_EMPTY(POLICY_SERVER) && BOOTSTRAP)
{
int ret = AutomaticBootstrap();
if (ret < 0)
{
return 1;
}
}
#endif
#endif
ReportContext *report_context = OpenReports(config->agent_type);
GenericAgentDiscoverContext(config, report_context);
Policy *policy = NULL;
if (GenericAgentCheckPolicy(config, report_context, ALWAYS_VALIDATE))
{
policy = GenericAgentLoadPolicy(config->agent_type, config, report_context);
}
else if (config->tty_interactive)
{
FatalError("CFEngine was not able to get confirmation of promises from cf-promises, please verify input file\n");
}
else
{
CfOut(OUTPUT_LEVEL_ERROR, "", "CFEngine was not able to get confirmation of promises from cf-promises, so going to failsafe\n");
HardClass("failsafe_fallback");
GenericAgentConfigSetInputFile(config, "failsafe.cf");
policy = GenericAgentLoadPolicy(config->agent_type, config, report_context);
}
CheckLicenses();
ThisAgentInit();
BeginAudit();
KeepPromises(policy, config, report_context);
CloseReports("agent", report_context);
// only note class usage when default policy is run
if (!config->input_file)
{
NoteClassUsage(VHEAP, true);
NoteClassUsage(VHARDHEAP, true);
}
#ifdef HAVE_NOVA
Nova_NoteVarUsageDB();
Nova_TrackExecution(config->input_file);
#endif
PurgeLocks();
if (BOOTSTRAP && !VerifyBootstrap())
{
ret = 1;
}
EndAudit(CFA_BACKGROUND);
GenericAgentConfigDestroy(config);
return ret;
}
int main(int argc, char *argv[])
{
Rlist *rp;
Promise *pp;
#if !defined(__MINGW32__)
int count = 0;
int status;
int pid;
#endif
GenericAgentConfig *config = CheckOpts(argc, argv);
ReportContext *report_context = OpenReports(config->agent_type);
GenericAgentDiscoverContext(config, report_context);
Policy *policy = GenericAgentLoadPolicy(config->agent_type, config, report_context);
CheckLicenses();
ThisAgentInit();
KeepControlPromises(policy); // Set RUNATTR using copy
if (BACKGROUND && INTERACTIVE)
{
CfOut(OUTPUT_LEVEL_ERROR, "", " !! You cannot specify background mode and interactive mode together");
exit(1);
}
pp = MakeDefaultRunAgentPromise();
/* 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(rp->item, RUNATTR, pp);
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(rp->item, RUNATTR, pp);
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
PromiseDestroy(pp);
GenericAgentConfigDestroy(config);
ReportContextDestroy(report_context);
return 0;
}
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);
}
}
void GenericInitialize(int argc,char **argv,char *agents)
{ enum cfagenttype ag = Agent2Type(agents);
char vbuff[CF_BUFSIZE];
int ok = false;
#ifdef HAVE_NOVA
CF_DEFAULT_DIGEST = cf_sha256;
CF_DEFAULT_DIGEST_LEN = CF_SHA256_LEN;
#else
CF_DEFAULT_DIGEST = cf_md5;
CF_DEFAULT_DIGEST_LEN = CF_MD5_LEN;
#endif
InitializeGA(argc,argv);
SetReferenceTime(true);
SetStartTime(false);
SetSignals();
SanitizeEnvironment();
strcpy(THIS_AGENT,CF_AGENTTYPES[ag]);
NewClass(THIS_AGENT);
THIS_AGENT_TYPE = ag;
// need scope sys to set vars in expiry function
SetNewScope("sys");
if (EnterpriseExpiry())
{
CfOut(cf_error,"","Cfengine - autonomous configuration engine. This enterprise license is invalid.\n");
exit(1);
}
if (AM_NOVA)
{
CfOut(cf_verbose,""," -> This is CFE Nova\n");
}
if (AM_CONSTELLATION)
{
CfOut(cf_verbose,""," -> This is CFE Constellation\n");
}
NewScope("const");
NewScope("match");
NewScope("mon");
GetNameInfo3();
CfGetInterfaceInfo(ag);
if (ag != cf_know)
{
Get3Environment();
BuiltinClasses();
OSClasses();
}
LoadPersistentContext();
LoadSystemConstants();
snprintf(vbuff,CF_BUFSIZE,"control_%s",THIS_AGENT);
SetNewScope(vbuff);
NewScope("this");
NewScope("match");
if (BOOTSTRAP)
{
CheckAutoBootstrap();
}
else
{
if (strlen(POLICY_SERVER) > 0)
{
CfOut(cf_verbose,""," -> Found a policy server (hub) on %s",POLICY_SERVER);
}
else
{
CfOut(cf_verbose,""," -> No policy server (hub) watch yet registered");
}
}
SetPolicyServer(POLICY_SERVER);
if (ag != cf_keygen)
{
if (!MissingInputFile())
{
bool check_promises = false;
if (SHOWREPORTS)
{
check_promises = true;
CfOut(cf_verbose, "", " -> Reports mode is enabled, force-validating policy");
}
if (IsFileOutsideDefaultRepository(VINPUTFILE))
{
check_promises = true;
CfOut(cf_verbose, "", " -> Input file is outside default repository, validating it");
}
if (NewPromiseProposals())
{
check_promises = true;
CfOut(cf_verbose, "", " -> Input file is changed since last validation, validating it");
}
if (check_promises)
{
ok = CheckPromises(ag);
if (BOOTSTRAP && !ok)
{
CfOut(cf_verbose, "", " -> Policy is not valid, but proceeding with bootstrap");
ok = true;
}
}
else
{
CfOut(cf_verbose, "", " -> Policy is already validated");
ok = true;
}
}
if (ok)
{
ReadPromises(ag,agents);
}
else
{
CfOut(cf_error,"","cf-agent was not able to get confirmation of promises from cf-promises, so going to failsafe\n");
snprintf(VINPUTFILE,CF_BUFSIZE-1,"failsafe.cf");
ReadPromises(ag,agents);
}
if (SHOWREPORTS)
{
CompilationReport(VINPUTFILE);
}
CheckLicenses();
}
XML = 0;
}
