apr_xml_doc* UmcFramework::LoadDocument()
{
apr_xml_parser* pParser = NULL;
apr_xml_doc* pDoc = NULL;
apr_file_t* pFD = NULL;
apr_status_t rv;
const char* pFilePath;
pFilePath = apr_psprintf(m_pPool,"%s/%s",m_pDirLayout->conf_dir_path,"umcscenarios.xml");
apt_log(APT_LOG_MARK,APT_PRIO_NOTICE,"Open Config File [%s]",pFilePath);
rv = apr_file_open(&pFD,pFilePath,APR_READ|APR_BINARY,0,m_pPool);
if(rv != APR_SUCCESS)
{
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Open Config File [%s]",pFilePath);
return NULL;
}
rv = apr_xml_parse_file(m_pPool,&pParser,&pDoc,pFD,2000);
if(rv != APR_SUCCESS)
{
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Parse Config File [%s]",pFilePath);
pDoc = NULL;
}
apr_file_close(pFD);
return pDoc;
}
/** Parse config file */
static apr_xml_doc* unimrcp_server_config_parse(const char *dir_path, apr_pool_t *pool)
{
apr_xml_parser *parser;
apr_xml_doc *doc;
apr_file_t *fd;
apr_status_t rv;
const char *file_path;
if(!dir_path) {
dir_path = DEFAULT_CONF_DIR_PATH;
}
if(*dir_path == '\0') {
file_path = CONF_FILE_NAME;
}
else {
file_path = apr_psprintf(pool,"%s/%s",dir_path,CONF_FILE_NAME);
}
apt_log(APT_PRIO_NOTICE,"Open Config File [%s]",file_path);
rv = apr_file_open(&fd,file_path,APR_READ|APR_BINARY,0,pool);
if(rv != APR_SUCCESS) {
apt_log(APT_PRIO_WARNING,"Failed to Open Config File [%s]",file_path);
return NULL;
}
rv = apr_xml_parse_file(pool,&parser,&doc,fd,XML_FILE_BUFFER_LENGTH);
if(rv != APR_SUCCESS) {
apt_log(APT_PRIO_WARNING,"Failed to Parse Config File [%s]",file_path);
return NULL;
}
apr_file_close(fd);
return doc;
}
static apr_xml_doc* apt_dir_layout_doc_parse(const char *file_path, apr_pool_t *pool)
{
apr_xml_parser *parser = NULL;
apr_xml_doc *xml_doc = NULL;
apr_file_t *fd = NULL;
apr_status_t rv;
rv = apr_file_open(&fd,file_path,APR_READ|APR_BINARY,0,pool);
if(rv != APR_SUCCESS) {
return NULL;
}
rv = apr_xml_parse_file(pool,&parser,&xml_doc,fd,2000);
if(rv != APR_SUCCESS) {
xml_doc = NULL;
}
apr_file_close(fd);
return xml_doc;
}
/** Parse XML document */
static apr_xml_doc* unimrcp_client_doc_parse(const char *file_path, apr_pool_t *pool)
{
apr_xml_parser *parser = NULL;
apr_xml_doc *xml_doc = NULL;
apr_file_t *fd = NULL;
apr_status_t rv;
apt_log(APT_LOG_MARK,APT_PRIO_NOTICE,"Open Config File [%s]",file_path);
rv = apr_file_open(&fd,file_path,APR_READ|APR_BINARY,0,pool);
if(rv != APR_SUCCESS) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Open Config File [%s]",file_path);
return NULL;
}
rv = apr_xml_parse_file(pool,&parser,&xml_doc,fd,XML_FILE_BUFFER_LENGTH);
if(rv != APR_SUCCESS) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Parse Config File [%s]",file_path);
xml_doc = NULL;
}
apr_file_close(fd);
return xml_doc;
}
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;
}
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;
}
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;
}
bool UmcFramework::LoadScenario(const char* pFilePath)
{
apr_xml_parser* pParser = NULL;
apr_xml_doc* pDoc = NULL;
apr_file_t* pFD = NULL;
const apr_xml_attr* pAttr;
const apr_xml_elem* pRoot;
const char* pName = NULL;
const char* pClass = NULL;
const char* pMrcpProfile = NULL;
apr_status_t rv;
apt_log(APT_LOG_MARK,APT_PRIO_DEBUG,"Open Scenario File [%s]",pFilePath);
rv = apr_file_open(&pFD,pFilePath,APR_READ|APR_BINARY,0,m_pPool);
if(rv != APR_SUCCESS)
{
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Open Scenario File [%s]",pFilePath);
return false;
}
rv = apr_xml_parse_file(m_pPool,&pParser,&pDoc,pFD,2000);
apr_file_close(pFD);
if(rv != APR_SUCCESS)
{
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Parse Scenario File [%s]",pFilePath);
return false;
}
pRoot = pDoc->root;
if(!pRoot || strcasecmp(pRoot->name,"umcscenario") != 0)
{
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Unknown Document");
return false;
}
for(pAttr = pRoot->attr; pAttr; pAttr = pAttr->next)
{
if(strcasecmp(pAttr->name,"name") == 0)
{
pName = pAttr->value;
}
else if(strcasecmp(pAttr->name,"class") == 0)
{
pClass = pAttr->value;
}
else if(strcasecmp(pAttr->name,"profile") == 0)
{
pMrcpProfile = pAttr->value;
}
}
if(!pName)
{
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Missing Scenario Name");
return false;
}
if(!pClass)
{
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Missing Scenario Class");
return false;
}
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Load Scenario Name [%s] Class [%s]",pName,pClass);
UmcScenario* pScenario = CreateScenario(pClass);
if(!pScenario)
{
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"No Such Scenario Class [%s]",pClass);
return false;
}
pScenario->SetDirLayout(m_pDirLayout);
pScenario->SetName(pName);
pScenario->SetMrcpProfile(pMrcpProfile);
if(!pScenario->Load(pRoot,m_pPool))
{
delete pScenario;
return false;
}
apr_hash_set(m_pScenarioTable,pScenario->GetName(),APR_HASH_KEY_STRING,pScenario);
return true;
}
