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; }