int VerifyMount(char *name, Attributes a, Promise *pp)
{
char comm[CF_BUFSIZE], line[CF_BUFSIZE];
FILE *pfp;
char *host, *rmountpt, *mountpt;
host = a.mount.mount_server;
rmountpt = a.mount.mount_source;
mountpt = name;
if (!DONTDO)
{
snprintf(comm, CF_BUFSIZE, "%s %s:%s %s", GetArg0(VMOUNTCOMM[VSYSTEMHARDCLASS]), host, rmountpt, mountpt);
if ((pfp = cf_popen(comm, "r")) == NULL)
{
CfOut(cf_error, "", " !! Failed to open pipe from %s\n", GetArg0(VMOUNTCOMM[VSYSTEMHARDCLASS]));
return 0;
}
CfReadLine(line, CF_BUFSIZE, pfp);
if ((strstr(line, "busy")) || (strstr(line, "Busy")))
{
cfPS(cf_inform, CF_INTERPT, "", pp, a, " !! The device under %s cannot be mounted\n", mountpt);
cf_pclose(pfp);
return 1;
}
cf_pclose(pfp);
}
cfPS(cf_inform, CF_CHG, "", pp, a, " -> Mounting %s to keep promise\n", mountpt);
return 0;
}
int VerifyMount(char *name, Attributes a, Promise *pp)
{
char comm[CF_BUFSIZE], line[CF_BUFSIZE];
FILE *pfp;
char *host, *rmountpt, *mountpt, *opts=NULL;
host = a.mount.mount_server;
rmountpt = a.mount.mount_source;
mountpt = name;
/* Check for options required for this mount - i.e., -o ro,rsize, etc. */
if (a.mount.mount_options)
{
opts = Rlist2String(a.mount.mount_options, ",");
}
else
{
opts = xstrdup(VMOUNTOPTS[VSYSTEMHARDCLASS]);
}
if (!DONTDO)
{
snprintf(comm, CF_BUFSIZE, "%s -o %s %s:%s %s", GetArg0(VMOUNTCOMM[VSYSTEMHARDCLASS]), opts, host, rmountpt, mountpt);
if ((pfp = cf_popen(comm, "r")) == NULL)
{
CfOut(cf_error, "", " !! Failed to open pipe from %s\n", GetArg0(VMOUNTCOMM[VSYSTEMHARDCLASS]));
return 0;
}
if (CfReadLine(line, CF_BUFSIZE, pfp) == -1)
{
FatalError("Error in CfReadLine");
}
if ((strstr(line, "busy")) || (strstr(line, "Busy")))
{
cfPS(cf_inform, CF_INTERPT, "", pp, a, " !! The device under %s cannot be mounted\n", mountpt);
cf_pclose(pfp);
return 1;
}
cf_pclose(pfp);
}
/* Since opts is either Rlist2String or xstrdup'd, we need to always free it */
free(opts);
cfPS(cf_inform, CF_CHG, "", pp, a, " -> Mounting %s to keep promise\n", mountpt);
return 0;
}
void ManPage(const char *component, const struct option options[], const char *hints[], const char *id)
{ int i;
printf(".TH %s 8 \"Maintenance Commands\"\n",GetArg0(component));
printf(".SH NAME\n%s\n\n",component);
printf(".SH SYNOPSIS:\n\n %s [options]\n\n.SH DESCRIPTION:\n\n%s\n",GetArg0(component),id);
printf(".B cfengine\n"
"is a self-healing configuration and change management based system. You can think of"
".B cfengine\n"
"as a very high level language, much higher level than Perl or shell. A"
"single statement is called a promise, and compliance can result in many hundreds of files"
"being created, or the permissions of many hundreds of"
"files being set. The idea of "
".B cfengine\n"
"is to create a one or more sets of configuration files which will"
"classify and describe the setup of every host in a network.\n");
printf(".SH COMMAND LINE OPTIONS:\n");
for (i=0; options[i].name != NULL; i++)
{
if (options[i].has_arg)
{
printf(".IP \"--%s, -%c\" value\n%s\n",options[i].name,(char)options[i].val,hints[i]);
}
else
{
printf(".IP \"--%s, -%c\"\n%s\n",options[i].name,(char)options[i].val,hints[i]);
}
}
printf(".SH AUTHOR\n"
"Mark Burgess and CFEngine AS\n"
".SH INFORMATION\n");
printf("\nBug reports: http://bug.cfengine.com, ");
printf(".pp\nCommunity help: http://forum.cfengine.com\n");
printf(".pp\nCommunity info: http://www.cfengine.com/pages/community\n");
printf(".pp\nSupport services: http://www.cfengine.com\n");
printf(".pp\nThis software is Copyright (C) 2008-%d CFEngine AS.\n", BUILD_YEAR);
}
static const char *getlogname (void)
{
const char *name;
#if (DOSX & PHARLAP)
extern char *GetArg0 (USHORT sel);
CONFIG_INF cnf;
char *arg0;
_dx_config_inf (&cnf, (UCHAR*)&cnf); /* get config block */
arg0 = GetArg0 (cnf.c_env_sel); /* in exc_??.lib */
if (arg0)
name = strdup (arg0);
else name = NULL;
#elif defined (__DJGPP__)
extern char **__crt0_argv;
name = strdup (__crt0_argv[0]);
#elif defined (_MSC_VER)
extern char **__argv;
name = strdup (__argv[0]);
#else
extern char **_argv;
name = strdup (_argv[0]);
#endif
if (name)
{
char *exe = strrchr (name, '.'); /* ".exe" or ".exp" */
if (exe)
{
strcpy (exe, ".log");
return (name);
}
}
return ("$unknown.log");
}
static void VerifyExec(Attributes a, Promise *pp)
{
CfLock thislock;
char unsafeLine[CF_BUFSIZE], line[sizeof(unsafeLine) * 2], eventname[CF_BUFSIZE];
char comm[20];
char execstr[CF_EXPANDSIZE];
int outsourced, count = 0;
mode_t maskval = 0;
FILE *pfp;
char cmdOutBuf[CF_BUFSIZE];
int cmdOutBufPos = 0;
int lineOutLen;
if (!IsExecutable(GetArg0(pp->promiser)))
{
cfPS(cf_error, CF_FAIL, "", pp, a, "%s promises to be executable but isn't\n", pp->promiser);
if (strchr(pp->promiser, ' '))
{
CfOut(cf_verbose, "", "Paths with spaces must be inside escaped quoutes (e.g. \\\"%s\\\")", pp->promiser);
}
return;
}
else
{
CfOut(cf_verbose, "", " -> Promiser string contains a valid executable (%s) - ok\n", GetArg0(pp->promiser));
}
DeleteScalar("this", "promiser");
NewScalar("this", "promiser", pp->promiser, cf_str);
if (a.args)
{
snprintf(execstr, CF_EXPANDSIZE - 1, "%s %s", pp->promiser, a.args);
}
else
{
strncpy(execstr, pp->promiser, CF_BUFSIZE);
}
thislock = AcquireLock(execstr, VUQNAME, CFSTARTTIME, a, pp, false);
if (thislock.lock == NULL)
{
return;
}
PromiseBanner(pp);
CfOut(cf_inform, "", " -> Executing \'%s\' ...(timeout=%d,owner=%ju,group=%ju)\n", execstr, a.contain.timeout,
(uintmax_t)a.contain.owner, (uintmax_t)a.contain.group);
BeginMeasure();
if (DONTDO && !a.contain.preview)
{
CfOut(cf_error, "", "-> Would execute script %s\n", execstr);
}
else if (a.transaction.action != cfa_fix)
{
cfPS(cf_error, CF_WARN, "", pp, a, " !! Command \"%s\" needs to be executed, but only warning was promised",
execstr);
}
else
{
CommPrefix(execstr, comm);
if (a.transaction.background)
{
#ifdef MINGW
outsourced = true;
#else
CfOut(cf_verbose, "", " -> Backgrounding job %s\n", execstr);
outsourced = fork();
#endif
}
else
{
outsourced = false;
}
if (outsourced || !a.transaction.background) // work done here: either by child or non-background parent
{
if (a.contain.timeout != CF_NOINT)
{
SetTimeOut(a.contain.timeout);
}
#ifndef MINGW
CfOut(cf_verbose, "", " -> (Setting umask to %jo)\n", (uintmax_t)a.contain.umask);
maskval = umask(a.contain.umask);
if (a.contain.umask == 0)
{
CfOut(cf_verbose, "", " !! Programming %s running with umask 0! Use umask= to set\n", execstr);
}
#endif /* NOT MINGW */
if (a.contain.useshell)
{
pfp =
cf_popen_shsetuid(execstr, "r", a.contain.owner, a.contain.group, a.contain.chdir, a.contain.chroot,
a.transaction.background);
}
else
{
pfp =
cf_popensetuid(execstr, "r", a.contain.owner, a.contain.group, a.contain.chdir, a.contain.chroot,
a.transaction.background);
}
if (pfp == NULL)
{
cfPS(cf_error, CF_FAIL, "cf_popen", pp, a, "!! Couldn't open pipe to command %s\n", execstr);
YieldCurrentLock(thislock);
return;
}
while (!feof(pfp))
{
if (ferror(pfp)) /* abortable */
{
cfPS(cf_error, CF_TIMEX, "ferror", pp, a, "!! Command pipe %s\n", execstr);
cf_pclose(pfp);
YieldCurrentLock(thislock);
return;
}
CfReadLine(unsafeLine, CF_BUFSIZE - 1, pfp);
ReplaceStr(unsafeLine, line, sizeof(line), "%", "%%"); // escape format char
if (strstr(line, "cfengine-die"))
{
break;
}
if (ferror(pfp)) /* abortable */
{
cfPS(cf_error, CF_TIMEX, "ferror", pp, a, "!! Command pipe %s\n", execstr);
cf_pclose(pfp);
YieldCurrentLock(thislock);
return;
}
if (a.contain.preview)
{
PreviewProtocolLine(line, execstr);
}
if (a.module)
{
ModuleProtocol(execstr, line, !a.contain.nooutput);
}
else if (!a.contain.nooutput && NonEmptyLine(line))
{
lineOutLen = strlen(comm) + strlen(line) + 12;
// if buffer is to small for this line, output it directly
if (lineOutLen > sizeof(cmdOutBuf))
{
CfOut(cf_cmdout, "", "Q: \"...%s\": %s\n", comm, line);
}
else
{
if (cmdOutBufPos + lineOutLen > sizeof(cmdOutBuf))
{
CfOut(cf_cmdout, "", "%s", cmdOutBuf);
cmdOutBufPos = 0;
}
sprintf(cmdOutBuf + cmdOutBufPos, "Q: \"...%s\": %s\n", comm, line);
cmdOutBufPos += (lineOutLen - 1);
}
count++;
}
}
#ifdef MINGW
if (outsourced) // only get return value if we waited for command execution
{
cf_pclose(pfp);
}
else
{
cf_pclose_def(pfp, a, pp);
}
#else /* NOT MINGW */
cf_pclose_def(pfp, a, pp);
#endif
}
if (count)
{
if (cmdOutBufPos)
{
CfOut(cf_cmdout, "", "%s", cmdOutBuf);
}
CfOut(cf_cmdout, "", "I: Last %d quoted lines were generated by promiser \"%s\"\n", count, execstr);
}
if (a.contain.timeout != CF_NOINT)
{
alarm(0);
signal(SIGALRM, SIG_DFL);
}
CfOut(cf_inform, "", " -> Completed execution of %s\n", execstr);
#ifndef MINGW
umask(maskval);
#endif
YieldCurrentLock(thislock);
snprintf(eventname, CF_BUFSIZE - 1, "Exec(%s)", execstr);
#ifndef MINGW
if (a.transaction.background && outsourced)
{
CfOut(cf_verbose, "", " -> Backgrounded command (%s) is done - exiting\n", execstr);
exit(0);
}
#endif /* NOT MINGW */
}
}
static void test_command_promiser(void **state)
{
char *t1 = "/bin/echo";
assert_string_equal(GetArg0(t1), "/bin/echo");
char *t2 = "/bin/rpm -qa --queryformat \"i | repos | %{name} | %{version}-%{release} | %{arch}\n\"";
assert_string_equal(GetArg0(t2), "/bin/rpm");
char *t3 = "/bin/mount -va";
assert_string_equal(GetArg0(t3), "/bin/mount");
char *t4 = "\"/bin/echo\"";
assert_string_equal(GetArg0(t4), "/bin/echo");
char *t5 = "\"/bin/echo\" 123";
assert_string_equal(GetArg0(t5), "/bin/echo");
char *t6 = "\"/bin/echo with space\" 123";
assert_string_equal(GetArg0(t6), "/bin/echo with space");
char *t7 = "c:\\Windows\\System32\\cmd.exe";
assert_string_equal(GetArg0(t7), "c:\\Windows\\System32\\cmd.exe");
char *t8 = "\"c:\\Windows\\System32\\cmd.exe\"";
assert_string_equal(GetArg0(t8), "c:\\Windows\\System32\\cmd.exe");
char *t9 = "\"c:\\Windows\\System32\\cmd.exe\" /some args here";
assert_string_equal(GetArg0(t9), "c:\\Windows\\System32\\cmd.exe");
char *t10 = "\"c:\\Windows\\System32 with space\\cmd.exe\"";
assert_string_equal(GetArg0(t10), "c:\\Windows\\System32 with space\\cmd.exe");
char *t11 = "\"c:\\Windows\\System32 with space\\cmd.exe\" /some args here";
assert_string_equal(GetArg0(t11), "c:\\Windows\\System32 with space\\cmd.exe");
char *t12 = "\"c:\\Windows\\System32 with space\\cmd.exe\" /some \"args here\"";
assert_string_equal(GetArg0(t12), "c:\\Windows\\System32 with space\\cmd.exe");
char *t13 = "\\\\mycommand";
assert_string_equal(GetArg0(t13), "\\\\mycommand");
char *t14 = "\\\\myhost\\share\\command.exe";
assert_string_equal(GetArg0(t14), "\\\\myhost\\share\\command.exe");
char *t15 = "\"\\\\myhost\\share\\command.exe\"";
assert_string_equal(GetArg0(t15), "\\\\myhost\\share\\command.exe");
/* bad input */
char *b1 = "\"/bin/echo 123";
assert_string_equal(GetArg0(b1), "/bin/echo 123");
char *b2 = "/bin/echo\" 123";
assert_string_equal(GetArg0(b2), "/bin/echo\"");
char *b3 = "";
assert_string_equal(GetArg0(b3), "");
}
void dCILInstrGoto::SetTarget (dCILInstrLabel* const target)
{
m_tagetNode = target->GetNode();
dAssert (target->GetArg0().m_label == GetArg0().m_label);
}
static void VerifyProcessOp(Item *procdata, Attributes a, Promise *pp)
{
int matches = 0, do_signals = true, out_of_range, killed = 0, need_to_restart = true;
Item *killlist = NULL;
CfDebug("VerifyProcessOp\n");
matches = FindPidMatches(procdata, &killlist, a, pp);
/* promise based on number of matches */
if (a.process_count.min_range != CF_NOINT) /* if a range is specified */
{
if (matches < a.process_count.min_range || matches > a.process_count.max_range)
{
cfPS(cf_error, CF_CHG, "", pp, a, " !! Process count for \'%s\' was out of promised range (%d found)\n",
pp->promiser, matches);
AddEphemeralClasses(a.process_count.out_of_range_define);
out_of_range = true;
}
else
{
AddEphemeralClasses(a.process_count.in_range_define);
cfPS(cf_verbose, CF_NOP, "", pp, a, " -> Process promise for %s is kept", pp->promiser);
out_of_range = false;
}
}
else
{
out_of_range = true;
}
if (!out_of_range)
{
return;
}
if (a.transaction.action == cfa_warn)
{
do_signals = false;
}
else
{
do_signals = true;
}
/* signal/kill promises for existing matches */
if (do_signals && matches > 0)
{
if (a.process_stop != NULL)
{
if (DONTDO)
{
cfPS(cf_error, CF_WARN, "", pp, a,
" -- Need to keep process-stop promise for %s, but only a warning is promised", pp->promiser);
}
else
{
if (IsExecutable(GetArg0(a.process_stop)))
{
ShellCommandReturnsZero(a.process_stop, false);
}
else
{
cfPS(cf_verbose, CF_FAIL, "", pp, a,
"Process promise to stop %s could not be kept because %s the stop operator failed",
pp->promiser, a.process_stop);
DeleteItemList(killlist);
return;
}
}
}
killed = DoAllSignals(killlist, a, pp);
}
/* delegated promise to restart killed or non-existent entries */
need_to_restart = (a.restart_class != NULL) && (killed || matches == 0);
DeleteItemList(killlist);
if (!need_to_restart)
{
cfPS(cf_verbose, CF_NOP, "", pp, a, " -> No restart promised for %s\n", pp->promiser);
return;
}
else
{
if (a.transaction.action == cfa_warn)
{
cfPS(cf_error, CF_WARN, "", pp, a,
" -- Need to keep restart promise for %s, but only a warning is promised", pp->promiser);
}
else
{
cfPS(cf_inform, CF_CHG, "", pp, a, " -> Making a one-time restart promise for %s", pp->promiser);
NewClass(a.restart_class);
}
}
}