static void test_remove_range(void)
{
Seq *seq = SequenceCreateRange(10, 0, 9);
SeqRemoveRange(seq, 3, 9);
assert_int_equal(seq->length, 3);
assert_int_equal(*(size_t *) seq->data[0], 0);
assert_int_equal(*(size_t *) seq->data[1], 1);
assert_int_equal(*(size_t *) seq->data[2], 2);
SeqDestroy(seq);
seq = SequenceCreateRange(10, 0, 9);
SeqRemoveRange(seq, 0, 2);
assert_int_equal(seq->length, 7);
assert_int_equal(*(size_t *) seq->data[0], 3);
SeqDestroy(seq);
seq = SequenceCreateRange(10, 0, 9);
SeqRemoveRange(seq, 5, 5);
assert_int_equal(seq->length, 9);
assert_int_equal(*(size_t *) seq->data[5], 6);
SeqDestroy(seq);
}
static void test_remove(void)
{
Seq *seq = SequenceCreateRange(10, 0, 9);
SeqRemove(seq, 5);
assert_int_equal(seq->length, 9);
assert_int_equal(*(size_t *) seq->data[5], 6);
SeqDestroy(seq);
seq = SequenceCreateRange(10, 0, 9);
SeqRemove(seq, 0);
assert_int_equal(seq->length, 9);
assert_int_equal(*(size_t *) seq->data[0], 1);
SeqDestroy(seq);
seq = SequenceCreateRange(10, 0, 9);
SeqRemove(seq, 9);
assert_int_equal(seq->length, 9);
assert_int_equal(*(size_t *) seq->data[8], 8);
SeqDestroy(seq);
}
// TODO: should be replaced by something not complected with loading
static void ShowContext(EvalContext *ctx)
{
Seq *hard_contexts = SeqNew(1000, NULL);
Seq *soft_contexts = SeqNew(1000, NULL);
{
ClassTableIterator *iter = EvalContextClassTableIteratorNewGlobal(ctx, NULL, true, true);
Class *cls = NULL;
while ((cls = ClassTableIteratorNext(iter)))
{
if (cls->is_soft)
{
SeqAppend(soft_contexts, cls->name);
}
else
{
SeqAppend(hard_contexts, cls->name);
}
}
ClassTableIteratorDestroy(iter);
}
SeqSort(soft_contexts, (SeqItemComparator)strcmp, NULL);
SeqSort(hard_contexts, (SeqItemComparator)strcmp, NULL);
Log(LOG_LEVEL_VERBOSE, "----------------------------------------------------------------");
{
Log(LOG_LEVEL_VERBOSE, "BEGIN Discovered hard classes:");
for (size_t i = 0; i < SeqLength(hard_contexts); i++)
{
const char *context = SeqAt(hard_contexts, i);
Log(LOG_LEVEL_VERBOSE, "C: discovered hard class %s", context);
}
Log(LOG_LEVEL_VERBOSE, "END Discovered hard classes");
}
Log(LOG_LEVEL_VERBOSE, "----------------------------------------------------------------");
if (SeqLength(soft_contexts))
{
Log(LOG_LEVEL_VERBOSE, "BEGIN initial soft classes:");
for (size_t i = 0; i < SeqLength(soft_contexts); i++)
{
const char *context = SeqAt(soft_contexts, i);
Log(LOG_LEVEL_VERBOSE, "C: added soft class %s", context);
}
Log(LOG_LEVEL_VERBOSE, "END initial soft classes");
}
SeqDestroy(hard_contexts);
SeqDestroy(soft_contexts);
}
static Policy *LoadPolicyFile(EvalContext *ctx, GenericAgentConfig *config, const char *policy_file, StringSet *parsed_files, StringSet *failed_files)
{
Policy *policy = Cf3ParseFile(config, policy_file);
StringSetAdd(parsed_files, xstrdup(policy_file));
if (!policy)
{
StringSetAdd(failed_files, xstrdup(policy_file));
return NULL;
}
PolicyResolve(ctx, policy, config);
Body *body_common_control = PolicyGetBody(policy, NULL, "common", "control");
Body *body_file_control = PolicyGetBody(policy, NULL, "file", "control");
if (body_common_control)
{
Seq *potential_inputs = BodyGetConstraint(body_common_control, "inputs");
Constraint *cp = EffectiveConstraint(ctx, potential_inputs);
SeqDestroy(potential_inputs);
if (cp)
{
Policy *aux_policy = LoadPolicyInputFiles(ctx, config, RvalRlistValue(cp->rval), parsed_files, failed_files);
if (aux_policy)
{
policy = PolicyMerge(policy, aux_policy);
}
}
}
PolicyResolve(ctx, policy, config);
if (body_file_control)
{
Seq *potential_inputs = BodyGetConstraint(body_file_control, "inputs");
Constraint *cp = EffectiveConstraint(ctx, potential_inputs);
SeqDestroy(potential_inputs);
if (cp)
{
Policy *aux_policy = LoadPolicyInputFiles(ctx, config, RvalRlistValue(cp->rval), parsed_files, failed_files);
if (aux_policy)
{
policy = PolicyMerge(policy, aux_policy);
}
}
}
return policy;
}
static void test_bundle_reserved_name(void)
{
Seq *errs = LoadAndCheck("bundle_reserved_name.cf");
assert_int_equal(1, errs->length);
SeqDestroy(errs);
}
static void test_new_csv_reader_basic()
{
Seq *list = NULL;
char *lines[5] = {
"aaaa,bbb,ccccc",
"\"aaaa\",\"bbb\",\"ccccc\"",
"\"aaaa\",bbb,\"ccccc\"",
"aaaa,\"bbb\",ccccc",
",\"bbb\",ccccc",
};
for (int i=0; i<5; i++)
{
list = SeqParseCsvString(lines[i]);
assert_int_equal(list->length, 3);
assert_string_equal(list->data[2], "ccccc");
if (list != NULL)
{
SeqDestroy(list);
} else {
assert_true(false);
}
}
}
static void ShowContextsFormatted(EvalContext *ctx)
{
ClassTableIterator *iter = EvalContextClassTableIteratorNewGlobal(ctx, NULL, true, true);
Class *cls = NULL;
Seq *seq = SeqNew(1000, free);
while ((cls = ClassTableIteratorNext(iter)))
{
char *class_name = ClassRefToString(cls->ns, cls->name);
StringSet *tagset = EvalContextClassTags(ctx, cls->ns, cls->name);
Buffer *tagbuf = StringSetToBuffer(tagset, ',');
char *line;
xasprintf(&line, "%-60s %-40s", class_name, BufferData(tagbuf));
SeqAppend(seq, line);
BufferDestroy(tagbuf);
free(class_name);
}
SeqSort(seq, (SeqItemComparator)strcmp, NULL);
printf("%-60s %-40s\n", "Class name", "Meta tags");
for (size_t i = 0; i < SeqLength(seq); i++)
{
const char *context = SeqAt(seq, i);
printf("%s\n", context);
}
SeqDestroy(seq);
ClassTableIteratorDestroy(iter);
}
static void test_failsafe(void)
{
char *tmp = tempnam(NULL, "cfengine_test");
WriteBuiltinFailsafePolicyToPath(tmp);
Policy *failsafe = ParserParseFile(tmp, PARSER_WARNING_ALL, PARSER_WARNING_ALL);
unlink(tmp);
free(tmp);
assert_true(failsafe);
Seq *errs = SeqNew(10, PolicyErrorDestroy);
PolicyCheckPartial(failsafe, errs);
DumpErrors(errs);
assert_int_equal(0, SeqLength(errs));
{
EvalContext *ctx = EvalContextNew();
PolicyCheckRunnable(ctx, failsafe, errs, false);
DumpErrors(errs);
assert_int_equal(0, SeqLength(errs));
EvalContextDestroy(ctx);
}
assert_int_equal(0, (SeqLength(errs)));
SeqDestroy(errs);
PolicyDestroy(failsafe);
}
static void test_constraint_comment_nonscalar(void)
{
Seq *errs = LoadAndCheck("constraint_comment_nonscalar.cf");
assert_int_equal(1, errs->length);
SeqDestroy(errs);
}
static void test_promise_duplicate_handle(void)
{
Seq *errs = LoadAndCheck("promise_duplicate_handle.cf");
assert_int_equal(1, errs->length);
SeqDestroy(errs);
}
static void test_promiser_empty_varref(void)
{
Seq *errs = LoadAndCheck("promiser_empty_varref.cf");
assert_int_equal(1, errs->length);
SeqDestroy(errs);
}
static void test_methods_invalid_arity(void)
{
Seq *errs = LoadAndCheck("methods_invalid_arity.cf");
assert_int_equal(1, errs->length);
SeqDestroy(errs);
}
static void test_vars_multiple_types(void)
{
Seq *errs = LoadAndCheck("vars_multiple_types.cf");
assert_int_equal(1, errs->length);
SeqDestroy(errs);
}
static void test_body_redefinition(void)
{
Seq *errs = LoadAndCheck("body_redefinition.cf");
assert_int_equal(2, errs->length);
SeqDestroy(errs);
}
static void test_sort(void)
{
Seq *seq = SeqNew(5, NULL);
size_t one = 1;
size_t two = 2;
size_t three = 3;
size_t four = 4;
size_t five = 5;
SeqAppend(seq, &three);
SeqAppend(seq, &two);
SeqAppend(seq, &five);
SeqAppend(seq, &one);
SeqAppend(seq, &four);
SeqSort(seq, CompareNumbers, NULL);
assert_int_equal(seq->data[0], &one);
assert_int_equal(seq->data[1], &two);
assert_int_equal(seq->data[2], &three);
assert_int_equal(seq->data[3], &four);
assert_int_equal(seq->data[4], &five);
SeqDestroy(seq);
}
static void ShowVariablesFormatted(EvalContext *ctx)
{
VariableTableIterator *iter = EvalContextVariableTableIteratorNew(ctx, NULL, NULL, NULL);
Variable *v = NULL;
Seq *seq = SeqNew(2000, free);
while ((v = VariableTableIteratorNext(iter)))
{
char *varname = VarRefToString(v->ref, true);
Writer *w = StringWriter();
switch (DataTypeToRvalType(v->type))
{
case RVAL_TYPE_CONTAINER:
JsonWriteCompact(w, RvalContainerValue(v->rval));
break;
default:
RvalWrite(w, v->rval);
}
const char *var_value;
if (StringIsPrintable(StringWriterData(w)))
{
var_value = StringWriterData(w);
}
else
{
var_value = "<non-printable>";
}
StringSet *tagset = EvalContextVariableTags(ctx, v->ref);
Buffer *tagbuf = StringSetToBuffer(tagset, ',');
char *line;
xasprintf(&line, "%-40s %-60s %-40s", varname, var_value, BufferData(tagbuf));
SeqAppend(seq, line);
BufferDestroy(tagbuf);
WriterClose(w);
free(varname);
}
SeqSort(seq, (SeqItemComparator)strcmp, NULL);
printf("%-40s %-60s %-40s\n", "Variable name", "Variable value", "Meta tags");
for (size_t i = 0; i < SeqLength(seq); i++)
{
const char *variable = SeqAt(seq, i);
printf("%s\n", variable);
}
SeqDestroy(seq);
VariableTableIteratorDestroy(iter);
}
void CFTestD_ConfigDestroy(CFTestD_Config *config)
{
free(config->report_file);
SeqDestroy(config->report);
free(config->key_file);
free(config->address);
free(config);
}
Policy *GenericAgentLoadPolicy(EvalContext *ctx, GenericAgentConfig *config)
{
config->policy_last_read_attempt = time(NULL);
StringSet *parsed_files = StringSetNew();
StringSet *failed_files = StringSetNew();
Policy *policy = LoadPolicyFile(ctx, config, config->input_file, parsed_files, failed_files);
if (StringSetSize(failed_files) > 0)
{
Log(LOG_LEVEL_ERR, "There are syntax errors in policy files");
exit(EXIT_FAILURE);
}
StringSetDestroy(parsed_files);
StringSetDestroy(failed_files);
{
Seq *errors = SeqNew(100, PolicyErrorDestroy);
if (PolicyCheckPartial(policy, errors))
{
if (!config->bundlesequence && (PolicyIsRunnable(policy) || config->check_runnable))
{
Log(LOG_LEVEL_VERBOSE, "Running full policy integrity checks");
PolicyCheckRunnable(ctx, policy, errors, config->ignore_missing_bundles);
}
}
if (SeqLength(errors) > 0)
{
Writer *writer = FileWriter(stderr);
for (size_t i = 0; i < errors->length; i++)
{
PolicyErrorWrite(writer, errors->data[i]);
}
WriterClose(writer);
exit(EXIT_FAILURE); // TODO: do not exit
}
SeqDestroy(errors);
}
if (LogGetGlobalLevel() >= LOG_LEVEL_VERBOSE)
{
ShowContext(ctx);
}
if (policy)
{
VerifyPromises(ctx, policy, config);
}
return policy;
}
// TODO: consider moving this into a mod_common_test
static void test_body_action_with_log_repaired_needs_log_string(void)
{
{
Seq *errs = LoadAndCheckString("body action foo {"
" log_repaired => '/tmp/abc';"
"}");
assert_int_equal(1, errs->length);
SeqDestroy(errs);
}
{
Seq *errs = LoadAndCheckString("body action foo {"
" log_repaired => '/tmp/abc';"
" log_string => 'stuff';"
"}");
assert_int_equal(0, errs->length);
SeqDestroy(errs);
}
}
void ExecConfigDestroy(ExecConfig *exec_config)
{
if (exec_config)
{
free(exec_config->exec_command);
free(exec_config->mail_server);
free(exec_config->mail_from_address);
free(exec_config->mail_to_address);
free(exec_config->mail_subject);
SeqDestroy(exec_config->mailfilter_include);
SeqDestroy(exec_config->mailfilter_exclude);
SeqDestroy(exec_config->mailfilter_include_regex);
SeqDestroy(exec_config->mailfilter_exclude_regex);
free(exec_config->fq_name);
free(exec_config->ip_address);
free(exec_config->ip_addresses);
free(exec_config);
}
}
void PromiseIteratorDestroy(PromiseIterator *iter)
{
if (iter)
{
for (size_t i = 0; i < SeqLength(iter->vars); i++)
{
CfAssoc *var = SeqAt(iter->vars, i);
void *state = SeqAt(iter->var_states, i);
if (var->rval.type == RVAL_TYPE_CONTAINER)
{
free(state);
}
}
SeqDestroy(iter->var_states);
SeqDestroy(iter->vars);
free(iter);
}
}
static void test_reverse(void)
{
{
Seq *seq = SequenceCreateRange(2, 0, 1);
assert_int_equal(0, *(size_t *)seq->data[0]);
assert_int_equal(1, *(size_t *)seq->data[1]);
SeqReverse(seq);
assert_int_equal(1, *(size_t *)seq->data[0]);
assert_int_equal(0, *(size_t *)seq->data[1]);
SeqDestroy(seq);
}
{
Seq *seq = SequenceCreateRange(3, 0, 2);
SeqReverse(seq);
assert_int_equal(2, *(size_t *)seq->data[0]);
assert_int_equal(1, *(size_t *)seq->data[1]);
assert_int_equal(0, *(size_t *)seq->data[2]);
SeqDestroy(seq);
}
}
static void RemoveRemotelyInjectedVars(const EvalContext *ctx, const Bundle *bundle)
{
const Seq *remote_var_promises = EvalContextGetRemoteVarPromises(ctx, bundle->name);
if ((remote_var_promises == NULL) || SeqLength(remote_var_promises) == 0)
{
/* nothing to do here */
return;
}
size_t promises_length = SeqLength(remote_var_promises);
Seq *remove_vars = SeqNew(promises_length, NULL);
/* remove variables that have been attempted to be inserted into this
* bundle */
/* TODO: this is expensive and should be removed! */
for (size_t i = 0; i < promises_length; i++)
{
const Promise *pp = (Promise *) SeqAt(remote_var_promises, i);
VariableTableIterator *iter = EvalContextVariableTableIteratorNew(ctx, NULL, bundle->name, NULL);
const Variable *var = VariableTableIteratorNext(iter);
while (var != NULL)
{
/* variables are stored together with their original promises (org_pp) */
if (var->promise && var->promise->org_pp == pp)
{
Log(LOG_LEVEL_ERR, "Ignoring remotely-injected variable '%s'",
var->ref->lval);
/* avoid modifications of the variable table being iterated
* over and avoid trying to remove the same variable twice */
SeqAppendOnce(remove_vars, (void *) var, PointerCmp);
}
var = VariableTableIteratorNext(iter);
}
VariableTableIteratorDestroy(iter);
}
/* iteration over the variable table done, time to remove the variables */
size_t remove_vars_length = SeqLength(remove_vars);
for (size_t i = 0; i < remove_vars_length; i++)
{
Variable *var = (Variable *) SeqAt(remove_vars, i);
if (var->ref != NULL)
{
EvalContextVariableRemove(ctx, var->ref);
}
}
SeqDestroy(remove_vars);
}
void EvalContextDestroy(EvalContext *ctx)
{
if (ctx)
{
StringSetDestroy(ctx->heap_soft);
StringSetDestroy(ctx->heap_hard);
StringSetDestroy(ctx->heap_negated);
DeleteItemList(ctx->heap_abort);
DeleteItemList(ctx->heap_abort_current_bundle);
SeqDestroy(ctx->stack);
StringSetDestroy(ctx->dependency_handles);
}
}
static void test_append(void)
{
Seq *seq = SeqNew(2, free);
for (size_t i = 0; i < 1000; i++)
{
SeqAppend(seq, xstrdup("snookie"));
}
assert_int_equal(seq->length, 1000);
for (size_t i = 0; i < 1000; i++)
{
assert_string_equal(seq->data[i], "snookie");
}
SeqDestroy(seq);
}
static void test_new_csv_reader_lfln_at_end2()
{
Seq *list = NULL;
char line[]=" Type ,\"walo1\", \"walo2\" , \"wal\r\n,o \"\" 3\", \" ab,cd \", walo solo , ,walo\r\n";
list = SeqParseCsvString(line);
assert_int_equal(list->length, 8);
assert_string_equal(list->data[7], "walo");
if (list != NULL)
{
SeqDestroy(list);
}
else
{
assert_true(false);
}
}
static void test_lookup(void)
{
Seq *seq = SequenceCreateRange(10, 0, 9);
size_t *key = xmalloc(sizeof(size_t));
*key = 5;
size_t *result = SeqLookup(seq, key, CompareNumbers);
assert_int_equal(*result, *key);
*key = 17;
result = SeqLookup(seq, key, CompareNumbers);
assert_int_equal(result, NULL);
SeqDestroy(seq);
free(key);
}
static void test_index_of(void)
{
Seq *seq = SequenceCreateRange(10, 0, 9);
size_t *key = xmalloc(sizeof(size_t));
*key = 5;
ssize_t index = SeqIndexOf(seq, key, CompareNumbers);
assert_int_equal(index, 5);
*key = 17;
index = SeqIndexOf(seq, key, CompareNumbers);
assert_true(index == -1);
SeqDestroy(seq);
free(key);
}
void EvalContextDestroy(EvalContext *ctx)
{
if (ctx)
{
StringSetDestroy(ctx->heap_soft);
StringSetDestroy(ctx->heap_hard);
StringSetDestroy(ctx->heap_negated);
DeleteItemList(ctx->heap_abort);
DeleteItemList(ctx->heap_abort_current_bundle);
SeqDestroy(ctx->stack);
ScopeDeleteAll();
StringSetDestroy(ctx->dependency_handles);
PromiseSetDestroy(ctx->promises_done);
free(ctx);
}
}
static void test_len(void)
{
Seq *seq = SeqNew(5, NULL);
size_t one = 1;
size_t two = 2;
size_t three = 3;
size_t four = 4;
size_t five = 5;
SeqAppend(seq, &three);
SeqAppend(seq, &two);
SeqAppend(seq, &five);
SeqAppend(seq, &one);
SeqAppend(seq, &four);
assert_int_equal(SeqLength(seq),5);
SeqDestroy(seq);
}
