自学教程：C++ xmlTextReaderGetAttribute函数代码示例

static voidread_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 voidread_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 voidload_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 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;}