static void
read_iso_3166_entry (xmlTextReaderPtr reader,
GHashTable *table)
{
xmlChar *code, *name;
code = xmlTextReaderGetAttribute (reader, (const xmlChar *) "alpha_2_code");
name = xmlTextReaderGetAttribute (reader, (const xmlChar *) "name");
if (code != NULL && code[0] != '\0' && name != NULL && name[0] != '\0')
{
char *lcode;
lcode = g_ascii_strdown ((char *) code, -1);
xmlFree (code);
g_hash_table_insert (table, lcode, name);
}
else
{
xmlFree (code);
xmlFree (name);
}
}
void processNode( xmlTextReaderPtr reader, node *nodeTable) {
int index ;
const xmlChar *name, *value;
name = xmlTextReaderConstName(reader);
if (name == NULL)
name = BAD_CAST "--";
index = 0 ;
while ( xmlTextReaderRead( reader) == 1) {
switch ( xmlTextReaderNodeType(reader)) {
case XML_READER_TYPE_ELEMENT :
if ( strcmp((char *) xmlTextReaderName( reader), "groupobject") == 0) {
strcpy( nodeTable[index].name, (char *) xmlTextReaderGetAttribute( reader, (xmlChar *) "name")) ;
strcpy( nodeTable[index].alias, (char *) xmlTextReaderGetAttribute( reader, (xmlChar *) "alias")) ;
nodeTable[index].knxGroupAddr = atoi( (char *) xmlTextReaderGetAttribute( reader, (xmlChar *) "knxGroupAddr")) ;
nodeTable[index].type = lookupDPT( (char *) xmlTextReaderGetAttribute( reader, (xmlChar *) "dpt")) ;
// printf( "Element node\n") ;
// printf( " Id............: %s \n", (char *) xmlTextReaderGetAttribute( reader, (xmlChar *) "id")) ;
// printf( " Name..........: '%s' \n", (char *) xmlTextReaderGetAttribute( reader, (xmlChar *) "name")) ;
// printf( " DPT...........: %s(%d) \n", (char *) xmlTextReaderGetAttribute( reader, (xmlChar *) "dpt"), nodeTable[index].type) ;
// printf( " Group addr....: %s \n", (char *) xmlTextReaderGetAttribute( reader, (xmlChar *) "groupAddr")) ;
// printf( " Trigger only..: %s \n", (char *) xmlTextReaderGetAttribute( reader, (xmlChar *) "trigger")) ;
index++ ;
}
break ;
}
}
}
static void
read_iso_639_entry (xmlTextReaderPtr reader,
GHashTable *table)
{
xmlChar *code, *name;
code = xmlTextReaderGetAttribute (reader, (const xmlChar *) "iso_639_1_code");
name = xmlTextReaderGetAttribute (reader, (const xmlChar *) "name");
/* Get iso-639-2 code */
if (code == NULL || code[0] == '\0')
{
xmlFree (code);
/* FIXME: use the 2T or 2B code? */
code = xmlTextReaderGetAttribute (reader, (const xmlChar *) "iso_639_2T_code");
}
if (code != NULL && code[0] != '\0' && name != NULL && name[0] != '\0')
{
g_hash_table_insert (table, code, name);
}
else
{
xmlFree (code);
xmlFree (name);
}
}
static int _oval_test_parse_tag(xmlTextReaderPtr reader, struct oval_parser_context *context, void *user)
{
struct oval_test *test = (struct oval_test *)user;
char *tagname = (char *)xmlTextReaderLocalName(reader);
int return_code = 0;
if ((strcmp(tagname, "notes") == 0)) {
return_code = oval_parser_parse_tag(reader, context, &_oval_test_parse_notes, test);
} else if ((strcmp(tagname, "object") == 0)) {
char *object_ref = (char *)xmlTextReaderGetAttribute(reader, BAD_CAST "object_ref");
if (object_ref != NULL) {
struct oval_definition_model *model = context->definition_model;
struct oval_object *object = oval_definition_model_get_new_object(model, object_ref);
oscap_free(object_ref);
object_ref = NULL;
oval_test_set_object(test, object);
}
} else if ((strcmp(tagname, "state") == 0)) {
char *state_ref = (char *)xmlTextReaderGetAttribute(reader, BAD_CAST "state_ref");
if (state_ref != NULL) {
struct oval_definition_model *model = context->definition_model;
struct oval_state *state = oval_definition_model_get_new_state(model, state_ref);
oval_test_add_state(test, state);
oscap_free(state_ref);
state_ref = NULL;
}
} else {
oscap_dlprintf(DBG_W, "Skipping tag <%s>.\n", tagname);
return_code = oval_parser_skip_tag(reader, context);
}
oscap_free(tagname);
return return_code;
}
static int parse_tileset(xmlTextReaderPtr reader, tmx_tileset **ts_headadr, const char *filename) {
tmx_tileset *res = NULL;
int ret;
char *value, *ab_path;
xmlTextReaderPtr sub_reader;
if (!(res = alloc_tileset())) return 0;
res->next = *ts_headadr;
*ts_headadr = res;
/* parses each attribute */
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"firstgid"))) { /* fisrtgid */
res->firstgid = atoi(value);
tmx_free_func(value);
} else {
tmx_err(E_MISSEL, "xml parser: missing 'firstgid' attribute in the 'tileset' element");
return 0;
}
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"source"))) { /* source */
if (!(ab_path = mk_absolute_path(filename, value))) return 0;
tmx_free_func(value);
if (!(sub_reader = create_parser(ab_path))) return 0; /* opens */
ret = parse_tileset_sub(sub_reader, res, ab_path); /* and parses the tsx file */
xmlFreeTextReader(sub_reader);
tmx_free_func(ab_path);
return ret;
}
return parse_tileset_sub(reader, res, filename);
}
static bool TestExample(xmlTextReaderPtr reader, procdraw::LispInterpreter *L, int *numTests)
{
bool testPassed = false;
xmlChar *expr = xmlTextReaderGetAttribute(reader, BAD_CAST "expr");
if (expr != NULL) {
xmlChar *expectedValue = xmlTextReaderGetAttribute(reader, BAD_CAST "value");
if (expectedValue != NULL) {
std::string result = L->PrintToString(L->Eval(L->Read(reinterpret_cast<char*>(expr))));
*numTests = *numTests + 1;
if (xmlStrEqual(expectedValue, BAD_CAST result.c_str())) {
testPassed = true;
}
else {
testPassed = false;
std::cerr << "EXPR: " << expr;
std::cerr << " EXPECTED: " << expectedValue;
std::cerr << " ACTUAL: " << result << std::endl;
}
xmlFree(expectedValue);
}
xmlFree(expr);
}
return testPassed;
}
/**
* Callback for XML-Node processing
**/
void processNode(xmlTextReaderPtr reader, char *objPath, ruleExecInfo_t* rei) {
xmlChar *name, *value;
rodsLog( LOG_NOTICE, "Calling processNode()\n");
name = xmlTextReaderName(reader);
value = xmlTextReaderValue(reader);
if (xmlStrEqual(name, BAD_CAST "spectrumList")) {
end = 1;
}
else if (xmlStrEqual(name, BAD_CAST "cvParam")) {
if(xmlTextReaderHasAttributes(reader) > 0) {
rodsLog(LOG_NOTICE, "Extracting cvParam information...\n");
xmlChar *cvLabel = xmlTextReaderGetAttribute(reader, (xmlChar *) "cvLabel");
xmlChar *cvAccession = xmlTextReaderGetAttribute(reader, (xmlChar *) "accession");
xmlChar *cvName = xmlTextReaderGetAttribute(reader, (xmlChar *) "name");
xmlChar *cvValue = xmlTextReaderGetAttribute(reader, (xmlChar *) "name");
printf("cvParam: [%s] [%s] [%s] [%s]\n", cvLabel, cvAccession, cvName, cvValue);
createMetadataOnObject(objPath, (char*) "cvParam", (char *) cvLabel, (char*) "", rei);
createMetadataOnObject(objPath, (char *) cvLabel, (char *) cvValue, (char *) cvAccession, rei);
createMetadataOnObject(objPath, (char *) cvLabel, (char *) cvName, (char*) "", rei);
}
}
}
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;
}
int oval_test_parse_tag(xmlTextReaderPtr reader, struct oval_parser_context *context, void *usr)
{
int ret = 0;
char *comm = NULL;
char *version = NULL;
struct oval_definition_model *model = context->definition_model;
char *id = (char *)xmlTextReaderGetAttribute(reader, BAD_CAST "id");
struct oval_test *test = oval_definition_model_get_new_test(model, id);
oval_subtype_t subtype = oval_subtype_parse(reader);
if ( subtype == OVAL_SUBTYPE_UNKNOWN) {
oscap_seterr(OSCAP_EFAMILY_OVAL, "Unknown test type %s.", id);
ret = -1;
goto cleanup;
}
oval_test_set_subtype(test, subtype);
oval_operator_t ste_operator = oval_operator_parse(reader, "state_operator", OVAL_OPERATOR_AND);
oval_test_set_state_operator(test, ste_operator);
oval_check_t check = oval_check_parse(reader, "check", OVAL_CHECK_UNKNOWN);
if (check == OVAL_CHECK_NONE_EXIST) {
dW("The 'none exist' CheckEnumeration value has been deprecated. "
"Converted to check='none satisfy' and check_existence='none exist'.\n");
oval_test_set_check(test, OVAL_CHECK_NONE_SATISFY);
oval_test_set_existence(test, OVAL_NONE_EXIST);
} else {
oval_existence_t existence;
oval_test_set_check(test, check);
existence = oval_existence_parse(reader, "check_existence", OVAL_AT_LEAST_ONE_EXISTS);
oval_test_set_existence(test, existence);
}
comm = (char *)xmlTextReaderGetAttribute(reader, BAD_CAST "comment");
if (comm != NULL) {
oval_test_set_comment(test, comm);
}
int deprecated = oval_parser_boolean_attribute(reader, "deprecated", 0);
oval_test_set_deprecated(test, deprecated);
version = (char *)xmlTextReaderGetAttribute(reader, BAD_CAST "version");
oval_test_set_version(test, atoi(version));
ret = oval_parser_parse_tag(reader, context, &_oval_test_parse_tag, test);
cleanup:
oscap_free(version);
oscap_free(comm);
oscap_free(id);
return ret;
}
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;
}
ExtractionWay XMLParser::_ReadXMLWay() {
ExtractionWay way;
if ( xmlTextReaderIsEmptyElement( inputReader ) != 1 ) {
const int depth = xmlTextReaderDepth( inputReader );
while ( xmlTextReaderRead( inputReader ) == 1 ) {
const int childType = xmlTextReaderNodeType( inputReader );
if ( childType != 1 && childType != 15 ) {
continue;
}
const int childDepth = xmlTextReaderDepth( inputReader );
xmlChar* childName = xmlTextReaderName( inputReader );
if ( childName == NULL ) {
continue;
}
if ( depth == childDepth && childType == 15 && xmlStrEqual( childName, ( const xmlChar* ) "way" ) == 1 ) {
xmlChar* id = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "id" );
way.id = stringToUint((char*)id);
xmlFree(id);
xmlFree( childName );
break;
}
if ( childType != 1 ) {
xmlFree( childName );
continue;
}
if ( xmlStrEqual( childName, ( const xmlChar* ) "tag" ) == 1 ) {
xmlChar* k = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "k" );
xmlChar* value = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "v" );
// cout << "->k=" << k << ", v=" << value << endl;
if ( k != NULL && value != NULL ) {
way.keyVals.Add(std::string( (char *) k ), std::string( (char *) value));
}
if ( k != NULL ) {
xmlFree( k );
}
if ( value != NULL ) {
xmlFree( value );
}
} else if ( xmlStrEqual( childName, ( const xmlChar* ) "nd" ) == 1 ) {
xmlChar* ref = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "ref" );
if ( ref != NULL ) {
way.path.push_back( stringToUint(( const char* ) ref ) );
xmlFree( ref );
}
}
xmlFree( childName );
}
}
return way;
}
static GSList *
parse_classes (ParserState *parser_state)
{
GSList *ret = NULL;
xmlChar *en = xmlTextReaderGetAttribute (parser_state->reader, BAD_CAST "class");
xmlChar *dis = xmlTextReaderGetAttribute (parser_state->reader, BAD_CAST "class-disabled");
ret = add_classes (ret, (gchar const *)en, TRUE);
ret = add_classes (ret, (gchar const *)dis, FALSE);
xmlFree (en);
xmlFree (dis);
return ret;
}
string BEXMLTextReader::get_attribute ( const string attribute_name )
{
const xmlChar * attribute_value = xmlTextReaderGetAttribute ( reader, (xmlChar *)attribute_name.c_str() );
string value = (const char *)attribute_value;
xmlFree ( (xmlChar *)attribute_value );
return value;
}
//## @Native String XmlReader.getAttribute();
static KMETHOD XmlReader_getAttribute(KonohaContext *kctx, KonohaStack *sfp)
{
xmlTextReaderPtr reader = getRawXmlReader(sfp[0]);
xmlChar* ns = (xmlChar *)kString_text(sfp[1].asString);
char* ret = (reader != NULL) ? (char *) xmlTextReaderGetAttribute(reader,ns) : NULL;
KReturn(KLIB new_kString(kctx, GcUnsafe, ret, strlen(ret), 0));
}
/*
* call-seq:
* attribute(name)
*
* Get the value of attribute named +name+
*/
static VALUE reader_attribute(VALUE self, VALUE name)
{
xmlTextReaderPtr reader;
xmlChar *value ;
Data_Get_Struct(self, xmlTextReader, reader);
if(name == Qnil) return Qnil;
name = StringValue(name) ;
value = xmlTextReaderGetAttribute(reader, (xmlChar*)StringValuePtr(name));
if(value == NULL) {
/* this section is an attempt to workaround older versions of libxml that
don't handle namespaces properly in all attribute-and-friends functions */
xmlChar *prefix = NULL ;
xmlChar *localname = xmlSplitQName2((xmlChar*)StringValuePtr(name), &prefix);
if (localname != NULL) {
value = xmlTextReaderLookupNamespace(reader, localname);
xmlFree(localname) ;
} else {
value = xmlTextReaderLookupNamespace(reader, prefix);
}
xmlFree(prefix);
}
if(value == NULL) return Qnil;
VALUE MAYBE_UNUSED(enc) = rb_iv_get(self, "@encoding");
VALUE rb_value = NOKOGIRI_STR_NEW2(value,
RTEST(enc) ? StringValuePtr(enc) : NULL);
xmlFree(value);
return rb_value;
}
static const char *
getAttribute(xmlTextReaderPtr const xmlReaderP,
const char * const attributeName) {
return (const char *)
xmlTextReaderGetAttribute(xmlReaderP, (const xmlChar *)attributeName);
}
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;
}
static int parse_property(xmlTextReaderPtr reader, tmx_property *prop) {
char *value;
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"name"))) { /* name */
prop->name = value;
} else {
tmx_err(E_MISSEL, "xml parser: missing 'name' attribute in the 'property' element");
return 0;
}
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"value"))) { /* source */
prop->value = value;
} else {
tmx_err(E_MISSEL, "xml parser: missing 'value' attribute in the 'property' element");
return 0;
}
return 1;
}
int oval_result_definition_parse_tag(xmlTextReaderPtr reader, struct oval_parser_context *context, void *usr) {
struct oval_result_system *sys = (struct oval_result_system *) usr;
int return_code = 0;
struct oval_definition_model *dmod;
struct oval_definition *ddef;
struct oval_result_definition *definition;
xmlChar *definition_id = xmlTextReaderGetAttribute(reader, BAD_CAST "definition_id");
xmlChar *definition_version = xmlTextReaderGetAttribute(reader, BAD_CAST "version");
int resvsn = atoi((char *)definition_version);
oval_result_t result = oval_result_parse(reader, "result", OVAL_ENUMERATION_INVALID);
int instance = oval_parser_int_attribute(reader, "variable_instance", 1);
dmod = context->definition_model;
ddef = oval_definition_model_get_new_definition(dmod, (char *) definition_id);
definition = oval_result_system_get_new_definition(sys, ddef, instance);
if (definition == NULL)
return -1;
int defvsn = oval_definition_get_version(definition->definition);
if (defvsn && resvsn != defvsn) {
dW("Definition versions don't match: definition id: %s, ovaldef vsn: %d, resdef vsn: %d.", definition_id, defvsn, resvsn);
}
oval_definition_set_version(definition->definition, resvsn);
// The following _set_instance() might be overabundant, since it should be already set
// by oval_result_system_get_new_definition() Let's see if the assert agrees over time:
assert(oval_result_definition_get_instance(definition) == instance);
oval_result_definition_set_instance(definition, instance);
if ((int)result != OVAL_ENUMERATION_INVALID) {
oval_result_definition_set_result(definition, result);
} else {
dW("Can't resolve result attribute, definition id: %s.", definition_id);
oval_result_definition_set_result(definition, OVAL_RESULT_UNKNOWN);
}
return_code = oval_parser_parse_tag(reader, context, oval_result_definition_parse, definition);
oscap_free(definition_id);
oscap_free(definition_version);
return return_code;
}
char* readRequiredAttribute( xmlTextReaderPtr xmlRead, const char* name ) {
char* s = (char*) xmlTextReaderGetAttribute( xmlRead, name );
if( s == NULL || strlen( s ) == 0 ) {
printf( "Error on line %d: expected required attribute\n", xmlTextReaderGetParserLineNumber( xmlRead ) );
return NULL;
}
return s;
}
static void
load_mime_from_xml (void)
{
xmlTextReaderPtr reader;
const char *xml_file;
int ret;
LibreImpuestoMimePermission permission = LIBRE_IMPUESTO_MIME_PERMISSION_UNKNOWN;
g_return_if_fail (mime_table == NULL);
mime_table = g_hash_table_new_full (g_str_hash, g_str_equal,
xmlFree, NULL);
xml_file = libre_impuesto_file ("mime-types-permissions.xml");
if (xml_file == NULL)
{
g_warning ("MIME types permissions file not found!\n");
return;
}
reader = xmlNewTextReaderFilename (xml_file);
if (reader == NULL)
{
g_warning ("Could not load MIME types permissions file!\n");
return;
}
ret = xmlTextReaderRead (reader);
while (ret == 1)
{
const xmlChar *tag;
xmlReaderTypes type;
tag = xmlTextReaderConstName (reader);
type = xmlTextReaderNodeType (reader);
if (xmlStrEqual (tag, (const xmlChar *)"safe") && type == XML_READER_TYPE_ELEMENT)
{
permission = LIBRE_IMPUESTO_MIME_PERMISSION_SAFE;
}
else if (xmlStrEqual (tag, (const xmlChar *)"unsafe") && type == XML_READER_TYPE_ELEMENT)
{
permission = LIBRE_IMPUESTO_MIME_PERMISSION_UNSAFE;
}
else if (xmlStrEqual (tag, (const xmlChar *)"mime-type"))
{
xmlChar *type;
type = xmlTextReaderGetAttribute (reader, (const xmlChar *)"type");
g_hash_table_insert (mime_table, type,
GINT_TO_POINTER (permission));
}
ret = xmlTextReaderRead (reader);
}
xmlFreeTextReader (reader);
}
CError CInterfaceDefinitionLoader::handle_element_attributes()
{
CError error = CError::SUCCESS;
assert( m_interface_definition && m_reader && !m_element_path.empty() );
if( m_element_path == "InterfaceDeclaration" )
{
char *module_guid_attribute = ( char * ) xmlTextReaderGetAttribute( m_reader, BAD_CAST "moduleGuid" );
if( module_guid_attribute )
{
if( CGuidHelper::string_to_guid( module_guid_attribute, m_interface_definition->m_module_guid ) != CError::SUCCESS )
{
INTEGRA_TRACE_ERROR << "Couldn't parse guid: " << module_guid_attribute;
error = CError::INPUT_ERROR;
}
xmlFree( module_guid_attribute );
}
else
{
INTEGRA_TRACE_ERROR << "InterfaceDeclaration lacks moduleGuid attribute";
error = CError::INPUT_ERROR;
}
char *origin_guid_attribute = ( char * ) xmlTextReaderGetAttribute( m_reader, BAD_CAST "originGuid" );
if( origin_guid_attribute )
{
if( CGuidHelper::string_to_guid( origin_guid_attribute, m_interface_definition->m_origin_guid ) != CError::SUCCESS )
{
INTEGRA_TRACE_ERROR << "Couldn't parse guid: " << origin_guid_attribute;
error = CError::INPUT_ERROR;
}
xmlFree( origin_guid_attribute );
}
else
{
INTEGRA_TRACE_ERROR << "InterfaceDeclaration lacks originGuid attribute";
error = CError::INPUT_ERROR;
}
}
return error;
}
gchar *
xml_reader_get_attribute (XmlReader *reader,
const gchar *name)
{
g_return_val_if_fail (XML_IS_READER (reader), NULL);
g_return_val_if_fail (reader->xml != NULL, NULL);
RETURN_STRDUP_AND_XMLFREE (xmlTextReaderGetAttribute (reader->xml, CHAR_TO_XML (name)));
}
static GWeatherTimezone *
parse_timezone (GWeatherParser *parser)
{
GWeatherTimezone *zone = NULL;
char *id = NULL;
char *name = NULL;
int offset = 0, dst_offset = 0;
gboolean has_dst = FALSE;
id = (char *) xmlTextReaderGetAttribute (parser->xml, (xmlChar *) "id");
if (!id) {
xmlTextReaderNext (parser->xml);
return NULL;
}
if (!xmlTextReaderIsEmptyElement (parser->xml)) {
if (xmlTextReaderRead (parser->xml) != 1) {
xmlFree (id);
return NULL;
}
while (xmlTextReaderNodeType (parser->xml) != XML_READER_TYPE_END_ELEMENT) {
if (xmlTextReaderNodeType (parser->xml) != XML_READER_TYPE_ELEMENT) {
if (xmlTextReaderRead (parser->xml) != 1)
break;
continue;
}
if (!strcmp ((const char *) xmlTextReaderConstName (parser->xml), "name"))
name = _gweather_parser_get_localized_value (parser);
else {
if (xmlTextReaderNext (parser->xml) != 1)
break;
}
}
}
if (parse_tzdata (id, parser->year_start, parser->year_end,
&offset, &has_dst, &dst_offset)) {
zone = g_slice_new0 (GWeatherTimezone);
zone->ref_count = 1;
zone->id = g_strdup (id);
zone->name = name;
zone->offset = offset;
zone->has_dst = has_dst;
zone->dst_offset = dst_offset;
g_hash_table_insert (parser->timezone_cache, zone->id, zone);
name = NULL;
}
g_free (name);
xmlFree (id);
return zone;
}
static int openioc_is_context_hash(xmlTextReaderPtr reader)
{
xmlChar * document = xmlTextReaderGetAttribute(reader, (const xmlChar *)"document");
xmlChar * search = xmlTextReaderGetAttribute(reader, (const xmlChar *)"search");
int rc = 0;
if ((document != NULL && search != NULL) &&
!xmlStrcmp(document, (const xmlChar *)"FileItem") &&
(!xmlStrcmp(search, (const xmlChar *)"FileItem/Md5sum") ||
!xmlStrcmp(search, (const xmlChar *)"FileItem/Sha1sum") ||
!xmlStrcmp(search, (const xmlChar *)"FileItem/Sha256sum")))
rc = 1;
if (document != NULL)
xmlFree(document);
if (search != NULL)
xmlFree(search);
return rc;
}
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;
}
static inline char *
get_type_attribute(xmlTextReaderPtr reader)
{
#if __LP64__
char *value = get_type64_attribute(reader);
if (value != NULL)
return value;
#endif
return (char *)xmlTextReaderGetAttribute(reader, (xmlChar *)"type");
}
/*
* Parse the configuration file's metadata element
*/
static void ows_parse_config_metadata(ows * o, xmlTextReaderPtr r)
{
xmlChar *a;
assert(o);
assert(r);
o->metadata = ows_metadata_init();
a = xmlTextReaderGetAttribute(r, (xmlChar *) "name");
if (a) {
o->metadata->name = buffer_init();
buffer_add_str(o->metadata->name, (char *) a);
xmlFree(a);
}
a = xmlTextReaderGetAttribute(r, (xmlChar *) "title");
if (a) {
o->metadata->title = buffer_init();
buffer_add_str(o->metadata->title, (char *) a);
xmlFree(a);
}
a = xmlTextReaderGetAttribute(r, (xmlChar *) "keywords");
if (a) {
o->metadata->keywords = list_explode_str(',', (char *) a);
xmlFree(a);
}
a = xmlTextReaderGetAttribute(r, (xmlChar *) "fees");
if (a) {
o->metadata->fees = buffer_init();
buffer_add_str(o->metadata->fees, (char *) a);
xmlFree(a);
}
a = xmlTextReaderGetAttribute(r, (xmlChar *) "access_constraints");
if (a) {
o->metadata->access_constraints = buffer_init();
buffer_add_str(o->metadata->access_constraints, (char *) a);
xmlFree(a);
}
}
/* @method String XmlReader.getAttribute() */
METHOD XmlReader_getAttribute(Ctx *ctx, knh_sfp_t *sfp)
{
xmlTextReaderPtr reader = (xmlTextReaderPtr) p_cptr(sfp[0]);
xmlChar * ns = (xmlChar *) p_char(sfp[1]);
char* ret = (char*) xmlTextReaderGetAttribute(reader,ns);
if(ret == NULL){
ret = "";
}
KNH_RETURN(ctx,sfp,new_String(ctx,B(ret),NULL));
}
int oval_result_test_parse_tag(xmlTextReaderPtr reader, struct oval_parser_context *context, void *usr) {
struct oval_result_system *sys = (struct oval_result_system *) usr;
int return_code = 0;
struct oval_definition_model *dmod;
struct oval_test *dtst;
struct oval_result_test *test;
xmlChar *test_id = xmlTextReaderGetAttribute(reader, BAD_CAST "test_id");
dmod = context->definition_model;
dtst = oval_definition_model_get_new_test(dmod, (char *) test_id);
oval_result_t result = oval_result_parse(reader, "result", 0);
int variable_instance = oval_parser_int_attribute(reader, "variable_instance", 1);
test = oval_result_system_get_new_test(sys, dtst, variable_instance);
if (test == NULL)
return -1;
oval_result_test_set_result(test, result);
oval_result_test_set_instance(test, variable_instance);
struct oval_test *ovaltst = oval_result_test_get_test(test);
oval_existence_t check_existence = oval_existence_parse(reader, "check_existence", OVAL_AT_LEAST_ONE_EXISTS);
oval_existence_t tst_check_existence = oval_test_get_existence(ovaltst);
if (tst_check_existence == OVAL_EXISTENCE_UNKNOWN) {
oval_test_set_existence(ovaltst, check_existence);
} else if (tst_check_existence != check_existence) {
oscap_dlprintf(DBG_W, "@check_existence does not match, test_id: %s.\n", test_id);
}
oval_check_t check = oval_check_parse(reader, "check", OVAL_CHECK_UNKNOWN);
oval_check_t tst_check = oval_test_get_check(ovaltst);
if (tst_check == OVAL_CHECK_UNKNOWN) {
oval_test_set_check(ovaltst, check);
} else if (tst_check != check) {
oscap_dlprintf(DBG_W, "@check does not match, test_id: %s.\n", test_id);
}
int version = oval_parser_int_attribute(reader, "version", 0);
int tst_version = oval_test_get_version(ovaltst);
if (tst_version == 0) {
oval_test_set_version(ovaltst, version);
} else if (tst_version != version) {
oscap_dlprintf(DBG_W, "@version does not match, test_id: %s.\n", test_id);
}
struct oval_string_map *itemmap = oval_string_map_new();
void *args[] = { sys, test, itemmap };
return_code = oval_parser_parse_tag(reader, context, (oval_xml_tag_parser) _oval_result_test_parse, args);
oval_string_map_free(itemmap, NULL);
test->bindings_initialized = true;
oscap_free(test_id);
return return_code;
}
