static void LogPromiseContext(const EvalContext *ctx, const Promise *pp)
{
Rval retval;
char *v;
if (EvalContextVariableControlCommonGet(ctx, COMMON_CONTROL_VERSION, &retval))
{
v = (char *) retval.item;
}
else
{
v = "not specified";
}
const char *sp = PromiseGetHandle(pp);
if (sp == NULL)
{
sp = PromiseID(pp);
}
if (sp == NULL)
{
sp = "(unknown)";
}
Log(LOG_LEVEL_INFO, "Report relates to a promise with handle '%s'", sp);
if (PromiseGetBundle(pp)->source_path)
{
Log(LOG_LEVEL_INFO, "Made in version '%s' of '%s' near line %zu",
v, PromiseGetBundle(pp)->source_path, pp->offset.line);
}
else
{
Log(LOG_LEVEL_INFO, "Promise is made internally by CFEngine");
}
switch (pp->promisee.type)
{
case RVAL_TYPE_SCALAR:
Log(LOG_LEVEL_INFO,"The promise was made to '%s'", (char *) pp->promisee.item);
break;
case RVAL_TYPE_LIST:
{
Writer *w = StringWriter();
RlistWrite(w, pp->promisee.item);
Log(LOG_LEVEL_INFO, "The promise was made to (stakeholders) '%s'", StringWriterData(w));
WriterClose(w);
break;
}
default:
break;
}
if (pp->comment)
{
Log(LOG_LEVEL_INFO, "Comment '%s'", pp->comment);
}
}
PromiseIterator *PromiseIteratorNew(EvalContext *ctx, const Promise *pp, const Rlist *lists, const Rlist *containers)
{
PromiseIterator *iter = xmalloc(sizeof(PromiseIterator));
iter->vars = SeqNew(RlistLen(lists), DeleteAssoc);
iter->var_states = SeqNew(RlistLen(lists), NULL);
iter->has_null_list = false;
for (const Rlist *rp = lists; rp != NULL; rp = rp->next)
{
VarRef *ref = VarRefParseFromBundle(RlistScalarValue(rp), PromiseGetBundle(pp));
DataType dtype = CF_DATA_TYPE_NONE;
const void *value = EvalContextVariableGet(ctx, ref, &dtype);
if (!value)
{
Log(LOG_LEVEL_ERR, "Couldn't locate variable '%s' apparently in '%s'", RlistScalarValue(rp), PromiseGetBundle(pp)->name);
VarRefDestroy(ref);
continue;
}
VarRefDestroy(ref);
CfAssoc *new_var = NewAssoc(RlistScalarValue(rp), (Rval) { (void *)value, DataTypeToRvalType(dtype) }, dtype);
iter->has_null_list |= !AppendIterationVariable(iter, new_var);
}
for (const Rlist *rp = containers; rp; rp = rp->next)
{
VarRef *ref = VarRefParseFromBundle(RlistScalarValue(rp), PromiseGetBundle(pp));
DataType dtype = CF_DATA_TYPE_NONE;
const JsonElement *value = EvalContextVariableGet(ctx, ref, &dtype);
if (!value)
{
Log(LOG_LEVEL_ERR, "Couldn't locate variable '%s' apparently in '%s'", RlistScalarValue(rp), PromiseGetBundle(pp)->name);
VarRefDestroy(ref);
continue;
}
VarRefDestroy(ref);
assert(dtype == CF_DATA_TYPE_CONTAINER);
/* Mimics NewAssoc() but bypassing extra copying of ->rval: */
CfAssoc *new_var = xmalloc(sizeof(CfAssoc));
new_var->lval = xstrdup(RlistScalarValue(rp));
new_var->rval = (Rval) { ContainerToRlist(value), RVAL_TYPE_LIST };
new_var->dtype = CF_DATA_TYPE_STRING_LIST;
iter->has_null_list |= !AppendIterationVariable(iter, new_var);
}
// We now have a control list of list-variables, with internal state in state_ptr
return iter;
}
static void GetReturnValue(EvalContext *ctx, const Bundle *callee, const Promise *caller)
{
char *result = PromiseGetConstraintAsRval(caller, "useresult", RVAL_TYPE_SCALAR);
if (result)
{
VarRef *ref = VarRefParseFromBundle("last-result", callee);
VariableTableIterator *iter = EvalContextVariableTableIteratorNew(ctx, ref->ns, ref->scope, ref->lval);
Variable *result_var = NULL;
while ((result_var = VariableTableIteratorNext(iter)))
{
assert(result_var->ref->num_indices == 1);
if (result_var->ref->num_indices != 1)
{
continue;
}
VarRef *new_ref = VarRefParseFromBundle(result, PromiseGetBundle(caller));
VarRefAddIndex(new_ref, result_var->ref->indices[0]);
EvalContextVariablePut(ctx, new_ref, result_var->rval.item, result_var->type, "source=bundle");
VarRefDestroy(new_ref);
}
VarRefDestroy(ref);
VariableTableIteratorDestroy(iter);
}
}
FnCallResult FnCallEvaluate(EvalContext *ctx, FnCall *fp, const Promise *caller)
{
Rlist *expargs;
const FnCallType *fp_type = FnCallTypeGet(fp->name);
if (fp_type)
{
if (DEBUG)
{
printf("EVALUATE FN CALL %s\n", fp->name);
FnCallShow(stdout, fp);
printf("\n");
}
}
else
{
if (caller)
{
CfOut(OUTPUT_LEVEL_ERROR, "", "No such FnCall \"%s()\" in promise @ %s near line %zd\n",
fp->name, PromiseGetBundle(caller)->source_path, caller->offset.line);
}
else
{
CfOut(OUTPUT_LEVEL_ERROR, "", "No such FnCall \"%s()\" - context info unavailable\n", fp->name);
}
return (FnCallResult) { FNCALL_FAILURE, { FnCallCopy(fp), RVAL_TYPE_FNCALL } };
}
/* If the container classes seem not to be defined at this stage, then don't try to expand the function */
if ((caller != NULL) && !IsDefinedClass(ctx, caller->classes, PromiseGetNamespace(caller)))
{
return (FnCallResult) { FNCALL_FAILURE, { FnCallCopy(fp), RVAL_TYPE_FNCALL } };
}
expargs = NewExpArgs(ctx, fp, caller);
if (UnresolvedArgs(expargs))
{
DeleteExpArgs(expargs);
return (FnCallResult) { FNCALL_FAILURE, { FnCallCopy(fp), RVAL_TYPE_FNCALL } };
}
fp->caller = caller;
FnCallResult result = CallFunction(ctx, fp_type, fp, expargs);
if (result.status == FNCALL_FAILURE)
{
/* We do not assign variables to failed function calls */
DeleteExpArgs(expargs);
return (FnCallResult) { FNCALL_FAILURE, { FnCallCopy(fp), RVAL_TYPE_FNCALL } };
}
DeleteExpArgs(expargs);
return result;
}
static void LogPromiseContext(const EvalContext *ctx, const Promise *pp)
{
Writer *w = StringWriter();
WriterWrite(w, "Additional promise info:");
if (PromiseGetHandle(pp))
{
WriterWriteF(w, " handle '%s'", PromiseGetHandle(pp));
}
{
Rval retval;
if (EvalContextVariableControlCommonGet(ctx, COMMON_CONTROL_VERSION, &retval))
{
WriterWriteF(w, " version '%s'", RvalScalarValue(retval));
}
}
if (PromiseGetBundle(pp)->source_path)
{
WriterWriteF(w, " source path '%s' at line %zu", PromiseGetBundle(pp)->source_path, pp->offset.line);
}
switch (pp->promisee.type)
{
case RVAL_TYPE_SCALAR:
WriterWriteF(w, " promisee '%s'", RvalScalarValue(pp->promisee));
break;
case RVAL_TYPE_LIST:
WriterWrite(w, " promisee ");
RlistWrite(w, pp->promisee.item);
break;
default:
break;
}
if (pp->comment)
{
WriterWriteF(w, " comment '%s'", pp->comment);
}
Log(LOG_LEVEL_VERBOSE, "%s", StringWriterData(w));
WriterClose(w);
}
static bool DistributeClass(EvalContext *ctx, const Rlist *dist, const Promise *pp)
{
int total = 0;
const Rlist *rp;
for (rp = dist; rp != NULL; rp = rp->next)
{
int result = IntFromString(RlistScalarValue(rp));
if (result < 0)
{
Log(LOG_LEVEL_ERR, "Negative integer in class distribution");
PromiseRef(LOG_LEVEL_ERR, pp);
return false;
}
total += result;
}
if (total == 0)
{
Log(LOG_LEVEL_ERR, "An empty distribution was specified on RHS");
PromiseRef(LOG_LEVEL_ERR, pp);
return false;
}
double fluct = drand48() * total;
assert(0 <= fluct && fluct < total);
for (rp = dist; rp != NULL; rp = rp->next)
{
fluct -= IntFromString(RlistScalarValue(rp));
if (fluct < 0)
{
break;
}
}
assert(rp);
char buffer[CF_MAXVARSIZE];
snprintf(buffer, CF_MAXVARSIZE, "%s_%s", pp->promiser, RlistScalarValue(rp));
if (strcmp(PromiseGetBundle(pp)->type, "common") == 0)
{
EvalContextClassPutSoft(ctx, buffer, CONTEXT_SCOPE_NAMESPACE,
"source=promise");
}
else
{
EvalContextClassPutSoft(ctx, buffer, CONTEXT_SCOPE_BUNDLE,
"source=promise");
}
return true;
}
static void GetReturnValue(EvalContext *ctx, char *scope, Promise *pp)
{
char *result = ConstraintGetRvalValue(ctx, "useresult", pp, RVAL_TYPE_SCALAR);
if (result)
{
AssocHashTableIterator i;
CfAssoc *assoc;
char newname[CF_BUFSIZE];
Scope *ptr;
char index[CF_MAXVARSIZE], match[CF_MAXVARSIZE];
if ((ptr = ScopeGet(scope)) == NULL)
{
Log(LOG_LEVEL_INFO, "useresult was specified but the method returned no data");
return;
}
i = HashIteratorInit(ptr->hashtable);
while ((assoc = HashIteratorNext(&i)))
{
snprintf(match, CF_MAXVARSIZE - 1, "last-result[");
if (strncmp(match, assoc->lval, strlen(match)) == 0)
{
char *sp;
index[0] = '\0';
sscanf(assoc->lval + strlen(match), "%127[^\n]", index);
if ((sp = strchr(index, ']')))
{
*sp = '\0';
}
else
{
index[strlen(index) - 1] = '\0';
}
if (strlen(index) > 0)
{
snprintf(newname, CF_BUFSIZE, "%s[%s]", result, index);
}
else
{
snprintf(newname, CF_BUFSIZE, "%s", result);
}
EvalContextVariablePut(ctx, (VarRef) { NULL, PromiseGetBundle(pp)->name, newname }, assoc->rval, DATA_TYPE_STRING);
}
}
}
}
void ExpandPromise(EvalContext *ctx, Promise *pp, PromiseActuator *ActOnPromise, void *param)
{
Rlist *listvars = NULL;
Rlist *scalars = NULL;
Promise *pcopy;
// Set a default for packages here...general defaults that need to come before
//fix me wth a general function SetMissingDefaults
SetAnyMissingDefaults(ctx, pp);
ScopeClear("match"); /* in case we expand something expired accidentially */
EvalContextStackPushPromiseFrame(ctx, pp);
pcopy = DeRefCopyPromise(ctx, pp);
MapIteratorsFromRval(ctx, PromiseGetBundle(pp)->name, &listvars, &scalars, (Rval) { pcopy->promiser, RVAL_TYPE_SCALAR });
if (pcopy->promisee.item != NULL)
{
MapIteratorsFromRval(ctx, PromiseGetBundle(pp)->name, &listvars, &scalars, pp->promisee);
}
for (size_t i = 0; i < SeqLength(pcopy->conlist); i++)
{
Constraint *cp = SeqAt(pcopy->conlist, i);
MapIteratorsFromRval(ctx, PromiseGetBundle(pp)->name, &listvars, &scalars, cp->rval);
}
CopyLocalizedIteratorsToThisScope(ctx, PromiseGetBundle(pp)->name, listvars);
CopyLocalizedScalarsToThisScope(ctx, PromiseGetBundle(pp)->name, scalars);
ScopePushThis();
ExpandPromiseAndDo(ctx, pcopy, listvars, ActOnPromise, param);
ScopePopThis();
PromiseDestroy(pcopy);
RlistDestroy(listvars);
RlistDestroy(scalars);
EvalContextStackPopFrame(ctx);
}
PromiseResult ExpandPromise(EvalContext *ctx, const Promise *pp, PromiseActuator *ActOnPromise, void *param)
{
Rlist *lists = NULL;
Rlist *scalars = NULL;
Rlist *containers = NULL;
Promise *pcopy = DeRefCopyPromise(ctx, pp);
MapIteratorsFromRval(ctx, PromiseGetBundle(pp), (Rval) { pcopy->promiser, RVAL_TYPE_SCALAR }, &scalars, &lists, &containers);
if (pcopy->promisee.item != NULL)
{
MapIteratorsFromRval(ctx, PromiseGetBundle(pp), pp->promisee, &scalars, &lists, &containers);
}
for (size_t i = 0; i < SeqLength(pcopy->conlist); i++)
{
Constraint *cp = SeqAt(pcopy->conlist, i);
MapIteratorsFromRval(ctx, PromiseGetBundle(pp), cp->rval, &scalars, &lists, &containers);
}
CopyLocalizedReferencesToBundleScope(ctx, PromiseGetBundle(pp), lists);
CopyLocalizedReferencesToBundleScope(ctx, PromiseGetBundle(pp), scalars);
CopyLocalizedReferencesToBundleScope(ctx, PromiseGetBundle(pp), containers);
PromiseResult result = ExpandPromiseAndDo(ctx, pcopy, lists, containers, ActOnPromise, param);
PromiseDestroy(pcopy);
RlistDestroy(lists);
RlistDestroy(scalars);
RlistDestroy(containers);
return result;
}
PromiseResult ExpandPromise(EvalContext *ctx, const Promise *pp,
PromiseActuator *ActOnPromise, void *param)
{
Log(LOG_LEVEL_VERBOSE, "Evaluating promise '%s'", pp->promiser);
if (!IsDefinedClass(ctx, pp->classes))
{
if (LEGACY_OUTPUT)
{
Log(LOG_LEVEL_VERBOSE, ". . . . . . . . . . . . . . . . . . . . . . . . . . . . ");
Log(LOG_LEVEL_VERBOSE, "Skipping whole next promise (%s), as context %s is not relevant", pp->promiser,
pp->classes);
Log(LOG_LEVEL_VERBOSE, ". . . . . . . . . . . . . . . . . . . . . . . . . . . . ");
}
else
{
Log(LOG_LEVEL_VERBOSE, "Skipping next promise '%s', as context '%s' is not relevant", pp->promiser, pp->classes);
}
return PROMISE_RESULT_SKIPPED;
}
Rlist *lists = NULL;
Rlist *scalars = NULL;
Rlist *containers = NULL;
Promise *pcopy = DeRefCopyPromise(ctx, pp);
MapIteratorsFromRval(ctx, PromiseGetBundle(pp), (Rval) { pcopy->promiser, RVAL_TYPE_SCALAR }, &scalars, &lists, &containers);
if (pcopy->promisee.item != NULL)
{
MapIteratorsFromRval(ctx, PromiseGetBundle(pp), pp->promisee, &scalars, &lists, &containers);
}
for (size_t i = 0; i < SeqLength(pcopy->conlist); i++)
{
Constraint *cp = SeqAt(pcopy->conlist, i);
MapIteratorsFromRval(ctx, PromiseGetBundle(pp), cp->rval, &scalars, &lists, &containers);
}
CopyLocalizedReferencesToBundleScope(ctx, PromiseGetBundle(pp), lists);
CopyLocalizedReferencesToBundleScope(ctx, PromiseGetBundle(pp), scalars);
CopyLocalizedReferencesToBundleScope(ctx, PromiseGetBundle(pp), containers);
PromiseResult result = ExpandPromiseAndDo(ctx, pcopy, lists, containers, ActOnPromise, param);
PromiseDestroy(pcopy);
RlistDestroy(lists);
RlistDestroy(scalars);
RlistDestroy(containers);
return result;
}
static FnCall *DefaultServiceBundleCall(const Promise *pp, const char *service_policy)
{
Rlist *args = NULL;
FnCall *call = NULL;
RlistAppend(&args, pp->promiser, RVAL_TYPE_SCALAR);
RlistAppend(&args, service_policy, RVAL_TYPE_SCALAR);
Rval name = DefaultBundleConstraint(pp, "service");
if (PolicyGetBundle(PolicyFromPromise(pp), PromiseGetBundle(pp)->ns, "agent", (char *)name.item))
{
Log(LOG_LEVEL_VERBOSE, "Found service special bundle %s in ns %s\n", (char *)name.item, PromiseGetBundle(pp)->ns);
call = FnCallNew(name.item, args);
}
else
{
call = FnCallNew("standard_services", args);
}
return call;
}
void ExpandPromise(EvalContext *ctx, Promise *pp, PromiseActuator *ActOnPromise, void *param)
{
Rlist *lists = NULL;
Rlist *scalars = NULL;
Rlist *containers = NULL;
// Set a default for packages here...general defaults that need to come before
//fix me wth a general function SetMissingDefaults
SetAnyMissingDefaults(ctx, pp);
Promise *pcopy = DeRefCopyPromise(ctx, pp);
MapIteratorsFromRval(ctx, PromiseGetBundle(pp)->name, (Rval) { pcopy->promiser, RVAL_TYPE_SCALAR }, &scalars, &lists, &containers);
if (pcopy->promisee.item != NULL)
{
MapIteratorsFromRval(ctx, PromiseGetBundle(pp)->name, pp->promisee, &scalars, &lists, &containers);
}
for (size_t i = 0; i < SeqLength(pcopy->conlist); i++)
{
Constraint *cp = SeqAt(pcopy->conlist, i);
MapIteratorsFromRval(ctx, PromiseGetBundle(pp)->name, cp->rval,&scalars, &lists, &containers);
}
CopyLocalizedReferencesToBundleScope(ctx, PromiseGetBundle(pp), lists);
CopyLocalizedReferencesToBundleScope(ctx, PromiseGetBundle(pp), scalars);
CopyLocalizedReferencesToBundleScope(ctx, PromiseGetBundle(pp), containers);
ExpandPromiseAndDo(ctx, pcopy, lists, containers, ActOnPromise, param);
PromiseDestroy(pcopy);
RlistDestroy(lists);
RlistDestroy(scalars);
RlistDestroy(containers);
}
PromiseResult VerifyReportPromise(EvalContext *ctx, const Promise *pp)
{
CfLock thislock;
char unique_name[CF_EXPANDSIZE];
Attributes a = GetReportsAttributes(ctx, pp);
// We let AcquireLock worry about making a unique name
snprintf(unique_name, CF_EXPANDSIZE - 1, "%s", pp->promiser);
thislock = AcquireLock(ctx, unique_name, VUQNAME, CFSTARTTIME, a.transaction, pp, false);
// Handle return values before locks, as we always do this
if (a.report.result)
{
// User-unwritable value last-result contains the useresult
if (strlen(a.report.result) > 0)
{
snprintf(unique_name, CF_BUFSIZE, "last-result[%s]", a.report.result);
}
else
{
snprintf(unique_name, CF_BUFSIZE, "last-result");
}
VarRef *ref = VarRefParseFromBundle(unique_name, PromiseGetBundle(pp));
EvalContextVariablePut(ctx, ref, pp->promiser, CF_DATA_TYPE_STRING, "source=bundle");
VarRefDestroy(ref);
if (thislock.lock)
{
YieldCurrentLock(thislock);
}
return PROMISE_RESULT_NOOP;
}
if (thislock.lock == NULL)
{
return PROMISE_RESULT_SKIPPED;
}
PromiseBanner(ctx, pp);
if (a.transaction.action == cfa_warn)
{
cfPS(ctx, LOG_LEVEL_WARNING, PROMISE_RESULT_WARN, pp, a, "Need to repair reports promise: %s", pp->promiser);
YieldCurrentLock(thislock);
return PROMISE_RESULT_WARN;
}
if (a.report.to_file)
{
ReportToFile(a.report.to_file, pp->promiser);
}
else
{
ReportToLog(pp->promiser);
}
PromiseResult result = PROMISE_RESULT_NOOP;
if (a.report.haveprintfile)
{
if (!PrintFile(a.report.filename, a.report.numlines))
{
result = PromiseResultUpdate(result, PROMISE_RESULT_FAIL);
}
}
YieldCurrentLock(thislock);
ClassAuditLog(ctx, pp, a, result);
return result;
}
static int EvalClassExpression(EvalContext *ctx, Constraint *cp, const Promise *pp)
{
assert(pp);
int result_and = true;
int result_or = false;
int result_xor = 0;
int result = 0, total = 0;
char buffer[CF_MAXVARSIZE];
Rlist *rp;
if (cp == NULL) // ProgrammingError ? We'll crash RSN anyway ...
{
Log(LOG_LEVEL_ERR, "EvalClassExpression internal diagnostic discovered an ill-formed condition");
}
if (!IsDefinedClass(ctx, pp->classes))
{
return false;
}
if (IsDefinedClass(ctx, pp->promiser))
{
if (PromiseGetConstraintAsInt(ctx, "persistence", pp) == 0)
{
Log(LOG_LEVEL_VERBOSE, " ?> Cancelling cached persistent class %s", pp->promiser);
EvalContextHeapPersistentRemove(pp->promiser);
}
return false;
}
switch (cp->rval.type)
{
Rval rval;
FnCall *fp;
case RVAL_TYPE_FNCALL:
fp = RvalFnCallValue(cp->rval);
/* Special expansion of functions for control, best effort only: */
FnCallResult res = FnCallEvaluate(ctx, PromiseGetPolicy(pp), fp, pp);
FnCallDestroy(fp);
cp->rval = res.rval;
break;
case RVAL_TYPE_LIST:
for (rp = (Rlist *) cp->rval.item; rp != NULL; rp = rp->next)
{
rval = EvaluateFinalRval(ctx, PromiseGetPolicy(pp), NULL, "this", rp->val, true, pp);
RvalDestroy(rp->val);
rp->val = rval;
}
break;
default:
rval = ExpandPrivateRval(ctx, NULL, "this", cp->rval.item, cp->rval.type);
RvalDestroy(cp->rval);
cp->rval = rval;
break;
}
if (strcmp(cp->lval, "expression") == 0)
{
return (cp->rval.type == RVAL_TYPE_SCALAR &&
IsDefinedClass(ctx, RvalScalarValue(cp->rval)));
}
if (strcmp(cp->lval, "not") == 0)
{
return (cp->rval.type == RVAL_TYPE_SCALAR &&
!IsDefinedClass(ctx, RvalScalarValue(cp->rval)));
}
// Class selection
if (strcmp(cp->lval, "select_class") == 0)
{
char splay[CF_MAXVARSIZE];
int i, n;
double hash;
total = 0;
for (rp = (Rlist *) cp->rval.item; rp != NULL; rp = rp->next)
{
total++;
}
if (total == 0)
{
Log(LOG_LEVEL_ERR, "No classes to select on RHS");
PromiseRef(LOG_LEVEL_ERR, pp);
return false;
}
snprintf(splay, CF_MAXVARSIZE, "%s+%s+%ju", VFQNAME, VIPADDRESS, (uintmax_t)getuid());
hash = (double) StringHash(splay, 0, CF_HASHTABLESIZE);
n = (int) (total * hash / (double) CF_HASHTABLESIZE);
for (rp = (Rlist *) cp->rval.item, i = 0; rp != NULL; rp = rp->next, i++)
{
if (i == n)
{
EvalContextClassPutSoft(ctx, RlistScalarValue(rp), CONTEXT_SCOPE_NAMESPACE, "source=promise");
return true;
}
}
}
/* If we get here, anything remaining on the RHS must be a clist */
if (cp->rval.type != RVAL_TYPE_LIST)
{
Log(LOG_LEVEL_ERR, "RHS of promise body attribute '%s' is not a list", cp->lval);
PromiseRef(LOG_LEVEL_ERR, pp);
return true;
}
// Class distributions
if (strcmp(cp->lval, "dist") == 0)
{
for (rp = (Rlist *) cp->rval.item; rp != NULL; rp = rp->next)
{
result = IntFromString(RlistScalarValue(rp));
if (result < 0)
{
Log(LOG_LEVEL_ERR, "Non-positive integer in class distribution");
PromiseRef(LOG_LEVEL_ERR, pp);
return false;
}
total += result;
}
if (total == 0)
{
Log(LOG_LEVEL_ERR, "An empty distribution was specified on RHS");
PromiseRef(LOG_LEVEL_ERR, pp);
return false;
}
double fluct = drand48();
double cum = 0.0;
for (rp = (Rlist *) cp->rval.item; rp != NULL; rp = rp->next)
{
double prob = ((double) IntFromString(RlistScalarValue(rp))) / ((double) total);
cum += prob;
if (fluct < cum)
{
break;
}
}
snprintf(buffer, CF_MAXVARSIZE - 1, "%s_%s", pp->promiser, RlistScalarValue(rp));
if (strcmp(PromiseGetBundle(pp)->type, "common") == 0)
{
EvalContextClassPutSoft(ctx, buffer, CONTEXT_SCOPE_NAMESPACE, "source=promise");
}
else
{
EvalContextClassPutSoft(ctx, buffer, CONTEXT_SCOPE_BUNDLE, "source=promise");
}
return true;
}
/* and/or/xor expressions */
enum {
c_or = 0, c_and, c_xor
} logic;
if (strcmp(cp->lval, "or") == 0)
{
logic = c_or;
}
else if (strcmp(cp->lval, "and") == 0)
{
logic = c_and;
}
else if (strcmp(cp->lval, "xor") == 0)
{
logic = c_xor;
}
for (rp = (Rlist *) cp->rval.item; rp != NULL; rp = rp->next)
{
// tolerate unexpanded entries here and interpret as "class not set"
if (rp->val.type != RVAL_TYPE_SCALAR)
{
result = false;
}
else
{
result = IsDefinedClass(ctx, RlistScalarValue(rp));
}
// shortcut and and or
switch (logic)
{
case c_or:
if (result)
{
return true;
}
break;
case c_and:
if (!result)
{
return false;
}
break;
default:
break;
}
result_and = result_and && result;
result_or = result_or || result;
result_xor ^= result;
}
// Class combinations
switch (logic)
{
case c_or:
return result_or;
case c_xor:
return result_xor == 1;
case c_and:
return result_and;
}
return false;
}
static void AmendErrorMessageWithPromiseInformation(EvalContext *ctx, Item **error_message, const Promise *pp)
{
Rval retval;
char *v;
if (ScopeControlCommonGet(ctx, COMMON_CONTROL_VERSION, &retval) != DATA_TYPE_NONE)
{
v = (char *) retval.item;
}
else
{
v = "not specified";
}
const char *sp;
char handle[CF_MAXVARSIZE];
if ((sp = PromiseGetHandle(pp)) || (sp = PromiseID(pp)))
{
strncpy(handle, sp, CF_MAXVARSIZE - 1);
}
else
{
strcpy(handle, "(unknown)");
}
char output[CF_BUFSIZE];
if (INFORM || VERBOSE || DEBUG)
{
snprintf(output, CF_BUFSIZE - 1, "I: Report relates to a promise with handle \"%s\"", handle);
AppendItem(error_message, output, NULL);
}
if (pp && PromiseGetBundle(pp)->source_path)
{
snprintf(output, CF_BUFSIZE - 1, "I: Made in version \'%s\' of \'%s\' near line %zu",
v, PromiseGetBundle(pp)->source_path, pp->offset.line);
}
else
{
snprintf(output, CF_BUFSIZE - 1, "I: Promise is made internally by cfengine");
}
AppendItem(error_message, output, NULL);
if (pp != NULL)
{
switch (pp->promisee.type)
{
case RVAL_TYPE_SCALAR:
snprintf(output, CF_BUFSIZE - 1, "I: The promise was made to: \'%s\'", (char *) pp->promisee.item);
AppendItem(error_message, output, NULL);
break;
case RVAL_TYPE_LIST:
{
Writer *w = StringWriter();
WriterWriteF(w, "I: The promise was made to (stakeholders): ");
RlistWrite(w, pp->promisee.item);
AppendItem(error_message, StringWriterClose(w), NULL);
break;
}
default:
break;
}
if (pp->ref)
{
snprintf(output, CF_BUFSIZE - 1, "I: Comment: %s\n", pp->ref);
AppendItem(error_message, output, NULL);
}
}
}
void VerifyReportPromise(EvalContext *ctx, Promise *pp)
{
Attributes a = { {0} };
CfLock thislock;
char unique_name[CF_EXPANDSIZE];
a = GetReportsAttributes(ctx, pp);
snprintf(unique_name, CF_EXPANDSIZE - 1, "%s_%zu", pp->promiser, pp->offset.line);
thislock = AcquireLock(ctx, unique_name, VUQNAME, CFSTARTTIME, a.transaction, pp, false);
// Handle return values before locks, as we always do this
if (a.report.result)
{
// User-unwritable value last-result contains the useresult
if (strlen(a.report.result) > 0)
{
snprintf(unique_name, CF_BUFSIZE, "last-result[%s]", a.report.result);
}
else
{
snprintf(unique_name, CF_BUFSIZE, "last-result");
}
VarRef *ref = VarRefParseFromBundle(unique_name, PromiseGetBundle(pp));
EvalContextVariablePut(ctx, ref, (Rval) {
pp->promiser, RVAL_TYPE_SCALAR
}, DATA_TYPE_STRING);
VarRefDestroy(ref);
return;
}
// Now do regular human reports
if (thislock.lock == NULL)
{
return;
}
PromiseBanner(pp);
if (a.transaction.action == cfa_warn)
{
cfPS(ctx, LOG_LEVEL_VERBOSE, PROMISE_RESULT_WARN, pp, a, "Need to repair reports promise: %s", pp->promiser);
YieldCurrentLock(thislock);
return;
}
cfPS(ctx, LOG_LEVEL_VERBOSE, PROMISE_RESULT_CHANGE, pp, a, "Report: %s", pp->promiser);
if (a.report.to_file)
{
ReportToFile(a.report.to_file, pp->promiser);
}
else
{
Log(LOG_LEVEL_NOTICE, "R: %s", pp->promiser);
}
if (a.report.haveprintfile)
{
PrintFile(ctx, a, pp);
}
if (a.report.showstate)
{
/* Do nothing. Deprecated. */
}
if (a.report.havelastseen)
{
/* Do nothing. Deprecated. */
}
YieldCurrentLock(thislock);
}
static void ExpandPromiseAndDo(EvalContext *ctx, const Promise *pp, Rlist *lists, Rlist *containers, PromiseActuator *ActOnPromise, void *param)
{
const char *handle = PromiseGetHandle(pp);
char v[CF_MAXVARSIZE];
EvalContextStackPushPromiseFrame(ctx, pp, true);
PromiseIterator *iter_ctx = NULL;
for (iter_ctx = PromiseIteratorNew(ctx, pp, lists, containers); PromiseIteratorHasMore(iter_ctx); PromiseIteratorNext(iter_ctx))
{
EvalContextStackPushPromiseIterationFrame(ctx, iter_ctx);
char number[CF_SMALLBUF];
/* Allow $(this.handle) etc variables */
if (PromiseGetBundle(pp)->source_path)
{
EvalContextVariablePutSpecial(ctx, SPECIAL_SCOPE_THIS, "promise_filename",PromiseGetBundle(pp)->source_path, DATA_TYPE_STRING);
snprintf(number, CF_SMALLBUF, "%zu", pp->offset.line);
EvalContextVariablePutSpecial(ctx, SPECIAL_SCOPE_THIS, "promise_linenumber", number, DATA_TYPE_STRING);
}
snprintf(v, CF_MAXVARSIZE, "%d", (int) getuid());
EvalContextVariablePutSpecial(ctx, SPECIAL_SCOPE_THIS, "promiser_uid", v, DATA_TYPE_INT);
snprintf(v, CF_MAXVARSIZE, "%d", (int) getgid());
EvalContextVariablePutSpecial(ctx, SPECIAL_SCOPE_THIS, "promiser_gid", v, DATA_TYPE_INT);
EvalContextVariablePutSpecial(ctx, SPECIAL_SCOPE_THIS, "bundle", PromiseGetBundle(pp)->name, DATA_TYPE_STRING);
EvalContextVariablePutSpecial(ctx, SPECIAL_SCOPE_THIS, "namespace", PromiseGetNamespace(pp), DATA_TYPE_STRING);
/* Must expand $(this.promiser) here for arg dereferencing in things
like edit_line and methods, but we might have to
adjust again later if the value changes -- need to qualify this
so we don't expand too early for some other promsies */
if (pp->has_subbundles)
{
EvalContextVariablePutSpecial(ctx, SPECIAL_SCOPE_THIS, "promiser", pp->promiser, DATA_TYPE_STRING);
}
if (handle)
{
char tmp[CF_EXPANDSIZE];
// This ordering is necessary to get automated canonification
ExpandScalar(ctx, NULL, "this", handle, tmp);
CanonifyNameInPlace(tmp);
Log(LOG_LEVEL_DEBUG, "Expanded handle to '%s'", tmp);
EvalContextVariablePutSpecial(ctx, SPECIAL_SCOPE_THIS, "handle", tmp, DATA_TYPE_STRING);
}
else
{
EvalContextVariablePutSpecial(ctx, SPECIAL_SCOPE_THIS, "handle", PromiseID(pp), DATA_TYPE_STRING);
}
Promise *pexp = ExpandDeRefPromise(ctx, pp);
assert(ActOnPromise);
ActOnPromise(ctx, pexp, param);
if (strcmp(pp->parent_promise_type->name, "vars") == 0 || strcmp(pp->parent_promise_type->name, "meta") == 0)
{
VerifyVarPromise(ctx, pexp, true);
}
PromiseDestroy(pexp);
EvalContextStackPopFrame(ctx);
}
PromiseIteratorDestroy(iter_ctx);
EvalContextStackPopFrame(ctx);
}
static int EvalClassExpression(EvalContext *ctx, Constraint *cp, Promise *pp)
{
int result_and = true;
int result_or = false;
int result_xor = 0;
int result = 0, total = 0;
char buffer[CF_MAXVARSIZE];
Rlist *rp;
FnCall *fp;
Rval rval;
if (cp == NULL)
{
Log(LOG_LEVEL_ERR, "EvalClassExpression internal diagnostic discovered an ill-formed condition");
}
if (!IsDefinedClass(ctx, pp->classes, PromiseGetNamespace(pp)))
{
return false;
}
if (EvalContextPromiseIsDone(ctx, pp))
{
return false;
}
if (IsDefinedClass(ctx, pp->promiser, PromiseGetNamespace(pp)))
{
if (PromiseGetConstraintAsInt(ctx, "persistence", pp) == 0)
{
Log(LOG_LEVEL_VERBOSE, " ?> Cancelling cached persistent class %s", pp->promiser);
EvalContextHeapPersistentRemove(pp->promiser);
}
return false;
}
switch (cp->rval.type)
{
case RVAL_TYPE_FNCALL:
fp = (FnCall *) cp->rval.item; /* Special expansion of functions for control, best effort only */
FnCallResult res = FnCallEvaluate(ctx, fp, pp);
FnCallDestroy(fp);
cp->rval = res.rval;
break;
case RVAL_TYPE_LIST:
for (rp = (Rlist *) cp->rval.item; rp != NULL; rp = rp->next)
{
rval = EvaluateFinalRval(ctx, "this", (Rval) {rp->item, rp->type}, true, pp);
RvalDestroy((Rval) {rp->item, rp->type});
rp->item = rval.item;
rp->type = rval.type;
}
break;
default:
rval = ExpandPrivateRval(ctx, "this", cp->rval);
RvalDestroy(cp->rval);
cp->rval = rval;
break;
}
if (strcmp(cp->lval, "expression") == 0)
{
if (cp->rval.type != RVAL_TYPE_SCALAR)
{
return false;
}
if (IsDefinedClass(ctx, (char *) cp->rval.item, PromiseGetNamespace(pp)))
{
return true;
}
else
{
return false;
}
}
if (strcmp(cp->lval, "not") == 0)
{
if (cp->rval.type != RVAL_TYPE_SCALAR)
{
return false;
}
if (IsDefinedClass(ctx, (char *) cp->rval.item, PromiseGetNamespace(pp)))
{
return false;
}
else
{
return true;
}
}
// Class selection
if (strcmp(cp->lval, "select_class") == 0)
{
char splay[CF_MAXVARSIZE];
int i, n;
double hash;
total = 0;
for (rp = (Rlist *) cp->rval.item; rp != NULL; rp = rp->next)
{
total++;
}
if (total == 0)
{
Log(LOG_LEVEL_ERR, "No classes to select on RHS");
PromiseRef(LOG_LEVEL_ERR, pp);
return false;
}
snprintf(splay, CF_MAXVARSIZE, "%s+%s+%ju", VFQNAME, VIPADDRESS, (uintmax_t)getuid());
hash = (double) OatHash(splay, CF_HASHTABLESIZE);
n = (int) (total * hash / (double) CF_HASHTABLESIZE);
for (rp = (Rlist *) cp->rval.item, i = 0; rp != NULL; rp = rp->next, i++)
{
if (i == n)
{
EvalContextHeapAddSoft(ctx, rp->item, PromiseGetNamespace(pp));
return true;
}
}
}
/* If we get here, anything remaining on the RHS must be a clist */
if (cp->rval.type != RVAL_TYPE_LIST)
{
Log(LOG_LEVEL_ERR, "RHS of promise body attribute '%s' is not a list", cp->lval);
PromiseRef(LOG_LEVEL_ERR, pp);
return true;
}
// Class distributions
if (strcmp(cp->lval, "dist") == 0)
{
for (rp = (Rlist *) cp->rval.item; rp != NULL; rp = rp->next)
{
result = IntFromString(rp->item);
if (result < 0)
{
Log(LOG_LEVEL_ERR, "Non-positive integer in class distribution");
PromiseRef(LOG_LEVEL_ERR, pp);
return false;
}
total += result;
}
if (total == 0)
{
Log(LOG_LEVEL_ERR, "An empty distribution was specified on RHS");
PromiseRef(LOG_LEVEL_ERR, pp);
return false;
}
double fluct = drand48();
double cum = 0.0;
for (rp = (Rlist *) cp->rval.item; rp != NULL; rp = rp->next)
{
double prob = ((double) IntFromString(rp->item)) / ((double) total);
cum += prob;
if (fluct < cum)
{
break;
}
}
snprintf(buffer, CF_MAXVARSIZE - 1, "%s_%s", pp->promiser, (char *) rp->item);
/* FIXME: figure why explicit mark and get rid of it */
EvalContextMarkPromiseDone(ctx, pp);
if (strcmp(PromiseGetBundle(pp)->type, "common") == 0)
{
EvalContextHeapAddSoft(ctx, buffer, PromiseGetNamespace(pp));
}
else
{
EvalContextStackFrameAddSoft(ctx, buffer);
}
return true;
}
/* and/or/xor expressions */
for (rp = (Rlist *) cp->rval.item; rp != NULL; rp = rp->next)
{
if (rp->type != RVAL_TYPE_SCALAR)
{
return false;
}
result = IsDefinedClass(ctx, (char *) (rp->item), PromiseGetNamespace(pp));
result_and = result_and && result;
result_or = result_or || result;
result_xor ^= result;
}
// Class combinations
if (strcmp(cp->lval, "or") == 0)
{
return result_or;
}
if (strcmp(cp->lval, "xor") == 0)
{
return (result_xor == 1) ? true : false;
}
if (strcmp(cp->lval, "and") == 0)
{
return result_and;
}
return false;
}
PromiseResult VerifyVarPromise(EvalContext *ctx, const Promise *pp, bool allow_duplicates)
{
ConvergeVariableOptions opts = CollectConvergeVariableOptions(ctx, pp, allow_duplicates);
if (!opts.should_converge)
{
return PROMISE_RESULT_NOOP;
}
Attributes a = { {0} };
// More consideration needs to be given to using these
//a.transaction = GetTransactionConstraints(pp);
a.classes = GetClassDefinitionConstraints(ctx, pp);
VarRef *ref = VarRefParseFromBundle(pp->promiser, PromiseGetBundle(pp));
if (strcmp("meta", pp->parent_promise_type->name) == 0)
{
VarRefSetMeta(ref, true);
}
DataType existing_value_type = CF_DATA_TYPE_NONE;
const void *const existing_value =
IsExpandable(pp->promiser) ? NULL : EvalContextVariableGet(ctx, ref, &existing_value_type);
PromiseResult result = PROMISE_RESULT_NOOP;
Rval rval = opts.cp_save->rval;
if (rval.item != NULL)
{
DataType data_type = DataTypeFromString(opts.cp_save->lval);
if (opts.cp_save->rval.type == RVAL_TYPE_FNCALL)
{
FnCall *fp = RvalFnCallValue(rval);
const FnCallType *fn = FnCallTypeGet(fp->name);
if (!fn)
{
assert(false && "Canary: should have been caught before this point");
FatalError(ctx, "While setting variable '%s' in bundle '%s', unknown function '%s'",
pp->promiser, PromiseGetBundle(pp)->name, fp->name);
}
if (fn->dtype != DataTypeFromString(opts.cp_save->lval))
{
FatalError(ctx, "While setting variable '%s' in bundle '%s', variable declared type '%s' but function '%s' returns type '%s'",
pp->promiser, PromiseGetBundle(pp)->name, opts.cp_save->lval,
fp->name, DataTypeToString(fn->dtype));
}
if (existing_value_type != CF_DATA_TYPE_NONE)
{
// Already did this
VarRefDestroy(ref);
return PROMISE_RESULT_NOOP;
}
FnCallResult res = FnCallEvaluate(ctx, PromiseGetPolicy(pp), fp, pp);
if (res.status == FNCALL_FAILURE)
{
/* We do not assign variables to failed fn calls */
RvalDestroy(res.rval);
VarRefDestroy(ref);
return PROMISE_RESULT_NOOP;
}
else
{
rval = res.rval;
}
}
else
{
Buffer *conv = BufferNew();
bool malformed = false, misprint = false;
if (strcmp(opts.cp_save->lval, "int") == 0)
{
long int asint = IntFromString(opts.cp_save->rval.item);
if (asint == CF_NOINT)
{
malformed = true;
}
else if (0 > BufferPrintf(conv, "%ld", asint))
{
misprint = true;
}
else
{
rval = RvalNew(BufferData(conv), opts.cp_save->rval.type);
}
}
else if (strcmp(opts.cp_save->lval, "real") == 0)
{
double real_value;
if (!DoubleFromString(opts.cp_save->rval.item, &real_value))
{
malformed = true;
}
else if (0 > BufferPrintf(conv, "%lf", real_value))
{
misprint = true;
}
else
{
rval = RvalNew(BufferData(conv), opts.cp_save->rval.type);
}
}
else
{
rval = RvalCopy(opts.cp_save->rval);
}
BufferDestroy(conv);
if (malformed)
{
/* Arises when opts->cp_save->rval.item isn't yet expanded. */
/* Has already been logged by *FromString */
VarRefDestroy(ref);
return PromiseResultUpdate(result, PROMISE_RESULT_FAIL);
}
else if (misprint)
{
/* Even though no problems with memory allocation can
* get here, there might be other problems. */
UnexpectedError("Problems writing to buffer");
VarRefDestroy(ref);
return PROMISE_RESULT_NOOP;
}
else if (rval.type == RVAL_TYPE_LIST)
{
Rlist *rval_list = RvalRlistValue(rval);
RlistFlatten(ctx, &rval_list);
rval.item = rval_list;
}
}
if (Epimenides(ctx, PromiseGetBundle(pp)->ns, PromiseGetBundle(pp)->name, pp->promiser, rval, 0))
{
Log(LOG_LEVEL_ERR, "Variable '%s' contains itself indirectly - an unkeepable promise", pp->promiser);
exit(EXIT_FAILURE);
}
else
{
/* See if the variable needs recursively expanding again */
Rval returnval = EvaluateFinalRval(ctx, PromiseGetPolicy(pp), ref->ns, ref->scope, rval, true, pp);
RvalDestroy(rval);
// freed before function exit
rval = returnval;
}
if (existing_value_type != CF_DATA_TYPE_NONE)
{
if (!opts.ok_redefine) /* only on second iteration, else we ignore broken promises */
{
if (THIS_AGENT_TYPE == AGENT_TYPE_COMMON &&
!CompareRval(existing_value, DataTypeToRvalType(existing_value_type),
rval.item, rval.type))
{
switch (rval.type)
{
case RVAL_TYPE_SCALAR:
Log(LOG_LEVEL_VERBOSE, "Redefinition of a constant scalar '%s', was '%s' now '%s'",
pp->promiser, (const char *)existing_value, RvalScalarValue(rval));
PromiseRef(LOG_LEVEL_VERBOSE, pp);
break;
case RVAL_TYPE_LIST:
{
Log(LOG_LEVEL_VERBOSE, "Redefinition of a constant list '%s'", pp->promiser);
Writer *w = StringWriter();
RlistWrite(w, existing_value);
char *oldstr = StringWriterClose(w);
Log(LOG_LEVEL_VERBOSE, "Old value '%s'", oldstr);
free(oldstr);
w = StringWriter();
RlistWrite(w, rval.item);
char *newstr = StringWriterClose(w);
Log(LOG_LEVEL_VERBOSE, " New value '%s'", newstr);
free(newstr);
PromiseRef(LOG_LEVEL_VERBOSE, pp);
}
break;
case RVAL_TYPE_CONTAINER:
case RVAL_TYPE_FNCALL:
case RVAL_TYPE_NOPROMISEE:
break;
}
}
RvalDestroy(rval);
VarRefDestroy(ref);
return result;
}
}
if (IsCf3VarString(pp->promiser))
{
// Unexpanded variables, we don't do anything with
RvalDestroy(rval);
VarRefDestroy(ref);
return result;
}
if (!IsValidVariableName(pp->promiser))
{
Log(LOG_LEVEL_ERR, "Variable identifier contains illegal characters");
PromiseRef(LOG_LEVEL_ERR, pp);
RvalDestroy(rval);
VarRefDestroy(ref);
return result;
}
if (rval.type == RVAL_TYPE_LIST)
{
if (opts.drop_undefined)
{
for (Rlist *rp = RvalRlistValue(rval); rp; rp = rp->next)
{
if (IsNakedVar(RlistScalarValue(rp), '@'))
{
free(rp->val.item);
rp->val.item = xstrdup(CF_NULL_VALUE);
}
}
}
for (const Rlist *rp = RvalRlistValue(rval); rp; rp = rp->next)
{
switch (rp->val.type)
{
case RVAL_TYPE_SCALAR:
break;
default:
// Cannot assign variable because value is a list containing a non-scalar item
VarRefDestroy(ref);
RvalDestroy(rval);
return result;
}
}
}
if (ref->num_indices > 0)
{
if (data_type == CF_DATA_TYPE_CONTAINER)
{
char *lval_str = VarRefToString(ref, true);
Log(LOG_LEVEL_ERR, "Cannot assign a container to an indexed variable name '%s'. Should be assigned to '%s' instead",
lval_str, ref->lval);
free(lval_str);
VarRefDestroy(ref);
RvalDestroy(rval);
return result;
}
else
{
DataType existing_type = CF_DATA_TYPE_NONE;
VarRef *base_ref = VarRefCopyIndexless(ref);
if (EvalContextVariableGet(ctx, ref, &existing_type) && existing_type == CF_DATA_TYPE_CONTAINER)
{
char *lval_str = VarRefToString(ref, true);
char *base_ref_str = VarRefToString(base_ref, true);
Log(LOG_LEVEL_ERR, "Cannot assign value to indexed variable name '%s', because a container is already assigned to the base name '%s'",
lval_str, base_ref_str);
free(lval_str);
free(base_ref_str);
VarRefDestroy(base_ref);
VarRefDestroy(ref);
RvalDestroy(rval);
return result;
}
VarRefDestroy(base_ref);
}
}
DataType required_datatype = DataTypeFromString(opts.cp_save->lval);
if (rval.type != DataTypeToRvalType(required_datatype))
{
char *ref_str = VarRefToString(ref, true);
char *value_str = RvalToString(rval);
Log(LOG_LEVEL_ERR, "Variable '%s' expected a variable of type '%s', but was given incompatible value '%s'",
ref_str, DataTypeToString(required_datatype), value_str);
PromiseRef(LOG_LEVEL_ERR, pp);
free(ref_str);
free(value_str);
VarRefDestroy(ref);
RvalDestroy(rval);
return PromiseResultUpdate(result, PROMISE_RESULT_FAIL);
}
if (!EvalContextVariablePut(ctx, ref, rval.item, required_datatype, "source=promise"))
{
Log(LOG_LEVEL_VERBOSE,
"Unable to converge %s.%s value (possibly empty or infinite regression)",
ref->scope, pp->promiser);
PromiseRef(LOG_LEVEL_VERBOSE, pp);
result = PromiseResultUpdate(result, PROMISE_RESULT_FAIL);
}
else
{
Rlist *promise_meta = PromiseGetConstraintAsList(ctx, "meta", pp);
if (promise_meta)
{
StringSet *class_meta = EvalContextVariableTags(ctx, ref);
Buffer *print;
for (const Rlist *rp = promise_meta; rp; rp = rp->next)
{
StringSetAdd(class_meta, xstrdup(RlistScalarValue(rp)));
print = StringSetToBuffer(class_meta, ',');
Log(LOG_LEVEL_DEBUG,
"Added tag %s to class %s, tags now [%s]",
RlistScalarValue(rp), pp->promiser, BufferData(print));
BufferDestroy(print);
}
}
}
}
else
{
Log(LOG_LEVEL_ERR, "Variable %s has no promised value", pp->promiser);
Log(LOG_LEVEL_ERR, "Rule from %s at/before line %llu",
PromiseGetBundle(pp)->source_path,
(unsigned long long)opts.cp_save->offset.line);
result = PromiseResultUpdate(result, PROMISE_RESULT_FAIL);
}
/*
* FIXME: Variable promise are exempt from normal evaluation logic still, so
* they are not pushed to evaluation stack before being evaluated. Due to
* this reason, we cannot call cfPS here to set classes, as it will error
* out with ProgrammingError.
*
* In order to support 'classes' body for variables as well, we call
* ClassAuditLog explicitly.
*/
ClassAuditLog(ctx, pp, a, result);
VarRefDestroy(ref);
RvalDestroy(rval);
return result;
}
void KeepClassContextPromise(EvalContext *ctx, Promise *pp, ARG_UNUSED const ReportContext *report_context)
{
Attributes a;
a = GetClassContextAttributes(ctx, pp);
if (!FullTextMatch("[a-zA-Z0-9_]+", pp->promiser))
{
CfOut(OUTPUT_LEVEL_VERBOSE, "", "Class identifier \"%s\" contains illegal characters - canonifying", pp->promiser);
snprintf(pp->promiser, strlen(pp->promiser) + 1, "%s", CanonifyName(pp->promiser));
}
if (a.context.nconstraints == 0)
{
cfPS(ctx, OUTPUT_LEVEL_ERROR, PROMISE_RESULT_FAIL, "", pp, a, "No constraints for class promise %s", pp->promiser);
return;
}
if (a.context.nconstraints > 1)
{
cfPS(ctx, OUTPUT_LEVEL_ERROR, PROMISE_RESULT_FAIL, "", pp, a, "Irreconcilable constraints in classes for %s", pp->promiser);
return;
}
// If this is a common bundle ...
if (strcmp(PromiseGetBundle(pp)->type, "common") == 0)
{
if (EvalClassExpression(ctx, a.context.expression, pp))
{
CfOut(OUTPUT_LEVEL_VERBOSE, "", " ?> defining additional global class %s\n", pp->promiser);
if (!ValidClassName(pp->promiser))
{
cfPS(ctx, OUTPUT_LEVEL_ERROR, PROMISE_RESULT_FAIL, "", pp, a,
" !! Attempted to name a class \"%s\", which is an illegal class identifier", pp->promiser);
}
else
{
if (a.context.persistent > 0)
{
CfOut(OUTPUT_LEVEL_VERBOSE, "", " ?> defining explicit persistent class %s (%d mins)\n", pp->promiser,
a.context.persistent);
EvalContextHeapPersistentSave(pp->promiser, PromiseGetNamespace(pp), a.context.persistent, CONTEXT_STATE_POLICY_RESET);
EvalContextHeapAddSoft(ctx, pp->promiser, PromiseGetNamespace(pp));
}
else
{
CfOut(OUTPUT_LEVEL_VERBOSE, "", " ?> defining explicit global class %s\n", pp->promiser);
EvalContextHeapAddSoft(ctx, pp->promiser, PromiseGetNamespace(pp));
}
}
}
/* These are global and loaded once */
/* *(pp->donep) = true; */
return;
}
// If this is some other kind of bundle (else here??)
if (strcmp(PromiseGetBundle(pp)->type, CF_AGENTTYPES[THIS_AGENT_TYPE]) == 0 || FullTextMatch("edit_.*", PromiseGetBundle(pp)->type))
{
if (EvalClassExpression(ctx, a.context.expression, pp))
{
if (!ValidClassName(pp->promiser))
{
cfPS(ctx, OUTPUT_LEVEL_ERROR, PROMISE_RESULT_FAIL, "", pp, a,
" !! Attempted to name a class \"%s\", which is an illegal class identifier", pp->promiser);
}
else
{
if (a.context.persistent > 0)
{
CfOut(OUTPUT_LEVEL_VERBOSE, "", " ?> defining explicit persistent class %s (%d mins)\n", pp->promiser,
a.context.persistent);
CfOut(OUTPUT_LEVEL_VERBOSE, "",
" ?> Warning: persistent classes are global in scope even in agent bundles\n");
EvalContextHeapPersistentSave(pp->promiser, PromiseGetNamespace(pp), a.context.persistent, CONTEXT_STATE_POLICY_RESET);
EvalContextHeapAddSoft(ctx, pp->promiser, PromiseGetNamespace(pp));
}
else
{
CfOut(OUTPUT_LEVEL_VERBOSE, "", " ?> defining explicit local bundle class %s\n", pp->promiser);
EvalContextStackFrameAddSoft(ctx, pp->promiser);
}
}
}
// Private to bundle, can be reloaded
*(pp->donep) = false;
return;
}
}
PromiseResult VerifyClassPromise(EvalContext *ctx, const Promise *pp, ARG_UNUSED void *param)
{
assert(param == NULL);
Attributes a = GetClassContextAttributes(ctx, pp);
if (!StringMatchFull("[a-zA-Z0-9_]+", pp->promiser))
{
Log(LOG_LEVEL_VERBOSE, "Class identifier '%s' contains illegal characters - canonifying", pp->promiser);
xsnprintf(pp->promiser, strlen(pp->promiser) + 1, "%s", CanonifyName(pp->promiser));
}
if (a.context.nconstraints == 0)
{
cfPS(ctx, LOG_LEVEL_ERR, PROMISE_RESULT_FAIL, pp, a, "No constraints for class promise '%s'", pp->promiser);
return PROMISE_RESULT_FAIL;
}
if (a.context.nconstraints > 1)
{
cfPS(ctx, LOG_LEVEL_ERR, PROMISE_RESULT_FAIL, pp, a, "Irreconcilable constraints in classes for '%s'", pp->promiser);
return PROMISE_RESULT_FAIL;
}
if (EvalClassExpression(ctx, a.context.expression, pp))
{
if (!ValidClassName(pp->promiser))
{
cfPS(ctx, LOG_LEVEL_ERR, PROMISE_RESULT_FAIL, pp, a,
"Attempted to name a class '%s', which is an illegal class identifier", pp->promiser);
return PROMISE_RESULT_FAIL;
}
else
{
char *tags = NULL;
{
Buffer *tag_buffer = BufferNew();
BufferAppendString(tag_buffer, "classes promise,attribute_name=label,source=promise");
for (const Rlist *rp = PromiseGetConstraintAsList(ctx, "meta", pp); rp; rp = rp->next)
{
BufferAppendChar(tag_buffer, ',');
BufferAppendString(tag_buffer, RlistScalarValue(rp));
}
tags = BufferClose(tag_buffer);
}
if (/* Persistent classes are always global: */
a.context.persistent > 0 ||
/* Namespace-scope is global: */
a.context.scope == CONTEXT_SCOPE_NAMESPACE ||
/* If there is no explicit scope, common bundles define global
* classes, other bundles define local classes: */
(a.context.scope == CONTEXT_SCOPE_NONE &&
0 == strcmp(PromiseGetBundle(pp)->type, "common")))
{
Log(LOG_LEVEL_VERBOSE, "C: + Global class: %s ", pp->promiser);
EvalContextClassPutSoft(ctx, pp->promiser, CONTEXT_SCOPE_NAMESPACE, tags);
}
else
{
Log(LOG_LEVEL_VERBOSE, "C: + Private class: %s ", pp->promiser);
EvalContextClassPutSoft(ctx, pp->promiser, CONTEXT_SCOPE_BUNDLE, tags);
}
if (a.context.persistent > 0)
{
Log(LOG_LEVEL_VERBOSE, "C: + Persistent class: '%s'. (%d minutes)", pp->promiser, a.context.persistent);
EvalContextHeapPersistentSave(ctx, pp->promiser, a.context.persistent,
CONTEXT_STATE_POLICY_RESET, tags);
}
free(tags);
return PROMISE_RESULT_NOOP;
}
}
return PROMISE_RESULT_NOOP;
}
int VerifyMethod(EvalContext *ctx, char *attrname, Attributes a, Promise *pp)
{
Bundle *bp;
void *vp;
FnCall *fp;
char method_name[CF_EXPANDSIZE], qualified_method[CF_BUFSIZE], *method_deref;
Rlist *params = NULL;
int retval = false;
CfLock thislock;
char lockname[CF_BUFSIZE];
if (a.havebundle)
{
if ((vp = ConstraintGetRvalValue(ctx, attrname, pp, RVAL_TYPE_FNCALL)))
{
fp = (FnCall *) vp;
ExpandScalar(ctx, PromiseGetBundle(pp)->name, fp->name, method_name);
params = fp->args;
}
else if ((vp = ConstraintGetRvalValue(ctx, attrname, pp, RVAL_TYPE_SCALAR)))
{
ExpandScalar(ctx, PromiseGetBundle(pp)->name, (char *) vp, method_name);
params = NULL;
}
else
{
return false;
}
}
GetLockName(lockname, "method", pp->promiser, params);
thislock = AcquireLock(ctx, lockname, VUQNAME, CFSTARTTIME, a.transaction, pp, false);
if (thislock.lock == NULL)
{
return false;
}
PromiseBanner(pp);
if (strncmp(method_name,"default:",strlen("default:")) == 0) // CF_NS == ':'
{
method_deref = strchr(method_name, CF_NS) + 1;
}
else if ((strchr(method_name, CF_NS) == NULL) && (strcmp(PromiseGetNamespace(pp), "default") != 0))
{
snprintf(qualified_method, CF_BUFSIZE, "%s%c%s", PromiseGetNamespace(pp), CF_NS, method_name);
method_deref = qualified_method;
}
else
{
method_deref = method_name;
}
bp = PolicyGetBundle(PolicyFromPromise(pp), NULL, "agent", method_deref);
if (!bp)
{
bp = PolicyGetBundle(PolicyFromPromise(pp), NULL, "common", method_deref);
}
if (bp)
{
BannerSubBundle(bp, params);
EvalContextStackPushBundleFrame(ctx, bp, a.inherit);
ScopeClear(bp->name);
BundleHashVariables(ctx, bp);
ScopeAugment(ctx, bp, pp, params);
retval = ScheduleAgentOperations(ctx, bp);
GetReturnValue(ctx, bp->name, pp);
EvalContextStackPopFrame(ctx);
switch (retval)
{
case PROMISE_RESULT_FAIL:
cfPS(ctx, LOG_LEVEL_INFO, PROMISE_RESULT_FAIL, pp, a, "Method failed in some repairs or aborted");
break;
case PROMISE_RESULT_CHANGE:
cfPS(ctx, LOG_LEVEL_VERBOSE, PROMISE_RESULT_CHANGE, pp, a, "Method invoked repairs");
break;
default:
cfPS(ctx, LOG_LEVEL_VERBOSE, PROMISE_RESULT_NOOP, pp, a, "Method verified");
break;
}
for (const Rlist *rp = bp->args; rp; rp = rp->next)
{
const char *lval = rp->item;
ScopeDeleteScalar((VarRef) { NULL, bp->name, lval });
}
}
else
{
if (IsCf3VarString(method_name))
{
Log(LOG_LEVEL_ERR,
"A variable seems to have been used for the name of the method. In this case, the promiser also needs to contain the unique name of the method");
}
if (bp && (bp->name))
{
cfPS(ctx, LOG_LEVEL_ERR, PROMISE_RESULT_FAIL, pp, a, "Method '%s' was used but was not defined", bp->name);
}
else
{
cfPS(ctx, LOG_LEVEL_ERR, PROMISE_RESULT_FAIL, pp, a,
"A method attempted to use a bundle '%s' that was apparently not defined", method_name);
}
}
YieldCurrentLock(thislock);
return retval;
}
void ScopeAugment(EvalContext *ctx, const Bundle *bp, const Promise *pp, const Rlist *arguments)
{
if (RlistLen(bp->args) != RlistLen(arguments))
{
Log(LOG_LEVEL_ERR, "While constructing scope '%s'", bp->name);
fprintf(stderr, "Formal = ");
RlistShow(stderr, bp->args);
fprintf(stderr, ", Actual = ");
RlistShow(stderr, arguments);
fprintf(stderr, "\n");
FatalError(ctx, "Augment scope, formal and actual parameter mismatch is fatal");
}
const Bundle *pbp = NULL;
if (pp != NULL)
{
pbp = PromiseGetBundle(pp);
}
for (const Rlist *rpl = bp->args, *rpr = arguments; rpl != NULL; rpl = rpl->next, rpr = rpr->next)
{
const char *lval = rpl->item;
Log(LOG_LEVEL_VERBOSE, "Augment scope '%s' with variable '%s' (type: %c)", bp->name, lval, rpr->type);
// CheckBundleParameters() already checked that there is no namespace collision
// By this stage all functions should have been expanded, so we only have scalars left
if (IsNakedVar(rpr->item, '@'))
{
DataType vtype;
char naked[CF_BUFSIZE];
GetNaked(naked, rpr->item);
Rval retval;
if (pbp != NULL)
{
VarRef *ref = VarRefParseFromBundle(naked, pbp);
EvalContextVariableGet(ctx, ref, &retval, &vtype);
VarRefDestroy(ref);
}
else
{
VarRef *ref = VarRefParseFromBundle(naked, bp);
EvalContextVariableGet(ctx, ref, &retval, &vtype);
VarRefDestroy(ref);
}
switch (vtype)
{
case DATA_TYPE_STRING_LIST:
case DATA_TYPE_INT_LIST:
case DATA_TYPE_REAL_LIST:
{
VarRef *ref = VarRefParseFromBundle(lval, bp);
EvalContextVariablePut(ctx, ref, (Rval) { retval.item, RVAL_TYPE_LIST}, DATA_TYPE_STRING_LIST);
VarRefDestroy(ref);
}
break;
default:
{
Log(LOG_LEVEL_ERR, "List parameter '%s' not found while constructing scope '%s' - use @(scope.variable) in calling reference", naked, bp->name);
VarRef *ref = VarRefParseFromBundle(lval, bp);
EvalContextVariablePut(ctx, ref, (Rval) { rpr->item, RVAL_TYPE_SCALAR }, DATA_TYPE_STRING);
VarRefDestroy(ref);
}
break;
}
}
else
{
switch(rpr->type)
{
case RVAL_TYPE_SCALAR:
{
VarRef *ref = VarRefParseFromBundle(lval, bp);
EvalContextVariablePut(ctx, ref, (Rval) { rpr->item, RVAL_TYPE_SCALAR }, DATA_TYPE_STRING);
VarRefDestroy(ref);
}
break;
case RVAL_TYPE_FNCALL:
{
FnCall *subfp = rpr->item;
Rval rval = FnCallEvaluate(ctx, subfp, pp).rval;
if (rval.type == RVAL_TYPE_SCALAR)
{
VarRef *ref = VarRefParseFromBundle(lval, bp);
EvalContextVariablePut(ctx, ref, (Rval) { rval.item, RVAL_TYPE_SCALAR }, DATA_TYPE_STRING);
VarRefDestroy(ref);
}
else
{
Log(LOG_LEVEL_ERR, "Only functions returning scalars can be used as arguments");
}
}
break;
default:
ProgrammingError("An argument neither a scalar nor a list seemed to appear. Impossible");
}
}
}
/* Check that there are no danglers left to evaluate in the hash table itself */
return;
}
PromiseResult VerifyMethod(EvalContext *ctx, const Rval call, Attributes a, const Promise *pp)
{
const Rlist *args = NULL;
Buffer *method_name = BufferNew();
switch (call.type)
{
case RVAL_TYPE_FNCALL:
{
const FnCall *fp = RvalFnCallValue(call);
ExpandScalar(ctx, PromiseGetBundle(pp)->ns, PromiseGetBundle(pp)->name, fp->name, method_name);
args = fp->args;
int arg_index = 0;
while (args)
{
++arg_index;
if (strcmp(args->val.item, CF_NULL_VALUE) == 0)
{
Log(LOG_LEVEL_DEBUG, "Skipping invokation of method '%s' due to null-values in argument '%d'",
fp->name, arg_index);
BufferDestroy(method_name);
return PROMISE_RESULT_SKIPPED;
}
args = args->next;
}
args = fp->args;
EvalContextSetBundleArgs(ctx, args);
}
break;
case RVAL_TYPE_SCALAR:
{
ExpandScalar(ctx, PromiseGetBundle(pp)->ns, PromiseGetBundle(pp)->name,
RvalScalarValue(call), method_name);
args = NULL;
}
break;
default:
BufferDestroy(method_name);
return PROMISE_RESULT_NOOP;
}
char lockname[CF_BUFSIZE];
GetLockName(lockname, "method", pp->promiser, args);
CfLock thislock = AcquireLock(ctx, lockname, VUQNAME, CFSTARTTIME, a.transaction, pp, false);
if (thislock.lock == NULL)
{
BufferDestroy(method_name);
return PROMISE_RESULT_SKIPPED;
}
PromiseBanner(ctx, pp);
const Bundle *bp = EvalContextResolveBundleExpression(ctx, PromiseGetPolicy(pp), BufferData(method_name), "agent");
if (!bp)
{
bp = EvalContextResolveBundleExpression(ctx, PromiseGetPolicy(pp), BufferData(method_name), "common");
}
PromiseResult result = PROMISE_RESULT_NOOP;
if (bp)
{
if (a.transaction.action == cfa_warn) // don't skip for dry-runs (ie ignore DONTDO)
{
result = PROMISE_RESULT_WARN;
cfPS(ctx, LOG_LEVEL_WARNING, result, pp, a, "Bundle '%s' should be invoked, but only a warning was promised!", BufferData(method_name));
}
else
{
BundleBanner(bp, args);
EvalContextStackPushBundleFrame(ctx, bp, args, a.inherit);
/* Clear all array-variables that are already set in the sub-bundle.
Otherwise, array-data accumulates between multiple bundle evaluations.
Note: for bundles invoked multiple times via bundlesequence, array
data *does* accumulate. */
VariableTableIterator *iter = EvalContextVariableTableIteratorNew(ctx, bp->ns, bp->name, NULL);
Variable *var;
while ((var = VariableTableIteratorNext(iter)))
{
if (!var->ref->num_indices)
{
continue;
}
EvalContextVariableRemove(ctx, var->ref);
}
VariableTableIteratorDestroy(iter);
BundleResolve(ctx, bp);
result = ScheduleAgentOperations(ctx, bp);
GetReturnValue(ctx, bp, pp);
EvalContextStackPopFrame(ctx);
switch (result)
{
case PROMISE_RESULT_SKIPPED:
// if a bundle returns 'skipped', meaning that all promises were locked in the bundle,
// we explicitly consider the method 'kept'
result = PROMISE_RESULT_NOOP;
// intentional fallthru
case PROMISE_RESULT_NOOP:
cfPS(ctx, LOG_LEVEL_VERBOSE, PROMISE_RESULT_NOOP, pp, a, "Method '%s' verified", bp->name);
break;
case PROMISE_RESULT_WARN:
cfPS(ctx, LOG_LEVEL_WARNING, PROMISE_RESULT_WARN, pp, a, "Method '%s' invoked repairs, but only warnings promised", bp->name);
break;
case PROMISE_RESULT_CHANGE:
cfPS(ctx, LOG_LEVEL_VERBOSE, PROMISE_RESULT_CHANGE, pp, a, "Method '%s' invoked repairs", bp->name);
break;
case PROMISE_RESULT_FAIL:
case PROMISE_RESULT_DENIED:
cfPS(ctx, LOG_LEVEL_ERR, PROMISE_RESULT_FAIL, pp, a, "Method '%s' failed in some repairs", bp->name);
break;
default: // PROMISE_RESULT_INTERRUPTED, TIMEOUT
cfPS(ctx, LOG_LEVEL_INFO, PROMISE_RESULT_FAIL, pp, a, "Method '%s' aborted in some repairs", bp->name);
break;
}
}
for (const Rlist *rp = bp->args; rp; rp = rp->next)
{
const char *lval = RlistScalarValue(rp);
VarRef *ref = VarRefParseFromBundle(lval, bp);
EvalContextVariableRemove(ctx, ref);
VarRefDestroy(ref);
}
}
else
{
if (IsCf3VarString(BufferData(method_name)))
{
Log(LOG_LEVEL_ERR,
"A variable seems to have been used for the name of the method. In this case, the promiser also needs to contain the unique name of the method");
}
cfPS(ctx, LOG_LEVEL_ERR, PROMISE_RESULT_FAIL, pp, a,
"A method attempted to use a bundle '%s' that was apparently not defined",
BufferData(method_name));
result = PromiseResultUpdate(result, PROMISE_RESULT_FAIL);
}
YieldCurrentLock(thislock);
BufferDestroy(method_name);
EndBundleBanner(bp);
return result;
}
Promise *DeRefCopyPromise(EvalContext *ctx, const Promise *pp)
{
Promise *pcopy;
Rval returnval;
pcopy = xcalloc(1, sizeof(Promise));
if (pp->promiser)
{
pcopy->promiser = xstrdup(pp->promiser);
}
if (pp->promisee.item)
{
pcopy->promisee = RvalCopy(pp->promisee);
if (pcopy->promisee.type == RVAL_TYPE_LIST)
{
Rlist *rval_list = RvalRlistValue(pcopy->promisee);
RlistFlatten(ctx, &rval_list);
pcopy->promisee.item = rval_list;
}
}
if (pp->classes)
{
pcopy->classes = xstrdup(pp->classes);
}
/* FIXME: may it happen? */
if ((pp->promisee.item != NULL && pcopy->promisee.item == NULL))
{
ProgrammingError("Unable to copy promise");
}
pcopy->parent_promise_type = pp->parent_promise_type;
pcopy->offset.line = pp->offset.line;
pcopy->comment = pp->comment ? xstrdup(pp->comment) : NULL;
pcopy->has_subbundles = pp->has_subbundles;
pcopy->conlist = SeqNew(10, ConstraintDestroy);
pcopy->org_pp = pp->org_pp;
pcopy->offset = pp->offset;
/* No further type checking should be necessary here, already done by CheckConstraintTypeMatch */
for (size_t i = 0; i < SeqLength(pp->conlist); i++)
{
Constraint *cp = SeqAt(pp->conlist, i);
Body *bp = NULL;
FnCall *fp = NULL;
/* A body template reference could look like a scalar or fn to the parser w/w () */
const Policy *policy = PolicyFromPromise(pp);
Seq *bodies = policy ? policy->bodies : NULL;
char body_ns[CF_MAXVARSIZE] = "";
char body_name[CF_MAXVARSIZE] = "";
switch (cp->rval.type)
{
case RVAL_TYPE_SCALAR:
if (cp->references_body)
{
SplitScopeName(RvalScalarValue(cp->rval), body_ns, body_name);
if (EmptyString(body_ns))
{
strncpy(body_ns, PromiseGetNamespace(pp), CF_MAXVARSIZE);
}
bp = IsBody(bodies, body_ns, body_name);
}
fp = NULL;
break;
case RVAL_TYPE_FNCALL:
fp = RvalFnCallValue(cp->rval);
SplitScopeName(fp->name, body_ns, body_name);
if (EmptyString(body_ns))
{
strncpy(body_ns, PromiseGetNamespace(pp), CF_MAXVARSIZE);
}
bp = IsBody(bodies, body_ns, body_name);
break;
default:
bp = NULL;
fp = NULL;
break;
}
/* First case is: we have a body template to expand lval = body(args), .. */
if (bp)
{
EvalContextStackPushBodyFrame(ctx, pcopy, bp, fp ? fp->args : NULL);
if (strcmp(bp->type, cp->lval) != 0)
{
Log(LOG_LEVEL_ERR,
"Body type mismatch for body reference '%s' in promise at line %zu of file '%s', '%s' does not equal '%s'",
body_name, pp->offset.line, PromiseGetBundle(pp)->source_path, bp->type, cp->lval);
}
/* Keep the referent body type as a boolean for convenience when checking later */
if (IsDefinedClass(ctx, cp->classes, PromiseGetNamespace(pcopy)))
{
Constraint *cp_copy = PromiseAppendConstraint(pcopy, cp->lval, (Rval) {xstrdup("true"), RVAL_TYPE_SCALAR }, false);
cp_copy->offset = cp->offset;
}
if (bp->args != NULL)
{
/* There are arguments to insert */
if (fp == NULL || fp->args == NULL)
{
Log(LOG_LEVEL_ERR, "Argument mismatch for body reference '%s' in promise at line %zu of file '%s'",
body_name, pp->offset.line, PromiseGetBundle(pp)->source_path);
}
for (size_t k = 0; k < SeqLength(bp->conlist); k++)
{
Constraint *scp = SeqAt(bp->conlist, k);
returnval = ExpandPrivateRval(ctx, NULL, "body", scp->rval.item, scp->rval.type);
if (IsDefinedClass(ctx, scp->classes, PromiseGetNamespace(pcopy)))
{
Constraint *scp_copy = PromiseAppendConstraint(pcopy, scp->lval, returnval, false);
scp_copy->offset = scp->offset;
}
}
}
else
{
/* No arguments to deal with or body undeclared */
if (fp != NULL)
{
Log(LOG_LEVEL_ERR,
"An apparent body \"%s()\" was undeclared or could have incorrect args, but used in a promise near line %zu of %s (possible unquoted literal value)",
body_name, pp->offset.line, PromiseGetBundle(pp)->source_path);
}
else
{
for (size_t k = 0; k < SeqLength(bp->conlist); k++)
{
Constraint *scp = SeqAt(bp->conlist, k);
Rval newrv = RvalCopy(scp->rval);
if (newrv.type == RVAL_TYPE_LIST)
{
Rlist *new_list = RvalRlistValue(newrv);
RlistFlatten(ctx, &new_list);
newrv.item = new_list;
}
if (IsDefinedClass(ctx, scp->classes, PromiseGetNamespace(pcopy)))
{
Constraint *scp_copy = PromiseAppendConstraint(pcopy, scp->lval, newrv, false);
scp_copy->offset = scp->offset;
}
}
}
}
EvalContextStackPopFrame(ctx);
}
else
{
const Policy *policy = PolicyFromPromise(pp);
if (cp->references_body && !IsBundle(policy->bundles, EmptyString(body_ns) ? NULL : body_ns, body_name))
{
Log(LOG_LEVEL_ERR,
"Apparent body \"%s()\" was undeclared, but used in a promise near line %zu of %s (possible unquoted literal value)",
body_name, pp->offset.line, PromiseGetBundle(pp)->source_path);
}
Rval newrv = RvalCopy(cp->rval);
if (newrv.type == RVAL_TYPE_LIST)
{
Rlist *new_list = RvalRlistValue(newrv);
RlistFlatten(ctx, &new_list);
newrv.item = new_list;
}
if (IsDefinedClass(ctx, cp->classes, PromiseGetNamespace(pcopy)))
{
Constraint *cp_copy = PromiseAppendConstraint(pcopy, cp->lval, newrv, false);
cp_copy->offset = cp->offset;
}
}
}
return pcopy;
}
FnCallResult FnCallEvaluate(EvalContext *ctx, const Policy *policy, FnCall *fp, const Promise *caller)
{
assert(ctx);
assert(policy);
assert(fp);
fp->caller = caller;
if (!EvalContextGetEvalOption(ctx, EVAL_OPTION_EVAL_FUNCTIONS))
{
Log(LOG_LEVEL_VERBOSE, "Skipping function '%s', because evaluation was turned off in the evaluator",
fp->name);
return (FnCallResult) { FNCALL_FAILURE, { FnCallCopy(fp), RVAL_TYPE_FNCALL } };
}
else if (caller && !EvalContextPromiseIsActive(ctx, caller))
{
Log(LOG_LEVEL_VERBOSE, "Skipping function '%s', because it was excluded by classes", fp->name);
return (FnCallResult) { FNCALL_FAILURE, { FnCallCopy(fp), RVAL_TYPE_FNCALL } };
}
const FnCallType *fp_type = FnCallTypeGet(fp->name);
if (!fp_type)
{
if (caller)
{
Log(LOG_LEVEL_ERR, "No such FnCall '%s' in promise '%s' near line %llu",
fp->name, PromiseGetBundle(caller)->source_path,
(unsigned long long)caller->offset.line);
}
else
{
Log(LOG_LEVEL_ERR, "No such FnCall '%s', context info unavailable", fp->name);
}
return (FnCallResult) { FNCALL_FAILURE, { FnCallCopy(fp), RVAL_TYPE_FNCALL } };
}
Rlist *expargs = NewExpArgs(ctx, policy, fp);
if (RlistIsUnresolved(expargs))
{
RlistDestroy(expargs);
return (FnCallResult) { FNCALL_FAILURE, { FnCallCopy(fp), RVAL_TYPE_FNCALL } };
}
Rval cached_rval;
if ((fp_type->options & FNCALL_OPTION_CACHED) && EvalContextFunctionCacheGet(ctx, fp, expargs, &cached_rval))
{
Writer *w = StringWriter();
FnCallWrite(w, fp);
Log(LOG_LEVEL_DEBUG, "Using previously cached result for function '%s'", StringWriterData(w));
WriterClose(w);
RlistDestroy(expargs);
return (FnCallResult) { FNCALL_SUCCESS, RvalCopy(cached_rval) };
}
FnCallResult result = CallFunction(ctx, policy, fp, expargs);
if (result.status == FNCALL_FAILURE)
{
RlistDestroy(expargs);
return (FnCallResult) { FNCALL_FAILURE, { FnCallCopy(fp), RVAL_TYPE_FNCALL } };
}
if (fp_type->options & FNCALL_OPTION_CACHED)
{
Writer *w = StringWriter();
FnCallWrite(w, fp);
Log(LOG_LEVEL_VERBOSE, "Caching result for function '%s'", StringWriterData(w));
WriterClose(w);
EvalContextFunctionCachePut(ctx, fp, expargs, &result.rval);
}
RlistDestroy(expargs);
return result;
}
FnCallResult FnCallEvaluate(EvalContext *ctx, const Policy *policy, FnCall *fp, const Promise *caller)
{
assert(ctx);
assert(policy);
assert(fp);
fp->caller = caller;
if (!EvalContextGetEvalOption(ctx, EVAL_OPTION_EVAL_FUNCTIONS))
{
Log(LOG_LEVEL_VERBOSE, "Skipping function '%s', because evaluation was turned off in the evaluator",
fp->name);
return (FnCallResult) { FNCALL_FAILURE, { FnCallCopy(fp), RVAL_TYPE_FNCALL } };
}
const FnCallType *fp_type = FnCallTypeGet(fp->name);
if (!fp_type)
{
if (caller)
{
Log(LOG_LEVEL_ERR, "No such FnCall '%s' in promise '%s' near line %zd",
fp->name, PromiseGetBundle(caller)->source_path, caller->offset.line);
}
else
{
Log(LOG_LEVEL_ERR, "No such FnCall '%s', context info unavailable", fp->name);
}
return (FnCallResult) { FNCALL_FAILURE, { FnCallCopy(fp), RVAL_TYPE_FNCALL } };
}
Rlist *expargs = NewExpArgs(ctx, policy, fp, fp_type);
Writer *fncall_writer = NULL;
const char *fncall_string = "";
if (LogGetGlobalLevel() >= LOG_LEVEL_DEBUG)
{
fncall_writer = StringWriter();
FnCallWrite(fncall_writer, fp);
fncall_string = StringWriterData(fncall_writer);
}
// Check if arguments are resolved, except for delayed evaluation functions
if ( ! (fp_type->options & FNCALL_OPTION_DELAYED_EVALUATION) &&
RlistIsUnresolved(expargs))
{
// Special case: ifelse(isvariable("x"), $(x), "default")
// (the first argument will come down expanded as "!any")
if (strcmp(fp->name, "ifelse") == 0 &&
RlistLen(expargs) == 3 &&
strcmp("!any", RlistScalarValueSafe(expargs)) == 0 &&
!RlistIsUnresolved(expargs->next->next))
{
Log(LOG_LEVEL_DEBUG, "Allowing ifelse() function evaluation even"
" though its arguments contain unresolved variables: %s",
fncall_string);
}
else
{
if (LogGetGlobalLevel() >= LOG_LEVEL_DEBUG)
{
Log(LOG_LEVEL_DEBUG, "Skipping function evaluation for now,"
" arguments contain unresolved variables: %s",
fncall_string);
WriterClose(fncall_writer);
}
RlistDestroy(expargs);
return (FnCallResult) { FNCALL_FAILURE, { FnCallCopy(fp), RVAL_TYPE_FNCALL } };
}
}
Rval cached_rval;
if ((fp_type->options & FNCALL_OPTION_CACHED) && EvalContextFunctionCacheGet(ctx, fp, expargs, &cached_rval))
{
if (LogGetGlobalLevel() >= LOG_LEVEL_DEBUG)
{
Log(LOG_LEVEL_DEBUG,
"Using previously cached result for function: %s",
fncall_string);
WriterClose(fncall_writer);
}
Writer *w = StringWriter();
FnCallWrite(w, fp);
WriterClose(w);
RlistDestroy(expargs);
return (FnCallResult) { FNCALL_SUCCESS, RvalCopy(cached_rval) };
}
if (LogGetGlobalLevel() >= LOG_LEVEL_DEBUG)
{
Log(LOG_LEVEL_DEBUG, "Evaluating function: %s",
fncall_string);
WriterClose(fncall_writer);
}
FnCallResult result = CallFunction(ctx, policy, fp, expargs);
if (result.status == FNCALL_FAILURE)
{
RlistDestroy(expargs);
return (FnCallResult) { FNCALL_FAILURE, { FnCallCopy(fp), RVAL_TYPE_FNCALL } };
}
if (fp_type->options & FNCALL_OPTION_CACHED)
{
Writer *w = StringWriter();
FnCallWrite(w, fp);
Log(LOG_LEVEL_VERBOSE, "Caching result for function '%s'", StringWriterData(w));
WriterClose(w);
EvalContextFunctionCachePut(ctx, fp, expargs, &result.rval);
}
RlistDestroy(expargs);
return result;
}
void VerifyVarPromise(EvalContext *ctx, const Promise *pp, bool allow_duplicates)
{
ConvergeVariableOptions opts = CollectConvergeVariableOptions(ctx, pp, allow_duplicates);
if (!opts.should_converge)
{
return;
}
char *scope = NULL;
if (strcmp("meta", pp->parent_promise_type->name) == 0)
{
scope = StringConcatenate(2, PromiseGetBundle(pp)->name, "_meta");
}
else
{
scope = xstrdup(PromiseGetBundle(pp)->name);
}
//More consideration needs to be given to using these
//a.transaction = GetTransactionConstraints(pp);
Attributes a = { {0} };
a.classes = GetClassDefinitionConstraints(ctx, pp);
Rval existing_var_rval;
DataType existing_var_type = DATA_TYPE_NONE;
EvalContextVariableGet(ctx, (VarRef) { NULL, scope, pp->promiser }, &existing_var_rval, &existing_var_type);
Buffer *qualified_scope = BufferNew();
int result = 0;
if (strcmp(PromiseGetNamespace(pp), "default") == 0)
{
result = BufferSet(qualified_scope, scope, strlen(scope));
if (result < 0)
{
/*
* Even though there will be no problems with memory allocation, there
* might be other problems.
*/
UnexpectedError("Problems writing to buffer");
free(scope);
BufferDestroy(&qualified_scope);
return;
}
}
else
{
if (strchr(scope, ':') == NULL)
{
result = BufferPrintf(qualified_scope, "%s:%s", PromiseGetNamespace(pp), scope);
if (result < 0)
{
/*
* Even though there will be no problems with memory allocation, there
* might be other problems.
*/
UnexpectedError("Problems writing to buffer");
free(scope);
BufferDestroy(&qualified_scope);
return;
}
}
else
{
result = BufferSet(qualified_scope, scope, strlen(scope));
if (result < 0)
{
/*
* Even though there will be no problems with memory allocation, there
* might be other problems.
*/
UnexpectedError("Problems writing to buffer");
free(scope);
BufferDestroy(&qualified_scope);
return;
}
}
}
PromiseResult promise_result;
Rval rval = opts.cp_save->rval;
if (rval.item != NULL)
{
FnCall *fp = (FnCall *) rval.item;
if (opts.cp_save->rval.type == RVAL_TYPE_FNCALL)
{
if (existing_var_type != DATA_TYPE_NONE)
{
// Already did this
free(scope);
BufferDestroy(&qualified_scope);
return;
}
FnCallResult res = FnCallEvaluate(ctx, fp, pp);
if (res.status == FNCALL_FAILURE)
{
/* We do not assign variables to failed fn calls */
RvalDestroy(res.rval);
free(scope);
BufferDestroy(&qualified_scope);
return;
}
else
{
rval = res.rval;
}
}
else
{
Buffer *conv = BufferNew();
if (strcmp(opts.cp_save->lval, "int") == 0)
{
result = BufferPrintf(conv, "%ld", IntFromString(opts.cp_save->rval.item));
if (result < 0)
{
/*
* Even though there will be no problems with memory allocation, there
* might be other problems.
*/
UnexpectedError("Problems writing to buffer");
free(scope);
BufferDestroy(&qualified_scope);
BufferDestroy(&conv);
return;
}
rval = RvalCopy((Rval) {(char *)BufferData(conv), opts.cp_save->rval.type});
}
else if (strcmp(opts.cp_save->lval, "real") == 0)
{
double real_value = 0.0;
if (DoubleFromString(opts.cp_save->rval.item, &real_value))
{
result = BufferPrintf(conv, "%lf", real_value);
}
else
{
result = BufferPrintf(conv, "(double conversion error)");
}
if (result < 0)
{
/*
* Even though there will be no problems with memory allocation, there
* might be other problems.
*/
UnexpectedError("Problems writing to buffer");
free(scope);
BufferDestroy(&conv);
BufferDestroy(&qualified_scope);
return;
}
rval = RvalCopy((Rval) {(char *)BufferData(conv), opts.cp_save->rval.type});
}
else
{
rval = RvalCopy(opts.cp_save->rval);
}
if (rval.type == RVAL_TYPE_LIST)
{
Rlist *rval_list = RvalRlistValue(rval);
RlistFlatten(ctx, &rval_list);
rval.item = rval_list;
}
BufferDestroy(&conv);
}
if (Epimenides(ctx, PromiseGetBundle(pp)->name, pp->promiser, rval, 0))
{
Log(LOG_LEVEL_ERR, "Variable \"%s\" contains itself indirectly - an unkeepable promise", pp->promiser);
exit(1);
}
else
{
/* See if the variable needs recursively expanding again */
Rval returnval = EvaluateFinalRval(ctx, BufferData(qualified_scope), rval, true, pp);
RvalDestroy(rval);
// freed before function exit
rval = returnval;
}
if (existing_var_type != DATA_TYPE_NONE)
{
if (opts.ok_redefine) /* only on second iteration, else we ignore broken promises */
{
ScopeDeleteVariable(BufferData(qualified_scope), pp->promiser);
}
else if ((THIS_AGENT_TYPE == AGENT_TYPE_COMMON) && (CompareRval(existing_var_rval, rval) == false))
{
switch (rval.type)
{
case RVAL_TYPE_SCALAR:
Log(LOG_LEVEL_VERBOSE, "Redefinition of a constant scalar \"%s\" (was %s now %s)",
pp->promiser, RvalScalarValue(existing_var_rval), RvalScalarValue(rval));
PromiseRef(LOG_LEVEL_VERBOSE, pp);
break;
case RVAL_TYPE_LIST:
{
Log(LOG_LEVEL_VERBOSE, "Redefinition of a constant list \"%s\".", pp->promiser);
Writer *w = StringWriter();
RlistWrite(w, existing_var_rval.item);
char *oldstr = StringWriterClose(w);
Log(LOG_LEVEL_VERBOSE, "Old value: %s", oldstr);
free(oldstr);
w = StringWriter();
RlistWrite(w, rval.item);
char *newstr = StringWriterClose(w);
Log(LOG_LEVEL_VERBOSE, " New value: %s", newstr);
free(newstr);
PromiseRef(LOG_LEVEL_VERBOSE, pp);
}
break;
default:
break;
}
}
}
if (IsCf3VarString(pp->promiser))
{
// Unexpanded variables, we don't do anything with
RvalDestroy(rval);
free(scope);
BufferDestroy(&qualified_scope);
return;
}
if (!FullTextMatch("[a-zA-Z0-9_\200-\377.]+(\\[.+\\])*", pp->promiser))
{
Log(LOG_LEVEL_ERR, "Variable identifier contains illegal characters");
PromiseRef(LOG_LEVEL_ERR, pp);
RvalDestroy(rval);
free(scope);
BufferDestroy(&qualified_scope);
return;
}
if (opts.drop_undefined && rval.type == RVAL_TYPE_LIST)
{
for (Rlist *rp = rval.item; rp != NULL; rp = rp->next)
{
if (IsNakedVar(rp->item, '@'))
{
free(rp->item);
rp->item = xstrdup(CF_NULL_VALUE);
}
}
}
if (!EvalContextVariablePut(ctx, (VarRef) { NULL, BufferData(qualified_scope), pp->promiser }, rval, DataTypeFromString(opts.cp_save->lval)))
{
Log(LOG_LEVEL_VERBOSE, "Unable to converge %s.%s value (possibly empty or infinite regression)", BufferData(qualified_scope), pp->promiser);
PromiseRef(LOG_LEVEL_VERBOSE, pp);
promise_result = PROMISE_RESULT_FAIL;
}
else
{
promise_result = PROMISE_RESULT_CHANGE;
}
}
else
{
Log(LOG_LEVEL_ERR, "Variable %s has no promised value", pp->promiser);
Log(LOG_LEVEL_ERR, "Rule from %s at/before line %zu", PromiseGetBundle(pp)->source_path, opts.cp_save->offset.line);
promise_result = PROMISE_RESULT_FAIL;
}
/*
* FIXME: Variable promise are exempt from normal evaluation logic still, so
* they are not pushed to evaluation stack before being evaluated. Due to
* this reason, we cannot call cfPS here to set classes, as it will error
* out with ProgrammingError.
*
* In order to support 'classes' body for variables as well, we call
* ClassAuditLog explicitly.
*/
ClassAuditLog(ctx, pp, a, promise_result);
free(scope);
BufferDestroy(&qualified_scope);
RvalDestroy(rval);
}
void VerifyClassPromise(EvalContext *ctx, Promise *pp, ARG_UNUSED void *param)
{
assert(param == NULL);
Attributes a;
a = GetClassContextAttributes(ctx, pp);
if (!FullTextMatch("[a-zA-Z0-9_]+", pp->promiser))
{
Log(LOG_LEVEL_VERBOSE, "Class identifier '%s' contains illegal characters - canonifying", pp->promiser);
snprintf(pp->promiser, strlen(pp->promiser) + 1, "%s", CanonifyName(pp->promiser));
}
if (a.context.nconstraints == 0)
{
cfPS(ctx, LOG_LEVEL_ERR, PROMISE_RESULT_FAIL, pp, a, "No constraints for class promise '%s'", pp->promiser);
return;
}
if (a.context.nconstraints > 1)
{
cfPS(ctx, LOG_LEVEL_ERR, PROMISE_RESULT_FAIL, pp, a, "Irreconcilable constraints in classes for '%s'", pp->promiser);
return;
}
bool global_class;
if (a.context.persistent > 0) /* Persistent classes are always global */
{
global_class = true;
}
else if (a.context.scope == CONTEXT_SCOPE_NONE)
{
/* If there is no explicit scope, common bundles define global classes, other bundles define local classes */
if (strcmp(PromiseGetBundle(pp)->type, "common") == 0)
{
global_class = true;
}
else
{
global_class = false;
}
}
else if (a.context.scope == CONTEXT_SCOPE_NAMESPACE)
{
global_class = true;
}
else if (a.context.scope == CONTEXT_SCOPE_BUNDLE)
{
global_class = false;
}
if (EvalClassExpression(ctx, a.context.expression, pp))
{
if (!ValidClassName(pp->promiser))
{
cfPS(ctx, LOG_LEVEL_ERR, PROMISE_RESULT_FAIL, pp, a,
"Attempted to name a class '%s', which is an illegal class identifier", pp->promiser);
}
else
{
if (global_class)
{
Log(LOG_LEVEL_VERBOSE, "Adding global class '%s'", pp->promiser);
EvalContextHeapAddSoft(ctx, pp->promiser, PromiseGetNamespace(pp));
}
else
{
Log(LOG_LEVEL_VERBOSE, "Adding local bundle class '%s'", pp->promiser);
EvalContextStackFrameAddSoft(ctx, pp->promiser);
}
if (a.context.persistent > 0)
{
Log(LOG_LEVEL_VERBOSE, "Adding persistent class '%s'. (%d minutes)", pp->promiser,
a.context.persistent);
EvalContextHeapPersistentSave(pp->promiser, PromiseGetNamespace(pp), a.context.persistent, CONTEXT_STATE_POLICY_RESET);
}
}
}
}
FnCallResult FnCallEvaluate(EvalContext *ctx, const Policy *policy, FnCall *fp, const Promise *caller)
{
assert(ctx);
assert(policy);
assert(fp);
fp->caller = caller;
if (!EvalContextGetEvalOption(ctx, EVAL_OPTION_EVAL_FUNCTIONS))
{
Log(LOG_LEVEL_VERBOSE, "Skipping function '%s', because evaluation was turned off in the evaluator",
fp->name);
return (FnCallResult) { FNCALL_FAILURE, { FnCallCopy(fp), RVAL_TYPE_FNCALL } };
}
const FnCallType *fp_type = FnCallTypeGet(fp->name);
if (!fp_type)
{
if (caller)
{
Log(LOG_LEVEL_ERR, "No such FnCall '%s' in promise '%s' near line %zd",
fp->name, PromiseGetBundle(caller)->source_path, caller->offset.line);
}
else
{
Log(LOG_LEVEL_ERR, "No such FnCall '%s', context info unavailable", fp->name);
}
return (FnCallResult) { FNCALL_FAILURE, { FnCallCopy(fp), RVAL_TYPE_FNCALL } };
}
Rlist *expargs = NewExpArgs(ctx, policy, fp);
Writer *fncall_writer;
const char *fncall_string;
if (LogGetGlobalLevel() >= LOG_LEVEL_DEBUG)
{
fncall_writer = StringWriter();
FnCallWrite(fncall_writer, fp);
fncall_string = StringWriterData(fncall_writer);
}
if (RlistIsUnresolved(expargs))
{
if (LogGetGlobalLevel() >= LOG_LEVEL_DEBUG)
{
Log(LOG_LEVEL_DEBUG, "Skipping function evaluation for now,"
" arguments contain unresolved variables: %s",
fncall_string);
WriterClose(fncall_writer);
}
RlistDestroy(expargs);
return (FnCallResult) { FNCALL_FAILURE, { FnCallCopy(fp), RVAL_TYPE_FNCALL } };
}
Rval cached_rval;
if ((fp_type->options & FNCALL_OPTION_CACHED) && EvalContextFunctionCacheGet(ctx, fp, expargs, &cached_rval))
{
if (LogGetGlobalLevel() >= LOG_LEVEL_DEBUG)
{
Log(LOG_LEVEL_DEBUG,
"Using previously cached result for function: %s",
fncall_string);
WriterClose(fncall_writer);
}
Writer *w = StringWriter();
FnCallWrite(w, fp);
WriterClose(w);
RlistDestroy(expargs);
return (FnCallResult) { FNCALL_SUCCESS, RvalCopy(cached_rval) };
}
if (LogGetGlobalLevel() >= LOG_LEVEL_DEBUG)
{
Log(LOG_LEVEL_DEBUG, "Evaluating function: %s",
fncall_string);
WriterClose(fncall_writer);
}
FnCallResult result = CallFunction(ctx, policy, fp, expargs);
if (result.status == FNCALL_FAILURE)
{
RlistDestroy(expargs);
return (FnCallResult) { FNCALL_FAILURE, { FnCallCopy(fp), RVAL_TYPE_FNCALL } };
}
else if (result.rval.type == RVAL_TYPE_LIST && !result.rval.item)
{
Rlist *seq = NULL;
// don't pass NULL items to evaluator
RlistPrepend(&seq, CF_NULL_VALUE, RVAL_TYPE_SCALAR);
result.rval.item = seq;
}
if (fp_type->options & FNCALL_OPTION_CACHED)
{
Writer *w = StringWriter();
FnCallWrite(w, fp);
Log(LOG_LEVEL_VERBOSE, "Caching result for function '%s'", StringWriterData(w));
WriterClose(w);
EvalContextFunctionCachePut(ctx, fp, expargs, &result.rval);
}
RlistDestroy(expargs);
return result;
}
