static GenericAgentConfig *CheckOpts(int argc, char **argv)
{
extern char *optarg;
int optindex = 0;
int c;
GenericAgentConfig *config = GenericAgentConfigNewDefault(AGENT_TYPE_KEYGEN);
while ((c = getopt_long(argc, argv, "dvf:VMsr:hl:", OPTIONS, &optindex)) != EOF)
{
switch ((char) c)
{
case 'f':
snprintf(CFPRIVKEYFILE, CF_BUFSIZE, "%s.priv", optarg);
snprintf(CFPUBKEYFILE, CF_BUFSIZE, "%s.pub", optarg);
break;
case 'd':
DEBUG = true;
break;
case 'V':
PrintVersionBanner("cf-key");
exit(0);
case 'v':
VERBOSE = true;
break;
case 's':
SHOWHOSTS = true;
break;
case 'r':
REMOVEKEYS = true;
remove_keys_host = optarg;
break;
case 'l':
LICENSE_INSTALL = true;
strlcpy(LICENSE_SOURCE, optarg, sizeof(LICENSE_SOURCE));
break;
case 'h':
Syntax("cf-key - CFEngine's key generator", OPTIONS, HINTS, ID);
exit(0);
case 'M':
ManPage("cf-key - CFEngine's key generator", OPTIONS, HINTS, ID);
exit(0);
default:
Syntax("cf-key - CFEngine's key generator", OPTIONS, HINTS, ID);
exit(1);
}
}
return config;
}
static GenericAgentConfig *CheckOpts(int argc, char **argv)
{
extern char *optarg;
int optindex = 0;
int c;
GenericAgentConfig *config = GenericAgentConfigNewDefault(AGENT_TYPE_GENDOC);
if (getcwd(SOURCE_DIR, CF_BUFSIZE) == NULL)
{
UnexpectedError("Failed to get the pathname to the current directory");
}
snprintf(OUTPUT_FILE, CF_BUFSIZE, "%scf3-Reference.texinfo", SOURCE_DIR);
while ((c = getopt_long(argc, argv, "hxi:o:", OPTIONS, &optindex)) != EOF)
{
switch ((char) c)
{
case 'h':
Syntax("cf-gendoc - reference manual generator", OPTIONS, HINTS, ID);
exit(0);
case 'x':
GENERATE_XML = true;
break;
case 'i':
strlcpy(SOURCE_DIR, optarg, CF_BUFSIZE);
case 'o':
strlcpy(OUTPUT_FILE, optarg, CF_BUFSIZE);
break;
default:
Syntax("cf-gendoc - reference manual generator", 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 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);
}
GenericAgentConfig *CheckOpts(int argc, char **argv)
{
extern char *optarg;
char ld_library_path[CF_BUFSIZE];
int optindex = 0;
int c;
GenericAgentConfig *config = GenericAgentConfigNewDefault(AGENT_TYPE_SERVER);
while ((c = getopt_long(argc, argv, "dvIKf:D:N:VSxLFMhAlC::", OPTIONS, &optindex)) != EOF)
{
switch ((char) c)
{
case 'l':
LEGACY_OUTPUT = true;
break;
case 'f':
if (optarg && (strlen(optarg) < 5))
{
Log(LOG_LEVEL_ERR, " -f used but argument '%s' incorrect", optarg);
exit(EXIT_FAILURE);
}
GenericAgentConfigSetInputFile(config, GetInputDir(), optarg);
MINUSF = true;
break;
case 'd':
LogSetGlobalLevel(LOG_LEVEL_DEBUG);
NO_FORK = true;
case 'K':
config->ignore_locks = true;
break;
case 'D':
config->heap_soft = StringSetFromString(optarg, ',');
break;
case 'N':
config->heap_negated = StringSetFromString(optarg, ',');
break;
case 'I':
LogSetGlobalLevel(LOG_LEVEL_INFO);
break;
case 'v':
LogSetGlobalLevel(LOG_LEVEL_VERBOSE);
NO_FORK = true;
break;
case 'F':
NO_FORK = true;
break;
case 'L':
Log(LOG_LEVEL_VERBOSE, "Setting LD_LIBRARY_PATH to '%s'", optarg);
snprintf(ld_library_path, CF_BUFSIZE - 1, "LD_LIBRARY_PATH=%s", optarg);
putenv(ld_library_path);
break;
case 'V':
{
Writer *w = FileWriter(stdout);
GenericAgentWriteVersion(w);
FileWriterDetach(w);
}
exit(EXIT_SUCCESS);
case 'h':
{
Writer *w = FileWriter(stdout);
GenericAgentWriteHelp(w, "cf-serverd", OPTIONS, HINTS, true);
FileWriterDetach(w);
}
exit(EXIT_SUCCESS);
case 'M':
{
Writer *out = FileWriter(stdout);
ManPageWrite(out, "cf-serverd", time(NULL),
CF_SERVERD_SHORT_DESCRIPTION,
CF_SERVERD_MANPAGE_LONG_DESCRIPTION,
OPTIONS, HINTS,
true);
FileWriterDetach(out);
exit(EXIT_SUCCESS);
}
case 'x':
Log(LOG_LEVEL_ERR, "Self-diagnostic functionality is retired.");
exit(EXIT_SUCCESS);
case 'A':
#ifdef HAVE_AVAHI_CLIENT_CLIENT_H
#ifdef HAVE_AVAHI_COMMON_ADDRESS_H
Log(LOG_LEVEL_NOTICE, "Generating Avahi configuration file.");
if (GenerateAvahiConfig("/etc/avahi/services/cfengine-hub.service") != 0)
{
exit(EXIT_FAILURE);
}
cf_popen("/etc/init.d/avahi-daemon restart", "r", true);
Log(LOG_LEVEL_NOTICE, "Avahi configuration file generated successfuly.");
exit(EXIT_SUCCESS);
#endif
#endif
Log(LOG_LEVEL_ERR, "Generating avahi configuration can only be done when avahi-daemon and libavahi are installed on the machine.");
exit(EXIT_SUCCESS);
case 'C':
if (!GenericAgentConfigParseColor(config, optarg))
{
exit(EXIT_FAILURE);
}
break;
default:
{
Writer *w = FileWriter(stdout);
GenericAgentWriteHelp(w, "cf-serverd", OPTIONS, HINTS, true);
FileWriterDetach(w);
}
exit(EXIT_FAILURE);
}
}
if (!GenericAgentConfigParseArguments(config, argc - optind, argv + optind))
{
Log(LOG_LEVEL_ERR, "Too many arguments");
exit(EXIT_FAILURE);
}
return config;
}
GenericAgentConfig *CheckOpts(int argc, char **argv)
{
extern char *optarg;
char ld_library_path[CF_BUFSIZE];
int optindex = 0;
int c;
GenericAgentConfig *config = GenericAgentConfigNewDefault(AGENT_TYPE_SERVER);
while ((c = getopt_long(argc, argv, "dvIKf:D:N:VSxLFMhA", 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':
DEBUG = true;
NO_FORK = true;
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 'F':
NO_FORK = true;
break;
case 'L':
CfOut(cf_verbose, "", "Setting LD_LIBRARY_PATH=%s\n", optarg);
snprintf(ld_library_path, CF_BUFSIZE - 1, "LD_LIBRARY_PATH=%s", optarg);
putenv(ld_library_path);
break;
case 'V':
PrintVersionBanner("cf-serverd");
exit(0);
case 'h':
Syntax("cf-serverd - cfengine's server agent", OPTIONS, HINTS, ID);
exit(0);
case 'M':
ManPage("cf-serverd - cfengine's server agent", OPTIONS, HINTS, ID);
exit(0);
case 'x':
CfOut(cf_error, "", "Self-diagnostic functionality is retired.");
exit(0);
case 'A':
#ifdef HAVE_AVAHI_CLIENT_CLIENT_H
#ifdef HAVE_AVAHI_COMMON_ADDRESS_H
printf("Generating Avahi configuration file.\n");
if (GenerateAvahiConfig("/etc/avahi/services/cfengine-hub.service") != 0)
{
exit(1);
}
cf_popen("/etc/init.d/avahi-daemon restart", "r");
printf("Avahi configuration file generated successfuly.\n");
exit(0);
#else
printf("This option can only be used when avahi-daemon and libavahi are installed on the machine.\n");
#endif
#endif
default:
Syntax("cf-serverd - cfengine's server agent", OPTIONS, HINTS, ID);
exit(1);
}
}
if (argv[optind] != NULL)
{
CfOut(cf_error, "", "Unexpected argument with no preceding option: %s\n", argv[optind]);
FatalError("Aborted");
}
CfDebug("Set debugging\n");
return config;
}
static GenericAgentConfig *CheckOpts(int argc, char **argv)
{
extern char *optarg;
int optindex = 0;
int c;
GenericAgentConfig *config = GenericAgentConfigNewDefault(AGENT_TYPE_MONITOR);
while ((c = getopt_long(argc, argv, "dvnIf:VSxHTKMFh", OPTIONS, &optindex)) != EOF)
{
switch ((char) c)
{
case 'f':
GenericAgentConfigSetInputFile(config, optarg);
MINUSF = true;
break;
case 'd':
config->debug_mode = true;
NO_FORK = true;
break;
case 'K':
IGNORELOCK = true;
break;
case 'I':
INFORM = true;
break;
case 'v':
VERBOSE = true;
NO_FORK = true;
break;
case 'F':
NO_FORK = true;
break;
case 'H': /* Keep accepting this option for compatibility -- no longer used */
break;
case 'T':
MonNetworkSnifferEnable(true);
break;
case 'V':
PrintVersionBanner("cf-monitord");
exit(0);
case 'h':
Syntax("cf-monitord - cfengine's monitoring agent", OPTIONS, HINTS, ID);
exit(0);
case 'M':
ManPage("cf-monitord - cfengine's monitoring agent", OPTIONS, HINTS, ID);
exit(0);
case 'x':
CfOut(OUTPUT_LEVEL_ERROR, "", "Self-diagnostic functionality is retired.");
exit(0);
default:
Syntax("cf-monitord - cfengine's monitoring agent", OPTIONS, HINTS, ID);
exit(1);
}
}
CfDebug("Set debugging\n");
return config;
}
static GenericAgentConfig *CheckOpts(int argc, char **argv)
{
extern char *optarg;
int optindex = 0;
int c;
GenericAgentConfig *config = GenericAgentConfigNewDefault(AGENT_TYPE_MONITOR);
while ((c = getopt_long(argc, argv, "dvnIf:VSxHTKMFhlC::", OPTIONS, &optindex)) != EOF)
{
switch ((char) c)
{
case 'l':
LEGACY_OUTPUT = true;
break;
case 'f':
GenericAgentConfigSetInputFile(config, GetWorkDir(), optarg);
MINUSF = true;
break;
case 'd':
LogSetGlobalLevel(LOG_LEVEL_DEBUG);
NO_FORK = true;
break;
case 'K':
IGNORELOCK = true;
break;
case 'I':
LogSetGlobalLevel(LOG_LEVEL_INFO);
break;
case 'v':
LogSetGlobalLevel(LOG_LEVEL_VERBOSE);
NO_FORK = true;
break;
case 'F':
NO_FORK = true;
break;
case 'H': /* Keep accepting this option for compatibility -- no longer used */
break;
case 'T':
MonNetworkSnifferEnable(true);
break;
case 'V':
PrintVersion();
exit(0);
case 'h':
PrintHelp("cf-monitord", OPTIONS, HINTS, true);
exit(0);
case 'M':
{
Writer *out = FileWriter(stdout);
ManPageWrite(out, "cf-monitord", time(NULL),
CF_MONITORD_SHORT_DESCRIPTION,
CF_MONITORD_MANPAGE_LONG_DESCRIPTION,
OPTIONS, HINTS,
true);
FileWriterDetach(out);
exit(EXIT_SUCCESS);
}
case 'x':
Log(LOG_LEVEL_ERR, "Self-diagnostic functionality is retired.");
exit(0);
case 'C':
if (!GenericAgentConfigParseColor(config, optarg))
{
exit(EXIT_FAILURE);
}
break;
default:
PrintHelp("cf-monitord", OPTIONS, HINTS, true);
exit(1);
}
}
if (!GenericAgentConfigParseArguments(config, argc - optind, argv + optind))
{
Log(LOG_LEVEL_ERR, "Too many arguments");
exit(EXIT_FAILURE);
}
return config;
}
GenericAgentConfig *CheckOpts(int argc, char **argv)
{
extern char *optarg;
char ld_library_path[CF_BUFSIZE];
int optindex = 0;
int c;
GenericAgentConfig *config = GenericAgentConfigNewDefault(AGENT_TYPE_SERVER);
while ((c = getopt_long(argc, argv, "dvIKf:D:N:VSxLFMhA", OPTIONS, &optindex)) != EOF)
{
switch ((char) c)
{
case 'f':
if (optarg && (strlen(optarg) < 5))
{
CfOut(OUTPUT_LEVEL_ERROR, "", " -f used but argument \"%s\" incorrect", optarg);
exit(EXIT_FAILURE);
}
GenericAgentConfigSetInputFile(config, GetWorkDir(), optarg);
MINUSF = true;
break;
case 'd':
config->debug_mode = true;
NO_FORK = true;
case 'K':
IGNORELOCK = true;
break;
case 'D':
config->heap_soft = StringSetFromString(optarg, ',');
break;
case 'N':
config->heap_negated = StringSetFromString(optarg, ',');
break;
case 'I':
INFORM = true;
break;
case 'v':
VERBOSE = true;
NO_FORK = true;
break;
case 'F':
NO_FORK = true;
break;
case 'L':
CfOut(OUTPUT_LEVEL_VERBOSE, "", "Setting LD_LIBRARY_PATH=%s\n", optarg);
snprintf(ld_library_path, CF_BUFSIZE - 1, "LD_LIBRARY_PATH=%s", optarg);
putenv(ld_library_path);
break;
case 'V':
PrintVersion();
exit(0);
case 'h':
Syntax("cf-serverd", OPTIONS, HINTS, ID, true);
exit(0);
case 'M':
ManPage("cf-serverd - CFEngine's server agent", OPTIONS, HINTS, ID);
exit(0);
case 'x':
CfOut(OUTPUT_LEVEL_ERROR, "", "Self-diagnostic functionality is retired.");
exit(0);
case 'A':
#ifdef HAVE_AVAHI_CLIENT_CLIENT_H
#ifdef HAVE_AVAHI_COMMON_ADDRESS_H
printf("Generating Avahi configuration file.\n");
if (GenerateAvahiConfig("/etc/avahi/services/cfengine-hub.service") != 0)
{
exit(1);
}
cf_popen("/etc/init.d/avahi-daemon restart", "r", true);
printf("Avahi configuration file generated successfuly.\n");
exit(0);
#else
printf("This option can only be used when avahi-daemon and libavahi are installed on the machine.\n");
#endif
#endif
default:
Syntax("cf-serverd", OPTIONS, HINTS, ID, true);
exit(1);
}
}
if (!GenericAgentConfigParseArguments(config, argc - optind, argv + optind))
{
Log(LOG_LEVEL_ERR, "Too many arguments");
exit(EXIT_FAILURE);
}
return config;
}
GenericAgentConfig *CheckOpts(int argc, char **argv)
{
extern char *optarg;
char ld_library_path[CF_BUFSIZE];
int optindex = 0;
int c;
GenericAgentConfig *config = GenericAgentConfigNewDefault(AGENT_TYPE_SERVER);
while ((c = getopt_long(argc, argv, "dvIKf:D:N:VSxLFMh", 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':
DEBUG = true;
NO_FORK = true;
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 'F':
NO_FORK = true;
break;
case 'L':
CfOut(cf_verbose, "", "Setting LD_LIBRARY_PATH=%s\n", optarg);
snprintf(ld_library_path, CF_BUFSIZE - 1, "LD_LIBRARY_PATH=%s", optarg);
putenv(ld_library_path);
break;
case 'V':
PrintVersionBanner("cf-serverd");
exit(0);
case 'h':
Syntax("cf-serverd - cfengine's server agent", OPTIONS, HINTS, ID);
exit(0);
case 'M':
ManPage("cf-serverd - cfengine's server agent", OPTIONS, HINTS, ID);
exit(0);
case 'x':
SelfDiagnostic();
exit(0);
default:
Syntax("cf-serverd - cfengine's server agent", OPTIONS, HINTS, ID);
exit(1);
}
}
if (argv[optind] != NULL)
{
CfOut(cf_error, "", "Unexpected argument with no preceding option: %s\n", argv[optind]);
FatalError("Aborted");
}
CfDebug("Set debugging\n");
return config;
}
static GenericAgentConfig *CheckOpts(int argc, char **argv)
{
extern char *optarg;
int optindex = 0;
int c;
GenericAgentConfig *config = GenericAgentConfigNewDefault(AGENT_TYPE_RUNAGENT);
DEFINECLASSES[0] = '\0';
SENDCLASSES[0] = '\0';
while ((c = getopt_long(argc, argv, "t:q:db:vnKhIif:D:VSxo:s:MH:", OPTIONS, &optindex)) != EOF)
{
switch ((char) c)
{
case 'f':
GenericAgentConfigSetInputFile(config, optarg);
MINUSF = true;
break;
case 'b':
BACKGROUND = true;
if (optarg)
{
MAXCHILD = atoi(optarg);
}
break;
case 'd':
HardClass("opt_debug");
DEBUG = true;
break;
case 'q':
if (optarg == NULL)
{
strcpy(MENU, "delta");
}
else
{
strncpy(MENU, optarg, CF_MAXVARSIZE);
}
break;
case 'K':
IGNORELOCK = true;
break;
case 's':
strncpy(SENDCLASSES, optarg, CF_MAXVARSIZE);
if (strlen(optarg) > CF_MAXVARSIZE)
{
FatalError("Argument too long\n");
}
break;
case 'D':
strncpy(DEFINECLASSES, optarg, CF_MAXVARSIZE);
if (strlen(optarg) > CF_MAXVARSIZE)
{
FatalError("Argument too long\n");
}
break;
case 'H':
HOSTLIST = SplitStringAsRList(optarg, ',');
break;
case 'o':
strncpy(REMOTE_AGENT_OPTIONS, optarg, CF_MAXVARSIZE);
break;
case 'I':
INFORM = true;
break;
case 'i':
INTERACTIVE = true;
break;
case 'v':
VERBOSE = true;
break;
case 'n':
DONTDO = true;
IGNORELOCK = true;
HardClass("opt_dry_run");
break;
case 't':
CONNTIMEOUT = atoi(optarg);
break;
case 'V':
PrintVersionBanner("cf-runagent");
exit(0);
case 'h':
Syntax("cf-runagent - Run agent", OPTIONS, HINTS, ID);
exit(0);
case 'M':
ManPage("cf-runagent - Run agent", OPTIONS, HINTS, ID);
exit(0);
case 'x':
SelfDiagnostic();
exit(0);
default:
Syntax("cf-runagent - Run agent", OPTIONS, HINTS, ID);
exit(1);
}
}
CfDebug("Set debugging\n");
return config;
}
GenericAgentConfig *CheckOpts(int argc, char **argv)
{
extern char *optarg;
int c;
GenericAgentConfig *config = GenericAgentConfigNewDefault(AGENT_TYPE_SERVER, GetTTYInteractive());
while ((c = getopt_long(argc, argv, "dvIKf:D:N:VSxLFMhAC::l",
OPTIONS, NULL))
!= -1)
{
switch (c)
{
case 'f':
GenericAgentConfigSetInputFile(config, GetInputDir(), optarg);
MINUSF = true;
break;
case 'd':
LogSetGlobalLevel(LOG_LEVEL_DEBUG);
NO_FORK = true;
break;
case 'K':
config->ignore_locks = true;
break;
case 'D':
{
StringSet *defined_classes = StringSetFromString(optarg, ',');
if (! config->heap_soft)
{
config->heap_soft = defined_classes;
}
else
{
StringSetJoin(config->heap_soft, defined_classes);
free(defined_classes);
}
}
break;
case 'N':
{
StringSet *negated_classes = StringSetFromString(optarg, ',');
if (! config->heap_negated)
{
config->heap_negated = negated_classes;
}
else
{
StringSetJoin(config->heap_negated, negated_classes);
free(negated_classes);
}
}
break;
case 'I':
LogSetGlobalLevel(LOG_LEVEL_INFO);
break;
case 'v':
LogSetGlobalLevel(LOG_LEVEL_VERBOSE);
NO_FORK = true;
break;
case 'F':
NO_FORK = true;
break;
case 'L':
{
static char ld_library_path[CF_BUFSIZE]; /* GLOBAL_A */
Log(LOG_LEVEL_VERBOSE, "Setting LD_LIBRARY_PATH to '%s'", optarg);
snprintf(ld_library_path, CF_BUFSIZE - 1, "LD_LIBRARY_PATH=%s", optarg);
putenv(ld_library_path);
break;
}
case 'V':
{
Writer *w = FileWriter(stdout);
GenericAgentWriteVersion(w);
FileWriterDetach(w);
}
exit(EXIT_SUCCESS);
case 'h':
{
Writer *w = FileWriter(stdout);
WriterWriteHelp(w, "cf-serverd", OPTIONS, HINTS, true, NULL);
FileWriterDetach(w);
}
exit(EXIT_SUCCESS);
case 'M':
{
Writer *out = FileWriter(stdout);
ManPageWrite(out, "cf-serverd", time(NULL),
CF_SERVERD_SHORT_DESCRIPTION,
CF_SERVERD_MANPAGE_LONG_DESCRIPTION,
OPTIONS, HINTS,
true);
FileWriterDetach(out);
exit(EXIT_SUCCESS);
}
case 'x':
Log(LOG_LEVEL_ERR, "Self-diagnostic functionality is retired.");
exit(EXIT_SUCCESS);
case 'A':
#ifdef SUPPORT_AVAHI_CONFIG
Log(LOG_LEVEL_NOTICE, "Generating Avahi configuration file.");
if (GenerateAvahiConfig("/etc/avahi/services/cfengine-hub.service") != 0)
{
exit(EXIT_FAILURE);
}
cf_popen("/etc/init.d/avahi-daemon restart", "r", true);
Log(LOG_LEVEL_NOTICE, "Avahi configuration file generated successfully.");
#else
Log(LOG_LEVEL_ERR, "Generating avahi configuration can only be done when avahi-daemon and libavahi are installed on the machine.");
#endif
exit(EXIT_SUCCESS);
case 'C':
if (!GenericAgentConfigParseColor(config, optarg))
{
exit(EXIT_FAILURE);
}
break;
case 'l':
LoggingEnableTimestamps(true);
break;
default:
{
Writer *w = FileWriter(stdout);
WriterWriteHelp(w, "cf-serverd", OPTIONS, HINTS, true, NULL);
FileWriterDetach(w);
}
exit(EXIT_FAILURE);
}
}
if (!GenericAgentConfigParseArguments(config, argc - optind, argv + optind))
{
Log(LOG_LEVEL_ERR, "Too many arguments");
exit(EXIT_FAILURE);
}
return config;
}
GenericAgentConfig *CheckOpts(EvalContext *ctx, int argc, char **argv)
{
extern char *optarg;
int optindex = 0;
int c;
GenericAgentConfig *config = GenericAgentConfigNewDefault(AGENT_TYPE_COMMON);
while ((c = getopt_long(argc, argv, "dvnIf:D:N:VSrxMb:i:p:cg:h", OPTIONS, &optindex)) != EOF)
{
switch ((char) c)
{
case 'c':
config->check_runnable = true;
break;
case 'f':
if (optarg && (strlen(optarg) < 5))
{
CfOut(OUTPUT_LEVEL_ERROR, "", " -f used but argument \"%s\" incorrect", optarg);
exit(EXIT_FAILURE);
}
GenericAgentConfigSetInputFile(config, optarg);
MINUSF = true;
break;
case 'd':
config->debug_mode = true;
break;
case 'b':
if (optarg)
{
Rlist *bundlesequence = RlistFromSplitString(optarg, ',');
GenericAgentConfigSetBundleSequence(config, bundlesequence);
RlistDestroy(bundlesequence);
CBUNDLESEQUENCE_STR = optarg; // TODO: wtf is this
}
break;
case 'p':
if (strcmp("none", optarg) == 0)
{
config->agent_specific.common.policy_output_format = GENERIC_AGENT_CONFIG_COMMON_POLICY_OUTPUT_FORMAT_NONE;
}
else if (strcmp("cf", optarg) == 0)
{
config->agent_specific.common.policy_output_format = GENERIC_AGENT_CONFIG_COMMON_POLICY_OUTPUT_FORMAT_CF;
}
else if (strcmp("json", optarg) == 0)
{
config->agent_specific.common.policy_output_format = GENERIC_AGENT_CONFIG_COMMON_POLICY_OUTPUT_FORMAT_JSON;
}
else
{
CfOut(OUTPUT_LEVEL_ERROR, "", "Invalid policy output format: '%s'. Possible values are 'none', 'cf', 'json'", optarg);
exit(EXIT_FAILURE);
}
break;
case 'K':
IGNORELOCK = true;
break;
case 'D':
config->heap_soft = StringSetFromString(optarg, ',');
break;
case 'N':
config->heap_negated = StringSetFromString(optarg, ',');
break;
case 'I':
INFORM = true;
break;
case 'v':
VERBOSE = true;
break;
case 'n':
DONTDO = true;
IGNORELOCK = true;
LOOKUP = true;
EvalContextHeapAddHard(ctx, "opt_dry_run");
break;
case 'V':
PrintVersionBanner("cf-promises");
exit(0);
case 'h':
Syntax("cf-promises - cfengine's promise analyzer", OPTIONS, HINTS, ID);
exit(0);
case 'M':
ManPage("cf-promises - cfengine's promise analyzer", OPTIONS, HINTS, ID);
exit(0);
case 'r':
SHOWREPORTS = true;
break;
case 'x':
CfOut(OUTPUT_LEVEL_ERROR, "", "Self-diagnostic functionality is retired.");
exit(0);
default:
Syntax("cf-promises - cfengine's promise analyzer", OPTIONS, HINTS, ID);
exit(1);
}
}
if (argv[optind] != NULL)
{
CfOut(OUTPUT_LEVEL_ERROR, "", "Unexpected argument: %s\n", argv[optind]);
}
CfDebug("Set debugging\n");
return config;
}
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:hFOV1gMWlC::", OPTIONS, &optindex)) != EOF)
{
switch ((char) c)
{
case 'l':
LEGACY_OUTPUT = true;
break;
case 'f':
GenericAgentConfigSetInputFile(config, GetInputDir(), optarg);
MINUSF = true;
break;
case 'd':
LogSetGlobalLevel(LOG_LEVEL_DEBUG);
break;
case 'K':
config->ignore_locks = true;
break;
case 'D':
config->heap_soft = StringSetFromString(optarg, ',');
break;
case 'N':
config->heap_negated = StringSetFromString(optarg, ',');
break;
case 'I':
LogSetGlobalLevel(LOG_LEVEL_INFO);
break;
case 'v':
LogSetGlobalLevel(LOG_LEVEL_VERBOSE);
NO_FORK = true; // TODO: really?
break;
case 'n':
DONTDO = true;
config->ignore_locks = true;
break;
case 'L':
snprintf(ld_library_path, CF_BUFSIZE - 1, "LD_LIBRARY_PATH=%s", optarg);
putenv(xstrdup(ld_library_path));
break;
case 'W':
WINSERVICE = false;
break;
case 'F':
NO_FORK = true;
break;
case 'O':
ONCE = true;
NO_FORK = true;
break;
case 'V':
{
Writer *w = FileWriter(stdout);
GenericAgentWriteVersion(w);
FileWriterDetach(w);
}
exit(EXIT_SUCCESS);
case 'h':
{
Writer *w = FileWriter(stdout);
GenericAgentWriteHelp(w, "cf-execd", OPTIONS, HINTS, true);
FileWriterDetach(w);
}
exit(EXIT_SUCCESS);
case 'M':
{
Writer *out = FileWriter(stdout);
ManPageWrite(out, "cf-execd", time(NULL),
CF_EXECD_SHORT_DESCRIPTION,
CF_EXECD_MANPAGE_LONG_DESCRIPTION,
OPTIONS, HINTS,
true);
FileWriterDetach(out);
exit(EXIT_SUCCESS);
}
case 'x':
Log(LOG_LEVEL_ERR, "Self-diagnostic functionality is retired.");
exit(EXIT_SUCCESS);
case 'C':
if (!GenericAgentConfigParseColor(config, optarg))
{
exit(EXIT_FAILURE);
}
break;
default:
{
Writer *w = FileWriter(stdout);
GenericAgentWriteHelp(w, "cf-execd", OPTIONS, HINTS, true);
FileWriterDetach(w);
}
exit(EXIT_FAILURE);
}
}
if (!GenericAgentConfigParseArguments(config, argc - optind, argv + optind))
{
Log(LOG_LEVEL_ERR, "Too many arguments");
exit(EXIT_FAILURE);
}
return config;
}
static GenericAgentConfig *CheckOpts(int argc, char **argv)
{
extern char *optarg;
int c;
GenericAgentConfig *config = GenericAgentConfigNewDefault(AGENT_TYPE_MONITOR, GetTTYInteractive());
while ((c = getopt_long(argc, argv, "dvnIf:g:VSxHTKMFhC::l",
OPTIONS, NULL)) != -1)
{
switch (c)
{
case 'f':
GenericAgentConfigSetInputFile(config, GetInputDir(), optarg);
MINUSF = true;
break;
case 'd':
LogSetGlobalLevel(LOG_LEVEL_DEBUG);
NO_FORK = true;
break;
case 'K':
config->ignore_locks = true;
break;
case 'I':
LogSetGlobalLevel(LOG_LEVEL_INFO);
break;
case 'v':
LogSetGlobalLevel(LOG_LEVEL_VERBOSE);
NO_FORK = true;
break;
case 'g':
LogSetGlobalLevelArgOrExit(optarg);
break;
case 'F':
NO_FORK = true;
break;
case 'H': /* Keep accepting this option for compatibility -- no longer used */
break;
case 'T':
MonNetworkSnifferEnable(true);
break;
case 'V':
{
Writer *w = FileWriter(stdout);
GenericAgentWriteVersion(w);
FileWriterDetach(w);
}
DoCleanupAndExit(EXIT_SUCCESS);
case 'h':
{
Writer *w = FileWriter(stdout);
WriterWriteHelp(w, "cf-monitord", OPTIONS, HINTS, true, NULL);
FileWriterDetach(w);
}
DoCleanupAndExit(EXIT_SUCCESS);
case 'M':
{
Writer *out = FileWriter(stdout);
ManPageWrite(out, "cf-monitord", time(NULL),
CF_MONITORD_SHORT_DESCRIPTION,
CF_MONITORD_MANPAGE_LONG_DESCRIPTION,
OPTIONS, HINTS,
true);
FileWriterDetach(out);
DoCleanupAndExit(EXIT_SUCCESS);
}
case 'x':
Log(LOG_LEVEL_ERR, "Self-diagnostic functionality is retired.");
DoCleanupAndExit(EXIT_SUCCESS);
case 'C':
if (!GenericAgentConfigParseColor(config, optarg))
{
DoCleanupAndExit(EXIT_FAILURE);
}
break;
case 'l':
LoggingEnableTimestamps(true);
break;
default:
{
Writer *w = FileWriter(stdout);
WriterWriteHelp(w, "cf-monitord", OPTIONS, HINTS, true, NULL);
FileWriterDetach(w);
}
DoCleanupAndExit(EXIT_FAILURE);
}
}
if (!GenericAgentConfigParseArguments(config, argc - optind, argv + optind))
{
Log(LOG_LEVEL_ERR, "Too many arguments");
DoCleanupAndExit(EXIT_FAILURE);
}
return config;
}
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);
}
static GenericAgentConfig *CheckOpts(int argc, char **argv)
{
extern char *optarg;
int c;
GenericAgentConfig *config = GenericAgentConfigNewDefault(AGENT_TYPE_RUNAGENT, GetTTYInteractive());
DEFINECLASSES[0] = '\0';
SENDCLASSES[0] = '\0';
REMOTEBUNDLES[0] = '\0';
int longopt_idx;
while ((c = getopt_long(argc, argv, "t:q:db:vnKhIif:g:D:VSxo:s:MH:C::l",
OPTIONS, &longopt_idx))
!= -1)
{
switch (c)
{
case 'f':
GenericAgentConfigSetInputFile(config, GetInputDir(), optarg);
MINUSF = true;
break;
case 'b':
BACKGROUND = true;
if (optarg)
{
MAXCHILD = StringToLongExitOnError(optarg);
}
break;
case 'd':
LogSetGlobalLevel(LOG_LEVEL_DEBUG);
break;
case 'K':
config->ignore_locks = true;
break;
case 's':
{
size_t len = strlen(SENDCLASSES);
StrCatDelim(SENDCLASSES, sizeof(SENDCLASSES), &len,
optarg, ',');
if (len >= sizeof(SENDCLASSES))
{
Log(LOG_LEVEL_ERR, "Argument too long (-s)");
exit(EXIT_FAILURE);
}
break;
}
case 'D':
{
size_t len = strlen(DEFINECLASSES);
StrCatDelim(DEFINECLASSES, sizeof(DEFINECLASSES), &len,
optarg, ',');
if (len >= sizeof(DEFINECLASSES))
{
Log(LOG_LEVEL_ERR, "Argument too long (-D)");
exit(EXIT_FAILURE);
}
break;
}
case 'H':
HOSTLIST = RlistFromSplitString(optarg, ',');
break;
case 'o':
Log(LOG_LEVEL_ERR, "Option \"-o\" has been deprecated,"
" you can not pass arbitrary arguments to remote cf-agent");
exit(EXIT_FAILURE);
break;
case 'I':
LogSetGlobalLevel(LOG_LEVEL_INFO);
break;
case 'i':
INTERACTIVE = true;
break;
case 'v':
LogSetGlobalLevel(LOG_LEVEL_VERBOSE);
break;
case 'g':
LogSetGlobalLevelArgOrExit(optarg);
break;
case 'n':
DONTDO = true;
config->ignore_locks = true;
break;
case 't':
CONNTIMEOUT = StringToLongExitOnError(optarg);
break;
case 'V':
{
Writer *w = FileWriter(stdout);
GenericAgentWriteVersion(w);
FileWriterDetach(w);
}
exit(EXIT_SUCCESS);
case 'h':
{
Writer *w = FileWriter(stdout);
WriterWriteHelp(w, "cf-runagent", OPTIONS, HINTS, true, NULL);
FileWriterDetach(w);
}
exit(EXIT_SUCCESS);
case 'M':
{
Writer *out = FileWriter(stdout);
ManPageWrite(out, "cf-runagent", time(NULL),
CF_RUNAGENT_SHORT_DESCRIPTION,
CF_RUNAGENT_MANPAGE_LONG_DESCRIPTION,
OPTIONS, HINTS,
true);
FileWriterDetach(out);
exit(EXIT_SUCCESS);
}
case 'x':
Log(LOG_LEVEL_ERR, "Option \"-x\" has been deprecated");
exit(EXIT_FAILURE);
case 'C':
if (!GenericAgentConfigParseColor(config, optarg))
{
exit(EXIT_FAILURE);
}
break;
case 'l':
LoggingEnableTimestamps(true);
break;
/* long options only */
case 0:
if (strcmp(OPTIONS[longopt_idx].name, "log-modules") == 0)
{
bool ret = LogEnableModulesFromString(optarg);
if (!ret)
{
exit(EXIT_FAILURE);
}
}
else if (strcmp(OPTIONS[longopt_idx].name, "remote-bundles") == 0)
{
size_t len = strlen(REMOTEBUNDLES);
StrCatDelim(REMOTEBUNDLES, sizeof(REMOTEBUNDLES), &len,
optarg, ',');
if (len >= sizeof(REMOTEBUNDLES))
{
Log(LOG_LEVEL_ERR, "Argument too long (--remote-bundles)");
exit(EXIT_FAILURE);
}
}
break;
default:
{
Writer *w = FileWriter(stdout);
WriterWriteHelp(w, "cf-runagent", OPTIONS, HINTS, true, NULL);
FileWriterDetach(w);
}
exit(EXIT_FAILURE);
}
}
if (!GenericAgentConfigParseArguments(config, argc - optind, argv + optind))
{
Log(LOG_LEVEL_ERR, "Too many arguments");
exit(EXIT_FAILURE);
}
return config;
}
static GenericAgentConfig *CheckOpts(int argc, char **argv)
{
extern char *optarg;
int c;
GenericAgentConfig *config = GenericAgentConfigNewDefault(AGENT_TYPE_KEYGEN, GetTTYInteractive());
while ((c = getopt_long(argc, argv, "dvIf:g:T:VMp:sr:xt:hl:C::n",
OPTIONS, NULL))
!= -1)
{
switch (c)
{
case 'f':
KEY_PATH = optarg;
break;
case 'T':
KEY_SIZE = StringToLongExitOnError(optarg);
break;
case 'd':
LogSetGlobalLevel(LOG_LEVEL_DEBUG);
break;
case 'V':
{
Writer *w = FileWriter(stdout);
GenericAgentWriteVersion(w);
FileWriterDetach(w);
}
DoCleanupAndExit(EXIT_SUCCESS);
case 'v':
LogSetGlobalLevel(LOG_LEVEL_VERBOSE);
break;
case 'g':
LogSetGlobalLevelArgOrExit(optarg);
break;
case 'I':
LogSetGlobalLevel(LOG_LEVEL_INFO);
break;
case 'p': /* print digest */
print_digest_arg = optarg;
break;
case 's':
SHOWHOSTS = true;
break;
case 'x':
FORCEREMOVAL = true;
break;
case 'r':
REMOVEKEYS = true;
remove_keys_host = optarg;
break;
case 'l':
LICENSE_INSTALL = true;
strlcpy(LICENSE_SOURCE, optarg, sizeof(LICENSE_SOURCE));
break;
case 't':
trust_key_arg = optarg;
break;
case 'h':
{
Writer *w = FileWriter(stdout);
WriterWriteHelp(w, "cf-key", OPTIONS, HINTS, false, NULL);
FileWriterDetach(w);
}
DoCleanupAndExit(EXIT_SUCCESS);
case 'M':
{
Writer *out = FileWriter(stdout);
ManPageWrite(out, "cf-key", time(NULL),
CF_KEY_SHORT_DESCRIPTION,
CF_KEY_MANPAGE_LONG_DESCRIPTION,
OPTIONS, HINTS,
false);
FileWriterDetach(out);
DoCleanupAndExit(EXIT_SUCCESS);
}
case 'C':
if (!GenericAgentConfigParseColor(config, optarg))
{
DoCleanupAndExit(EXIT_FAILURE);
}
break;
case TIMESTAMP_VAL:
LoggingEnableTimestamps(true);
break;
case 'n':
LOOKUP_HOSTS = false;
break;
default:
{
Writer *w = FileWriter(stdout);
WriterWriteHelp(w, "cf-key", OPTIONS, HINTS, false, NULL);
FileWriterDetach(w);
}
DoCleanupAndExit(EXIT_FAILURE);
}
}
return config;
}
GenericAgentConfig *CheckOpts(int argc, char **argv)
{
extern char *optarg;
int c;
GenericAgentConfig *config = GenericAgentConfigNewDefault(AGENT_TYPE_COMMON, GetTTYInteractive());
config->tag_release_dir = NULL;
while ((c = getopt_long(argc, argv, "dvnIw:f:D:N:VSrxMb:i:p:s:cg:hW:C::T:l",
OPTIONS, NULL))
!= -1)
{
switch (c)
{
case OPT_EVAL_FUNCTIONS:
if (!optarg)
{
optarg = "yes";
}
config->agent_specific.common.eval_functions = strcmp("yes", optarg) == 0;
break;
case OPT_SHOW_CLASSES:
config->agent_specific.common.show_classes = true;
break;
case OPT_SHOW_VARS:
config->agent_specific.common.show_variables = true;
break;
case 'w':
Log(LOG_LEVEL_INFO, "Setting workdir to '%s'", optarg);
putenv(StringConcatenate(2, "CFENGINE_TEST_OVERRIDE_WORKDIR=", optarg));
break;
case 'c':
config->check_runnable = true;
break;
case 'f':
GenericAgentConfigSetInputFile(config, GetInputDir(), optarg);
MINUSF = true;
break;
case 'd':
LogSetGlobalLevel(LOG_LEVEL_DEBUG);
break;
case 'b':
if (optarg)
{
Rlist *bundlesequence = RlistFromSplitString(optarg, ',');
GenericAgentConfigSetBundleSequence(config, bundlesequence);
RlistDestroy(bundlesequence);
}
break;
case 'p':
if (strcmp("none", optarg) == 0)
{
config->agent_specific.common.policy_output_format = GENERIC_AGENT_CONFIG_COMMON_POLICY_OUTPUT_FORMAT_NONE;
}
else if (strcmp("cf", optarg) == 0)
{
config->agent_specific.common.policy_output_format = GENERIC_AGENT_CONFIG_COMMON_POLICY_OUTPUT_FORMAT_CF;
}
else if (strcmp("json", optarg) == 0)
{
config->agent_specific.common.policy_output_format = GENERIC_AGENT_CONFIG_COMMON_POLICY_OUTPUT_FORMAT_JSON;
}
else if (strcmp("cf-full", optarg) == 0)
{
config->agent_specific.common.policy_output_format = GENERIC_AGENT_CONFIG_COMMON_POLICY_OUTPUT_FORMAT_CF_FULL;
}
else if (strcmp("json-full", optarg) == 0)
{
config->agent_specific.common.policy_output_format = GENERIC_AGENT_CONFIG_COMMON_POLICY_OUTPUT_FORMAT_JSON_FULL;
}
else
{
Log(LOG_LEVEL_ERR, "Invalid policy output format: '%s'. Possible values are 'none', 'cf', 'json', 'cf-full', 'json-full'", optarg);
exit(EXIT_FAILURE);
}
break;
case 's':
if (strcmp("none", optarg) == 0)
{
break;
}
else if (strcmp("json", optarg) == 0)
{
JsonElement *json_syntax = SyntaxToJson();
Writer *out = FileWriter(stdout);
JsonWrite(out, json_syntax, 0);
FileWriterDetach(out);
JsonDestroy(json_syntax);
exit(EXIT_SUCCESS);
}
else
{
Log(LOG_LEVEL_ERR, "Invalid syntax description output format: '%s'. Possible values are 'none', 'json'", optarg);
exit(EXIT_FAILURE);
}
break;
case 'K':
config->ignore_locks = true;
break;
case 'D':
{
StringSet *defined_classes = StringSetFromString(optarg, ',');
if (! config->heap_soft)
{
config->heap_soft = defined_classes;
}
else
{
StringSetJoin(config->heap_soft, defined_classes);
free(defined_classes);
}
}
break;
case 'N':
{
StringSet *negated_classes = StringSetFromString(optarg, ',');
if (! config->heap_negated)
{
config->heap_negated = negated_classes;
}
else
{
StringSetJoin(config->heap_negated, negated_classes);
free(negated_classes);
}
}
break;
case 'I':
LogSetGlobalLevel(LOG_LEVEL_INFO);
break;
case 'v':
LogSetGlobalLevel(LOG_LEVEL_VERBOSE);
break;
case 'n':
DONTDO = true;
config->ignore_locks = true;
break;
case 'V':
{
Writer *w = FileWriter(stdout);
GenericAgentWriteVersion(w);
FileWriterDetach(w);
}
exit(EXIT_SUCCESS);
case 'h':
{
Writer *w = FileWriter(stdout);
GenericAgentWriteHelp(w, "cf-promises", OPTIONS, HINTS, true);
FileWriterDetach(w);
}
exit(EXIT_SUCCESS);
case 'M':
{
Writer *out = FileWriter(stdout);
ManPageWrite(out, "cf-promises", time(NULL),
CF_PROMISES_SHORT_DESCRIPTION,
CF_PROMISES_MANPAGE_LONG_DESCRIPTION,
OPTIONS, HINTS,
true);
FileWriterDetach(out);
exit(EXIT_SUCCESS);
}
case 'r':
Log(LOG_LEVEL_ERR, "Option '-r' has been deprecated");
exit(EXIT_FAILURE);
break;
case 'W':
if (!GenericAgentConfigParseWarningOptions(config, optarg))
{
Log(LOG_LEVEL_ERR, "Error parsing warning option");
exit(EXIT_FAILURE);
}
break;
case 'x':
Log(LOG_LEVEL_ERR, "Self-diagnostic functionality is retired.");
exit(EXIT_SUCCESS);
case 'C':
if (!GenericAgentConfigParseColor(config, optarg))
{
exit(EXIT_FAILURE);
}
break;
case 'T':
GenericAgentConfigSetInputFile(config, optarg, "promises.cf");
MINUSF = true;
config->tag_release_dir = xstrdup(optarg);
break;
case 'l':
LoggingEnableTimestamps(true);
break;
default:
{
Writer *w = FileWriter(stdout);
GenericAgentWriteHelp(w, "cf-promises", OPTIONS, HINTS, true);
FileWriterDetach(w);
}
exit(EXIT_FAILURE);
}
}
if (!GenericAgentConfigParseArguments(config, argc - optind, argv + optind))
{
Log(LOG_LEVEL_ERR, "Too many arguments");
exit(EXIT_FAILURE);
}
return config;
}
GenericAgentConfig *CheckOpts(int argc, char **argv)
{
extern char *optarg;
int optindex = 0;
int c;
GenericAgentConfig *config = GenericAgentConfigNewDefault(AGENT_TYPE_COMMON);
while ((c = getopt_long(argc, argv, "dvnIf:D:N:VSrxMb:i:p:s:cg:hW:lC::", OPTIONS, &optindex)) != EOF)
{
switch ((char) c)
{
case 0:
switch (optindex)
{
case PROMISES_OPTION_EVAL_FUNCTIONS:
if (!optarg)
{
optarg = "yes";
}
config->agent_specific.common.eval_functions = strcmp("yes", optarg) == 0;
break;
case PROMISES_OPTION_SHOW_CLASSES:
if (!optarg)
{
optarg = "yes";
}
config->agent_specific.common.show_classes = strcmp("yes", optarg) == 0;
break;
case PROMISES_OPTION_SHOW_VARIABLES:
if (!optarg)
{
optarg = "yes";
}
config->agent_specific.common.show_variables = strcmp("yes", optarg) == 0;
break;
default:
break;
}
case 'l':
LEGACY_OUTPUT = true;
break;
case 'c':
config->check_runnable = true;
break;
case 'f':
if (optarg && (strlen(optarg) < 5))
{
Log(LOG_LEVEL_ERR, " -f used but argument '%s' incorrect", optarg);
exit(EXIT_FAILURE);
}
GenericAgentConfigSetInputFile(config, GetInputDir(), optarg);
MINUSF = true;
break;
case 'd':
LogSetGlobalLevel(LOG_LEVEL_DEBUG);
break;
case 'b':
if (optarg)
{
Rlist *bundlesequence = RlistFromSplitString(optarg, ',');
GenericAgentConfigSetBundleSequence(config, bundlesequence);
RlistDestroy(bundlesequence);
}
break;
case 'p':
if (strcmp("none", optarg) == 0)
{
config->agent_specific.common.policy_output_format = GENERIC_AGENT_CONFIG_COMMON_POLICY_OUTPUT_FORMAT_NONE;
}
else if (strcmp("cf", optarg) == 0)
{
config->agent_specific.common.policy_output_format = GENERIC_AGENT_CONFIG_COMMON_POLICY_OUTPUT_FORMAT_CF;
}
else if (strcmp("json", optarg) == 0)
{
config->agent_specific.common.policy_output_format = GENERIC_AGENT_CONFIG_COMMON_POLICY_OUTPUT_FORMAT_JSON;
}
else
{
Log(LOG_LEVEL_ERR, "Invalid policy output format: '%s'. Possible values are 'none', 'cf', 'json'", optarg);
exit(EXIT_FAILURE);
}
break;
case 's':
if (strcmp("none", optarg) == 0)
{
break;
}
else if (strcmp("json", optarg) == 0)
{
JsonElement *json_syntax = SyntaxToJson();
Writer *out = FileWriter(stdout);
JsonWrite(out, json_syntax, 0);
FileWriterDetach(out);
JsonDestroy(json_syntax);
exit(EXIT_SUCCESS);
}
else
{
Log(LOG_LEVEL_ERR, "Invalid syntax description output format: '%s'. Possible values are 'none', 'json'", optarg);
exit(EXIT_FAILURE);
}
break;
case 'K':
config->ignore_locks = true;
break;
case 'D':
config->heap_soft = StringSetFromString(optarg, ',');
break;
case 'N':
config->heap_negated = StringSetFromString(optarg, ',');
break;
case 'I':
LogSetGlobalLevel(LOG_LEVEL_INFO);
break;
case 'v':
LogSetGlobalLevel(LOG_LEVEL_VERBOSE);
break;
case 'n':
DONTDO = true;
config->ignore_locks = true;
break;
case 'V':
{
Writer *w = FileWriter(stdout);
GenericAgentWriteVersion(w);
FileWriterDetach(w);
}
exit(EXIT_SUCCESS);
case 'h':
{
Writer *w = FileWriter(stdout);
GenericAgentWriteHelp(w, "cf-promises", OPTIONS, HINTS, true);
FileWriterDetach(w);
}
exit(EXIT_SUCCESS);
case 'M':
{
Writer *out = FileWriter(stdout);
ManPageWrite(out, "cf-promises", time(NULL),
CF_PROMISES_SHORT_DESCRIPTION,
CF_PROMISES_MANPAGE_LONG_DESCRIPTION,
OPTIONS, HINTS,
true);
FileWriterDetach(out);
exit(EXIT_SUCCESS);
}
case 'r':
SHOWREPORTS = true;
break;
case 'W':
if (!GenericAgentConfigParseWarningOptions(config, optarg))
{
Log(LOG_LEVEL_ERR, "Error parsing warning option");
exit(EXIT_FAILURE);
}
break;
case 'x':
Log(LOG_LEVEL_ERR, "Self-diagnostic functionality is retired.");
exit(EXIT_SUCCESS);
case 'C':
if (!GenericAgentConfigParseColor(config, optarg))
{
exit(EXIT_FAILURE);
}
break;
default:
{
Writer *w = FileWriter(stdout);
GenericAgentWriteHelp(w, "cf-promises", OPTIONS, HINTS, true);
FileWriterDetach(w);
}
exit(EXIT_FAILURE);
}
}
if (!GenericAgentConfigParseArguments(config, argc - optind, argv + optind))
{
Log(LOG_LEVEL_ERR, "Too many arguments");
exit(EXIT_FAILURE);
}
return config;
}
static GenericAgentConfig *CheckOpts(int argc, char **argv)
{
extern char *optarg;
int c;
GenericAgentConfig *config = GenericAgentConfigNewDefault(AGENT_TYPE_RUNAGENT);
DEFINECLASSES[0] = '\0';
SENDCLASSES[0] = '\0';
while ((c = getopt_long(argc, argv, "t:q:db:vnKhIif:D:VSxo:s:MH:C::l",
OPTIONS, NULL)) != -1)
{
switch (c)
{
case 'f':
GenericAgentConfigSetInputFile(config, GetInputDir(), optarg);
MINUSF = true;
break;
case 'b':
BACKGROUND = true;
if (optarg)
{
MAXCHILD = atoi(optarg);
}
break;
case 'd':
LogSetGlobalLevel(LOG_LEVEL_DEBUG);
break;
case 'K':
config->ignore_locks = true;
break;
case 's':
strlcpy(SENDCLASSES, optarg, CF_MAXVARSIZE);
if (strlen(optarg) > CF_MAXVARSIZE)
{
Log(LOG_LEVEL_ERR, "Argument too long (-s)");
exit(EXIT_FAILURE);
}
break;
case 'D':
strlcpy(DEFINECLASSES, optarg, CF_MAXVARSIZE);
if (strlen(optarg) > CF_MAXVARSIZE)
{
Log(LOG_LEVEL_ERR, "Argument too long (-D)");
exit(EXIT_FAILURE);
}
break;
case 'H':
HOSTLIST = RlistFromSplitString(optarg, ',');
break;
case 'o':
Log(LOG_LEVEL_ERR, "Option \"-o\" has been deprecated,"
" you can not pass arbitrary arguments to remote cf-agent");
exit(EXIT_FAILURE);
break;
case 'I':
LogSetGlobalLevel(LOG_LEVEL_INFO);
break;
case 'i':
INTERACTIVE = true;
break;
case 'v':
LogSetGlobalLevel(LOG_LEVEL_VERBOSE);
break;
case 'n':
DONTDO = true;
config->ignore_locks = true;
break;
case 't':
CONNTIMEOUT = atoi(optarg);
break;
case 'V':
{
Writer *w = FileWriter(stdout);
GenericAgentWriteVersion(w);
FileWriterDetach(w);
}
exit(EXIT_SUCCESS);
case 'h':
{
Writer *w = FileWriter(stdout);
GenericAgentWriteHelp(w, "cf-runagent", OPTIONS, HINTS, true);
FileWriterDetach(w);
}
exit(EXIT_SUCCESS);
case 'M':
{
Writer *out = FileWriter(stdout);
ManPageWrite(out, "cf-runagent", time(NULL),
CF_RUNAGENT_SHORT_DESCRIPTION,
CF_RUNAGENT_MANPAGE_LONG_DESCRIPTION,
OPTIONS, HINTS,
true);
FileWriterDetach(out);
exit(EXIT_SUCCESS);
}
case 'x':
Log(LOG_LEVEL_ERR, "Self-diagnostic functionality is retired.");
exit(EXIT_SUCCESS);
case 'C':
if (!GenericAgentConfigParseColor(config, optarg))
{
exit(EXIT_FAILURE);
}
break;
case 'l':
LoggingEnableTimestamps(true);
break;
default:
{
Writer *w = FileWriter(stdout);
GenericAgentWriteHelp(w, "cf-runagent", OPTIONS, HINTS, true);
FileWriterDetach(w);
}
exit(EXIT_FAILURE);
}
}
if (!GenericAgentConfigParseArguments(config, argc - optind, argv + optind))
{
Log(LOG_LEVEL_ERR, "Too many arguments");
exit(EXIT_FAILURE);
}
return config;
}
static GenericAgentConfig *CheckOpts(int argc, char **argv)
{
extern char *optarg;
int optindex = 0;
int c;
GenericAgentConfig *config = GenericAgentConfigNewDefault(AGENT_TYPE_KEYGEN);
while ((c = getopt_long(argc, argv, "dvf:VMp:sr:t:hl:C::", OPTIONS, &optindex)) != EOF)
{
switch ((char) c)
{
case 'f':
KEY_PATH = optarg;
break;
case 'd':
LogSetGlobalLevel(LOG_LEVEL_DEBUG);
break;
case 'V':
PrintVersion();
exit(0);
case 'v':
LogSetGlobalLevel(LOG_LEVEL_VERBOSE);
break;
case 'p': /* print digest */
print_digest_arg = optarg;
break;
case 's':
SHOWHOSTS = true;
break;
case 'r':
REMOVEKEYS = true;
remove_keys_host = optarg;
break;
case 'l':
LICENSE_INSTALL = true;
strlcpy(LICENSE_SOURCE, optarg, sizeof(LICENSE_SOURCE));
break;
case 't':
trust_key_arg = optarg;
break;
case 'h':
PrintHelp("cf-key", OPTIONS, HINTS, false);
exit(0);
case 'M':
{
Writer *out = FileWriter(stdout);
ManPageWrite(out, "cf-key", time(NULL),
CF_KEY_SHORT_DESCRIPTION,
CF_KEY_MANPAGE_LONG_DESCRIPTION,
OPTIONS, HINTS,
false);
FileWriterDetach(out);
exit(EXIT_SUCCESS);
}
case 'C':
if (!GenericAgentConfigParseColor(config, optarg))
{
exit(EXIT_FAILURE);
}
break;
default:
PrintHelp("cf-key", OPTIONS, HINTS, false);
exit(1);
}
}
return config;
}
static GenericAgentConfig *CheckOpts(EvalContext *ctx, int argc, char **argv)
{
extern char *optarg;
int optindex = 0;
int c;
GenericAgentConfig *config = GenericAgentConfigNewDefault(AGENT_TYPE_RUNAGENT);
DEFINECLASSES[0] = '\0';
SENDCLASSES[0] = '\0';
while ((c = getopt_long(argc, argv, "t:q:db:vnKhIif:D:VSxo:s:MH:", OPTIONS, &optindex)) != EOF)
{
switch ((char) c)
{
case 'f':
GenericAgentConfigSetInputFile(config, optarg);
MINUSF = true;
break;
case 'b':
BACKGROUND = true;
if (optarg)
{
MAXCHILD = atoi(optarg);
}
break;
case 'd':
config->debug_mode = true;
break;
case 'K':
IGNORELOCK = true;
break;
case 's':
strncpy(SENDCLASSES, optarg, CF_MAXVARSIZE);
if (strlen(optarg) > CF_MAXVARSIZE)
{
CfOut(OUTPUT_LEVEL_ERROR, "", "Argument too long\n");
exit(EXIT_FAILURE);
}
break;
case 'D':
strncpy(DEFINECLASSES, optarg, CF_MAXVARSIZE);
if (strlen(optarg) > CF_MAXVARSIZE)
{
CfOut(OUTPUT_LEVEL_ERROR, "", "Argument too long\n");
exit(EXIT_FAILURE);
}
break;
case 'H':
HOSTLIST = RlistFromSplitString(optarg, ',');
break;
case 'o':
strncpy(REMOTE_AGENT_OPTIONS, optarg, CF_MAXVARSIZE);
break;
case 'I':
INFORM = true;
break;
case 'i':
INTERACTIVE = true;
break;
case 'v':
VERBOSE = true;
break;
case 'n':
DONTDO = true;
IGNORELOCK = true;
EvalContextHeapAddHard(ctx, "opt_dry_run");
break;
case 't':
CONNTIMEOUT = atoi(optarg);
break;
case 'V':
PrintVersion();
exit(0);
case 'h':
Syntax("cf-runagent - Run agent", OPTIONS, HINTS, ID);
exit(0);
case 'M':
ManPage("cf-runagent - Run agent", OPTIONS, HINTS, ID);
exit(0);
case 'x':
CfOut(OUTPUT_LEVEL_ERROR, "", "Self-diagnostic functionality is retired.");
exit(0);
default:
Syntax("cf-runagent - Run agent", OPTIONS, HINTS, ID);
exit(1);
}
}
CfDebug("Set debugging\n");
return config;
}
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);
}
static GenericAgentConfig *CheckOpts(int argc, char **argv)
{
extern char *optarg;
char *sp;
int optindex = 0;
int c, alpha = false, v6 = false;
GenericAgentConfig *config = GenericAgentConfigNewDefault(AGENT_TYPE_AGENT);
/* Because of the MacOS linker we have to call this from each agent
individually before Generic Initialize */
POLICY_SERVER[0] = '\0';
while ((c = getopt_long(argc, argv, "rdvnKIf:D:N:Vs:x:MBb:h", 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 'b':
if (optarg)
{
config->bundlesequence = SplitStringAsRList(optarg, ',');
CBUNDLESEQUENCE_STR = optarg;
}
break;
case 'd':
HardClass("opt_debug");
DEBUG = true;
break;
case 'B':
BOOTSTRAP = true;
MINUSF = true;
GenericAgentConfigSetInputFile(config, "promises.cf");
IGNORELOCK = true;
HardClass("bootstrap_mode");
break;
case 's':
if(IsLoopbackAddress(optarg))
{
FatalError("Use a non-loopback address when bootstrapping");
}
// temporary assure that network functions are working
OpenNetwork();
strncpy(POLICY_SERVER, Hostname2IPString(optarg), CF_BUFSIZE - 1);
CloseNetwork();
for (sp = POLICY_SERVER; *sp != '\0'; sp++)
{
if (isalpha((int)*sp))
{
alpha = true;
}
if (ispunct((int)*sp) && *sp != ':' && *sp != '.')
{
alpha = true;
}
if (*sp == ':')
{
v6 = true;
}
}
if (alpha && !v6)
{
FatalError
("Error specifying policy server. The policy server's IP address could not be looked up. Please use the IP address instead if there is no error.");
}
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;
break;
case 'n':
DONTDO = true;
IGNORELOCK = true;
HardClass("opt_dry_run");
break;
case 'V':
PrintVersionBanner("cf-agent");
exit(0);
case 'h':
Syntax("cf-agent - cfengine's change agent", OPTIONS, HINTS, ID);
exit(0);
case 'M':
ManPage("cf-agent - cfengine's change agent", OPTIONS, HINTS, ID);
exit(0);
case 'x':
CfOut(cf_error, "", "Self-diagnostic functionality is retired");
exit(0);
case 'r':
SHOWREPORTS = true;
break;
default:
Syntax("cf-agent - cfengine's change agent", OPTIONS, HINTS, ID);
exit(1);
}
}
if (argv[optind] != NULL)
{
CfOut(cf_error, "", "Unexpected argument with no preceding option: %s\n", argv[optind]);
FatalError("Aborted");
}
CfDebug("Set debugging\n");
return config;
}
static GenericAgentConfig *CheckOpts(EvalContext *ctx, 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)
{
CfOut(OUTPUT_LEVEL_ERROR, "", " -f used but argument \"%s\" incorrect", optarg);
exit(EXIT_FAILURE);
}
GenericAgentConfigSetInputFile(config, optarg);
MINUSF = true;
break;
case 'd':
config->debug_mode = true;
break;
case 'K':
IGNORELOCK = true;
break;
case 'D':
config->heap_soft = StringSetFromString(optarg, ',');
break;
case 'N':
config->heap_negated = StringSetFromString(optarg, ',');
break;
case 'I':
INFORM = true;
break;
case 'v':
VERBOSE = true;
NO_FORK = true;
break;
case 'n':
DONTDO = true;
IGNORELOCK = true;
EvalContextHeapAddHard(ctx, "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;
NO_FORK = true;
break;
case 'V':
PrintVersion();
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: %s\n", argv[optind]);
}
return config;
}
static GenericAgentConfig *CheckOpts(EvalContext *ctx, int argc, char **argv)
{
extern char *optarg;
int optindex = 0;
int c;
GenericAgentConfig *config = GenericAgentConfigNewDefault(AGENT_TYPE_RUNAGENT);
DEFINECLASSES[0] = '\0';
SENDCLASSES[0] = '\0';
while ((c = getopt_long(argc, argv, "t:q:db:vnKhIif:D:VSxo:s:MH:lC::", OPTIONS, &optindex)) != EOF)
{
switch ((char) c)
{
case 'l':
LEGACY_OUTPUT = true;
break;
case 'f':
GenericAgentConfigSetInputFile(config, GetWorkDir(), optarg);
MINUSF = true;
break;
case 'b':
BACKGROUND = true;
if (optarg)
{
MAXCHILD = atoi(optarg);
}
break;
case 'd':
LogSetGlobalLevel(LOG_LEVEL_DEBUG);
break;
case 'K':
IGNORELOCK = true;
break;
case 's':
strncpy(SENDCLASSES, optarg, CF_MAXVARSIZE);
if (strlen(optarg) > CF_MAXVARSIZE)
{
Log(LOG_LEVEL_ERR, "Argument too long (-s)");
exit(EXIT_FAILURE);
}
break;
case 'D':
strncpy(DEFINECLASSES, optarg, CF_MAXVARSIZE);
if (strlen(optarg) > CF_MAXVARSIZE)
{
Log(LOG_LEVEL_ERR, "Argument too long (-D)");
exit(EXIT_FAILURE);
}
break;
case 'H':
HOSTLIST = RlistFromSplitString(optarg, ',');
break;
case 'o':
strncpy(REMOTE_AGENT_OPTIONS, optarg, CF_MAXVARSIZE);
break;
case 'I':
LogSetGlobalLevel(LOG_LEVEL_INFO);
break;
case 'i':
INTERACTIVE = true;
break;
case 'v':
LogSetGlobalLevel(LOG_LEVEL_VERBOSE);
break;
case 'n':
DONTDO = true;
IGNORELOCK = true;
EvalContextClassPutHard(ctx, "opt_dry_run");
break;
case 't':
CONNTIMEOUT = atoi(optarg);
break;
case 'V':
{
Writer *w = FileWriter(stdout);
GenericAgentWriteVersion(w);
FileWriterDetach(w);
}
exit(0);
case 'h':
{
Writer *w = FileWriter(stdout);
GenericAgentWriteHelp(w, "cf-runagent", OPTIONS, HINTS, true);
FileWriterDetach(w);
}
exit(0);
case 'M':
{
Writer *out = FileWriter(stdout);
ManPageWrite(out, "cf-runagent", time(NULL),
CF_RUNAGENT_SHORT_DESCRIPTION,
CF_RUNAGENT_MANPAGE_LONG_DESCRIPTION,
OPTIONS, HINTS,
true);
FileWriterDetach(out);
exit(EXIT_SUCCESS);
}
case 'x':
Log(LOG_LEVEL_ERR, "Self-diagnostic functionality is retired.");
exit(0);
case 'C':
if (!GenericAgentConfigParseColor(config, optarg))
{
exit(EXIT_FAILURE);
}
break;
default:
{
Writer *w = FileWriter(stdout);
GenericAgentWriteHelp(w, "cf-runagent", OPTIONS, HINTS, true);
FileWriterDetach(w);
}
exit(1);
}
}
if (!GenericAgentConfigParseArguments(config, argc - optind, argv + optind))
{
Log(LOG_LEVEL_ERR, "Too many arguments");
exit(EXIT_FAILURE);
}
return config;
}