/* Helper func for dav_lock_to_svn_lock: take an incoming
"<D:owner><foo></D:owner>" tag and convert it to
"<foo>". */
static dav_error *
unescape_xml(const char **output,
const char *input,
apr_pool_t *pool)
{
apr_xml_parser *xml_parser = apr_xml_parser_create(pool);
apr_xml_doc *xml_doc;
apr_status_t apr_err;
const char *xml_input = apr_pstrcat
(pool, "<?xml version=\"1.0\" encoding=\"utf-8\"?>", input, (char *)NULL);
apr_err = apr_xml_parser_feed(xml_parser, xml_input, strlen(xml_input));
if (!apr_err)
apr_err = apr_xml_parser_done(xml_parser, &xml_doc);
if (apr_err)
{
char errbuf[1024];
(void)apr_xml_parser_geterror(xml_parser, errbuf, sizeof(errbuf));
return dav_svn__new_error(pool, HTTP_INTERNAL_SERVER_ERROR,
DAV_ERR_LOCK_SAVE_LOCK, errbuf);
}
apr_xml_to_text(pool, xml_doc->root, APR_XML_X2T_INNER,
xml_doc->namespaces, NULL, output, NULL);
return SVN_NO_ERROR;
}
/** Load NLSML document */
APT_DECLARE(apr_xml_doc*) nlsml_doc_load(const apt_str_t *data, apr_pool_t *pool)
{
apr_xml_parser *parser;
apr_xml_doc *doc = NULL;
const apr_xml_elem *root;
/* create XML parser */
parser = apr_xml_parser_create(pool);
if(apr_xml_parser_feed(parser,data->buf,data->length) != APR_SUCCESS) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to feed NLSML input to the parser");
return NULL;
}
/* done with XML tree creation */
if(apr_xml_parser_done(parser,&doc) != APR_SUCCESS) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to terminate NLSML parsing");
return NULL;
}
if(!doc || !doc->root) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"No NLSML root element");
return NULL;
}
root = doc->root;
/* NLSML validity check: root element must be <result> */
if(strcmp(root->name,"result") != 0) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Unexpected NLSML root element <%s>",root->name);
return NULL;
}
return doc;
}
/** Read configuration from string */
static apt_bool_t unimrcp_client_load2(unimrcp_client_loader_t *loader, const char *xmlconfig)
{
apr_pool_t *pool = loader->pool;
apr_xml_parser *parser;
apr_xml_doc *xml_doc;
char errbuf[4096];
apr_status_t rv;
parser = apr_xml_parser_create(pool);
if (!parser) return FALSE;
rv = apr_xml_parser_feed(parser, xmlconfig, strlen(xmlconfig));
if (rv != APR_SUCCESS) {
apr_xml_parser_geterror(parser, errbuf, sizeof(errbuf));
apt_log(APT_LOG_MARK, APT_PRIO_ERROR, "Error parsing XML configuration: %d %pm: %s",
rv, &rv, errbuf);
return FALSE;
}
rv = apr_xml_parser_done(parser, &xml_doc);
if (rv != APR_SUCCESS) {
apr_xml_parser_geterror(parser, errbuf, sizeof(errbuf));
apt_log(APT_LOG_MARK, APT_PRIO_ERROR, "Error parsing XML configuration: %d %pm: %s",
rv, &rv, errbuf);
return FALSE;
}
return unimrcp_client_doc_process(loader, NULL, xml_doc, pool);
}
Impl(const std::string src) : ImplAPR(), parser(NULL), doc(NULL) {
parser = apr_xml_parser_create(mPool);
check_apr(apr_xml_parser_feed(parser, src.c_str(), src.size()));
check_apr(apr_xml_parser_done(parser, &doc));
apr_xml_elem *root;
root = doc->root;
printf("root-element; name = %s, text = %s\n", root->name, root->first_cdata.first->text);
//traverse_xml_tree(root, mp);
}
int lua_apr_xml(lua_State *L)
{
lua_apr_xml_object *object;
apr_status_t status;
const char *filename;
filename = luaL_optstring(L, 1, NULL);
object = new_object(L, &lua_apr_xml_type);
if (object == NULL)
return push_error_memory(L);
status = apr_pool_create(&object->pool, NULL);
if (status != APR_SUCCESS)
return push_error_status(L, status);
if (filename == NULL) {
object->parser = apr_xml_parser_create(object->pool);
if (object->parser == NULL)
return push_error_memory(L);
} else {
apr_finfo_t info;
apr_file_t *xmlfd;
status = apr_file_open(&xmlfd, filename, APR_FOPEN_READ, 0, object->pool);
if (status != APR_SUCCESS)
return push_status(L, status);
status = apr_file_info_get(&info, APR_FINFO_SIZE, xmlfd);
if (status != APR_SUCCESS) {
apr_file_close(xmlfd);
return push_status(L, status);
}
status = apr_xml_parse_file(object->pool, &object->parser, &object->doc, xmlfd, (apr_size_t)info.size);
apr_file_close(xmlfd);
if (status != APR_SUCCESS)
return push_xml_status(L, object, status);
}
return 1;
}
APU_DECLARE(apr_status_t) apr_xml_parse_file(apr_pool_t *p,
apr_xml_parser **parser,
apr_xml_doc **ppdoc,
apr_file_t *xmlfd,
apr_size_t buffer_length)
{
apr_status_t rv;
char *buffer;
apr_size_t length;
*parser = apr_xml_parser_create(p);
if (*parser == NULL) {
/* FIXME: returning an error code would be nice,
* but we dont get one ;( */
return APR_EGENERAL;
}
buffer = apr_palloc(p, buffer_length);
length = buffer_length;
rv = apr_file_read(xmlfd, buffer, &length);
while (rv == APR_SUCCESS) {
rv = apr_xml_parser_feed(*parser, buffer, length);
if (rv != APR_SUCCESS) {
return rv;
}
length = buffer_length;
rv = apr_file_read(xmlfd, buffer, &length);
}
if (rv != APR_EOF) {
return rv;
}
rv = apr_xml_parser_done(*parser, ppdoc);
*parser = NULL;
return rv;
}
static const char *cmd_wurfldb(cmd_parms *cmd, void *dconf, const char *arg1)
{
WurflConfig *sconf;
apr_file_t *xmlfile;
apr_status_t fopen_status, xmlparse_status;
apr_xml_parser *xmlparser;
apr_xml_doc *xmldoc;
apr_time_t start, end, diff;
apr_xml_elem *child_element, *parent;
int level = 0;
if (cmd->path == NULL) { /* is server command */
sconf = ap_get_module_config(cmd->server->module_config, &wurfl_module);
fopen_status = apr_file_open(&xmlfile, arg1, APR_READ, APR_OS_DEFAULT, cmd->pool);
if( fopen_status != APR_SUCCESS )
{
char errbuf[1024] = {0};
char *errstr;
errstr = apr_strerror( fopen_status, errbuf, sizeof(errbuf) );
ap_log_error(APLOG_MARK, APLOG_ERR, xmlparse_status, cmd->server , "Error opening WURFL xml file: %s", errstr);
return NULL;
}
xmlparser = apr_xml_parser_create(cmd->pool);
start = apr_time_now();
xmlparse_status = apr_xml_parse_file(cmd->pool, &xmlparser, &xmldoc, xmlfile, 2000);
if( xmlparse_status != APR_SUCCESS )
{
if ( xmlparser == NULL ) {
ap_log_error(APLOG_MARK, APLOG_ERR, xmlparse_status, cmd->server , "Error initializing xmlparser");
} else {
char errbuf[1024] = {0};
char *errstr;
errstr = apr_xml_parser_geterror( xmlparser, errbuf, sizeof(errbuf) );
ap_log_error(APLOG_MARK, APLOG_ERR, xmlparse_status, cmd->server , "Error parsing WURFL xml file: %s", errstr);
}
return NULL;
}
end = apr_time_now();
diff = end - start;
// ap_log_error(APLOG_MARK, APLOG_NOTICE, 0, NULL , "Parsing WURFL xml file took %d microseconds", diff);
start = apr_time_now();
if (xmldoc->root) {
iterate_xml(cmd->pool, xmldoc->root, sconf->device_hash);
}
end = apr_time_now();
diff = end - start;
unsigned int hash_count = apr_hash_count(sconf->device_hash);
// ap_log_error(APLOG_MARK, APLOG_NOTICE, 0, NULL , "Intializing device_hash took %d microseconds and has %d entries", diff, hash_count);
sconf->wurfl_db = xmldoc;
}
return NULL;
}
static apr_status_t handle_response(serf_request_t *request,
serf_bucket_t *response,
void *handler_baton,
apr_pool_t *pool)
{
const char *data;
apr_size_t len;
serf_status_line sl;
apr_status_t status;
handler_baton_t *ctx = handler_baton;
if (!response) {
/* Oh no! We've been cancelled! */
abort();
}
status = serf_bucket_response_status(response, &sl);
if (status) {
if (APR_STATUS_IS_EAGAIN(status)) {
return APR_SUCCESS;
}
abort();
}
while (1) {
status = serf_bucket_read(response, 2048, &data, &len);
if (SERF_BUCKET_READ_ERROR(status))
return status;
/*fwrite(data, 1, len, stdout);*/
if (!ctx->hdr_read) {
serf_bucket_t *hdrs;
const char *val;
printf("Processing %s\n", ctx->path);
hdrs = serf_bucket_response_get_headers(response);
val = serf_bucket_headers_get(hdrs, "Content-Type");
/* FIXME: This check isn't quite right because Content-Type could
* be decorated; ideally strcasestr would be correct.
*/
if (val && strcasecmp(val, "text/html") == 0) {
ctx->is_html = 1;
apr_pool_create(&ctx->parser_pool, NULL);
ctx->parser = apr_xml_parser_create(ctx->parser_pool);
}
else {
ctx->is_html = 0;
}
ctx->hdr_read = 1;
}
if (ctx->is_html) {
apr_status_t xs;
xs = apr_xml_parser_feed(ctx->parser, data, len);
/* Uh-oh. */
if (xs) {
#ifdef SERF_VERBOSE
printf("XML parser error (feed): %d\n", xs);
#endif
ctx->is_html = 0;
}
}
/* are we done yet? */
if (APR_STATUS_IS_EOF(status)) {
if (ctx->is_html) {
apr_xml_doc *xmld;
apr_status_t xs;
doc_path_t *dup;
xs = apr_xml_parser_done(ctx->parser, &xmld);
if (xs) {
#ifdef SERF_VERBOSE
printf("XML parser error (done): %d\n", xs);
#endif
return xs;
}
dup = (doc_path_t*)
serf_bucket_mem_alloc(ctx->doc_queue_alloc,
sizeof(doc_path_t));
dup->doc = xmld;
dup->path = (char*)serf_bucket_mem_alloc(ctx->doc_queue_alloc,
ctx->path_len);
memcpy(dup->path, ctx->path, ctx->path_len);
dup->pool = ctx->parser_pool;
*(doc_path_t **)apr_array_push(ctx->doc_queue) = dup;
apr_thread_cond_signal(ctx->doc_queue_condvar);
}
apr_atomic_dec32(ctx->requests_outstanding);
serf_bucket_mem_free(ctx->allocator, ctx->path);
if (ctx->query) {
serf_bucket_mem_free(ctx->allocator, ctx->query);
serf_bucket_mem_free(ctx->allocator, ctx->full_path);
}
if (ctx->fragment) {
serf_bucket_mem_free(ctx->allocator, ctx->fragment);
}
serf_bucket_mem_free(ctx->allocator, ctx);
return APR_EOF;
}
/* have we drained the response so far? */
if (APR_STATUS_IS_EAGAIN(status))
return APR_SUCCESS;
/* loop to read some more. */
}
/* NOTREACHED */
}
AP_DECLARE(int) ap_xml_parse_input(request_rec * r, apr_xml_doc **pdoc)
{
apr_xml_parser *parser;
apr_bucket_brigade *brigade;
int seen_eos;
apr_status_t status;
char errbuf[200];
apr_size_t total_read = 0;
apr_size_t limit_xml_body = ap_get_limit_xml_body(r);
int result = HTTP_BAD_REQUEST;
parser = apr_xml_parser_create(r->pool);
brigade = apr_brigade_create(r->pool, r->connection->bucket_alloc);
seen_eos = 0;
total_read = 0;
do {
apr_bucket *bucket;
/* read the body, stuffing it into the parser */
status = ap_get_brigade(r->input_filters, brigade,
AP_MODE_READBYTES, APR_BLOCK_READ,
READ_BLOCKSIZE);
if (status != APR_SUCCESS) {
goto read_error;
}
for (bucket = APR_BRIGADE_FIRST(brigade);
bucket != APR_BRIGADE_SENTINEL(brigade);
bucket = APR_BUCKET_NEXT(bucket))
{
const char *data;
apr_size_t len;
if (APR_BUCKET_IS_EOS(bucket)) {
seen_eos = 1;
break;
}
if (APR_BUCKET_IS_METADATA(bucket)) {
continue;
}
status = apr_bucket_read(bucket, &data, &len, APR_BLOCK_READ);
if (status != APR_SUCCESS) {
goto read_error;
}
total_read += len;
if (limit_xml_body && total_read > limit_xml_body) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00539)
"XML request body is larger than the configured "
"limit of %lu", (unsigned long)limit_xml_body);
result = HTTP_REQUEST_ENTITY_TOO_LARGE;
goto read_error;
}
status = apr_xml_parser_feed(parser, data, len);
if (status) {
goto parser_error;
}
}
apr_brigade_cleanup(brigade);
} while (!seen_eos);
apr_brigade_destroy(brigade);
/* tell the parser that we're done */
status = apr_xml_parser_done(parser, pdoc);
if (status) {
/* Some parsers are stupid and return an error on blank documents. */
if (!total_read) {
*pdoc = NULL;
return OK;
}
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00540)
"XML parser error (at end). status=%d", status);
return HTTP_BAD_REQUEST;
}
#if APR_CHARSET_EBCDIC
apr_xml_parser_convert_doc(r->pool, *pdoc, ap_hdrs_from_ascii);
#endif
return OK;
parser_error:
(void) apr_xml_parser_geterror(parser, errbuf, sizeof(errbuf));
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00541)
"XML Parser Error: %s", errbuf);
/* FALLTHRU */
read_error:
/* make sure the parser is terminated */
(void) apr_xml_parser_done(parser, NULL);
apr_brigade_destroy(brigade);
/* Apache will supply a default error, plus the error log above. */
return result;
}
static apr_status_t
merge_xml_in_filter(ap_filter_t *f,
apr_bucket_brigade *bb,
ap_input_mode_t mode,
apr_read_type_e block,
apr_off_t readbytes)
{
apr_status_t rv;
request_rec *r = f->r;
merge_ctx_t *ctx = f->ctx;
apr_bucket *bucket;
int seen_eos = 0;
/* We shouldn't be added if we're not a MERGE/DELETE, but double check. */
if ((r->method_number != M_MERGE)
&& (r->method_number != M_DELETE))
{
ap_remove_input_filter(f);
return ap_get_brigade(f->next, bb, mode, block, readbytes);
}
if (!ctx)
{
f->ctx = ctx = apr_palloc(r->pool, sizeof(*ctx));
ctx->parser = apr_xml_parser_create(r->pool);
ctx->bb = apr_brigade_create(r->pool, r->connection->bucket_alloc);
apr_pool_create(&ctx->pool, r->pool);
}
rv = ap_get_brigade(f->next, ctx->bb, mode, block, readbytes);
if (rv != APR_SUCCESS)
return rv;
for (bucket = APR_BRIGADE_FIRST(ctx->bb);
bucket != APR_BRIGADE_SENTINEL(ctx->bb);
bucket = APR_BUCKET_NEXT(bucket))
{
const char *data;
apr_size_t len;
if (APR_BUCKET_IS_EOS(bucket))
{
seen_eos = 1;
break;
}
if (APR_BUCKET_IS_METADATA(bucket))
continue;
rv = apr_bucket_read(bucket, &data, &len, APR_BLOCK_READ);
if (rv != APR_SUCCESS)
return rv;
rv = apr_xml_parser_feed(ctx->parser, data, len);
if (rv != APR_SUCCESS)
{
/* Clean up the parser. */
(void) apr_xml_parser_done(ctx->parser, NULL);
break;
}
}
/* This will clear-out the ctx->bb as well. */
APR_BRIGADE_CONCAT(bb, ctx->bb);
if (seen_eos)
{
apr_xml_doc *pdoc;
/* Remove ourselves now. */
ap_remove_input_filter(f);
/* tell the parser that we're done */
rv = apr_xml_parser_done(ctx->parser, &pdoc);
if (rv == APR_SUCCESS)
{
#if APR_CHARSET_EBCDIC
apr_xml_parser_convert_doc(r->pool, pdoc, ap_hdrs_from_ascii);
#endif
/* stash the doc away for mod_dav_svn's later use. */
rv = apr_pool_userdata_set(pdoc, "svn-request-body",
NULL, r->pool);
if (rv != APR_SUCCESS)
return rv;
}
}
return APR_SUCCESS;
}
