static struct cpe_ext_deprecatedby *cpe_ext_deprecatedby_parse(xmlTextReaderPtr reader)
{
__attribute__nonnull__(reader);
if (xmlStrcmp(xmlTextReaderConstLocalName(reader), BAD_CAST TAG_CPE_EXT_DEPRECATEDBY_STR) != 0 ||
xmlTextReaderNodeType(reader) != 1) {
oscap_seterr(OSCAP_EFAMILY_OSCAP, "Found '%s' node when expecting: '%s'!",
xmlTextReaderConstLocalName(reader), TAG_CPE_EXT_DEPRECATEDBY_STR);
}
const xmlChar* nsuri = xmlTextReaderConstNamespaceUri(reader);
if (nsuri && xmlStrcmp(nsuri, BAD_CAST XMLNS_CPE2D3_EXTENSION) != 0) {
oscap_seterr(OSCAP_EFAMILY_OSCAP, "Found '%s' namespace when expecting: '%s'!",
nsuri, XMLNS_CPE2D3_EXTENSION);
return NULL;
}
struct cpe_ext_deprecatedby *deprecatedby = cpe_ext_deprecatedby_new();
deprecatedby->name = (char *) xmlTextReaderGetAttribute(reader, BAD_CAST ATTR_NAME_STR);
const char *type = (const char *) xmlTextReaderGetAttribute(reader, BAD_CAST ATTR_TYPE_STR);
if (type == NULL) {
oscap_seterr(OSCAP_EFAMILY_OSCAP, "Compulsory attribute '%s' missing at '%s' element.",
ATTR_TYPE_STR, TAG_CPE_EXT_DEPRECATEDBY_STR);
cpe_ext_deprecatedby_free(deprecatedby);
return NULL;
}
deprecatedby->type = oscap_string_to_enum(CPE_EXT_DEPRECATION_MAP, type);
return deprecatedby;
}
struct cvss_metrics *cvss_metrics_new_from_xml(xmlTextReaderPtr reader)
{
assert(reader != NULL);
int depth = oscap_element_depth(reader);
enum cvss_category cat = CVSS_NONE;
const char *elname = (const char *) xmlTextReaderConstLocalName(reader);
if (oscap_streq(elname, "base_metrics")) cat = CVSS_BASE;
if (oscap_streq(elname, "temporal_metrics")) cat = CVSS_TEMPORAL;
if (oscap_streq(elname, "environmental_metrics")) cat = CVSS_ENVIRONMENTAL;
if (cat == CVSS_NONE) return NULL;
struct cvss_metrics *ret = cvss_metrics_new(cat);
ret->upgraded_from_version = (char*) xmlTextReaderGetAttribute(reader, BAD_CAST "upgraded-from-version");
xmlTextReaderRead(reader);
while (oscap_to_start_element(reader, depth + 1)) {
elname = (const char *) xmlTextReaderConstLocalName(reader);
if (oscap_streq(elname, "score")) ret->score = atof(oscap_element_string_get(reader));
else if (oscap_streq(elname, "source")) cvss_metrics_set_source(ret, oscap_element_string_get(reader));
else if (oscap_streq(elname, "generated-on-datetime")) cvss_metrics_set_generated_on_datetime(ret, oscap_element_string_get(reader));
else {
const struct cvss_valtab_entry *val = cvss_valtab(cvss_keytab(0, elname)->key, 0, NULL, oscap_element_string_get(reader));
if (CVSS_CATEGORY(val->key) == cat) ret->metrics.ANY[CVSS_KEY_IDX(val->key)] = val->value;
}
xmlTextReaderRead(reader);
}
return ret;
}
struct cpe_lang_model *cpe_lang_model_parse(xmlTextReaderPtr reader)
{
struct cpe_lang_model *ret = NULL;
struct cpe_platform *platform = NULL;
__attribute__nonnull__(reader);
if (!xmlStrcmp(xmlTextReaderConstLocalName(reader), TAG_PLATFORM_SPEC_STR) &&
xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT) {
ret = cpe_lang_model_new();
if (ret == NULL)
return NULL;
// skip nodes until new element
xmlTextReaderNextElementWE(reader, TAG_PLATFORM_SPEC_STR);
while (xmlStrcmp(xmlTextReaderConstLocalName(reader), TAG_PLATFORM_STR) == 0) {
platform = cpe_platform_parse(reader);
if (platform)
cpe_lang_model_add_platform(ret, platform);
xmlTextReaderNextElementWE(reader, TAG_PLATFORM_SPEC_STR);
}
}
return ret;
}
/**
* Reads a Nodes from XML. The reader is assumed to be at the start element.
*
* @return the Nodes, or NULL in case of error.
*/
static struct full_ns0_nodes *xmlTextReaderReadNs0NodesType(xmlTextReaderPtr reader) {
int status, depth;
void *_child_accessor;
struct full_ns0_nodes *_nodes = calloc(1, sizeof(struct full_ns0_nodes));
if (xmlTextReaderIsEmptyElement(reader) == 0) {
depth = xmlTextReaderDepth(reader);//track the depth.
status = xmlTextReaderAdvanceToNextStartOrEndElement(reader);
while (xmlTextReaderDepth(reader) > depth) {
if (status < 1) {
//panic: XML read error.
#if DEBUG_ENUNCIATE
printf("Failure to advance to next child element.\n");
#endif
freeNs0NodesType(_nodes);
free(_nodes);
return NULL;
}
else if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT
&& xmlStrcmp(BAD_CAST "node", xmlTextReaderConstLocalName(reader)) == 0
&& xmlTextReaderConstNamespaceUri(reader) == NULL) {
#if DEBUG_ENUNCIATE > 1
printf("Attempting to read choice {}node of type {}node.\n");
#endif
_child_accessor = xmlTextReaderReadNs0NodeType(reader);
if (_child_accessor == NULL) {
#if DEBUG_ENUNCIATE
printf("Failed to read choice {}node of type {}node.\n");
#endif
//panic: unable to read the child element for some reason.
freeNs0NodesType(_nodes);
free(_nodes);
return NULL;
}
_nodes->node = realloc(_nodes->node, (_nodes->_sizeof_node + 1) * sizeof(struct full_ns0_node));
memcpy(&(_nodes->node[_nodes->_sizeof_node++]), _child_accessor, sizeof(struct full_ns0_node));
free(_child_accessor);
status = xmlTextReaderAdvanceToNextStartOrEndElement(reader);
}
else {
#if DEBUG_ENUNCIATE > 1
if (xmlTextReaderConstNamespaceUri(reader) == NULL) {
printf("unknown child element {}%s for type {}nodes. Skipping...\n", xmlTextReaderConstLocalName(reader));
}
else {
printf("unknown child element {%s}%s for type {}nodes. Skipping...\n", xmlTextReaderConstNamespaceUri(reader), xmlTextReaderConstLocalName(reader));
}
#endif
status = xmlTextReaderSkipElement(reader);
}
}
}
return _nodes;
}
static response_element_t *
parse_propfind_response (xmlTextReaderPtr reader)
{
parser_strings_t strings;
response_element_t *elements;
/* get internalized versions of some strings to avoid strcmp while
* parsing */
strings.multistatus
= xmlTextReaderConstString (reader, BAD_CAST "multistatus");
strings.dav = xmlTextReaderConstString (reader, BAD_CAST "DAV:");
strings.href = xmlTextReaderConstString (reader, BAD_CAST "href");
strings.response = xmlTextReaderConstString (reader, BAD_CAST "response");
strings.propstat = xmlTextReaderConstString (reader, BAD_CAST "propstat");
strings.prop = xmlTextReaderConstString (reader, BAD_CAST "prop");
strings.getetag = xmlTextReaderConstString (reader, BAD_CAST "getetag");
while (xmlTextReaderRead (reader) == 1 && xmlTextReaderNodeType (reader) != XML_READER_TYPE_ELEMENT) {
}
if (xmlTextReaderConstLocalName (reader) != strings.multistatus
|| xmlTextReaderConstNamespaceUri (reader) != strings.dav) {
g_warning ("webdav PROPFIND result is not <DAV:multistatus>");
return NULL;
}
elements = NULL;
/* parse all DAV:response tags */
while (xmlTextReaderRead (reader) == 1 && xmlTextReaderDepth (reader) > 0) {
response_element_t *element;
if (xmlTextReaderNodeType (reader) != XML_READER_TYPE_ELEMENT)
continue;
if (xmlTextReaderConstLocalName (reader) != strings.response
|| xmlTextReaderConstNamespaceUri (reader) != strings.dav)
continue;
element = parse_response_tag (&strings, reader);
if (element == NULL)
continue;
element->next = elements;
elements = element;
}
return elements;
}
G_CONST_RETURN gchar *
xml_reader_get_local_name (XmlReader *reader)
{
g_return_val_if_fail(XML_IS_READER (reader), NULL);
return XML_TO_CHAR (xmlTextReaderConstLocalName (reader->xml));
}
bool HHVM_METHOD(XMLReader, next,
const Variant& localname /*= null_variant*/) {
auto* data = Native::data<XMLReader>(this_);
const String& str_localname = localname.isNull()
? null_string
: localname.toString();
SYNC_VM_REGS_SCOPED();
if (data->m_ptr) {
int ret = xmlTextReaderNext(data->m_ptr);
while (!str_localname.empty() && ret == 1) {
if (xmlStrEqual(xmlTextReaderConstLocalName(data->m_ptr),
(xmlChar *)str_localname.data())) {
return true;
}
ret = xmlTextReaderNext(data->m_ptr);
}
if (ret == -1) {
raise_warning("An Error Occurred while reading");
return false;
} else {
return ret;
}
}
raise_warning("Load Data before trying to read");
return false;
}
static char *parse_text_element(xmlTextReaderPtr reader, char *name)
{
char *string = NULL;
__attribute__nonnull__(reader);
__attribute__nonnull__(name);
// parse string element attributes here (like xml:lang)
while (xmlTextReaderNextNode(reader)) {
if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT &&
!xmlStrcmp(xmlTextReaderConstLocalName(reader), BAD_CAST name)) {
return string;
}
switch (xmlTextReaderNodeType(reader)) {
case XML_READER_TYPE_TEXT:
string = (char *)xmlTextReaderValue(reader);
break;
default:
oscap_seterr(OSCAP_EFAMILY_OSCAP, "Unknown XML element in platform");
break;
}
}
return string;
}
/* {{{ proto bool XMLReader::next([string localname])
Moves the position of the current instance to the next node in the stream. */
PHP_METHOD(xmlreader, next)
{
zval *id;
int retval;
size_t name_len=0;
xmlreader_object *intern;
char *name = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "|s", &name, &name_len) == FAILURE) {
return;
}
id = ZEND_THIS;
intern = Z_XMLREADER_P(id);
if (intern != NULL && intern->ptr != NULL) {
retval = xmlTextReaderNext(intern->ptr);
while (name != NULL && retval == 1) {
if (xmlStrEqual(xmlTextReaderConstLocalName(intern->ptr), (xmlChar *)name)) {
RETURN_TRUE;
}
retval = xmlTextReaderNext(intern->ptr);
}
if (retval == -1) {
RETURN_FALSE;
} else {
RETURN_BOOL(retval);
}
}
php_error_docref(NULL, E_WARNING, "Load Data before trying to read");
RETURN_FALSE;
}
bool XMLReader::processNode()
{
if (m_reader == NULL)
{
std::cout << "error" << std::endl ;
}
if (xmlTextReaderRead(m_reader) != 1)
{
return false ;
}
m_attributes.clear() ;
if (xmlTextReaderHasAttributes(m_reader) == 1)
{
int count = xmlTextReaderAttributeCount(m_reader) ;
for (int i = 0 ; i < count ; i++)
{
xmlTextReaderMoveToAttributeNo(m_reader, i) ;
m_attributes.insert(
std::pair<std::string, std::string>(
(char*) xmlTextReaderConstLocalName(
m_reader),
(char*) xmlTextReaderConstValue(
m_reader))) ;
}
xmlTextReaderMoveToElement(m_reader) ;
}
// std::cout << print() << std::endl ;
return true ;
}
/*
* call-seq:
* reader.local_name -> name
*
* Return the local name of the node.
*/
static VALUE rxml_reader_local_name(VALUE self)
{
xmlTextReaderPtr xReader = rxml_text_reader_get(self);
const xmlChar *result = xmlTextReaderConstLocalName(xReader);
const xmlChar *xencoding = xmlTextReaderConstEncoding(xReader);
return (result == NULL ? Qnil : rxml_new_cstr(result, xencoding));
}
struct cpe_platform *cpe_platform_parse(xmlTextReaderPtr reader)
{
struct cpe_platform *ret;
__attribute__nonnull__(reader);
// allocate platform structure here
ret = cpe_platform_new();
if (ret == NULL)
return NULL;
// parse platform attributes here
ret->id = (char *)xmlTextReaderGetAttribute(reader, ATTR_ID_STR);
if (ret->id == NULL) {
cpe_platform_free(ret);
return NULL; // if there is no "id" in platform element, return NULL
}
// skip from <platform> node to next one
xmlTextReaderNextNode(reader);
// while we have element that is not "platform", it is inside this element, otherwise it's ended
// element </platform> and we should end. If there is no one from "if" statement cases, we are parsing
// attribute or text ,.. and we can continue to next node.
while (xmlStrcmp(xmlTextReaderConstLocalName(reader), TAG_PLATFORM_STR) != 0) {
if (!xmlStrcmp(xmlTextReaderConstLocalName(reader), ATTR_TITLE_STR) &&
xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT) {
oscap_list_add(ret->titles, oscap_text_new_parse(OSCAP_TEXT_TRAITS_PLAIN, reader));
} else
if (!xmlStrcmp(xmlTextReaderConstLocalName(reader), TAG_REMARK_STR) &&
xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT) {
ret->remark = parse_text_element(reader, (char *)TAG_REMARK_STR); // TODO: 0-n remarks !
} else
if (!xmlStrcmp(xmlTextReaderConstLocalName(reader), TAG_LOGICAL_TEST_STR) &&
xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT) {
/* Maybe we shall not allocate this in constructor? */
cpe_testexpr_free(ret->expr);
ret->expr = cpe_testexpr_parse(reader);
} else if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT)
oscap_seterr(OSCAP_EFAMILY_OSCAP, "Unknown XML element in platform");
// get the next node
xmlTextReaderNextNode(reader);
}
return ret;
}
struct rds_asset_index *rds_asset_index_parse(xmlTextReaderPtr reader)
{
// sanity check
if (xmlTextReaderNodeType(reader) != XML_READER_TYPE_ELEMENT ||
strcmp((const char*)xmlTextReaderConstLocalName(reader), "asset") != 0) {
oscap_seterr(OSCAP_EFAMILY_XML,
"Expected to have xmlTextReader at start of <arf:report>, "
"the current event is '%i' at '%s' instead. I refuse to parse!",
xmlTextReaderNodeType(reader), (const char*)xmlTextReaderConstLocalName(reader));
return NULL;
}
struct rds_asset_index *ret = rds_asset_index_new();
ret->id = (char*)xmlTextReaderGetAttribute(reader, BAD_CAST "id");
return ret;
}
EPUB3Error EPUB3ProcessXMLReaderNodeForManifestInOPF(EPUB3Ref epub, xmlTextReaderPtr reader, EPUB3XMLParseContextPtr *context)
{
assert(epub != NULL);
assert(reader != NULL);
EPUB3Error error = kEPUB3Success;
const xmlChar *name = xmlTextReaderConstLocalName(reader);
xmlReaderTypes nodeType = xmlTextReaderNodeType(reader);
switch(nodeType)
{
case XML_READER_TYPE_ELEMENT:
{
if(!xmlTextReaderIsEmptyElement(reader)) {
(void)EPUB3SaveParseContext(context, kEPUB3OPFStateManifest, name, 0, NULL, kEPUB3_YES, NULL);
} else {
if(xmlStrcmp(name, BAD_CAST "item") == 0) {
EPUB3ManifestItemRef newItem = EPUB3ManifestItemCreate();
newItem->itemId = (char *)xmlTextReaderGetAttribute(reader, BAD_CAST "id");
newItem->href = (char *)xmlTextReaderGetAttribute(reader, BAD_CAST "href");
newItem->mediaType = (char *)xmlTextReaderGetAttribute(reader, BAD_CAST "media-type");
newItem->properties = (char *)xmlTextReaderGetAttribute(reader, BAD_CAST "properties");
if(newItem->properties != NULL) {
// Look for the cover-image property
char *prop, *props, *tofree;
tofree = props = strdup(newItem->properties);
while((prop = strsep(&props, " ")) != NULL) {
if(strcmp(prop, "cover-image") == 0) {
EPUB3MetadataSetCoverImageId(epub->metadata, newItem->itemId);
}
}
EPUB3_FREE_AND_NULL(tofree);
}
if(newItem->mediaType != NULL && strcmp(newItem->mediaType, "application/x-dtbncx+xml") == 0) {
//This is the ref for the ncx document. Set it for v2 epubs
//if(epub->metadata->version == kEPUB3Version_2) {
EPUB3MetadataSetNCXItem(epub->metadata, newItem);
//}
}
EPUB3ManifestInsertItem(epub->manifest, newItem);
}
}
break;
}
case XML_READER_TYPE_TEXT:
{
break;
}
case XML_READER_TYPE_END_ELEMENT:
{
(void)EPUB3PopAndFreeParseContext(context);
break;
}
default: break;
}
return error;
}
static struct cpe_ext_deprecation *cpe_ext_deprecation_parse(xmlTextReaderPtr reader)
{
__attribute__nonnull__(reader);
if (xmlStrcmp(xmlTextReaderConstLocalName(reader), BAD_CAST TAG_CPE_EXT_DEPRECATION_STR) != 0 ||
xmlTextReaderNodeType(reader) != 1) {
oscap_seterr(OSCAP_EFAMILY_OSCAP, "Found '%s' node when expecting: '%s'!",
xmlTextReaderConstLocalName(reader), TAG_CPE_EXT_DEPRECATION_STR);
}
const xmlChar* nsuri = xmlTextReaderConstNamespaceUri(reader);
if (nsuri && xmlStrcmp(nsuri, BAD_CAST XMLNS_CPE2D3_EXTENSION) != 0) {
oscap_seterr(OSCAP_EFAMILY_OSCAP, "Found '%s' namespace when expecting: '%s'!",
nsuri, XMLNS_CPE2D3_EXTENSION);
return NULL;
}
struct cpe_ext_deprecation *deprecation = cpe_ext_deprecation_new();
deprecation->date = (char *) xmlTextReaderGetAttribute(reader, BAD_CAST ATTR_DATE_STR);
if (xmlTextReaderIsEmptyElement(reader) == 0) { // the element contains child nodes
xmlTextReaderNextNode(reader);
while (xmlStrcmp(xmlTextReaderConstLocalName(reader), BAD_CAST TAG_CPE_EXT_DEPRECATION_STR) != 0) {
if (xmlTextReaderNodeType(reader) != XML_READER_TYPE_ELEMENT) {
xmlTextReaderNextNode(reader);
continue;
}
if (xmlStrcmp(xmlTextReaderConstLocalName(reader), BAD_CAST TAG_CPE_EXT_DEPRECATEDBY_STR) == 0) {
struct cpe_ext_deprecatedby *deprecatedby = cpe_ext_deprecatedby_parse(reader);
if (deprecatedby == NULL) {
cpe_ext_deprecation_free(deprecation);
return NULL;
}
oscap_list_add(deprecation->deprecatedbys, deprecatedby);
}
else {
oscap_seterr(OSCAP_EFAMILY_OSCAP, "Unexpected element within deprecation element: '%s'",
xmlTextReaderConstLocalName(reader));
cpe_ext_deprecation_free(deprecation);
return NULL;
}
xmlTextReaderNextNode(reader);
}
}
return deprecation;
}
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()
EXPORT EPUB3Error EPUB3CopyRootFilePathFromContainer(EPUB3Ref epub, char ** rootPath)
{
assert(epub != NULL);
if(epub->archive == NULL) return kEPUB3ArchiveUnavailableError;
static const char *containerFilename = "META-INF/container.xml";
void *buffer = NULL;
uint32_t bufferSize = 0;
uint32_t bytesCopied;
xmlTextReaderPtr reader = NULL;
EPUB3Bool foundPath = kEPUB3_NO;
EPUB3Error error = kEPUB3Success;
error = EPUB3CopyFileIntoBuffer(epub, &buffer, &bufferSize, &bytesCopied, containerFilename);
if(error == kEPUB3Success) {
reader = xmlReaderForMemory(buffer, bufferSize, "", NULL, XML_PARSE_RECOVER);
if(reader != NULL) {
int retVal;
while((retVal = xmlTextReaderRead(reader)) == 1)
{
const char *rootFileName = "rootfile";
const xmlChar *name = xmlTextReaderConstLocalName(reader);
if(xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT && xmlStrcmp(name, BAD_CAST rootFileName) == 0) {
xmlChar *fullPath = xmlTextReaderGetAttribute(reader, BAD_CAST "full-path");
if(fullPath != NULL) {
// TODD: validate that the full-path attribute is of the form path-rootless
// see http://idpf.org/epub/30/spec/epub30-ocf.html#sec-container-metainf-container.xml
foundPath = kEPUB3_YES;
*rootPath = strdup((char *)fullPath);
} else {
// The spec requires the full-path attribute
error = kEPUB3XMLXDocumentInvalidError;
}
break;
}
}
if(retVal < 0) {
error = kEPUB3XMLParseError;
}
if(!foundPath) {
error = kEPUB3XMLXElementNotFoundError;
}
} else {
error = kEPUB3XMLReadFromBufferError;
}
EPUB3_FREE_AND_NULL(buffer);
}
xmlFreeTextReader(reader);
return error;
}
/*
* call-seq:
* local_name
*
* Get the local name of the node
*/
static VALUE local_name(VALUE self)
{
xmlTextReaderPtr reader;
Data_Get_Struct(self, xmlTextReader, reader);
const char * name = (const char *)xmlTextReaderConstLocalName(reader);
if(name == NULL) return Qnil;
VALUE MAYBE_UNUSED(enc) = rb_iv_get(self, "@encoding");
return NOKOGIRI_STR_NEW2(name,
RTEST(enc) ? StringValuePtr(enc) : NULL);
}
/*
* call-seq:
* local_name
*
* Get the local name of the node
*/
static VALUE local_name(VALUE self)
{
xmlTextReaderPtr reader;
const char *name;
Data_Get_Struct(self, xmlTextReader, reader);
name = (const char *)xmlTextReaderConstLocalName(reader);
if(name == NULL) return Qnil;
return NOKOGIRI_STR_NEW2(name);
}
/*
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;
}
static const xmlChar * openioc_read(xmlTextReaderPtr reader)
{
const xmlChar * name;
if (xmlTextReaderRead(reader) != 1)
return NULL;
name = xmlTextReaderConstLocalName(reader);
if (name != NULL) {
cli_dbgmsg("openioc_parse: xmlTextReaderRead read %s%s\n", name,
xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT?" end tag":"");
}
return name;
}
/*
* Parse the configuration file and initialize ows struct
*/
static void ows_parse_config_xml(ows * o, const char *filename)
{
xmlTextReaderPtr r;
const xmlChar *name;
int ret;
assert(o);
assert(filename);
r = xmlReaderForFile(filename, "UTF-8", 0);
if (!r) {
ows_error(o, OWS_ERROR_CONFIG_FILE, "Unable to open config file !", "parse_config_file");
return;
}
if (!o->layers) o->layers = ows_layer_list_init();
while ((ret = xmlTextReaderRead(r)) == 1) {
if (xmlTextReaderNodeType(r) == XML_READER_TYPE_ELEMENT) {
name = xmlTextReaderConstLocalName(r);
if (!strcmp((char *) name, "tinyows"))
ows_parse_config_tinyows(o, r);
if (!strcmp((char *) name, "metadata"))
ows_parse_config_metadata(o, r);
if (!strcmp((char *) name, "abstract"))
ows_parse_config_abstract(o, r);
if (!strcmp((char *) name, "contact"))
ows_parse_config_contact(o, r);
if (!strcmp((char *) name, "pg"))
ows_parse_config_pg(o, r);
if (!strcmp((char *) name, "limits"))
ows_parse_config_limits(o, r);
if (!strcmp((char *) name, "layer"))
ows_parse_config_layer(o, r);
}
}
if (ret != 0) {
xmlFreeTextReader(r);
ows_error(o, OWS_ERROR_CONFIG_FILE, "Unable to open config file !", "parse_config_file");
return;
}
xmlFreeTextReader(r);
}
EPUB3Error EPUB3ProcessXMLReaderNodeForSpineInOPF(EPUB3Ref epub, xmlTextReaderPtr reader, EPUB3XMLParseContextPtr *context)
{
assert(epub != NULL);
assert(reader != NULL);
EPUB3Error error = kEPUB3Success;
const xmlChar *name = xmlTextReaderConstLocalName(reader);
xmlReaderTypes nodeType = xmlTextReaderNodeType(reader);
switch(nodeType)
{
case XML_READER_TYPE_ELEMENT:
{
if(!xmlTextReaderIsEmptyElement(reader)) {
(void)EPUB3SaveParseContext(context, kEPUB3OPFStateManifest, name, 0, NULL, kEPUB3_YES, NULL);
} else {
if(xmlStrcmp(name, BAD_CAST "itemref") == 0) {
EPUB3SpineItemRef newItem = EPUB3SpineItemCreate();
xmlChar * linear = xmlTextReaderGetAttribute(reader, BAD_CAST "linear");
if(linear == NULL || xmlStrcmp(linear, BAD_CAST "yes") == 0) {
newItem->isLinear = kEPUB3_YES;
epub->spine->linearItemCount++;
}
EPUB3_XML_FREE_AND_NULL(linear);
newItem->idref = (char *)xmlTextReaderGetAttribute(reader, BAD_CAST "idref");
if(newItem->idref != NULL) {
EPUB3ManifestItemListItemPtr manifestPtr = EPUB3ManifestFindItemWithId(epub->manifest, newItem->idref);
if(manifestPtr == NULL) {
newItem->manifestItem = NULL;
} else {
newItem->manifestItem = manifestPtr->item;
}
}
EPUB3SpineAppendItem(epub->spine, newItem);
}
}
break;
}
case XML_READER_TYPE_TEXT:
{
break;
}
case XML_READER_TYPE_END_ELEMENT:
{
(void)EPUB3PopAndFreeParseContext(context);
break;
}
default: break;
}
return error;
}
/**
* Reads a SubnetConfig element from XML. The element to be read is "subnetConfig", and
* it is assumed that the reader is pointing to that element.
*
* @param reader The XML reader.
* @return The SubnetConfig, or NULL in case of error.
*/
struct full_ns0_subnetConfig *xmlTextReaderReadNs0SubnetConfigElement(xmlTextReaderPtr reader) {
struct full_ns0_subnetConfig *_subnetConfig = NULL;
if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT
&& xmlStrcmp(BAD_CAST "subnetConfig", xmlTextReaderConstLocalName(reader)) == 0
&& xmlTextReaderConstNamespaceUri(reader) == NULL) {
#if DEBUG_ENUNCIATE > 1
printf("Attempting to read root element {}subnetConfig.\n");
#endif
_subnetConfig = xmlTextReaderReadNs0SubnetConfigType(reader);
}
#if DEBUG_ENUNCIATE
if (_subnetConfig == NULL) {
if (xmlTextReaderConstNamespaceUri(reader) == NULL) {
printf("attempt to read {}subnetConfig failed. current element: {}%s\n", xmlTextReaderConstLocalName(reader));
}
else {
printf("attempt to read {}subnetConfig failed. current element: {%s}%s\n", xmlTextReaderConstNamespaceUri(reader), xmlTextReaderConstLocalName(reader));
}
}
#endif
return _subnetConfig;
}
/**
* Reads a Node element from XML. The element to be read is "node", and
* it is assumed that the reader is pointing to that element.
*
* @param reader The XML reader.
* @return The Node, or NULL in case of error.
*/
struct full_ns0_node *xmlTextReaderReadNs0NodeElement(xmlTextReaderPtr reader) {
struct full_ns0_node *_node = NULL;
if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT
&& xmlStrcmp(BAD_CAST "node", xmlTextReaderConstLocalName(reader)) == 0
&& xmlTextReaderConstNamespaceUri(reader) == NULL) {
#if DEBUG_ENUNCIATE > 1
printf("Attempting to read root element {}node.\n");
#endif
_node = xmlTextReaderReadNs0NodeType(reader);
}
#if DEBUG_ENUNCIATE
if (_node == NULL) {
if (xmlTextReaderConstNamespaceUri(reader) == NULL) {
printf("attempt to read {}node failed. current element: {}%s\n", xmlTextReaderConstLocalName(reader));
}
else {
printf("attempt to read {}node failed. current element: {%s}%s\n", xmlTextReaderConstNamespaceUri(reader), xmlTextReaderConstLocalName(reader));
}
}
#endif
return _node;
}
bool c_XMLReader::t_next(const String& localname /*= null_string*/) {
if (m_ptr) {
int ret = xmlTextReaderNext(m_ptr);
while (!localname.empty() && ret == 1) {
if (xmlStrEqual(xmlTextReaderConstLocalName(m_ptr), (xmlChar *)localname.data())) {
return true;
}
ret = xmlTextReaderNext(m_ptr);
}
if (ret == -1) {
raise_warning("An Error Occured while reading");
return false;
} else {
return ret;
}
}
raise_warning("Load Data before trying to read");
return false;
}
/////////////////////////////////////////////////////////
///Read and discard XML text up to the next occurrence of the tag e.g."/molecule>"
///This is left as the current node. Returns 1 on success, 0 if not found, -1 if failed.
int XMLConversion::SkipXML(const char* ctag)
{
string tag(ctag);
tag.erase(--tag.end()); //remove >
int targettyp = XML_READER_TYPE_ELEMENT;
if(tag[0]=='/')
{
tag.erase(0,1);
targettyp = XML_READER_TYPE_END_ELEMENT;
}
int result;
while((result = xmlTextReaderRead(_reader))==1)
{
if(xmlTextReaderNodeType(_reader)==targettyp
&& !xmlStrcmp(xmlTextReaderConstLocalName(_reader), BAD_CAST tag.c_str()))
break;
}
return result;
}
xccdf_element_t xccdf_element_get(xmlTextReaderPtr reader)
{
if (xmlTextReaderNodeType(reader) != XML_READER_TYPE_ELEMENT)
return XCCDFE_ERROR;
const struct xccdf_element_spec *mapptr;
const char *name = (const char *)xmlTextReaderConstLocalName(reader);
const char *nsuri = (const char *)xmlTextReaderConstNamespaceUri(reader);
for (mapptr = XCCDF_ELEMENT_MAP; mapptr->id != 0; ++mapptr) {
if (name && strcmp(mapptr->name, name) == 0) {
// element name exists and matches
if (!nsuri && !mapptr->ns)
// no namespace for the element and no namespace defined in the table
return mapptr->id;
if (nsuri && strcmp(mapptr->ns, nsuri) == 0)
// namespace exists and matches the table
return mapptr->id;
if (nsuri && (strcmp(mapptr->ns, XCCDF_XMLNS_PREFIX) == 0 || strcmp(mapptr->ns, XCCDF_OR_TAILORING_EXTENSION_XMLNS) == 0) &&
strncmp(XCCDF_XMLNS_PREFIX, nsuri, strlen(XCCDF_XMLNS_PREFIX)) == 0)
// Namespace exists and XCCDF version-less namespace prefix matches
// it. This is done to support multiple XCCDF versions.
//
// XSD schema will make sure there is no XCCDF version mixing in
// the document. The only thing we are solving here is making sure
// the element is some kind of an XCCDF element.
return mapptr->id;
if (nsuri && strcmp(mapptr->ns, XCCDF_OR_TAILORING_EXTENSION_XMLNS) == 0 &&
strcmp(XCCDF_OR_TAILORING_EXTENSION_XMLNS, nsuri) == 0)
// In case we are supposed to accept XCCDF tailoring extension
return mapptr->id;
}
}
return XCCDFE_UNMATCHED;
}
EPUB3Error EPUB3ParseXMLReaderNodeForNCX(EPUB3Ref epub, xmlTextReaderPtr reader, EPUB3XMLParseContextPtr *currentContext)
{
assert(epub != NULL);
assert(reader != NULL);
assert(*currentContext != NULL);
EPUB3Error error = kEPUB3Success;
const xmlChar *name = xmlTextReaderConstLocalName(reader);
xmlReaderTypes currentNodeType = xmlTextReaderNodeType(reader);
if(name != NULL && currentNodeType != XML_READER_TYPE_COMMENT) {
switch((*currentContext)->state)
{
case kEPUB3NCXStateRoot:
{
// fprintf(stdout, "NCX ROOT: %s\n", name);
if(currentNodeType == XML_READER_TYPE_ELEMENT) {
if(xmlStrcmp(name, BAD_CAST "navMap") == 0) {
(void)EPUB3SaveParseContext(currentContext, kEPUB3NCXStateNavMap, name, 0, NULL, kEPUB3_YES, NULL);
}
}
break;
}
case kEPUB3NCXStateNavMap:
{
// fprintf(stdout, "NCX NAV MAP: %s\n", name);
if(currentNodeType == XML_READER_TYPE_END_ELEMENT && xmlStrcmp(name, BAD_CAST "navMap") == 0) {
(void)EPUB3PopAndFreeParseContext(currentContext);
return kEPUB3NCXNavMapEnd;
} else {
error = EPUB3ProcessXMLReaderNodeForNavMapInNCX(epub, reader, currentContext);
}
break;
}
default: break;
}
}
return error;
}
/* {{{ proto boolean XMLReader::next([string localname])
Moves the position of the current instance to the next node in the stream. */
PHP_METHOD(xmlreader, next)
{
zval *id;
int retval;
size_t name_len=0;
xmlreader_object *intern;
char *name = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "|s", &name, &name_len) == FAILURE) {
return;
}
id = getThis();
intern = Z_XMLREADER_P(id);
if (intern != NULL && intern->ptr != NULL) {
#if LIBXML_VERSION <= 20617
/* Bug in libxml prevents a next in certain cases when positioned on end of element */
if (xmlTextReaderNodeType(intern->ptr) == XML_READER_TYPE_END_ELEMENT) {
retval = xmlTextReaderRead(intern->ptr);
} else
#endif
retval = xmlTextReaderNext(intern->ptr);
while (name != NULL && retval == 1) {
if (xmlStrEqual(xmlTextReaderConstLocalName(intern->ptr), (xmlChar *)name)) {
RETURN_TRUE;
}
retval = xmlTextReaderNext(intern->ptr);
}
if (retval == -1) {
RETURN_FALSE;
} else {
RETURN_BOOL(retval);
}
}
php_error_docref(NULL, E_WARNING, "Load Data before trying to read");
RETURN_FALSE;
}
