static void test_show_object_compound(void)
{
JsonElement *json = JsonObjectCreate(10);
JsonObjectAppendString(json, "first", "one");
{
JsonElement *inner = JsonObjectCreate(10);
JsonObjectAppendString(inner, "third", "three");
JsonObjectAppendObject(json, "second", inner);
}
{
JsonElement *inner = JsonObjectCreate(10);
JsonObjectAppendString(inner, "fifth", "five");
JsonObjectAppendObject(json, "fourth", inner);
}
Writer *writer = StringWriter();
JsonWrite(writer, json, 0);
char *output = StringWriterClose(writer);
assert_string_equal(OBJECT_COMPOUND, output);
JsonDestroy(json);
free(output);
}
char *MapNameCopy(const char *s)
{
Writer *w = StringWriter();
/* c:\a\b -> /cygdrive/c\a\b */
if (s[0] && isalpha(s[0]) && s[1] == ':')
{
WriterWriteF(w, "/cygdrive/%c", s[0]);
s += 2;
}
for (; *s; s++)
{
/* a//b//c -> a/b/c */
/* a\\b\\c -> a\b\c */
if (IsFileSep(*s) && IsFileSep(*(s + 1)))
{
continue;
}
/* a\b\c -> a/b/c */
WriterWriteChar(w, *s == '\\' ? '/' : *s);
}
return StringWriterClose(w);
}
static void test_show_object_compound_compact(void)
{
JsonElement *json = JsonObjectCreate(10);
JsonObjectAppendString(json, "first", "one");
{
JsonElement *inner = JsonObjectCreate(10);
JsonObjectAppendString(inner, "third", "three");
JsonObjectAppendObject(json, "second", inner);
}
{
JsonElement *inner = JsonObjectCreate(10);
JsonObjectAppendString(inner, "fifth", "five");
JsonObjectAppendObject(json, "fourth", inner);
}
Writer *writer = StringWriter();
JsonWriteCompact(writer, json);
char *output = StringWriterClose(writer);
assert_string_equal("{\"first\":\"one\",\"second\":{\"third\":\"three\"},\"fourth\":{\"fifth\":\"five\"}}", output);
JsonDestroy(json);
free(output);
}
static bool VerifyBundleSequence(EvalContext *ctx, const Policy *policy, const GenericAgentConfig *config)
{
Rlist *rp;
char *name;
Rval retval;
int ok = true;
FnCall *fp;
if (!EvalContextVariableControlCommonGet(ctx, COMMON_CONTROL_BUNDLESEQUENCE, &retval))
{
Log(LOG_LEVEL_ERR, " No bundlesequence in the common control body");
return false;
}
if (retval.type != RVAL_TYPE_LIST)
{
FatalError(ctx, "Promised bundlesequence was not a list");
}
for (rp = (Rlist *) retval.item; rp != NULL; rp = rp->next)
{
switch (rp->type)
{
case RVAL_TYPE_SCALAR:
name = (char *) rp->item;
break;
case RVAL_TYPE_FNCALL:
fp = (FnCall *) rp->item;
name = (char *) fp->name;
break;
default:
name = NULL;
ok = false;
{
Writer *w = StringWriter();
WriterWrite(w, "Illegal item found in bundlesequence '");
RvalWrite(w, (Rval) {rp->item, rp->type});
WriterWrite(w, "'");
Log(LOG_LEVEL_ERR, "%s", StringWriterData(w));
WriterClose(w);
}
break;
}
if (strcmp(name, CF_NULL_VALUE) == 0)
{
continue;
}
if (!config->ignore_missing_bundles && !PolicyGetBundle(policy, NULL, NULL, name))
{
Log(LOG_LEVEL_ERR, "Bundle '%s' listed in the bundlesequence is not a defined bundle", name);
ok = false;
}
}
return ok;
}
char *EvalContextStackPath(const EvalContext *ctx)
{
Writer *path = StringWriter();
for (size_t i = 0; i < SeqLength(ctx->stack); i++)
{
StackFrame *frame = SeqAt(ctx->stack, i);
switch (frame->type)
{
case STACK_FRAME_TYPE_BODY:
WriterWriteF(path, "/%s", frame->data.body.owner->name);
break;
case STACK_FRAME_TYPE_BUNDLE:
WriterWriteF(path, "/%s", frame->data.bundle.owner->name);
break;
case STACK_FRAME_TYPE_PROMISE_ITERATION:
WriterWriteF(path, "/%s", frame->data.promise.owner->parent_promise_type->name);
WriterWriteF(path, "/'%s'", frame->data.promise.owner->promiser);
break;
case STACK_FRAME_TYPE_PROMISE:
break;
}
}
return StringWriterClose(path);
}
char *SearchAndReplace(const char *source, const char *search, const char *replace)
{
const char *source_ptr = source;
if ((source == NULL) || (search == NULL) || (replace == NULL))
{
ProgrammingError("Programming error: NULL argument is passed to SearchAndReplace");
}
if (strcmp(search, "") == 0)
{
return xstrdup(source);
}
Writer *w = StringWriter();
for (;;)
{
const char *found_ptr = strstr(source_ptr, search);
if (found_ptr == NULL)
{
WriterWrite(w, source_ptr);
return StringWriterClose(w);
}
WriterWriteLen(w, source_ptr, found_ptr - source_ptr);
WriterWrite(w, replace);
source_ptr += found_ptr - source_ptr + strlen(search);
}
}
void test_comment(void **state)
{
Writer *w = StringWriter();
XmlComment(w, "foobar");
assert_string_equal(StringWriterClose(w), "<!-- foobar -->\n");
}
void test_no_attr(void **state)
{
Writer *w = StringWriter();
XmlTag(w, "foobar", NULL, 0);
assert_string_equal(StringWriterClose(w), "<foobar></foobar>\n");
}
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);
}
static void test_show_object_compound(void **state)
{
JsonElement *json = JsonObjectCreate(10);
JsonObjectAppendString(json, "first", "one");
{
JsonElement *inner = JsonObjectCreate(10);
JsonObjectAppendString(inner, "third", "three");
JsonObjectAppendObject(json, "second", inner);
}
{
JsonElement *inner = JsonObjectCreate(10);
JsonObjectAppendString(inner, "fifth", "five");
JsonObjectAppendObject(json, "fourth", inner);
}
Writer *writer = StringWriter();
JsonElementPrint(writer, json, 0);
assert_string_equal(OBJECT_COMPOUND, StringWriterData(writer));
JsonElementDestroy(json);
}
void test_empty(void **state)
{
Writer *w = StringWriter();
CsvWriter *c = CsvWriterOpen(w);
CsvWriterClose(c);
assert_string_equal(StringWriterClose(w), "");
}
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);
}
}
char *ReadTexinfoFileF(const char *source_dir, const char *fmt, ...)
{
Writer *filenamew = StringWriter();
struct stat sb;
char *buffer = NULL;
FILE *fp = NULL;
off_t file_size;
va_list ap;
va_start(ap, fmt);
WriterWriteF(filenamew, "%s/", source_dir);
WriterWriteVF(filenamew, fmt, ap);
va_end(ap);
char *filename = StringWriterClose(filenamew);
if (cfstat(filename, &sb) == -1)
{
if (!GenerateStub(filename))
{
CfOut(OUTPUT_LEVEL_INFORM, "", "Unable to write down stub for missing texinfo file");
free(filename);
return NULL;
}
}
if ((fp = fopen(filename, "r")) == NULL)
{
CfOut(OUTPUT_LEVEL_INFORM, "fopen", "Could not read manual source %s\n", filename);
free(filename);
return NULL;
}
fseek(fp, 0, SEEK_END);
file_size = ftello(fp);
fseek(fp, 0, SEEK_SET);
buffer = (char *) xcalloc(file_size + 1, sizeof(char));
buffer[file_size] = '\0';
int cnt = fread(buffer, sizeof(char), file_size, fp);
if ((ferror(fp)) || (cnt != file_size))
{
CfOut(OUTPUT_LEVEL_INFORM, "fread", "Could not read manual source %s\n", filename);
free(buffer);
fclose(fp);
free(filename);
return NULL;
}
fclose(fp);
free(filename);
return buffer;
}
void test_tag(void **state)
{
Writer *w = StringWriter();
XmlTag(w, "foobar", "some value", 1, (XmlAttribute)
{
"a", "b"});
assert_string_equal(StringWriterClose(w), "<foobar a=\"b\" >some value</foobar>\n");
}
void test_single_field(void **state)
{
Writer *w = StringWriter();
CsvWriter *c = CsvWriterOpen(w);
CsvWriterField(c, "test");
CsvWriterClose(c);
assert_string_equal(StringWriterClose(w), "test\r\n");
}
void test_escape(void **state)
{
Writer *w = StringWriter();
CsvWriter *c = CsvWriterOpen(w);
CsvWriterField(c, ",\"\r\n");
CsvWriterClose(c);
assert_string_equal(StringWriterClose(w), "\",\"\"\r\n\"\r\n");
}
static void test_show_string(void **state)
{
JsonElement *str = JsonStringCreate("snookie");
Writer *writer = StringWriter();
JsonElementPrint(writer, str, 0);
assert_string_equal("\"snookie\"", StringWriterClose(writer));
JsonElementDestroy(str);
}
void test_several_fields(void **state)
{
Writer *w = StringWriter();
CsvWriter *c = CsvWriterOpen(w);
CsvWriterField(c, "test1");
CsvWriterField(c, "test2");
CsvWriterField(c, "test3");
CsvWriterClose(c);
assert_string_equal(StringWriterClose(w), "test1,test2,test3\r\n");
}
static bool VerifyBundleSequence(EvalContext *ctx, const Policy *policy, const GenericAgentConfig *config)
{
Rlist *fallback = NULL;
const Rlist *bundlesequence = EvalContextVariableControlCommonGet(ctx, COMMON_CONTROL_BUNDLESEQUENCE);
if (!bundlesequence)
{
RlistAppendScalar(&fallback, "main");
bundlesequence = fallback;
}
const char *name;
int ok = true;
for (const Rlist *rp = bundlesequence; rp != NULL; rp = rp->next)
{
switch (rp->val.type)
{
case RVAL_TYPE_SCALAR:
name = RlistScalarValue(rp);
break;
case RVAL_TYPE_FNCALL:
name = RlistFnCallValue(rp)->name;
break;
default:
name = NULL;
ok = false;
{
Writer *w = StringWriter();
WriterWrite(w, "Illegal item found in bundlesequence '");
RvalWrite(w, rp->val);
WriterWrite(w, "'");
Log(LOG_LEVEL_ERR, "%s", StringWriterData(w));
WriterClose(w);
}
continue;
}
if (strcmp(name, CF_NULL_VALUE) == 0)
{
continue;
}
if (!config->ignore_missing_bundles && !PolicyGetBundle(policy, NULL, NULL, name))
{
Log(LOG_LEVEL_ERR, "Bundle '%s' listed in the bundlesequence is not a defined bundle", name);
ok = false;
}
}
RlistDestroy(fallback);
return ok;
}
static void test_show_array_empty(void **state)
{
JsonElement *array = JsonArrayCreate(10);
Writer *writer = StringWriter();
JsonElementPrint(writer, array, 0);
assert_string_equal("[]", StringWriterData(writer));
JsonElementDestroy(array);
}
void test_empty_record(void)
{
Writer *w = StringWriter();
CsvWriter *c = CsvWriterOpen(w);
CsvWriterNewRecord(c);
CsvWriterField(c, "test2");
CsvWriterNewRecord(c);
CsvWriterClose(c);
assert_string_equal(StringWriterClose(w), "\r\ntest2\r\n");
}
void test_empty_last_record(void **state)
{
Writer *w = StringWriter();
CsvWriter *c = CsvWriterOpen(w);
CsvWriterField(c, "test1");
CsvWriterNewRecord(c);
CsvWriterNewRecord(c);
CsvWriterClose(c);
assert_string_equal(StringWriterClose(w), "test1\r\n\r\n");
}
void test_empty_file_buffer(void **p)
{
global_w = StringWriter();
global_w_closed = false;
Writer *w = FileWriter(NULL);
assert_int_equal(StringWriterLength(global_w), 0);
assert_string_equal(StringWriterData(global_w), "");
WriterClose(w);
WriterClose(global_w);
assert_int_equal(global_w_closed, true);
}
static void AddOpenPortsClasses(const char *name, const Item *value, Item **classlist)
{
Writer *w = StringWriter();
WriterWriteF(w, "@%s=", name);
PrintItemList(value, w);
if (StringWriterLength(w) <= 1500)
{
AppendItem(classlist, StringWriterClose(w), NULL);
}
else
{
WriterClose(w);
}
}
static void test_show_object_escaped(void **state)
{
JsonElement *json = JsonObjectCreate(10);
JsonObjectAppendString(json, "escaped", "quote\"stuff \t \n\n");
Writer *writer = StringWriter();
JsonElementPrint(writer, json, 0);
assert_string_equal(OBJECT_ESCAPED, StringWriterData(writer));
JsonElementDestroy(json);
}
void test_write_file_buffer(void **p)
{
global_w = StringWriter();
Writer *w = FileWriter(NULL);
WriterWrite(w, "123");
assert_int_equal(StringWriterLength(global_w), 3);
assert_string_equal(StringWriterData(global_w), "123");
WriterClose(w);
WriterClose(global_w);
assert_int_equal(global_w_closed, true);
}
static char *GetLockNameExec(Attributes a, Promise *pp)
{
Writer *w = StringWriter();
if (a.args)
{
WriterWriteF(w, "%s %s", pp->promiser, a.args);
}
else
{
WriterWrite(w, pp->promiser);
}
return StringWriterClose(w);
}
static void test_show_array_empty(void)
{
JsonElement *array = JsonArrayCreate(10);
Writer *writer = StringWriter();
JsonWrite(writer, array, 0);
char *output = StringWriterClose(writer);
assert_string_equal("[]", output);
JsonDestroy(array);
free(output);
}
static void test_show_string(void)
{
JsonElement *str = JsonStringCreate("snookie");
Writer *writer = StringWriter();
JsonWrite(writer, str, 0);
char *output = StringWriterClose(writer);
assert_string_equal("\"snookie\"", output);
JsonDestroy(str);
free(output);
}
void test_complex_tag(void **state)
{
Writer *w = StringWriter();
XmlStartTag(w, "complex-tag", 2, (XmlAttribute)
{
"attr1", "value1"}, (XmlAttribute)
{
"attr2", "value2"});
XmlContent(w, "Some content");
XmlEndTag(w, "complex-tag");
assert_string_equal(StringWriterClose(w),
"<complex-tag attr1=\"value1\" attr2=\"value2\" >\nSome content</complex-tag>\n");
}
