static void
process_bijiben_html_content (BijiLazyDeserializer *self,
xmlTextReaderPtr reader)
{
BijiLazyDeserializerPrivate *priv = self->priv;
int ret;
gchar *sane_html;
sane_html = (gchar*) xmlTextReaderReadInnerXml (reader);
priv->inner = xmlReaderForMemory (sane_html,
strlen(sane_html),
"", "UTF-8", 0);
ret = xmlTextReaderRead (priv->inner);
/* Make the GString grow as we read */
while (ret == 1)
{
process_bijiben_node (self);
ret = xmlTextReaderRead (priv->inner);
}
biji_note_obj_set_raw_text (priv->note, priv->raw_text->str);
biji_note_obj_set_html (priv->note, sane_html);
xmlFree (BAD_CAST sane_html);
}
gchar *
xml_reader_read_inner_xml (XmlReader *reader)
{
g_return_val_if_fail (XML_IS_READER (reader), FALSE);
RETURN_STRDUP_AND_XMLFREE (xmlTextReaderReadInnerXml (reader->xml));
}
/*
xar_process_subdocument - check TOC for xml subdocument. If found, extract and
scan in memory.
Parameters:
reader - xmlTextReaderPtr
ctx - pointer to cli_ctx
Returns:
CL_SUCCESS - subdoc found and clean scan (or virus found and SCAN_ALL), or no subdocument
other - error return code from cli_mem_scandesc()
*/
static int xar_scan_subdocuments(xmlTextReaderPtr reader, cli_ctx *ctx)
{
int rc = CL_SUCCESS, subdoc_len, fd;
xmlChar * subdoc;
const xmlChar *name;
char * tmpname;
while (xmlTextReaderRead(reader) == 1) {
name = xmlTextReaderConstLocalName(reader);
if (name == NULL) {
cli_dbgmsg("cli_scanxar: xmlTextReaderConstLocalName() no name.\n");
rc = CL_EFORMAT;
break;
}
if (xmlStrEqual(name, (const xmlChar *)"toc") &&
xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT)
return CL_SUCCESS;
if (xmlStrEqual(name, (const xmlChar *)"subdoc") &&
xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT) {
subdoc = xmlTextReaderReadInnerXml(reader);
if (subdoc == NULL) {
cli_dbgmsg("cli_scanxar: no content in subdoc element.\n");
xmlTextReaderNext(reader);
continue;
}
subdoc_len = xmlStrlen(subdoc);
cli_dbgmsg("cli_scanxar: in-memory scan of xml subdocument, len %i.\n", subdoc_len);
rc = cli_mem_scandesc(subdoc, subdoc_len, ctx);
if (rc == CL_VIRUS && SCAN_ALL)
rc = CL_SUCCESS;
/* make a file to leave if --leave-temps in effect */
if(ctx->engine->keeptmp) {
if ((rc = cli_gentempfd(ctx->engine->tmpdir, &tmpname, &fd)) != CL_SUCCESS) {
cli_dbgmsg("cli_scanxar: Can't create temporary file for subdocument.\n");
} else {
cli_dbgmsg("cli_scanxar: Writing subdoc to temp file %s.\n", tmpname);
if (cli_writen(fd, subdoc, subdoc_len) < 0) {
cli_dbgmsg("cli_scanxar: cli_writen error writing subdoc temporary file.\n");
rc = CL_EWRITE;
}
rc = xar_cleanup_temp_file(ctx, fd, tmpname);
}
}
xmlFree(subdoc);
if (rc != CL_SUCCESS)
return rc;
xmlTextReaderNext(reader);
}
}
return rc;
}
/* reader:read_inner_xml() */
static int xmlreader_read_inner_xml(lua_State *L) {
xmlreader xr = check_xmlreader(L, 1);
char *str = (char*)xmlTextReaderReadInnerXml(xr);
if (str) {
lua_pushstring(L, str);
xmlFree(str);
return 1;
} else {
lua_pushnil(L);
lua_pushstring(L, ERR_MSG);
return 2;
}
}
/*
* call-seq:
* reader.read_inner_xml -> data
*
* Read the contents of the current node, including child nodes and markup.
*
* Return a string containing the XML content, or nil if the current node is
* neither an element nor attribute, or has no child nodes.
*/
static VALUE rxml_reader_read_inner_xml(VALUE self)
{
VALUE result = Qnil;
xmlTextReaderPtr xReader = rxml_text_reader_get(self);
xmlChar *xml = xmlTextReaderReadInnerXml(xReader);
if (xml)
{
const xmlChar *xencoding = xmlTextReaderConstEncoding(xReader);
result = rxml_new_cstr((const char*) xml, xencoding);
xmlFree(xml);
}
return result;
}
/*
* call-seq:
* inner_xml
*
* Read the contents of the current node, including child nodes and markup.
* Returns a utf-8 encoded string.
*/
static VALUE inner_xml(VALUE self)
{
xmlTextReaderPtr reader;
xmlChar* value;
VALUE str;
Data_Get_Struct(self, xmlTextReader, reader);
value = xmlTextReaderReadInnerXml(reader);
str = Qnil;
if(value) {
str = NOKOGIRI_STR_NEW2((char*)value);
xmlFree(value);
}
return str;
}
static int parse_data(xmlTextReaderPtr reader, int32_t **gidsadr, size_t gidscount) {
char *value, *inner_xml;
if (!(value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"encoding"))) { /* encoding */
tmx_err(E_MISSEL, "xml parser: missing 'encoding' attribute in the 'data' element");
return 0;
}
if (!(inner_xml = (char*)xmlTextReaderReadInnerXml(reader))) {
tmx_err(E_XDATA, "xml parser: missing content in the 'data' element");
tmx_free_func(value);
return 0;
}
if (!strcmp(value, "base64")) {
tmx_free_func(value);
if (!(value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"compression"))) { /* compression */
tmx_err(E_MISSEL, "xml parser: missing 'compression' attribute in the 'data' element");
goto cleanup;
}
if (strcmp(value, "zlib") && strcmp(value, "gzip")) {
tmx_err(E_ENCCMP, "xml parser: unsupported data compression: '%s'", value); /* unsupported compression */
goto cleanup;
}
if (!data_decode(str_trim(inner_xml), B64Z, gidscount, gidsadr)) goto cleanup;
} else if (!strcmp(value, "xml")) {
tmx_err(E_ENCCMP, "xml parser: unimplemented data encoding: XML");
goto cleanup;
} else if (!strcmp(value, "csv")) {
if (!data_decode(str_trim(inner_xml), CSV, gidscount, gidsadr)) goto cleanup;
} else {
tmx_err(E_ENCCMP, "xml parser: unknown data encoding: %s", value);
goto cleanup;
}
tmx_free_func(value);
tmx_free_func(inner_xml);
return 1;
cleanup:
tmx_free_func(value);
tmx_free_func(inner_xml);
return 0;
}
/*
* call-seq:
* reader.read_inner_xml -> data
*
* Read the contents of the current node, including child nodes and markup.
*
* Return a string containing the XML content, or nil if the current node is
* neither an element nor attribute, or has no child nodes.
*/
static VALUE rxml_reader_read_inner_xml(VALUE self)
{
const xmlChar *result = xmlTextReaderReadInnerXml(rxml_text_reader_get(self));
return (result == NULL ? Qnil : rb_str_new2((const char*)result));
}
/* Common XML format for both Bijiben / Tomboy */
static void
processNode (BijiLazyDeserializer *self)
{
xmlTextReaderPtr r = self->priv->r;
BijiNoteObj * n = self->priv->note;
xmlChar *name;
GdkRGBA *color;
gchar *tag;
GString *norm;
gchar *debug;
name = xmlTextReaderName (r);
if ( g_strcmp0((gchar*)name,"title") == 0 )
biji_process_string (r, (BijiReaderFunc*) biji_note_obj_set_title, n);
if ( g_strcmp0((gchar*)name,"text") == 0 )
{
if (self->priv->type == BIJIBEN_1)
{
self->priv->content = (gchar*) xmlTextReaderReadInnerXml (r);
process_bijiben_html_content (self);
}
else if (self->priv->type == TOMBOY_1 ||
self->priv->type == TOMBOY_2 ||
self->priv->type == TOMBOY_3 )
{
self->priv->content = (gchar*) xmlTextReaderReadInnerXml (r);
process_tomboy_xml_content (self);
}
}
if (g_strcmp0 ((gchar*) name, "last-change-date") == 0)
biji_process_string (r, (BijiReaderFunc*) biji_note_obj_set_last_change_date, n);
if (g_strcmp0 ((gchar*) name, "last-metadata-change-date") == 0)
biji_process_string (r, (BijiReaderFunc*) biji_note_obj_set_last_metadata_change_date, n);
if (g_strcmp0 ((gchar*) name, "create-date") == 0)
biji_process_string (r, (BijiReaderFunc*) biji_note_obj_set_create_date, n);
if (g_strcmp0 ((gchar*) name, "color") == 0 )
{
color = g_new (GdkRGBA,1);
debug = (gchar*) xmlTextReaderReadString (r);
if ( gdk_rgba_parse (color,debug))
{
biji_note_obj_set_rgba (n, color);
}
else
{
g_warning ("color invalid:%s",debug);
}
free (debug);
}
if ( g_strcmp0((gchar*)name,"tag") == 0 )
{
tag = (gchar*) xmlTextReaderReadString(r);
if (g_str_has_prefix (tag,"system:template"))
{
note_obj_set_is_template(n,TRUE);
}
else if (g_str_has_prefix (tag,"system:notebook:"))
{
norm = g_string_new (tag);
g_string_erase (norm,0,16);
_biji_note_obj_set_tags (n, g_list_prepend((GList*)_biji_note_obj_get_tags(n),
g_string_free (norm,FALSE)));
}
free (tag);
}
xmlFree(name);
}
int cli_scanxdp(cli_ctx *ctx)
{
#if HAVE_LIBXML2
xmlTextReaderPtr reader = NULL;
fmap_t *map = *(ctx->fmap);
const char *buf;
const xmlChar *name, *value;
char *decoded;
size_t decodedlen;
int rc = CL_SUCCESS;
char *dumpname;
size_t i;
buf = (const char *)fmap_need_off_once(map, map->offset, map->len);
if (!(buf))
return CL_EREAD;
if (ctx->engine->keeptmp) {
dumpname = dump_xdp(ctx, buf, map->len);
if (dumpname)
free(dumpname);
}
/*
* Since a PDF file can contain embedded XDP documents,
* it's possible that the filetyping code matched an embedded XDP document.
* If that's the case, then xmlReaderForMemory will throw an error. For now,
* silently ignore the error and return CL_SUCCESS so the filetyping code can
* continue on.
*/
reader = xmlReaderForMemory(buf, (int)(map->len), "noname.xml", NULL, CLAMAV_MIN_XMLREADER_FLAGS);
if (!(reader))
return CL_SUCCESS;
while (xmlTextReaderRead(reader) == 1) {
name = xmlTextReaderConstLocalName(reader);
if (!(name))
continue;
if (!strcmp((const char *)name, "chunk") && xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT) {
value = xmlTextReaderReadInnerXml(reader);
if (value) {
decoded = cl_base64_decode((char *)value, strlen((const char *)value), NULL, &decodedlen, 0);
if (decoded) {
unsigned int shouldscan=0;
if (decodedlen > 5) {
for (i=0; i < MIN(MAGIC_BUFFER_SIZE, decodedlen-5); i++) {
if (decoded[i] != '%')
continue;
if (decoded[i+1] == 'P' || decoded[i+1] == 'p') {
if (decoded[i+2] == 'D' || decoded[i+2] == 'd') {
if (decoded[i+3] == 'F' || decoded[i+3] == 'f') {
if (decoded[i+4] == '-') {
shouldscan=1;
break;
}
}
}
}
}
}
if (!shouldscan) {
free(decoded);
xmlFree((void *)value);
break;
}
rc = cli_mem_scandesc(decoded, decodedlen, ctx);
free(decoded);
if (rc != CL_SUCCESS || rc == CL_BREAK) {
xmlFree((void *)value);
break;
}
}
xmlFree((void *)value);
}
}
}
xmlFreeTextReader(reader);
return rc;
#else
return CL_SUCCESS;
#endif
}
char *oscap_get_xml(xmlTextReaderPtr reader)
{
return (char *)xmlTextReaderReadInnerXml(reader);
}
/* Common XML format for both Bijiben / Tomboy */
static void
processNode (BijiLazyDeserializer *self)
{
xmlTextReaderPtr r = self->priv->r;
BijiNoteObj * n = self->priv->note;
xmlChar *name;
GdkRGBA color;
gchar *tag, *color_str;
GString *norm;
name = xmlTextReaderName (r);
if ( g_strcmp0((gchar*)name,"title") == 0 )
biji_process_string (r, (BijiReaderFunc*) biji_note_obj_set_title, n);
if ( g_strcmp0((gchar*)name,"text") == 0 )
{
if (self->priv->type == BIJIBEN_1)
{
process_bijiben_html_content (self, r);
}
else if (self->priv->type == TOMBOY_1 ||
self->priv->type == TOMBOY_2 ||
self->priv->type == TOMBOY_3 )
{
self->priv->content = (gchar*) xmlTextReaderReadInnerXml (r);
process_tomboy_xml_content (self);
}
}
if (g_strcmp0 ((gchar*) name, "last-change-date") == 0)
{
gchar *result = (gchar*) xmlTextReaderReadString (r);
biji_note_obj_set_mtime (n, iso8601_to_gint64 (result));
free (result);
}
if (g_strcmp0 ((gchar*) name, "last-metadata-change-date") == 0)
{
gchar *result = (gchar*) xmlTextReaderReadString (r);
biji_note_obj_set_last_metadata_change_date (n, iso8601_to_gint64 (result));
free (result);
}
if (g_strcmp0 ((gchar*) name, "create-date") == 0)
{
gchar *result = (gchar*) xmlTextReaderReadString (r);
biji_note_obj_set_create_date (n, iso8601_to_gint64 (result));
free (result);
}
if (g_strcmp0 ((gchar*) name, "color") == 0 )
{
color_str = (gchar*) xmlTextReaderReadString (r);
if (gdk_rgba_parse (&color, color_str))
biji_note_obj_set_rgba (n, &color);
else
g_warning ("color invalid:%s", color_str);
free (color_str);
}
if ( g_strcmp0((gchar*)name,"tag") == 0 )
{
tag = (gchar*) xmlTextReaderReadString(r);
if (g_str_has_prefix (tag,"system:template"))
{
note_obj_set_is_template(n,TRUE);
}
else if (g_str_has_prefix (tag,"system:notebook:"))
{
norm = g_string_new (tag);
g_string_erase (norm,0,16);
biji_item_add_notebook (BIJI_ITEM (n), NULL, norm->str);
g_string_free (norm, TRUE);
}
free (tag);
}
xmlFree(name);
}
bool xccdf_benchmark_parse(struct xccdf_item * benchmark, xmlTextReaderPtr reader)
{
XCCDF_ASSERT_ELEMENT(reader, XCCDFE_BENCHMARK);
assert(benchmark != NULL);
if (benchmark->type != XCCDF_BENCHMARK)
return false;
xccdf_benchmark_set_schema_version(XBENCHMARK(benchmark), xccdf_detect_version_parser(reader));
if (!xccdf_item_process_attributes(benchmark, reader)) {
xccdf_benchmark_free(XBENCHMARK(benchmark));
return false;
}
benchmark->sub.benchmark.style = xccdf_attribute_copy(reader, XCCDFA_STYLE);
benchmark->sub.benchmark.style_href = xccdf_attribute_copy(reader, XCCDFA_STYLE_HREF);
benchmark->sub.benchmark.lang = (char *) xmlTextReaderXmlLang(reader);
if (xccdf_attribute_has(reader, XCCDFA_RESOLVED))
benchmark->item.flags.resolved = xccdf_attribute_get_bool(reader, XCCDFA_RESOLVED);
int depth = oscap_element_depth(reader) + 1;
while (oscap_to_start_element(reader, depth)) {
struct xccdf_model *parsed_model;
switch (xccdf_element_get(reader)) {
case XCCDFE_NOTICE:
oscap_list_add(benchmark->sub.benchmark.notices, xccdf_notice_new_parse(reader));
break;
case XCCDFE_FRONT_MATTER:
oscap_list_add(benchmark->sub.benchmark.front_matter, oscap_text_new_parse(XCCDF_TEXT_HTMLSUB, reader));
break;
case XCCDFE_REAR_MATTER:
oscap_list_add(benchmark->sub.benchmark.rear_matter, oscap_text_new_parse(XCCDF_TEXT_HTMLSUB, reader));
break;
case XCCDFE_PLATFORM:
oscap_list_add(benchmark->item.platforms, xccdf_attribute_copy(reader, XCCDFA_IDREF));
break;
case XCCDFE_MODEL:
parsed_model = xccdf_model_new_xml(reader);
// we won't add the implied default scoring model, it is already in the benchmark
if (strcmp(xccdf_model_get_system(parsed_model), "urn:xccdf:scoring:default") != 0)
assume_ex(xccdf_benchmark_add_model(XBENCHMARK(benchmark), parsed_model), false);
else
xccdf_model_free(parsed_model);
break;
case XCCDFE_PLAIN_TEXT:{
const char *id = xccdf_attribute_get(reader, XCCDFA_ID);
char *data = (char *)xmlTextReaderReadInnerXml(reader);
if (id)
oscap_list_add(benchmark->sub.benchmark.plain_texts,
xccdf_plain_text_new_fill(id,
data == NULL ? "" : data));
xmlFree(data);
break;
}
case XCCDFE_CPE_LIST:{
struct cpe_parser_ctx *ctx = cpe_parser_ctx_from_reader(reader);
xccdf_benchmark_set_cpe_list(XBENCHMARK(benchmark), cpe_dict_model_parse(ctx));
cpe_parser_ctx_free(ctx);
break;
}
case XCCDFE_CPE2_PLATFORMSPEC:
xccdf_benchmark_set_cpe_lang_model(XBENCHMARK(benchmark), cpe_lang_model_parse(reader));
break;
case XCCDFE_PROFILE:
oscap_list_add(benchmark->sub.benchmark.profiles, xccdf_profile_parse(reader, benchmark));
break;
case XCCDFE_GROUP:
case XCCDFE_RULE:
xccdf_content_parse(reader, benchmark);
break;
case XCCDFE_VALUE:
oscap_list_add(benchmark->sub.benchmark.values, xccdf_value_parse(reader, benchmark));
break;
case XCCDFE_TESTRESULT:
assume_ex(xccdf_benchmark_add_result(XBENCHMARK(benchmark), xccdf_result_new_parse(reader)), false);
break;
default:
if (!xccdf_item_process_element(benchmark, reader))
dW("Encountered an unknown element '%s' while parsing XCCDF benchmark.",
xmlTextReaderConstLocalName(reader));
}
xmlTextReaderRead(reader);
}
return true;
}
CInterfaceDefinition *CInterfaceDefinitionLoader::load( const unsigned char &buffer, unsigned int buffer_size )
{
assert( !m_interface_definition && !m_reader && m_element_path.empty() );
m_interface_definition = new CInterfaceDefinition;
xmlInitParser();
m_reader = xmlReaderForMemory( (char *) &buffer, buffer_size, NULL, NULL, 0 );
if( !m_reader )
{
INTEGRA_TRACE_ERROR << "unable to read file";
cleanup();
return NULL;
}
int depth = -1;
bool handled_element_content = false;
char *inner_xml = NULL;
while( xmlTextReaderRead( m_reader ) )
{
switch( xmlTextReaderNodeType( m_reader ) )
{
case XML_READER_TYPE_TEXT:
{
char *element_value = ( char * ) xmlTextReaderValue( m_reader );
if( handle_element_value( element_value ) != CError::SUCCESS )
{
xmlFree( element_value );
cleanup();
return NULL;
}
xmlFree( element_value );
handled_element_content = true;
store_map_entries();
}
break;
case XML_READER_TYPE_ELEMENT:
{
const char *element_name = ( const char * ) xmlTextReaderConstName( m_reader );
int new_depth = xmlTextReaderDepth( m_reader );
while( depth >= new_depth )
{
pop_element_name();
depth--;
}
if( depth < new_depth )
{
push_element_name( element_name );
depth++;
}
assert( depth == new_depth );
if( handle_element() != CError::SUCCESS )
{
cleanup();
return NULL;
}
if( xmlTextReaderHasAttributes( m_reader ) )
{
if( handle_element_attributes() != CError::SUCCESS )
{
cleanup();
return NULL;
}
}
if( xmlTextReaderIsEmptyElement( m_reader ) )
{
handle_element_value( "" );
handled_element_content = true;
}
else
{
handled_element_content = false;
inner_xml = ( char * ) xmlTextReaderReadInnerXml( m_reader );
}
}
break;
case XML_READER_TYPE_END_ELEMENT:
if( !handled_element_content && inner_xml )
{
handle_element_value( inner_xml );
}
if( inner_xml )
{
xmlFree( inner_xml );
inner_xml = NULL;
}
handled_element_content = true;
break;
default:
break;
}
}
CError CError = do_sanity_check();
if( CError != CError::SUCCESS )
{
INTEGRA_TRACE_ERROR << "sanity check failed";
cleanup();
return NULL;
}
m_interface_definition->propagate_defaults();
INTEGRA_TRACE_VERBOSE << "Loaded ok: " << m_interface_definition->get_interface_info().get_name();
CInterfaceDefinition *loaded_interface = m_interface_definition;
m_interface_definition = NULL;
cleanup();
return loaded_interface;
}