bool CSpmXml::LoadXML(const QString& strXML, bool bDTDValidation)
{
xmlParserCtxtPtr pXMLParser = xmlNewParserCtxt();
if (0 == pXMLParser)
return false;
int nOptions = XML_PARSE_NOBLANKS;
if (bDTDValidation)
nOptions |= XML_PARSE_DTDVALID;
m_pXMLDoc = xmlCtxtReadDoc(pXMLParser, (xmlChar*)strXML.toUtf8().data(), "", NULL, nOptions);
if (0 == m_pXMLDoc)
{
xmlFreeParserCtxt(pXMLParser);
return false;
}
// Проверка корректности структуры
if (bDTDValidation && (false == pXMLParser->valid))
{
xmlFreeParserCtxt(pXMLParser);
return false;
}
m_pCurNode = xmlDocGetRootElement(m_pXMLDoc);
if (0 == m_pCurNode)
return false;
SetModified(false);
xmlFreeParserCtxt(pXMLParser);
return true;
}
bool WeatherPlugin::done(unsigned code, Buffer &data, const char*)
{
if (code != 200)
return false;
m_data = "";
m_day = 0;
m_bBar = false;
m_bWind = false;
m_bUv = false;
m_bCC = false;
m_context = xmlCreatePushParserCtxt(&m_handler, this, "", 0, "");
if (xmlParseChunk(m_context, data.data(), data.size(), 0)){
log(L_WARN, "XML parse error");
xmlFreeParserCtxt(m_context);
return false;
}
xmlFreeParserCtxt(m_context);
time_t now;
time(&now);
setTime(now);
if (m_bForecast)
setForecastTime(now);
updateButton();
Event eUpdate(EventWeather);
eUpdate.process();
return false;
}
XDocument* XParser::ParseMemory(const char* content, bool keep_blank/*=false*/)
{
xmlParserCtxtPtr pxParseCtxt = NULL;
xmlKeepBlanksDefault(keep_blank?1:0);
xmlDoValidityCheckingDefaultValue =0;
pxParseCtxt = xmlCreateMemoryParserCtxt((const char*)content, strlen(content));
if(pxParseCtxt==NULL)
{
return NULL;
}
if(!ParseContext(pxParseCtxt))
{
xmlFreeParserCtxt(pxParseCtxt);
return NULL;
}
XDocument* pagXmlDoc = NULL;
pagXmlDoc = new XDocument(pxParseCtxt->myDoc);
xmlFreeParserCtxt(pxParseCtxt);
return pagXmlDoc;
}
XDocument* XParser::Parse(const char* szPath, bool keep_blank/*=false*/)
{
if(szPath==NULL)
return NULL;
xmlKeepBlanksDefault(keep_blank?1:0);
xmlDoValidityCheckingDefaultValue =0;
xmlParserCtxtPtr pxParseCtxt = NULL;
pxParseCtxt = xmlCreateFileParserCtxt(szPath);
if(pxParseCtxt==NULL)
{
return NULL;
}
if(pxParseCtxt->directory == NULL)
{
char* directory = xmlParserGetDirectory(szPath);
pxParseCtxt->directory = (char*)xmlStrdup((xmlChar*)directory);
}
if(!ParseContext(pxParseCtxt))
{
xmlFreeParserCtxt(pxParseCtxt);
return NULL;
}
XDocument* pagXmlDoc = NULL;
pagXmlDoc = new XDocument(pxParseCtxt->myDoc);
xmlFreeParserCtxt(pxParseCtxt);
return pagXmlDoc;
}
void Vpz::validateFile(const std::string& filename)
{
xmlParserCtxtPtr ctxt;
xmlDocPtr doc;
ctxt = xmlNewParserCtxt();
if (ctxt == NULL) {
throw utils::SaxParserError(_("Failed to allocate parser context\n"));
}
doc = xmlCtxtReadFile(ctxt, filename.c_str(), NULL, XML_PARSE_DTDVALID);
if (not doc) {
std::string msg((fmt(_("Failed to parse '%1%': %2%")) % filename %
(ctxt->lastError.message ? ctxt->lastError.message :
"")).str());
xmlFreeParserCtxt(ctxt);
throw utils::SaxParserError(msg);
}
if (ctxt->valid == 0) {
std::string msg((fmt(_("Failed to validate '%1%': %2%")) % filename %
(ctxt->lastError.message ? ctxt->lastError.message :
"")).str());
xmlFreeDoc(doc);
xmlFreeParserCtxt(ctxt);
throw utils::SaxParserError(msg);
}
xmlFreeParserCtxt(ctxt);
}
bool MainWindow::OpenXMLDocument(const QString &file_name) {
FreeXMLDocument();
xmlParserCtxtPtr parser = xmlNewParserCtxt();
if (0 == parser)
return false;
xml_doc_ptr_ = xmlCtxtReadFile(parser,
file_name.toLocal8Bit().data(),
NULL,
XML_PARSE_NOBLANKS);// | XML_PARSE_DTDVALID);
if (false == parser->valid) {
QMessageBox::critical(this, tr("Открытие XML документа"),
tr("Структура файла %1 не соответствует "
"DTD-диаграмме").arg(file_name),
QMessageBox::Ok);
SetCurrentFileName("", false);
xmlFreeParserCtxt(parser);
FreeXMLDocument();
return false;
}
AddItem(xmlDocGetRootElement(xml_doc_ptr_));
xmlFreeParserCtxt(parser);
UpdateButtons();
return true;
}
static dpl_status_t
_multipart_parse_init(const dpl_ctx_t *ctx,
const char *buf, int len,
const char **uploadidp)
{
dpl_status_t ret = DPL_SUCCESS;
xmlParserCtxtPtr ctxt;
xmlDocPtr doc;
xmlNode *elem;
ctxt = xmlNewParserCtxt();
if (ctxt == NULL)
return DPL_FAILURE;
doc = xmlCtxtReadMemory(ctxt, buf, len, NULL, NULL, 0u);
if (doc == NULL) {
xmlFreeParserCtxt(ctxt);
return DPL_FAILURE;
}
elem = xmlDocGetRootElement(doc);
while (elem != NULL)
{
if (elem->type == XML_ELEMENT_NODE)
{
if (!strcmp((char *) elem->name, "InitiateMultipartUploadResult"))
{
elem = elem->children;
ret = DPL_FAILURE;
while (elem != NULL)
{
if (elem->type == XML_ELEMENT_NODE)
{
if (!strcmp((char *) elem->name, "UploadId"))
{
ret = DPL_SUCCESS;
*uploadidp = strdup((char *) elem->children->content);
if (NULL == *uploadidp)
ret = DPL_ENOMEM;
break;
}
}
elem = elem->next;
}
// Reaching here means that we already browsed
// the InitiateMultipartUploadResult xml subtree,
// whether we found UploadId or not.
break;
}
}
elem = elem->next;
}
xmlFreeDoc(doc);
xmlFreeParserCtxt(ctxt);
return ret;
}
/* Taken from libxml2, xmlSAXParseMemoryWithData */
xmlDocPtr mxslt_doc_xml_load_entity(mxslt_doc_t * document, char * localfile) {
xmlParserCtxtPtr ctx;
xmlParserInputPtr input;
xmlDocPtr retval;
xmlChar * filename;
mxslt_doc_debug_print(document, MXSLT_DBG_LIBXML | MXSLT_DBG_DEBUG | MXSLT_DBG_VERBOSE0,
"load_entity/xmlCreateMemoryParserCtxt -- replacing entities: %08x\n", xmlSubstituteEntitiesDefaultValue);
/* SNIPPET: This is a good mix&shake of
* xmlCreateMemoryParserCtxt, xmlCreateFileParserCtxt */
ctx=xmlNewParserCtxt();
if(ctx == NULL)
return NULL;
#if LIBXML_VERSION >= 20600
xmlCtxtUseOptions(ctx, MXSLT_XSLT_OPTIONS);
#endif
/* Remember which document we are parsing
* in this context */
/* ctx->_private=document; */
filename=xmlCanonicPath((xmlChar *)localfile);
if(filename == NULL) {
xmlFreeParserCtxt(ctx);
return NULL;
}
input=xmlLoadExternalEntity((char *)filename, NULL, ctx);
xmlFree(filename);
if(input == NULL) {
xmlFreeParserCtxt(ctx);
return NULL;
}
inputPush(ctx, input);
if(ctx->directory == NULL)
ctx->directory=xmlParserGetDirectory(localfile);
/* END SNIPPET */
/* MXSLT_DUMP_CTX(ctx); */
/* Parse document */
xmlParseDocument(ctx);
if(ctx->wellFormed)
retval=ctx->myDoc;
else {
retval=NULL;
xmlFreeDoc(ctx->myDoc);
ctx->myDoc=NULL;
}
xmlFreeParserCtxt(ctx);
return retval;
}
static gboolean
xmms_xspf_browse (xmms_xform_t *xform, const gchar *url, xmms_error_t *error)
{
int ret;
char buf[4096];
xmlParserCtxtPtr ctx;
xmlDocPtr doc;
g_return_val_if_fail (xform, FALSE);
xmms_error_reset (error);
ctx = xmlCreatePushParserCtxt (NULL, NULL, buf, 0, NULL);
if (!ctx) {
xmms_error_set (error, XMMS_ERROR_OOM, "Could not allocate xml parser");
return FALSE;
}
while ((ret = xmms_xform_read (xform, buf, sizeof (buf), error)) > 0) {
if ((xmlParseChunk (ctx, buf, ret, 0)) != 0) {
break;
}
}
if (ret < 0) {
xmms_error_set (error, XMMS_ERROR_GENERIC,
"failed to read data from previous xform");
xmlFreeParserCtxt (ctx);
return FALSE;
}
xmlParseChunk (ctx, buf, 0, 1);
if (ctx->lastError.message) {
xmms_error_set (error, XMMS_ERROR_INVAL, ctx->lastError.message);
xmlFreeParserCtxt (ctx);
return FALSE;
}
doc = ctx->myDoc;
if (!xmms_xspf_browse_add_entries (xform, doc, error)) {
xmlFreeParserCtxt (ctx);
return FALSE;
}
xmms_error_reset (error);
xmlFreeParserCtxt (ctx);
return TRUE;
}
static gboolean
chatroom_manager_file_parse (EmpathyChatroomManager *manager,
const gchar *filename)
{
EmpathyChatroomManagerPriv *priv;
xmlParserCtxtPtr ctxt;
xmlDocPtr doc;
xmlNodePtr chatrooms;
xmlNodePtr node;
priv = GET_PRIV (manager);
DEBUG ("Attempting to parse file:'%s'...", filename);
ctxt = xmlNewParserCtxt ();
/* Parse and validate the file. */
doc = xmlCtxtReadFile (ctxt, filename, NULL, 0);
if (doc == NULL)
{
g_warning ("Failed to parse file:'%s'", filename);
xmlFreeParserCtxt (ctxt);
return FALSE;
}
if (!empathy_xml_validate (doc, CHATROOMS_DTD_FILENAME))
{
g_warning ("Failed to validate file:'%s'", filename);
xmlFreeDoc (doc);
xmlFreeParserCtxt (ctxt);
return FALSE;
}
/* The root node, chatrooms. */
chatrooms = xmlDocGetRootElement (doc);
for (node = chatrooms->children; node; node = node->next)
{
if (strcmp ((gchar *) node->name, "chatroom") == 0)
chatroom_manager_parse_chatroom (manager, node);
}
DEBUG ("Parsed %d chatrooms", g_list_length (priv->chatrooms));
xmlFreeDoc (doc);
xmlFreeParserCtxt (ctxt);
return TRUE;
}
rss_file *rss_open_file(const char *filename)
{
xmlParserCtxtPtr ctxt;
xmlDocPtr doc;
rss_file *f;
xmlNode *root_element = NULL;
gchar *fetched_time;
ctxt = xmlNewParserCtxt();
ctxt->sax->getEntity = _get_entity;
doc = xmlSAXParseFile(ctxt->sax, filename, 0);
if (!doc) {
fprintf(stderr, "Error parsing RSS file %s.\n", filename);
xmlFreeParserCtxt(ctxt);
return NULL;
}
root_element = xmlDocGetRootElement(doc);
if (!root_element) {
xmlFreeDoc(doc);
xmlFreeParserCtxt(ctxt);
fprintf(stderr, "Error parsing RSS file %s.\n", filename);
return NULL;
}
/* Establish the time the RSS file was 'fetched'. */
fetched_time = get_rfc822_time();
if (!fetched_time) {
xmlFreeDoc(doc);
xmlFreeParserCtxt(ctxt);
g_fprintf(stderr, "Error retrieving current time.\n");
return NULL;
}
f = rss_parse(filename, root_element, fetched_time);
xmlFreeDoc(doc);
xmlFreeParserCtxt(ctxt);
g_free(fetched_time);
return f;
}
bool XMLReader::isValid(const QString &_inFile)
{
LIBXML_TEST_VERSION
//reset the generic error handler
initGenericErrorDefaultFunc(NULL);
QString ErrorString;
//supply custom error handler
xmlSetStructuredErrorFunc(&ErrorString, XMLReader::xmlErrorHandler);
xmlParserCtxtPtr Context; /* the parser context */
xmlDocPtr Doc; /* the resulting document tree */
/* create a parser context */
Context = xmlNewParserCtxt();
if (Context == NULL)
throw exInvalidXML("Failed to allocate parser context");
QFile File(_inFile);
File.open(QIODevice::ReadOnly);
int FD = File.handle();
/* parse the file, activating the DTD validation option */
Doc = xmlCtxtReadFd(Context, FD, ".", NULL, XML_PARSE_DTDVALID);
/* check if parsing suceeded */
if (Doc == NULL)
throw exInvalidXML("Unable to read XML Buffer");
else
xmlFreeDoc(Doc);
/* free up the parser context */
xmlFreeParserCtxt(Context);
return true;
}
xmlDoc *XMLDocument::readDocument(const std::string & xmlCode, const char * encoding, bool validate, std::string * error)
{
xmlParserCtxt *ctxt = initContext(error, validate);
xmlDoc *doc = 0;
int options = XML_PARSE_NSCLEAN | XML_PARSE_NOBLANKS;
if (validate)
{
options |= XML_PARSE_DTDVALID;
}
if (!ctxt)
{
xmlSetGenericErrorFunc(0, errorFunctionWithoutOutput);
return 0;
}
doc = xmlCtxtReadDoc(ctxt, (const xmlChar *)xmlCode.c_str(), 0, encoding, options);
if (!doc || !ctxt->valid)
{
*error = errorBuffer;
}
xmlSetGenericErrorFunc(0, errorFunctionWithoutOutput);
xmlFreeParserCtxt(ctxt);
return doc;
}
/**
* Parses a descriptor that contains the last part of a document.
*/
void CXMLEngineSAXPlugin::ParseLastChunkL(const TDesC8& /*aDescriptor*/)
{
if (!iParserContext)
{
User::Leave(EXmlParserError);
}
//parsing process
TInt result(KErrNone);
result = xmlParseChunk(iParserContext, NULL, 0, 1);
if ((result == XML_ERR_NO_MEMORY) || (iParserContext->lastError.level == XML_ERR_FATAL)
|| (result < 0))
{
CleanupAndLeaveL(GetErrorNum(result));
}
//releasing context to the parser
xmlParserCtxtPtr ctxt = reinterpret_cast<xmlParserCtxtPtr>(iParserContext);
if(ctxt->myDoc)
{
xmlFreeDoc(ctxt->myDoc);
}
xmlFreeParserCtxt(ctxt);
iParserContext = NULL;
}
~libxml2_loader()
{
if (ctx_)
{
xmlFreeParserCtxt(ctx_);
}
}
int main(int argc, char **argv) {
xmlParserCtxtPtr ctxt;
xmlsatParseState state;
if (argc<2) {
printf("Usage: %s [-fta] filename.xmlsat\n",argv[0]);
} else {
if (argc==2) {
ctxt = (xmlParserCtxtPtr)xmlCreateFileParserCtxt(argv[1]);
} else if (argc==3) {
if (strcmp(argv[1],"-fta")==0) {
fta=1;
}
ctxt = (xmlParserCtxtPtr)xmlCreateFileParserCtxt(argv[2]);
}
if (ctxt == NULL) {
fprintf(stderr,"ERROR: can not open file\n");
}
ctxt->sax = &xmlsatSAXParser;
ctxt->userData = &state;
xmlParseDocument(ctxt);
ctxt->sax = NULL;
xmlFreeParserCtxt(ctxt);
}
return 0;
}
void *WeatherCfg::processEvent(Event *e)
{
if (e->type() == m_plugin->EventWeather){
fill();
}
if (e->type() == EventFetchDone){
fetchData *data = (fetchData*)(e->param());
if (data->req_id != m_fetch_id)
return NULL;
m_fetch_id = 0;
m_ids.clear();
m_names.clear();
m_id = "";
m_data = "";
m_context = xmlCreatePushParserCtxt(&m_handler, this, "", 0, "");
if (xmlParseChunk(m_context, data->data->data(), data->data->size(), 0))
log(L_WARN, "XML parse error");
xmlFreeParserCtxt(m_context);
btnSearch->setText(i18n("&Search"));
QString oldText = cmbLocation->lineEdit()->text();
cmbLocation->clear();
if (m_ids.empty()){
cmbLocation->lineEdit()->setText(oldText);
BalloonMsg::message(i18n("Location %1 not found") .arg(oldText), btnSearch, false);
}else{
for (vector<string>::iterator it = m_names.begin(); it != m_names.end(); ++it)
cmbLocation->insertItem(QString::fromUtf8((*it).c_str()));
cmbLocation->setCurrentItem(0);
activated(0);
}
textChanged(cmbLocation->lineEdit()->text());
return e->param();
}
return NULL;
}
/* call-seq:
* XML::Parser::Context.io(io) -> XML::Parser::Context
*
* Creates a new parser context based on the specified io object.
*
* Parameters:
*
* io - A ruby IO object.
*/
static VALUE rxml_parser_context_io(VALUE klass, VALUE io)
{
xmlParserCtxtPtr ctxt;
xmlParserInputBufferPtr input;
xmlParserInputPtr stream;
input = xmlParserInputBufferCreateIO((xmlInputReadCallback) rxml_read_callback, NULL,
(void*)io, XML_CHAR_ENCODING_NONE);
ctxt = xmlNewParserCtxt();
if (!ctxt)
{
xmlFreeParserInputBuffer(input);
rxml_raise(&xmlLastError);
}
stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
if (!stream)
{
xmlFreeParserInputBuffer(input);
xmlFreeParserCtxt(ctxt);
rxml_raise(&xmlLastError);
}
inputPush(ctxt, stream);
return rxml_parser_context_wrap(ctxt);
}
void CXMLEngineSAXPlugin::CleanupAndLeaveL(TInt aError)
{
// reseting OOM flag
if((aError == KErrNoMemory) && xmlOOMFlag())
{
xmlResetOOM();
}
//releasing context to the parser
if(iParserContext)
{
xmlParserCtxtPtr ctxt = reinterpret_cast<xmlParserCtxtPtr>(iParserContext);
if(ctxt->myDoc)
{
xmlFreeDoc(ctxt->myDoc);
}
xmlFreeParserCtxt(ctxt);
}
iParserContext = NULL;
if (aError)
{
User::Leave(aError);
}
else
{
User::Leave(EXmlParserError);
}
}
/**
* e_soap_message_parse_response:
* @msg: the #ESoapMessage.
*
* Parses the response returned by the server.
*
* Returns: a #ESoapResponse representing the response from
* the server, or %NULL if there was an error.
*
* Since: 2.92
*/
ESoapResponse *
e_soap_message_parse_response (ESoapMessage *msg)
{
ESoapMessagePrivate *priv;
xmlDocPtr xmldoc;
g_return_val_if_fail (E_IS_SOAP_MESSAGE (msg), NULL);
priv = E_SOAP_MESSAGE_GET_PRIVATE (msg);
if (!priv->ctxt)
return NULL;
xmlParseChunk (priv->ctxt, 0, 0, 1);
xmldoc = priv->ctxt->myDoc;
xmlFreeParserCtxt (priv->ctxt);
priv->ctxt = NULL;
if (!xmldoc)
return NULL;
return e_soap_response_new_from_xmldoc (xmldoc);
}
static gboolean
lj_entry_load_from_xml(LJEntry *entry, const char *data, int len, GError **err) {
xmlNodePtr cur;
xmlDocPtr doc = NULL;
xmlParserCtxtPtr ctxt;
ctxt = xmlCreatePushParserCtxt(NULL, NULL,
data, 4,
NULL /* XXX why does this want a filename? */);
/* suppress error messages */
ctxt->sax->warning = NULL;
ctxt->sax->error = NULL;
xmlParseChunk(ctxt, data+4, len-4, 0);
xmlParseChunk(ctxt, data, 0, 1);
if (!ctxt->errNo)
doc = ctxt->myDoc;
xmlFreeParserCtxt(ctxt);
if (!doc) {
/* XXX better error message. */
g_set_error(err, 0, 0, "Error parsing XML");
return FALSE;
}
cur = xmlDocGetRootElement(doc);
lj_entry_load_from_xml_node(entry, doc, cur);
xmlFreeDoc(doc);
return TRUE;
}
/**
* Finalise XML parsing.
*/
int xml_complete(modsec_rec *msr, char **error_msg) {
if (error_msg == NULL) return -1;
*error_msg = NULL;
/* Only if we have a context, meaning we've done some work. */
if (msr->xml->parsing_ctx != NULL) {
/* This is how we signalise the end of parsing to libxml. */
xmlParseChunk(msr->xml->parsing_ctx, NULL, 0, 1);
/* Preserve the results for our reference. */
msr->xml->well_formed = msr->xml->parsing_ctx->wellFormed;
msr->xml->doc = msr->xml->parsing_ctx->myDoc;
/* Clean up everything else. */
xmlFreeParserCtxt(msr->xml->parsing_ctx);
msr->xml->parsing_ctx = NULL;
msr_log(msr, 4, "XML: Parsing complete (well_formed %u).", msr->xml->well_formed);
if (msr->xml->well_formed != 1) {
*error_msg = ngx_pstrndup(msr->mp, "XML: Failed parsing document.");
return -1;
}
}
return 1;
}
static void
finalize (GObject *object)
{
ESoapMessagePrivate *priv = E_SOAP_MESSAGE_GET_PRIVATE (object);
if (priv->ctxt) {
if (priv->ctxt->myDoc)
xmlFreeDoc (priv->ctxt->myDoc);
xmlFreeParserCtxt (priv->ctxt);
}
if (priv->doc)
xmlFreeDoc (priv->doc);
if (priv->action)
g_free (priv->action);
if (priv->env_uri)
xmlFree (priv->env_uri);
if (priv->env_prefix)
xmlFree (priv->env_prefix);
g_free (priv->steal_node);
g_free (priv->steal_dir);
if (priv->steal_fd != -1)
close (priv->steal_fd);
G_OBJECT_CLASS (e_soap_message_parent_class)->finalize (object);
}
int main(void)
{
FILE *f;
int ret;
char chars[10];
xmlParserCtxtPtr ctxt;
xdebug_str message = {0, 0, NULL};
xdebug_xml_reader_priv data;
data.level = 0;
data.xml = NULL;
data.current = NULL;
f = fopen("test.xml", "r");
ctxt = xmlCreatePushParserCtxt(sax_handler_ptr, NULL, NULL, 0, "test");
ctxt->_private = &data;
while ((ret = fread(chars, 1, 3, f)) > 0) {
xmlParseChunk(ctxt, chars, ret, 0);
}
xmlParseChunk(ctxt, chars, 0, 1);
xdebug_xml_return_node(data.xml, &message);
xdebug_xml_node_dtor(data.xml);
printf("%s\n", message.d);
xdebug_str_dtor(message);
xmlFreeParserCtxt(ctxt);
fclose(f);
xmlCleanupParser();
xmlMemoryDump();
return 0;
}
static void ocr_callback(ocr_t *ocr, char *buf, int size)
{
if ( buf != NULL ) {
dprintf("READ '%s'\n", buf);
/* Create XML parser context if a new page is coming */
if ( ocr->xml == NULL )
ocr->xml = xmlCreatePushParserCtxt(&handlers, &(ocr->ctx), buf, size, "ocr-output");
else
xmlParseChunk(ocr->xml, buf, size, 0);
if ( (ocr->xml != NULL) && (ocr->ctx.state == OCR_STATE_END) ) {
/* End document parsing */
xmlParseChunk(ocr->xml, buf, 0, 1);
/* Free XML SAX parser */
xmlFreeParserCtxt(ocr->xml);
ocr->xml = NULL;
ocr->ctx.state = OCR_STATE_IDLE;
}
}
else {
ocr_terminate(ocr);
}
}
static void
eupnp_service_parser_free(Eupnp_Service_Parser *p)
{
if (!p) return;
if (p->ctx) xmlFreeParserCtxt(p->ctx);
free(p);
}
bool WeatherCfg::done(unsigned, Buffer &data, const char*)
{
m_ids.clear();
m_names.clear();
m_id = "";
m_data = "";
m_context = xmlCreatePushParserCtxt(&m_handler, this, "", 0, "");
if (xmlParseChunk(m_context, data.data(), data.size(), 0))
log(L_WARN, "XML parse error");
xmlFreeParserCtxt(m_context);
btnSearch->setText(i18n("&Search"));
QString oldText = cmbLocation->lineEdit()->text();
cmbLocation->clear();
if (m_ids.empty()){
cmbLocation->lineEdit()->setText(oldText);
BalloonMsg::message(i18n("Location %1 not found") .arg(oldText), btnSearch, false);
}else{
for (vector<string>::iterator it = m_names.begin(); it != m_names.end(); ++it)
cmbLocation->insertItem(QString::fromUtf8((*it).c_str()));
cmbLocation->setCurrentItem(0);
activated(0);
}
textChanged(cmbLocation->lineEdit()->text());
return false;
}
int
PmmContextREFCNT_dec( ProxyNodePtr node )
{
xmlParserCtxtPtr libnode = NULL;
int retval = 0;
if ( node != NULL ) {
retval = PmmREFCNT(node)--;
/* fprintf(stderr, "REFCNT on context 0x%08.8X decremented to %d\n", node, PmmREFCNT(node)); */
if ( PmmREFCNT(node) <= 0 ) {
xs_warn( "PmmContextREFCNT_dec: NODE DELETION\n" );
libnode = (xmlParserCtxtPtr)PmmNODE( node );
if ( libnode != NULL ) {
if (libnode->_private != NULL ) {
if ( libnode->_private != (void*)node ) {
PmmSAXCloseContext( libnode );
}
else {
xmlFree( libnode->_private );
}
libnode->_private = NULL;
}
PmmNODE( node ) = NULL;
xmlFreeParserCtxt(libnode);
}
}
xmlFree( node );
}
return retval;
}
// A modified version of XmlSAXParseFile in gnome-xml. This one lets us set
// the user_data that is passed to the various callbacks, to make it possible
// to avoid lots of global variables.
gboolean oreganoXmlSAXParseFile (xmlSAXHandlerPtr sax, gpointer user_data, const gchar *filename)
{
g_return_val_if_fail (filename != NULL, FALSE);
gboolean parser_failed, ret = TRUE;
xmlParserCtxtPtr ctxt;
ctxt = xmlCreateFileParserCtxt (filename);
if (ctxt == NULL)
return FALSE;
ctxt->sax = sax;
ctxt->userData = user_data;
#if defined(LIBXML_VERSION) && LIBXML_VERSION >= 20000
xmlKeepBlanksDefault (0);
#endif
parser_failed = FALSE;
if (xmlParseDocument (ctxt) < 0) {
// FIXME post a message to the log buffer with as much details as possible
g_message ("Failed to parse \"%s\"", filename);
ret = FALSE;
parser_failed = TRUE;
} else {
ret = ctxt->wellFormed ? TRUE : FALSE;
if (sax != NULL)
ctxt->sax = NULL;
}
if (!parser_failed)
xmlFreeParserCtxt (ctxt);
return ret;
}
xmlDocPtr _waitForAnswer(int sockfd) {
xmlParserCtxtPtr requestParserCtxt;
xmlDocPtr parsedDoc = NULL;
int resRead = 0;
int bytesRead = 0;
int readTries = 0;
int chunkParseResult = 0;
char buffer[XMLBUS_CHUNK_READLENGTH + 1];
resRead = recv(sockfd, buffer, XMLBUS_CHUNK_INITIAL_READLENGTH, 0);
if (resRead > 0) {
buffer[resRead] = '\0';
requestParserCtxt = xmlCreatePushParserCtxt(NULL, NULL, buffer, resRead, NULL);
bytesRead += resRead;
} else {
printf("Read failed socket readerror:%d -> closing clientsocket", resRead);
return NULL;
}
xmlCtxtUseOptions(requestParserCtxt,XML_PARSE_NOWARNING);
while(1) {
resRead = recv(sockfd, buffer, XMLBUS_CHUNK_READLENGTH, 0);
buffer[resRead] = '\0';
if (resRead > 0) {
chunkParseResult = xmlParseChunk(requestParserCtxt,buffer,resRead,0);
if (chunkParseResult != 0) {
xmlErrorPtr xmlErr = xmlGetLastError();
printf("request parsing found error %d: %s", chunkParseResult, xmlErr->message);
//@TODO recover or bail out
}
if (requestParserCtxt->instate == XML_PARSER_EPILOG) {
break;
}
bytesRead += resRead;
continue; // don't need to parse it another time... it is done already
} // end of reading (no data received)
else {
// Closed connection or error (in this case there is no buffer content, is it ?)
if (readTries < 5) {
readTries++;
continue;
}
else {
// end of parsing (check if the xml is valid)
if (bytesRead > 0) {
// end of reading, try to parse the message so far
break;
}
//log4c_category_error(loggerCategory, "thread %d read: data read failed, bailing out", threadId);
//close(request->clientSocket);
return NULL;
}
} // end resRead > 0 .. else
} // end while(1)
chunkParseResult = xmlParseChunk(requestParserCtxt, NULL, 0, 1);
parsedDoc = requestParserCtxt->myDoc;
xmlFreeParserCtxt(requestParserCtxt);
return parsedDoc;
}
