static int callback_scr_rule(struct xccdf_rule *rule, void *arg)
{
const char * rule_id = xccdf_rule_get_id(rule);
/* is rule selected? we print only selected rules */
const bool selected = xccdf_policy_is_item_selected((struct xccdf_policy *) arg, rule_id);
if (!selected)
return 0;
const char *title = xccdf_policy_get_readable_item_title((struct xccdf_policy *)arg, (struct xccdf_item *) rule, NULL);
/* print */
if (isatty(1))
printf("Title\r\t\033[1m%s\033[0;0m\n", title);
else
printf("Title\r\t%s\n", title);
free((char *)title);
printf("Rule\r\t%s\n", rule_id);
struct xccdf_ident_iterator *idents = xccdf_rule_get_idents(rule);
while (xccdf_ident_iterator_has_more(idents)) {
const struct xccdf_ident *ident = xccdf_ident_iterator_next(idents);
const char *ident_id = xccdf_ident_get_id(ident);
printf("Ident\r\t%s\n", ident_id);
}
xccdf_ident_iterator_free(idents);
printf("Result\r\t");
fflush(stdout);
return 0;
}
void xccdf_rule_to_dom(struct xccdf_rule *rule, xmlNode *rule_node, xmlDoc *doc, xmlNode *parent)
{
const struct xccdf_version_info* version_info = xccdf_item_get_schema_version(XITEM(rule));
xmlNs *ns_xccdf = lookup_xccdf_ns(doc, parent, version_info);
/* Handle Attributes */
const char *extends = xccdf_rule_get_extends(rule);
if (extends)
xmlNewProp(rule_node, BAD_CAST "extends", BAD_CAST extends);
if (xccdf_rule_get_multiple(rule))
xmlNewProp(rule_node, BAD_CAST "multiple", BAD_CAST "true");
if (xccdf_rule_get_selected(rule))
xmlNewProp(rule_node, BAD_CAST "selected", BAD_CAST "true");
else
xmlNewProp(rule_node, BAD_CAST "selected", BAD_CAST "false");
if (XITEM(rule)->item.defined_flags.weight) {
char *weight_str = oscap_sprintf("%f", xccdf_rule_get_weight(rule));
xmlNewProp(rule_node, BAD_CAST "weight", BAD_CAST weight_str);
free(weight_str);
}
xccdf_role_t role = xccdf_rule_get_role(rule);
if (role != 0)
xmlNewProp(rule_node, BAD_CAST "role", BAD_CAST XCCDF_ROLE_MAP[role - 1].string);
xccdf_level_t severity = xccdf_rule_get_severity(rule);
if (severity != XCCDF_LEVEL_NOT_DEFINED)
xmlNewProp(rule_node, BAD_CAST "severity", BAD_CAST XCCDF_LEVEL_MAP[severity - 1].string);
/* Handle Child Nodes */
xccdf_texts_to_dom(xccdf_rule_get_rationale(rule), rule_node, "rationale");
struct oscap_string_iterator *platforms = xccdf_rule_get_platforms(rule);
while (oscap_string_iterator_has_more(platforms)) {
const char *platform = oscap_string_iterator_next(platforms);
xmlNode * child = xmlNewTextChild(rule_node, ns_xccdf, BAD_CAST "platform", BAD_CAST NULL);
xmlNewProp(child, BAD_CAST "idref", BAD_CAST platform);
}
oscap_string_iterator_free(platforms);
struct oscap_stringlist_iterator *lists = xccdf_rule_get_requires(rule);
while (oscap_stringlist_iterator_has_more(lists)) {
struct oscap_stringlist *list = oscap_stringlist_iterator_next(lists);
struct oscap_string_iterator *strings = oscap_stringlist_get_strings(list);
while (oscap_string_iterator_has_more(strings)) {
const char *requires = oscap_string_iterator_next(strings);
xmlNode * child = xmlNewTextChild(rule_node, ns_xccdf, BAD_CAST "requires", BAD_CAST NULL);
xmlNewProp(child, BAD_CAST "idref", BAD_CAST requires);
}
oscap_string_iterator_free(strings);
}
oscap_stringlist_iterator_free(lists);
struct oscap_string_iterator *conflicts = xccdf_rule_get_conflicts(rule);
while (oscap_string_iterator_has_more(conflicts)) {
const char *conflict = oscap_string_iterator_next(conflicts);
xmlNode * child = xmlNewTextChild(rule_node, ns_xccdf, BAD_CAST "conflicts", BAD_CAST NULL);
xmlNewProp(child, BAD_CAST "idref", BAD_CAST conflict);
}
oscap_string_iterator_free(conflicts);
struct xccdf_ident_iterator *idents = xccdf_rule_get_idents(rule);
while (xccdf_ident_iterator_has_more(idents)) {
struct xccdf_ident *ident = xccdf_ident_iterator_next(idents);
xccdf_ident_to_dom(ident, doc, rule_node, version_info);
}
xccdf_ident_iterator_free(idents);
struct xccdf_profile_note_iterator *notes = xccdf_rule_get_profile_notes(rule);
while (xccdf_profile_note_iterator_has_more(notes)) {
struct xccdf_profile_note *note = xccdf_profile_note_iterator_next(notes);
xccdf_profile_note_to_dom(note, doc, rule_node);
}
xccdf_profile_note_iterator_free(notes);
struct xccdf_fixtext_iterator *fixtexts = xccdf_rule_get_fixtexts(rule);
while (xccdf_fixtext_iterator_has_more(fixtexts)) {
struct xccdf_fixtext *fixtext = xccdf_fixtext_iterator_next(fixtexts);
xccdf_fixtext_to_dom(fixtext, doc, rule_node);
}
xccdf_fixtext_iterator_free(fixtexts);
struct xccdf_fix_iterator *fixes = xccdf_rule_get_fixes(rule);
while (xccdf_fix_iterator_has_more(fixes)) {
struct xccdf_fix *fix = xccdf_fix_iterator_next(fixes);
xccdf_fix_to_dom(fix, doc, rule_node, version_info);
}
xccdf_fix_iterator_free(fixes);
struct xccdf_check_iterator *checks = xccdf_rule_get_checks(rule);
while (xccdf_check_iterator_has_more(checks)) {
struct xccdf_check *check = xccdf_check_iterator_next(checks);
xccdf_check_to_dom(check, doc, rule_node, version_info);
}
xccdf_check_iterator_free(checks);
}
void TailoringWindow::synchronizeTreeItem(QTreeWidgetItem* treeItem, struct xccdf_item* xccdfItem, bool recursive)
{
++mSynchronizeItemLock;
const QString title = oscapTextIteratorGetPreferred(xccdf_item_get_title(xccdfItem));
treeItem->setText(0, title);
QString searchable = QString("%1 %2").arg(title, QString::fromUtf8(xccdf_item_get_id(xccdfItem)));
switch (xccdf_item_get_type(xccdfItem))
{
case XCCDF_BENCHMARK:
treeItem->setIcon(0, getShareIcon("benchmark.png"));
break;
case XCCDF_GROUP:
treeItem->setIcon(0, getShareIcon("group.png"));
break;
case XCCDF_RULE:
treeItem->setIcon(0, getShareIcon("rule.png"));
{
struct xccdf_ident_iterator* idents = xccdf_rule_get_idents(xccdf_item_to_rule(xccdfItem));
while (xccdf_ident_iterator_has_more(idents))
{
struct xccdf_ident* ident = xccdf_ident_iterator_next(idents);
searchable += " " + QString::fromUtf8(xccdf_ident_get_id(ident));
}
xccdf_ident_iterator_free(idents);
}
break;
case XCCDF_VALUE:
treeItem->setIcon(0, getShareIcon("value.png"));
break;
default:
treeItem->setIcon(0, QIcon());
break;
}
treeItem->setText(1, searchable);
treeItem->setData(0, Qt::UserRole, QVariant::fromValue(reinterpret_cast<void*>(xccdfItem)));
xccdf_type_t xccdfItemType = xccdf_item_get_type(xccdfItem);
switch (xccdfItemType)
{
case XCCDF_RULE:
case XCCDF_GROUP:
{
treeItem->setFlags(treeItem->flags() | Qt::ItemIsUserCheckable);
treeItem->setCheckState(0,
getXccdfItemInternalSelected(mPolicy, xccdfItem) ? Qt::Checked : Qt::Unchecked);
_syncXCCDFItemChildrenDisabledState(treeItem, treeItem->checkState(0));
break;
}
case XCCDF_VALUE:
treeItem->setFlags(treeItem->flags() & ~Qt::ItemIsUserCheckable);
default:
break;
}
if (recursive)
{
typedef std::vector<struct xccdf_item*> XCCDFItemVector;
typedef std::map<struct xccdf_item*, QTreeWidgetItem*> XCCDFToQtItemMap;
XCCDFItemVector itemsToAdd;
XCCDFToQtItemMap existingItemsMap;
// valuesIt contains Values
struct xccdf_value_iterator* valuesIt = NULL;
// itemsIt contains Rules and Groups
struct xccdf_item_iterator* itemsIt = NULL;
switch (xccdfItemType)
{
case XCCDF_GROUP:
valuesIt = xccdf_group_get_values(xccdf_item_to_group(xccdfItem));
itemsIt = xccdf_group_get_content(xccdf_item_to_group(xccdfItem));
break;
case XCCDF_BENCHMARK:
valuesIt = xccdf_benchmark_get_values(xccdf_item_to_benchmark(xccdfItem));
itemsIt = xccdf_benchmark_get_content(xccdf_item_to_benchmark(xccdfItem));
break;
default:
break;
}
if (valuesIt != NULL)
{
while (xccdf_value_iterator_has_more(valuesIt))
{
struct xccdf_value* childItem = xccdf_value_iterator_next(valuesIt);
itemsToAdd.push_back(xccdf_value_to_item(childItem));
}
xccdf_value_iterator_free(valuesIt);
}
if (itemsIt != NULL)
{
while (xccdf_item_iterator_has_more(itemsIt))
{
struct xccdf_item* childItem = xccdf_item_iterator_next(itemsIt);
itemsToAdd.push_back(childItem);
}
xccdf_item_iterator_free(itemsIt);
}
for (int i = 0; i < treeItem->childCount(); ++i)
{
QTreeWidgetItem* childTreeItem = treeItem->child(i);
struct xccdf_item* childXccdfItem = getXccdfItemFromTreeItem(childTreeItem);
if (std::find(itemsToAdd.begin(), itemsToAdd.end(), childXccdfItem) == itemsToAdd.end())
{
// this will remove it from the tree as well, see ~QTreeWidgetItem()
delete childTreeItem;
}
else
{
existingItemsMap[childXccdfItem] = childTreeItem;
}
}
unsigned int idx = 0;
for (XCCDFItemVector::const_iterator it = itemsToAdd.begin();
it != itemsToAdd.end(); ++it, ++idx)
{
struct xccdf_item* childXccdfItem = *it;
QTreeWidgetItem* childTreeItem = 0;
XCCDFToQtItemMap::iterator mapIt = existingItemsMap.find(childXccdfItem);
if (mapIt == existingItemsMap.end())
{
childTreeItem = new QTreeWidgetItem();
childTreeItem->setFlags(
Qt::ItemIsSelectable |
Qt::ItemIsEnabled);
treeItem->insertChild(idx, childTreeItem);
}
else
{
childTreeItem = mapIt->second;
}
synchronizeTreeItem(childTreeItem, childXccdfItem, true);
}
}
--mSynchronizeItemLock;
}
