int cDataMap::processData(xmlTextReaderPtr reader)
{
// element callback from read_xmlfile
// args: pointer to the xmlTextreader
xmlNodePtr node ;
xmlChar *content;
string value;
int epgdataid;
int retval;
// get name, type and depth in the xml structure
string name = string((char *)xmlTextReaderConstName(reader));
int type = xmlTextReaderNodeType(reader) ;
int depth = xmlTextReaderDepth(reader) ;
// get ca0/ca1 or g0/g1 depending which file we read
if (type == XML_READER_TYPE_ELEMENT && depth == 2 && (name.compare("ca0") == 0)) {
node = xmlTextReaderExpand(reader);
content = xmlXPathCastNodeToString(node);
node = NULL ;
epgdataid = atoi((char *)content);
xmlFree(content);
retval = xmlTextReaderNext(reader); // jump to end element
retval = xmlTextReaderNext(reader); // jump to next start element
node = xmlTextReaderExpand(reader);
content = xmlXPathCastNodeToString(node);
node = NULL ;
value = string((char *)content);
xmlFree(content);
datamap[epgdataid] = value;
} else if (type == XML_READER_TYPE_ELEMENT && depth == 2 && ( name.compare("g0") == 0 )) {
node = xmlTextReaderExpand(reader);
content = xmlXPathCastNodeToString(node);
node = NULL ;
epgdataid = atoi((char *)content);
xmlFree(content);
retval = xmlTextReaderNext(reader); // jump to end element
retval = xmlTextReaderNext(reader); // jump to next start element
node = xmlTextReaderExpand(reader);
content = xmlXPathCastNodeToString(node);
node = NULL ;
value = string((char *)content);
xmlFree(content);
datamap[epgdataid] = value;
}
return 0 ;
}
/*
* call-seq:
* reader.expand -> node
*
* Returns the current node and its full subtree. Note the returned node
* is valid ONLY until the next read call.
*/
static VALUE rxml_reader_expand(VALUE self)
{
xmlTextReaderPtr xreader = rxml_text_reader_get(self);
xmlNodePtr xnode = NULL;
/* At this point we need to wrap the reader's document as explained above. */
xmlDocPtr xdoc = xmlTextReaderCurrentDoc(xreader);
if (!xdoc)
rb_raise(rb_eRuntimeError, "The reader does not have a document. Did you forget to call read?");
rxml_document_wrap(xdoc);
/* And now hook in a mark function */
RDATA(self)->dmark = (RUBY_DATA_FUNC)rxml_reader_mark;
xnode = xmlTextReaderExpand(xreader);
if (!xnode)
{
return Qnil;
}
else
{
return rxml_node_wrap(xnode);
}
}
bool XmlDocument::Create(IOStream *input, XmlDocument **r) {
if (!LibXmlInitialized) {
Error(StringPieceFromLiteral("XmlDocument::Create(): call LibXmlInit() first"));
return false;
}
if (!input)
return false;
std::auto_ptr<XmlDocument> xml(new XmlDocument());
xml->libxml_stuff.reset(new LibXmlStuff());
xml->libxml_stuff->reader = xmlReaderForIO(_readCallback, _closeCallback, input,
"url://", NULL,
XML_PARSE_NOBLANKS | XML_PARSE_NONET | XML_PARSE_NOCDATA | XML_PARSE_COMPACT);
if (!xml->libxml_stuff->reader) {
Error(StringPieceFromLiteral("XmlDocument::Create(): xmlReaderForIO fails"));
return false;
}
if (xmlTextReaderRead(xml->libxml_stuff->reader) != 1) {
Error(StringPieceFromLiteral("XmlDocument::Create(): xmlTextReaderRead fails"));
return false;
}
xmlNodePtr node = xmlTextReaderExpand(xml->libxml_stuff->reader);
if ((!node) || (!node->doc))
return false;
xml->libxml_stuff->xpath_context = xmlXPathNewContext(node->doc);
if (!xml->libxml_stuff->xpath_context)
return false;
if (r)
*r = xml.release();
return true;
}
Variant c_XMLReader::t_expand(const Object& basenode /* = null */) {
p_DOMDocument doc;
xmlDocPtr docp = nullptr;
if (!basenode.isNull()) {
c_DOMNode *dombasenode = basenode.getTyped<c_DOMNode>();
doc = dombasenode->doc();
docp = (xmlDocPtr) doc->m_node;
if (docp == nullptr) {
raise_warning("Invalid State Error");
return false;
}
} else {
doc = (p_DOMDocument) SystemLib::AllocDOMDocumentObject();
}
if (m_ptr) {
xmlNodePtr node = xmlTextReaderExpand(m_ptr);
if (node == nullptr) {
raise_warning("An Error Occurred while expanding");
return false;
} else {
xmlNodePtr nodec = xmlDocCopyNode(node, docp, 1);
if (nodec == nullptr) {
raise_notice("Cannot expand this node type");
return false;
} else {
return php_dom_create_object(nodec, doc, false);
}
}
}
raise_warning("Load Data before trying to read");
return false;
}
xmlNodePtr ProtoXml::IterParser::GetNext()
{
//TRACE("enter ProtoXml::IterParser::GetNext() prev_node:%s\n", prev_node ? (const char*)prev_node->name : "(null)");
int result;
// If we didn't just return a "prev_node", then read the
// very next sequential node w/ xmlTextReaderRead(), else
// skip entire "prev_node" sub-tree w/ xmlTextReaderNext()
if (NULL == prev_node)
result = xmlTextReaderRead(reader_ptr);
else
result = xmlTextReaderNext(reader_ptr);
prev_node = NULL;
switch (result)
{
case 0:
return NULL;
case -1:
PLOG(PL_ERROR, "ProtoXml::IterParser::GetNext() xmlTextReaderRead error!\n");
return NULL;
default:
break;
}
do
{
int nodeType = xmlTextReaderNodeType(reader_ptr);
if (XML_READER_TYPE_ELEMENT != nodeType)
continue;
const char* nodeName = (const char*)xmlTextReaderConstLocalName(reader_ptr);
if (NULL == nodeName)
{
PLOG(PL_ERROR, "ProtoXml::IterParser::GetNext() xmlTextReaderConstLocalName() error\n");
return NULL;
}
int nodeDepth = xmlTextReaderDepth(reader_ptr);
if (nodeDepth < 0)
{
PLOG(PL_ERROR, "ProtoXml::IterParser::GetNext() xmlTextReaderDepth() error\n");
return NULL;
}
if (!IterFilterBase::UpdateCurrentPath(nodeDepth, nodeName))
{
PLOG(PL_WARN, "ProtoXml::IterParser::GetNext() error: unable to update current path\n");
continue;
}
if (!IterFilterBase::IsMatch())
continue; // no match, so continue
prev_node = xmlTextReaderExpand(reader_ptr);
if (NULL == prev_node)
PLOG(PL_ERROR, "ProtoXml::IterParser::GetNext() xmlTextReaderExpand() error!\n");
return prev_node;
} while ((result = xmlTextReaderRead(reader_ptr)) > 0);
if (result < 0)
PLOG(PL_ERROR, "ProtoXml::IterParser::GetNext() xmlTextReaderRead() error!\n");
return NULL;
} // end ProtoXml::IterParser::GetNext()
static void
process_properties (xmlTextReaderPtr reader,
GtkSourceLanguage *language)
{
xmlNodePtr child;
xmlNodePtr node = NULL;
while (node == NULL && xmlTextReaderRead (reader) == 1)
{
xmlChar *name;
if (xmlTextReaderNodeType (reader) != 1)
continue;
name = xmlTextReaderName (reader);
if (xmlStrcmp (name, BAD_CAST "metadata") != 0)
{
xmlFree (name);
continue;
}
xmlFree (name);
node = xmlTextReaderExpand (reader);
if (node == NULL)
return;
}
if (node == NULL)
return;
for (child = node->children; child != NULL; child = child->next)
{
xmlChar *name;
xmlChar *content;
if (child->type != XML_ELEMENT_NODE ||
xmlStrcmp (child->name, BAD_CAST "property") != 0)
continue;
name = xmlGetProp (child, BAD_CAST "name");
content = xmlNodeGetContent (child);
if (name != NULL && content != NULL)
g_hash_table_insert (language->priv->properties,
g_strdup ((gchar *) name),
g_strdup ((gchar *) content));
xmlFree (name);
xmlFree (content);
}
}
/*
* call-seq:
* reader.expand -> node
*
* Returns the current node and its full subtree. Note the returned node
* is valid ONLY until the next read call.
*/
static VALUE rxml_reader_expand(VALUE self)
{
xmlTextReaderPtr xreader = rxml_text_reader_get(self);
xmlNodePtr xnode = xmlTextReaderExpand(xreader);
if (!xnode)
{
return Qnil;
}
else
{
return rxml_node_wrap(xnode);
}
}
struct oscap_reference *oscap_reference_new_parse(xmlTextReaderPtr reader)
{
assert(reader != NULL);
struct oscap_reference *ref = oscap_calloc(1, sizeof(struct oscap_reference));
int depth = oscap_element_depth(reader);
xmlNode* ref_node = xmlTextReaderExpand(reader);
ref->href = (char*) xmlGetProp(ref_node, BAD_CAST "href");
for (xmlNode* cur = ref_node->children; cur != NULL; cur = cur->next)
if (cur->type == XML_ELEMENT_NODE) { ref->is_dublincore = true; break; }
if (ref->is_dublincore) {
for (xmlNode* cur = ref_node->children; cur != NULL; cur = cur->next) {
if (cur->type != XML_ELEMENT_NODE
|| cur->ns == NULL
|| !oscap_streq((const char* ) cur->ns->href, (const char *) NS_DUBLINCORE))
continue;
DC_DOM_SCAN(title);
DC_DOM_SCAN(creator);
DC_DOM_SCAN(subject);
DC_DOM_SCAN(description);
DC_DOM_SCAN(publisher);
DC_DOM_SCAN(contributor);
DC_DOM_SCAN(date);
DC_DOM_SCAN(type);
DC_DOM_SCAN(format);
DC_DOM_SCAN(identifier);
DC_DOM_SCAN(source);
DC_DOM_SCAN(language);
DC_DOM_SCAN(relation);
DC_DOM_SCAN(coverage);
DC_DOM_SCAN(rights);
}
}
else {
ref->title = (char*) xmlNodeGetContent(ref_node);
}
if (!oscap_to_start_element(reader, depth))
dW("oscap_to_start_element returned `false'");
return ref;
}
/* {{{ proto bool XMLReader::expand()
Moves the position of the current instance to the next node in the stream. */
PHP_METHOD(xmlreader, expand)
{
#ifdef HAVE_DOM
zval *id, *basenode = NULL;
int ret;
xmlreader_object *intern;
xmlNode *node, *nodec;
xmlDocPtr docp = NULL;
php_libxml_node_object *domobj = NULL;
id = ZEND_THIS;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "|O!", &basenode, dom_node_class_entry) == FAILURE) {
return;
}
if (basenode != NULL) {
NODE_GET_OBJ(node, basenode, xmlNodePtr, domobj);
docp = node->doc;
}
intern = Z_XMLREADER_P(id);
if (intern && intern->ptr) {
node = xmlTextReaderExpand(intern->ptr);
if (node == NULL) {
php_error_docref(NULL, E_WARNING, "An Error Occurred while expanding ");
RETURN_FALSE;
} else {
nodec = xmlDocCopyNode(node, docp, 1);
if (nodec == NULL) {
php_error_docref(NULL, E_NOTICE, "Cannot expand this node type");
RETURN_FALSE;
} else {
DOM_RET_OBJ(nodec, &ret, (dom_object *)domobj);
}
}
} else {
php_error_docref(NULL, E_WARNING, "Load Data before trying to expand");
RETURN_FALSE;
}
#else
php_error(E_WARNING, "DOM support is not enabled");
return;
#endif
}
/*
* call-seq:
* namespaces
*
* Get a hash of namespaces for this Node
*/
static VALUE namespaces(VALUE self)
{
xmlTextReaderPtr reader;
VALUE attr ;
Data_Get_Struct(self, xmlTextReader, reader);
attr = rb_hash_new() ;
if (! has_attributes(reader))
return attr ;
xmlNodePtr ptr = xmlTextReaderExpand(reader);
if(ptr == NULL) return Qnil;
Nokogiri_xml_node_namespaces(ptr, attr);
return attr ;
}
/*
* call-seq:
* attribute_nodes
*
* Get a list of attributes for this Node
*/
static VALUE attribute_nodes(VALUE self)
{
xmlTextReaderPtr reader;
VALUE attr ;
Data_Get_Struct(self, xmlTextReader, reader);
attr = rb_ary_new() ;
if (! has_attributes(reader))
return attr ;
xmlNodePtr ptr = xmlTextReaderExpand(reader);
if(ptr == NULL) return Qnil;
// FIXME I'm not sure if this is correct..... I don't really like pointing
// at this document, but I have to because of the assertions in
// the node wrapping code.
if(! DOC_RUBY_OBJECT_TEST(ptr->doc)) {
VALUE rb_doc = Data_Wrap_Struct(cNokogiriXmlDocument, 0, 0, ptr->doc);
ptr->doc->_private = malloc(sizeof(nokogiriTuple));
rb_iv_set(rb_doc, "@decorators", Qnil);
((nokogiriTuplePtr)(ptr->doc->_private))->doc = (void *)rb_doc;
((nokogiriTuplePtr)(ptr->doc->_private))->unlinkedNodes = xmlXPathNodeSetCreate(NULL);
}
VALUE enc = rb_iv_get(self, "@encoding");
if(enc != Qnil && NULL == ptr->doc->encoding) {
ptr->doc->encoding = calloc((size_t)RSTRING_LEN(enc), sizeof(char));
strncpy(
(char *)ptr->doc->encoding,
StringValuePtr(enc),
(size_t)RSTRING_LEN(enc)
);
}
Nokogiri_xml_node_properties(ptr, attr);
return attr ;
}
/*
* call-seq:
* reader.expand -> node
*
* Read the contents of the current node and the full subtree. It then makes
* the subtree available until the next read call.
*
* Return an XML::Node object, or nil in case of error.
*/
static VALUE rxml_reader_expand(VALUE self)
{
xmlNodePtr node;
xmlDocPtr doc;
xmlTextReaderPtr reader = rxml_text_reader_get(self);
node = xmlTextReaderExpand(reader);
if (!node)
return Qnil;
/* Okay this is tricky. By accessing the returned node, we
take ownership of the reader's document. Thus we need to
tell the reader to not free it. Otherwise it will be
freed twice - once when the Ruby document wrapper goes
out of scope and once when the reader goes out of scope. */
xmlTextReaderPreserve(reader);
doc = xmlTextReaderCurrentDoc(reader);
rxml_document_wrap(doc);
return rxml_node_wrap(node);
}
Variant HHVM_METHOD(XMLReader, expand,
const Variant& basenode /* = null */) {
auto* data = Native::data<XMLReader>(this_);
Object doc;
xmlDocPtr docp = nullptr;
SYNC_VM_REGS_SCOPED();
if (!basenode.isNull()) {
DOMNode *dombasenode = toDOMNode(basenode.toObject().get());
doc = dombasenode->doc();
docp = (xmlDocPtr) toDOMNode(doc.get())->m_node;
if (docp == nullptr) {
raise_warning("Invalid State Error");
return false;
}
} else {
doc = DOMDocument::newInstance();
}
if (data->m_ptr) {
xmlNodePtr node = xmlTextReaderExpand(data->m_ptr);
if (node == nullptr) {
raise_warning("An Error Occurred while expanding");
return false;
} else {
xmlNodePtr nodec = xmlDocCopyNode(node, docp, 1);
if (nodec == nullptr) {
raise_notice("Cannot expand this node type");
return false;
} else {
return php_dom_create_object(nodec, doc, false);
}
}
}
raise_warning("Load Data before trying to read");
return false;
}
/**
* ephy_node_db_load_from_file:
* @db: a new #EphyNodeDb
* @xml_file: the filename from which @db will be populated
* @xml_root: the root element in @xml_file
* @xml_version: the required version attribute in the @xml_root
*
* Populates @db with data from @xml_file. The node database will be populated
* with everything inside of the @xml_root tag from @xml_file. If @xml_version
* is different from the version attribute of the @xml_root element, this
* function will fail.
*
* The data will most probably have been stored using
* ephy_node_db_write_to_xml_safe().
*
* Return value: %TRUE if successful
**/
gboolean
ephy_node_db_load_from_file (EphyNodeDb *db,
const char *xml_file,
const xmlChar *xml_root,
const xmlChar *xml_version)
{
xmlTextReaderPtr reader;
gboolean success = TRUE;
gboolean was_immutable;
int ret;
LOG ("ephy_node_db_load_from_file %s", xml_file);
START_PROFILER ("loading node db")
if (g_file_test (xml_file, G_FILE_TEST_EXISTS) == FALSE)
{
return FALSE;
}
reader = xmlNewTextReaderFilename (xml_file);
if (reader == NULL)
{
return FALSE;
}
was_immutable = db->priv->immutable;
db->priv->immutable = FALSE;
ret = xmlTextReaderRead (reader);
while (ret == 1)
{
const xmlChar *name;
xmlReaderTypes type;
gboolean skip = FALSE;
name = xmlTextReaderConstName (reader);
type = xmlTextReaderNodeType (reader);
if (xmlStrEqual (name, (const xmlChar *)"node")
&& type == XML_READER_TYPE_ELEMENT)
{
xmlNodePtr subtree;
/* grow the subtree and load the node from it */
subtree = xmlTextReaderExpand (reader);
if (subtree != NULL)
{
ephy_node_new_from_xml (db, subtree);
}
skip = TRUE;
}
else if (xmlStrEqual (name, xml_root)
&& type == XML_READER_TYPE_ELEMENT)
{
xmlChar *version;
/* check version info */
version = xmlTextReaderGetAttribute (reader, (const xmlChar *)"version");
if (xmlStrEqual (version, xml_version) == FALSE)
{
success = FALSE;
xmlFree (version);
break;
}
xmlFree (version);
}
/* next one, please */
ret = skip ? xmlTextReaderNext (reader)
: xmlTextReaderRead (reader);
}
xmlFreeTextReader (reader);
db->priv->immutable = was_immutable;
STOP_PROFILER ("loading node db")
return (success && ret == 0);
}
static gboolean
create_definition (ParserState *parser_state,
gchar *id,
gchar *parent_id,
gchar *style,
GSList *context_classes,
GError **error)
{
gchar *match = NULL, *start = NULL, *end = NULL;
gchar *prefix = NULL, *suffix = NULL;
GtkSourceContextFlags flags;
xmlNode *context_node, *child;
GString *all_items = NULL;
GRegexCompileFlags match_flags = 0, start_flags = 0, end_flags = 0;
GError *tmp_error = NULL;
g_assert (parser_state->ctx_data != NULL);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
flags = get_context_flags (parser_state);
DEBUG (g_message ("creating context %s, child of %s", id, parent_id ? parent_id : "(null)"));
/* Fetch the content of the sublements using the tree API on
* the current node */
context_node = xmlTextReaderExpand (parser_state->reader);
/* The file should be validated so this should not happen */
g_assert (context_node != NULL);
for (child = context_node->children; child != NULL; child = child->next)
{
if (child->type != XML_ELEMENT_NODE)
continue;
/* FIXME: add PCRE_EXTRA support in EggRegex
* Huh? */
g_assert (child->name);
if (xmlStrcmp (BAD_CAST "match", child->name) == 0
&& child->children != NULL)
{
/* <match> */
match = g_strdup ((gchar *)child->children->content);
match_flags = get_regex_flags (child, parser_state->regex_compile_flags);
}
else if (xmlStrcmp (BAD_CAST "start", child->name) == 0)
{
/* <start> */
if (child->children != NULL)
{
start = g_strdup ((gchar *)child->children->content);
}
else
{
/* If the <start> element is present but
* has no content use an empty string */
start = g_strdup ("");
}
start_flags = get_regex_flags (child, parser_state->regex_compile_flags);
}
else if (xmlStrcmp (BAD_CAST "end", child->name) == 0)
{
/* <end> */
if (child->children != NULL)
end = g_strdup ((gchar *)child->children->content);
else
{
/* If the <end> element is present but
* has no content use an empty string */
end = g_strdup ("");
}
end_flags = get_regex_flags (child, parser_state->regex_compile_flags);
}
else if (xmlStrcmp (BAD_CAST "prefix", child->name) == 0)
{
/* <prefix> */
if (child->children != NULL)
prefix = g_strdup ((gchar*) child->children->content);
else
prefix = g_strdup ("");
}
else if (xmlStrcmp (BAD_CAST "suffix", child->name) == 0)
{
/* <suffix> */
if (child->children != NULL)
suffix = g_strdup ((gchar*) child->children->content);
else
suffix = g_strdup ("");
}
else if (xmlStrcmp (BAD_CAST "keyword", child->name) == 0 &&
child->children != NULL)
{
/* FIXME: how to specify regex options for keywords?
* They can be specified in prefix, so it's not really
* important, but would be nice (case-sensitive). */
/* <keyword> */
if (all_items == NULL)
{
all_items = g_string_new (NULL);
if (prefix != NULL)
g_string_append (all_items, prefix);
else
g_string_append (all_items,
parser_state->opening_delimiter);
g_string_append (all_items, "(");
g_string_append (all_items, (gchar*) child->children->content);
}
else
{
g_string_append (all_items, "|");
g_string_append (all_items, (gchar*) child->children->content);
}
}
}
if (all_items != NULL)
{
g_string_append (all_items, ")");
if (suffix != NULL)
g_string_append (all_items, suffix);
else
g_string_append (all_items,
parser_state->closing_delimiter);
match = g_string_free (all_items, FALSE);
match_flags = parser_state->regex_compile_flags;
}
DEBUG (g_message ("start: '%s'", start ? start : "(null)"));
DEBUG (g_message ("end: '%s'", end ? end : "(null)"));
DEBUG (g_message ("match: '%s'", match ? match : "(null)"));
if (tmp_error == NULL && start != NULL)
{
gchar *tmp = start;
start = expand_regex (parser_state, start, start_flags,
TRUE, FALSE, &tmp_error);
g_free (tmp);
}
if (tmp_error == NULL && end != NULL)
{
gchar *tmp = end;
end = expand_regex (parser_state, end, end_flags,
TRUE, FALSE, &tmp_error);
g_free (tmp);
}
if (tmp_error == NULL && match != NULL)
{
gchar *tmp = match;
match = expand_regex (parser_state, match, match_flags,
TRUE, FALSE, &tmp_error);
g_free (tmp);
}
if (tmp_error == NULL)
{
_gtk_source_context_data_define_context (parser_state->ctx_data,
id,
parent_id,
match,
start,
end,
style,
context_classes,
flags,
&tmp_error);
}
g_free (match);
g_free (start);
g_free (end);
g_free (prefix);
g_free (suffix);
if (tmp_error != NULL)
{
g_propagate_error (error, tmp_error);
return FALSE;
}
return TRUE;
}
static void marcdump_read_xml(yaz_marc_t mt, const char *fname)
{
WRBUF wrbuf = wrbuf_alloc();
#if USE_XMLREADER
xmlTextReaderPtr reader = xmlReaderForFile(fname, 0 /* encoding */,
0 /* options */);
if (reader)
{
int ret;
while ((ret = xmlTextReaderRead(reader)) == 1)
{
int type = xmlTextReaderNodeType(reader);
if (type == XML_READER_TYPE_ELEMENT)
{
const char *name = (const char *)
xmlTextReaderLocalName(reader);
if (!strcmp(name, "record") || !strcmp(name, "r"))
{
xmlNodePtr ptr = xmlTextReaderExpand(reader);
int r = yaz_marc_read_xml(mt, ptr);
if (r)
{
no_errors++;
fprintf(stderr, "yaz_marc_read_xml failed\n");
}
else
{
int write_rc = yaz_marc_write_mode(mt, wrbuf);
if (write_rc)
{
yaz_log(YLOG_WARN, "yaz_marc_write_mode: "
"write error: %d", write_rc);
no_errors++;
}
fputs(wrbuf_cstr(wrbuf), stdout);
wrbuf_rewind(wrbuf);
}
}
}
}
}
#else
xmlDocPtr doc = xmlParseFile(fname);
if (doc)
{
xmlNodePtr ptr = xmlDocGetRootElement(doc);
for (; ptr; ptr = ptr->next)
{
if (ptr->type == XML_ELEMENT_NODE)
{
if (!strcmp((const char *) ptr->name, "collection"))
{
ptr = ptr->children;
continue;
}
if (!strcmp((const char *) ptr->name, "record") ||
!strcmp((const char *) ptr->name, "r"))
{
int r = yaz_marc_read_xml(mt, ptr);
if (r)
{
no_errors++;
fprintf(stderr, "yaz_marc_read_xml failed\n");
}
else
{
yaz_marc_write_mode(mt, wrbuf);
fputs(wrbuf_cstr(wrbuf), stdout);
wrbuf_rewind(wrbuf);
}
}
}
}
xmlFreeDoc(doc);
}
#endif
fputs(wrbuf_cstr(wrbuf), stdout);
wrbuf_destroy(wrbuf);
}
struct xccdf_tailoring *xccdf_tailoring_parse(xmlTextReaderPtr reader, struct xccdf_item *benchmark)
{
XCCDF_ASSERT_ELEMENT(reader, XCCDFE_TAILORING);
struct xccdf_tailoring *tailoring = xccdf_tailoring_new();
const char *id = xccdf_attribute_get(reader, XCCDFA_ID);
xccdf_tailoring_set_id(tailoring, id);
int depth = oscap_element_depth(reader) + 1;
// Read to the inside of Tailoring.
xmlTextReaderRead(reader);
while (oscap_to_start_element(reader, depth)) {
switch (xccdf_element_get(reader)) {
case XCCDFE_BENCHMARK_REF: {
oscap_free(tailoring->benchmark_ref);
tailoring->benchmark_ref = 0;
oscap_free(tailoring->benchmark_ref_version);
tailoring->benchmark_ref_version = 0;
const char *ref = xccdf_attribute_get(reader, XCCDFA_HREF);
if (ref)
tailoring->benchmark_ref = oscap_strdup(ref);
const char *ref_version = xccdf_attribute_get(reader, XCCDFA_VERSION);
if (ref_version)
tailoring->benchmark_ref_version = oscap_strdup(ref_version);
break;
}
case XCCDFE_STATUS: {
const char *date = xccdf_attribute_get(reader, XCCDFA_DATE);
char *str = oscap_element_string_copy(reader);
struct xccdf_status *status = xccdf_status_new_fill(str, date);
oscap_free(str);
oscap_list_add(tailoring->statuses, status);
break;
}
case XCCDFE_DC_STATUS:
oscap_list_add(tailoring->dc_statuses, oscap_reference_new_parse(reader));
break;
case XCCDFE_VERSION: {
xmlNode *ver = xmlTextReaderExpand(reader);
/* optional attributes */
tailoring->version_time = (char*) xmlGetProp(ver, BAD_CAST "time");
tailoring->version_update = (char*) xmlGetProp(ver, BAD_CAST "update");
/* content */
tailoring->version = (char *) xmlNodeGetContent(ver);
if (oscap_streq(tailoring->version, "")) {
oscap_free(tailoring->version);
tailoring->version = NULL;
}
break;
}
case XCCDFE_METADATA: {
char* xml = oscap_get_xml(reader);
oscap_list_add(tailoring->metadata, oscap_strdup(xml));
oscap_free(xml);
break;
}
case XCCDFE_PROFILE: {
struct xccdf_item *item = xccdf_profile_parse(reader, benchmark);
if (!xccdf_tailoring_add_profile(tailoring, XPROFILE(item))) {
dW("Failed to add profile to tailoring while parsing!");
}
break;
}
default:
dW("Encountered an unknown element '%s' while parsing XCCDF Tailoring element.",
xmlTextReaderConstLocalName(reader));
}
xmlTextReaderRead(reader);
}
return tailoring;
}
