Rval ExpandBundleReference(EvalContext *ctx,
const char *ns, const char *scope,
Rval rval)
{
// Allocates new memory for the copy
switch (rval.type)
{
case RVAL_TYPE_SCALAR:
{
Buffer *buffer = BufferNew();
ExpandScalar(ctx, ns, scope, RvalScalarValue(rval), buffer);
return (Rval) { BufferClose(buffer), RVAL_TYPE_SCALAR };
}
case RVAL_TYPE_FNCALL:
return (Rval) {ExpandFnCall(ctx, ns, scope, RvalFnCallValue(rval)), RVAL_TYPE_FNCALL};
case RVAL_TYPE_CONTAINER:
case RVAL_TYPE_LIST:
case RVAL_TYPE_NOPROMISEE:
return RvalNew(NULL, RVAL_TYPE_NOPROMISEE);
}
assert(false);
return RvalNew(NULL, RVAL_TYPE_NOPROMISEE);
}
Rval ExpandPrivateRval(EvalContext *ctx,
const char *ns, const char *scope,
const void *rval_item, RvalType rval_type)
{
Rval returnval;
returnval.item = NULL;
returnval.type = RVAL_TYPE_NOPROMISEE;
switch (rval_type)
{
case RVAL_TYPE_SCALAR:
{
Buffer *buffer = BufferNew();
ExpandScalar(ctx, ns, scope, rval_item, buffer);
returnval = (Rval) { BufferClose(buffer), RVAL_TYPE_SCALAR };
}
break;
case RVAL_TYPE_LIST:
returnval.item = ExpandList(ctx, ns, scope, rval_item, true);
returnval.type = RVAL_TYPE_LIST;
break;
case RVAL_TYPE_FNCALL:
returnval.item = ExpandFnCall(ctx, ns, scope, rval_item);
returnval.type = RVAL_TYPE_FNCALL;
break;
case RVAL_TYPE_CONTAINER:
returnval = RvalNew(rval_item, RVAL_TYPE_CONTAINER);
break;
case RVAL_TYPE_NOPROMISEE:
break;
}
return returnval;
}
/**
* Expand a #string into Buffer #out, returning the pointer to the string
* itself, inside the Buffer #out. If #out is NULL then the buffer will be
* created and destroyed internally.
*
* @retval NULL something went wrong
*/
char *ExpandScalar(const EvalContext *ctx, const char *ns, const char *scope,
const char *string, Buffer *out)
{
bool out_belongs_to_us = false;
if (out == NULL)
{
out = BufferNew();
out_belongs_to_us = true;
}
assert(string != NULL);
assert(out != NULL);
Buffer *current_item = BufferNew();
for (const char *sp = string; *sp != '\0'; sp++)
{
BufferClear(current_item);
ExtractScalarPrefix(current_item, sp, strlen(sp));
BufferAppend(out, BufferData(current_item), BufferSize(current_item));
sp += BufferSize(current_item);
if (*sp == '\0')
{
break;
}
BufferClear(current_item);
char varstring = sp[1];
ExtractScalarReference(current_item, sp, strlen(sp), true);
sp += BufferSize(current_item) + 2;
if (IsCf3VarString(BufferData(current_item)))
{
Buffer *temp = BufferCopy(current_item);
BufferClear(current_item);
ExpandScalar(ctx, ns, scope, BufferData(temp), current_item);
BufferDestroy(temp);
}
if (!IsExpandable(BufferData(current_item)))
{
VarRef *ref = VarRefParseFromNamespaceAndScope(
BufferData(current_item),
ns, scope, CF_NS, '.');
DataType value_type;
const void *value = EvalContextVariableGet(ctx, ref, &value_type);
VarRefDestroy(ref);
switch (DataTypeToRvalType(value_type))
{
case RVAL_TYPE_SCALAR:
assert(value != NULL);
BufferAppendString(out, value);
continue;
break;
case RVAL_TYPE_CONTAINER:
{
assert(value != NULL);
const JsonElement *jvalue = value; /* instead of casts */
if (JsonGetElementType(jvalue) == JSON_ELEMENT_TYPE_PRIMITIVE)
{
BufferAppendString(out, JsonPrimitiveGetAsString(jvalue));
continue;
}
break;
}
default:
/* TODO Log() */
break;
}
}
if (varstring == '{')
{
BufferAppendF(out, "${%s}", BufferData(current_item));
}
else
{
BufferAppendF(out, "$(%s)", BufferData(current_item));
}
}
BufferDestroy(current_item);
LogDebug(LOG_MOD_EXPAND, "ExpandScalar( %s : %s . %s ) => %s",
SAFENULL(ns), SAFENULL(scope), string, BufferData(out));
return out_belongs_to_us ? BufferClose(out) : BufferGet(out);
}
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;
}
Rlist *PipeReadData(const IOData *io, int pipe_timeout_secs, int pipe_termination_check_secs)
{
char buff[CF_BUFSIZE] = {0};
Buffer *data = BufferNew();
if (!data)
{
Log(LOG_LEVEL_VERBOSE,
"Unable to allocate buffer for handling pipe responses.");
return NULL;
}
int timeout_seconds_left = pipe_timeout_secs;
while (!IsPendingTermination() && timeout_seconds_left > 0)
{
int fd = PipeIsReadWriteReady(io, pipe_termination_check_secs);
if (fd < 0)
{
Log(LOG_LEVEL_DEBUG,
"Error reading data from application pipe %d", fd);
break;
}
else if (fd == io->read_fd)
{
ssize_t res = read(fd, buff, sizeof(buff) - 1);
if (res == -1)
{
if (errno == EINTR)
{
continue;
}
else
{
Log(LOG_LEVEL_ERR,
"Unable to read output from application pipe: %s",
GetErrorStr());
BufferDestroy(data);
return NULL;
}
}
else if (res == 0) /* reached EOF */
{
break;
}
Log(LOG_LEVEL_DEBUG, "Data read from application pipe: %zd [%s]",
res, buff);
BufferAppendString(data, buff);
memset(buff, 0, sizeof(buff));
}
else if (fd == 0) /* timeout */
{
timeout_seconds_left -= pipe_termination_check_secs;
continue;
}
}
char *read_string = BufferClose(data);
#ifdef __MINGW32__
bool detect_crlf = true;
#else
bool detect_crlf = false;
#endif
Rlist *response_lines = RlistFromStringSplitLines(read_string, detect_crlf);
free(read_string);
return response_lines;
}