/** 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);
}
/* 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;
}
static int xml_geterror(lua_State *L)
{
lua_apr_xml_object *object;
char message[LUA_APR_MSGSIZE];
object = check_xml_parser(L, 1, CHECK_PARSER);
apr_xml_parser_geterror(object->parser, message, sizeof(message));
lua_pushstring(L, message);
return 1;
}
static int push_xml_status(lua_State *L, lua_apr_xml_object *object, apr_status_t status)
{
if (status == APR_SUCCESS) {
lua_pushboolean(L, 1);
return 1;
} else {
char message[LUA_APR_MSGSIZE];
apr_xml_parser_geterror(object->parser, message, sizeof(message));
lua_pushnil(L);
lua_pushstring(L, message);
return 2;
}
}
void lt_server_logger_print_apr_xml( int priority,
apr_xml_parser * parser,
const char * format, ... )
{
va_list ap;
char error[1025];
if( priority > _logger_priority ) return;
va_start( ap, format );
vprintf( format, ap );
va_end( ap );
apr_xml_parser_geterror( parser, error, 1024 );
printf( "APR XML ERROR: %s\n", error );
fflush( stdout );
}
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;
}
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;
}
int main(int argc, const char *const * argv)
{
apr_pool_t *pool;
apr_file_t *fd;
apr_xml_parser *parser;
apr_xml_doc *doc;
apr_status_t rv;
char errbuf[2000];
char errbufXML[2000];
(void) apr_initialize();
apr_pool_create(&pool, NULL);
progname = argv[0];
if (argc == 1) {
rv = create_dummy_file(pool, &fd);
if (rv != APR_SUCCESS) {
oops("cannot create dummy file", "oops", rv);
}
}
else {
if (argc == 2) {
rv = apr_file_open(&fd, argv[1], APR_READ, APR_OS_DEFAULT, pool);
if (rv != APR_SUCCESS) {
oops("cannot open: %s", argv[1], rv);
}
}
else {
oops("usage: %s", usage, 0);
}
}
rv = apr_xml_parse_file(pool, &parser, &doc, fd, 2000);
if (rv != APR_SUCCESS) {
fprintf(stderr, "APR Error %s\nXML Error: %s\n",
apr_strerror(rv, errbuf, sizeof(errbuf)),
apr_xml_parser_geterror(parser, errbufXML, sizeof(errbufXML)));
return rv;
}
dump_xml(doc->root, 0);
apr_file_close(fd);
if (argc == 1) {
rv = create_dummy_file_error(pool, &fd);
if (rv != APR_SUCCESS) {
oops("cannot create error dummy file", "oops", rv);
}
rv = apr_xml_parse_file(pool, &parser, &doc, fd, 2000);
if (rv != APR_SUCCESS) {
fprintf(stdout, "APR Error %s\nXML Error: %s "
"(EXPECTED) This is good.\n",
apr_strerror(rv, errbuf, sizeof(errbuf)),
apr_xml_parser_geterror(parser, errbufXML, sizeof(errbufXML)));
rv = APR_SUCCESS; /* reset the return code, as the test is supposed to get this error */
}
else {
fprintf(stderr, "Expected an error, but didn't get one ;( ");
return APR_EGENERAL;
}
}
apr_pool_destroy(pool);
apr_terminate();
return rv;
}
