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); } }
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 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; }
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; }
/** * Parses a descriptor that contains part of a document. */ void CXMLEngineSAXPlugin::ParseChunkL(const TDesC8& aDescriptor) { TInt result = KErrNone; if (!iParserContext) { //creating sax parser object iParserContext = xmlCreatePushParserCtxt( (xmlSAXHandler*) &iParserEvents, this, (const char *) aDescriptor.Ptr(), aDescriptor.Length(), NULL ); if(!iParserContext) { CleanupAndLeaveL(KErrNoMemory); } //creating empty document object iParserContext->myDoc = xmlNewDoc(BAD_CAST "SAX compatibility mode document"); if(!iParserContext->myDoc) { CleanupAndLeaveL(KErrNoMemory); } iParserContext->myDoc->intSubset = xmlNewDtd(iParserContext->myDoc, BAD_CAST "fake", NULL, NULL); if(!iParserContext->myDoc->intSubset) { CleanupAndLeaveL(KErrNoMemory); } //parsing process result = xmlParseChunk(iParserContext, NULL, 0, 0); } else { //parsing process result = xmlParseChunk( iParserContext, (const char *) aDescriptor.Ptr(), aDescriptor.Length(), 0); } //handling error situation //if fatal error, function throws exception //in any other case next chunk is taken (recoverable) if ((result == XML_ERR_NO_MEMORY) || (iParserContext->lastError.level == XML_ERR_FATAL) || (result < 0)) { CleanupAndLeaveL(GetErrorNum(result)); } }
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 xmms_rss_browse (xmms_xform_t *xform, const gchar *url, xmms_error_t *error) { int ret; char buffer[1024]; xmlSAXHandler handler; xmlParserCtxtPtr ctx; xmms_rss_data_t data; g_return_val_if_fail (xform, FALSE); memset (&handler, 0, sizeof (handler)); memset (&data, 0, sizeof (data)); handler.startElement = (startElementSAXFunc) xmms_rss_start_element; handler.error = (errorSAXFunc) xmms_rss_error; handler.fatalError = (fatalErrorSAXFunc) xmms_rss_error; data.xform = xform; data.error = error; data.parse_failure = FALSE; xmms_error_reset (error); ctx = xmlCreatePushParserCtxt (&handler, &data, buffer, 0, NULL); if (!ctx) { xmms_error_set (error, XMMS_ERROR_OOM, "Could not allocate xml parser"); return FALSE; } while ((ret = xmms_xform_read (xform, buffer, sizeof (buffer), error)) > 0) { xmlParseChunk (ctx, buffer, ret, 0); } if (ret < 0) { xmms_error_set (error, XMMS_ERROR_GENERIC, "xmms_xform_read failed"); return FALSE; } if (data.parse_failure) return FALSE; xmlParseChunk (ctx, buffer, 0, 1); xmms_error_reset (error); xmlFreeParserCtxt (ctx); 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; }
/** * 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; }
/* feed a chunk of data to the parser */ int parser_feed(parser_t *parser, char *chunk, int len) { if (XML_ERR_OK == xmlParseChunk(parser->xmlctx, chunk, len, 0)) return 1; else 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; }
static void soap_got_chunk (SoupMessage *msg, SoupBuffer *chunk, gpointer data) { ESoapMessagePrivate *priv = E_SOAP_MESSAGE_GET_PRIVATE (msg); if (msg->status_code != 200) return; priv->response_received += chunk->length; if (priv->response_size && priv->progress_fn) { gint pc = priv->response_received * 100 / priv->response_size; priv->progress_fn (priv->progress_data, pc); } if (!priv->ctxt) { priv->ctxt = xmlCreatePushParserCtxt (NULL, msg, chunk->data, chunk->length, NULL); priv->ctxt->_private = priv; priv->ctxt->sax->startElementNs = soap_sax_startElementNs; priv->ctxt->sax->endElementNs = soap_sax_endElementNs; priv->ctxt->sax->characters = soap_sax_characters; } else xmlParseChunk (priv->ctxt, chunk->data, chunk->length, 0); }
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; }
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; }
ret_t cherokee_handler_tmi_step (cherokee_handler_tmi_t *hdl, cherokee_buffer_t *buffer) { char time_buf[21]; size_t len; len = strftime(time_buf, 21, "%Y-%m-%dT%H:%S:%MZ", &cherokee_bogonow_tmgmt); cherokee_buffer_add_buffer (buffer, &HANDLER_TMI_PROPS(hdl)->reply); cherokee_buffer_add (buffer, time_buf, len); #ifdef LIBXML_PUSH_ENABLED if (hdl->validate_xml) { cherokee_buffer_add_str (buffer, "</tmi8:Timestamp><tmi8:ResponseCode>"); if (hdl->inflated && hdl->z_ret != Z_OK) { cherokee_buffer_add_str(buffer, "PE"); } else { xmlParseChunk(hdl->ctxt, NULL, 0, 1); if (hdl->ctxt->wellFormed) { cherokee_buffer_add_str(buffer, "OK"); } else { cherokee_buffer_add_str(buffer, "SE"); } } cherokee_buffer_add_str (buffer, "</tmi8:ResponseCode></tmi8:VV_TM_RES>"); return ret_eof_have_data; } #endif cherokee_buffer_add_str (buffer, "</tmi8:Timestamp><tmi8:ResponseCode>OK</tmi8:ResponseCode></tmi8:VV_TM_RES>"); return ret_eof_have_data; }
/** * 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); }
xmlDocPtr ParseXML(SDL_RWops *io) { const size_t bufsize = 1024; size_t res; char buf [bufsize]; xmlParserCtxtPtr ctxt; xmlDocPtr doc; // read first 4 bytes if ((res = io->read (io, buf, 1, 4)) < 4) { SetError ("Failed to read first xml bytes: %s", SDL_GetError ()); return NULL; } // Create a progressive parsing context ctxt = xmlCreatePushParserCtxt (NULL, NULL, buf, res, NULL); if (! ctxt) { SetError ("Failed to create parser context!"); return NULL; } // loop on the input getting the document data while ((res = io->read (io, buf, 1, bufsize)) > 0) { xmlParseChunk (ctxt, buf, res, 0); } // there is no more input, indicate the parsing is finished. xmlParseChunk (ctxt, buf, 0, 1); // check if it was well formed doc = ctxt->myDoc; res = ctxt->wellFormed; xmlFreeParserCtxt (ctxt); if (!res) { SetError ("xml document is not well formed"); xmlFreeDoc (doc); doc = NULL; } return doc; }
/***************************************************************************** * Update the parser with more file content. ****************************************************************************/ void mxml_update(void *data, const char *chunk, size_t size, short end) { MXML_T *parser; int result; parser = (MXML_T*)data; if ((result = xmlParseChunk(parser->ctxt, chunk, size, end)) != 0) { local_error(parser->data, "MEME XML parser returned error code %d.\n", result); } }
void close_gps_file(struct gpsfile *gpsf,int closefd) { if (gpsf->ctxt) { xmlParseChunk(gpsf->ctxt,gpsf->buf,0,1); xmlFreeParserCtxt(gpsf->ctxt); } if (closefd) close(gpsf->fd); free(gpsf); }
/* feed a chunk of data to the parser */ int parser_feed(parser_t *parser, char *chunk, int len) { /* xmlParseChunk API returns 0 on success which is opposite logic to the status returned by parser_feed */ if(!xmlParseChunk(parser->xmlctx, chunk, len, 0)) { return 1; } else { return 0; } }
EAPI Eina_Bool eupnp_service_parse_buffer(const char *buffer, int buffer_len, Eupnp_Service_Proxy *s) { Eina_Bool ret = EINA_FALSE; if ((!buffer) || (!buffer_len) || (!s)) return ret; Eupnp_Service_Parser *parser; if (!s->xml_parser) { /* Creates the parser, which parses the first chunk */ DBG("Creating service parser."); s->xml_parser = eupnp_service_parser_new(buffer, buffer_len, s); if (!s->xml_parser) { ERR("Failed to parse first chunk"); goto parse_ret; } ret = EINA_TRUE; goto parse_ret; } parser = s->xml_parser; if (!parser->ctx) { // first_chunk_len < 4 case eina_error_set(EUPNP_ERROR_SERVICE_PARSER_INSUFFICIENT_FEED); return EINA_FALSE; } // Progressive feeds if (parser->state.state == FINISH) { WRN("Already finished parsing"); ret = EINA_TRUE; goto parse_ret; } DBG("Parsing XML (%d) at %p", buffer_len, buffer); if (!xmlParseChunk(parser->ctx, buffer, buffer_len, 0)) { ret = EINA_TRUE; goto parse_ret; } parse_ret: eupnp_service_parse_check_finished(s); return ret; }
size_t ParseXML::ParseHandler(char* data, size_t size, size_t count, ParseXML* This) { if((xmlParseChunk(This->mXmlContext, data, (int)(size * count), 0) == 0) && !This->mXmlContext->disableSAX) { return size * count; } else { std::cout << Error << std::endl; return 0; } }
bool LibXMLParser::parse(const std::string& data) { if (xmlParseChunk(context_, data.c_str(), data.size(), false) == XML_ERR_OK) { return true; } xmlError* error = xmlCtxtGetLastError(context_); if (error->code == XML_WAR_NS_URI || error->code == XML_WAR_NS_URI_RELATIVE) { xmlCtxtResetLastError(context_); context_->errNo = XML_ERR_OK; return true; } return false; }
void parseAndPrintFile(char *filename) { int res; FILE *f; char chars[CHUNKSIZE]; f = fopen(filename, "r"); if (f != NULL) { xmlParserCtxtPtr ctxt; res = fread(chars, 1, 4, f); if (res > 0) { ctxt = xmlCreatePushParserCtxt(SAXHandler, NULL, chars, res, filename); while ((res = fread(chars, 1, CHUNKSIZE, f)) > 0) { xmlParseChunk(ctxt, chars, res, 0); } xmlParseChunk(ctxt, chars, 0, 1); xmlFreeParserCtxt(ctxt); } fclose(f); } }
static void _unxmlize (gchar *string, ResultBuffer *buffer) { xmlParserCtxtPtr ctxt; xmlSAXHandler *sax_p; sax_p = g_new0 (xmlSAXHandler, 1); sax_p->characters = unhtmlizeHandleCharacters; ctxt = xmlCreatePushParserCtxt (sax_p, buffer, string, strlen (string), ""); xmlParseChunk (ctxt, string, 0, 1); xmlFreeParserCtxt (ctxt); g_free(sax_p); }
bool XepParser::parse(QFile &f) { char buf[4096]; char XML_START[] = "<smiles>"; xmlParseChunk(m_context, XML_START, strlen(XML_START), 0); unsigned start = 0; for (;;){ char s32[] = "<32bit_Icons>"; char e32[] = "</32bit_Icons>"; int size = f.readBlock(&buf[start], sizeof(buf) - start); if (size <= 0) break; size += start; replace(buf, size, s32, "<AA"); replace(buf, size, e32, "</AA"); if (size == sizeof(buf)){ start = strlen(e32); size -= start; } if (xmlParseChunk(m_context, buf, size, 0)) return false; if (start) memmove(buf, &buf[sizeof(buf) - start], start); } if ((m_pict.size() == 0) || (m_width == 0) || (m_height == 0)) return false; Buffer pict; pict.fromBase64(m_pict); if (pict.size() < 28) return false; QByteArray arr; arr.assign(pict.data(28), pict.size() - 28); QImage img(arr); if ((img.width() == 0) || (img.height() == 0)) return false; m_image.convertFromImage(img); return true; }
static Eina_Bool eupnp_service_parse_finish(Eupnp_Service_Proxy *d) { if (!d) return; if (!d->xml_parser) return; DBG("Service SCPD parse finish"); Eina_Bool ret; Eupnp_Service_Parser *parser = d->xml_parser; ret = xmlParseChunk(parser->ctx, NULL, 0, 1); eupnp_service_parser_free(parser); d->xml_parser = NULL; return !ret; }
S3Status simplexml_add(SimpleXml *simpleXml, const char *data, int dataLen) { if (!simpleXml->xmlParser && (!(simpleXml->xmlParser = xmlCreatePushParserCtxt (&saxHandlerG, simpleXml, 0, 0, 0)))) { return S3StatusInternalError; } if (xmlParseChunk((xmlParserCtxtPtr) simpleXml->xmlParser, data, dataLen, 0)) { return S3StatusXmlParseFailure; } return simpleXml->status; }
void CXMPPSocket::ReadData(const char *data, size_t len) { if (m_bResetParser) { m_uiDepth = 0; if (m_xmlContext) { xmlFreeParserCtxt(m_xmlContext); } m_xmlContext = xmlCreatePushParserCtxt(&m_xmlHandlers, this, NULL, 0, NULL); m_bResetParser = false; } xmlParseChunk(m_xmlContext, data, len, 0); }
static Eupnp_Service_Parser * eupnp_service_parser_new(const char *first_chunk, int first_chunk_len, Eupnp_Service_Proxy *d) { if (first_chunk_len < 4) { WRN("First chunk length less than 4 chars, user must provide more than 4."); return NULL; } Eupnp_Service_Parser *p; p = calloc(1, sizeof(Eupnp_Service_Parser)); if (!p) { ERR("Failed to alloc for service parser"); return NULL; } p->handler.initialized = XML_SAX2_MAGIC; p->handler.characters = &_characters; p->handler.error = &error; p->handler.startElementNs = &start_element_ns; p->handler.endElementNs = &end_element_ns; /* * Setup parser state to START, attach the service info object that * will get data written into. */ p->state.state = START; p->state.data = d; p->state.send_events = EINA_TRUE; // default is YES p->ctx = xmlCreatePushParserCtxt(&p->handler, &p->state, first_chunk, first_chunk_len, NULL); // Force first chunk parse. When not forced, the parser gets lazy on the // first time and doesn't parse one-big-chunk feeds. xmlParseChunk(p->ctx, NULL, 0, 0); if (!p->ctx) { free(p); return NULL; } return p; }