Bool load_config (const char *filename)
{
int rc;
XML_ITEM *config = NULL;
XML_ITEM *root = NULL;
char fullname[FILE_NAME_MAX + 1];
root = xml_create ("root", NULL);
ASSERT (filename != NULL);
ASSERT (strlen(filename) < FILE_NAME_MAX);
default_extension (fullname, filename, "cfg");
rc = xml_load_file (&root, ".", fullname, FALSE);
if (rc != XML_NOERROR)
{
coprintf ("Error while loading \"%s\". Check file presence and consistence",
fullname);
display_usage ();
return FALSE;;
}
config = xml_first_child (root);
ASSERT (config);
/* default server is localhost */
main_server = mem_strdup (xml_get_attr (config, "smtp", "127.0.0.1"));
main_sender = mem_strdup (xml_get_attr (config, "sender", "admin@crjo"));
main_dest = mem_strdup (xml_get_attr (config, "dest", "user@crjo"));
xml_free (root);
return TRUE;
}
void
prepare_xml_file (char *filename)
{
int
rc;
rc = xml_load_file (& xml_root, PATH, filename, FALSE);
if (rc == XML_NOERROR)
{
xml_source = xml_first_child (xml_root);
if (xml_source)
{
xml_put_attr (xml_switches, "filename", filename);
xml_put_attr (xml_switches, "template", "1");
}
else
xml_free (xml_root);
}
else
{
coprintf ("%s E: Error processing %s...", me, filename);
coprintf (xml_error ());
raise_exception (anomaly_event);
}
}
int main (int argc, char *argv [])
{
XML_ITEM
*root;
root = xml_new (NULL, "root", "");
if (xml_load_file (&root, ".", argv[1], FALSE) == 0)
{
xml_save_string (root);
xml_save_file (root, "testxml.txt");
xml_free (root);
}
else
printf ("Load error: %s\n", xml_error ());
return (EXIT_SUCCESS);
}
MODULE load_ddns_services_list (THREAD *thread)
{
char
*filename;
filename = CONFIG ("ddns:filename");
services = NULL;
switch (xml_load_file (&services, "PATH", filename, FALSE))
{
case XML_FILEERROR:
sendfmt (&operq, "ERROR",
"xiddns: cannot read '%s': %s", filename, xml_error ());
raise_exception (exception_event);
break;
case XML_LOADERROR:
sendfmt (&operq, "ERROR",
"xiddns: error in '%s': %s", filename, xml_error ());
raise_exception (exception_event);
break;
}
}
MODULE load_pipe_definitions (THREAD *thread)
{
if (file_where ('r', "PATH", filename, NULL))
{
pipes = NULL;
if (xml_load_file (&pipes, "PATH", filename, FALSE) != XML_NOERROR)
{
send_smtoper_error (&operq,
strprintf ("smtpipe: error in '%s': %s",
filename,
xml_error ()));
raise_exception (exception_event);
}
}
else
{
send_smtoper_error (&operq,
strprintf ("smtpipe: '%s' not found",
filename));
send_smtoper_error (&operq,
strerror (errno));
raise_exception (exception_event);
}
}
LsiCtl* lsi_ctl_create(const char* cfg_file)
{
if (!cfg_file)
{
return NULL;
}
LsiCtl* lsi_ctl = (LsiCtl*)malloc(sizeof(LsiCtl));
memset(lsi_ctl, 0, sizeof(lsi_ctl));
mxml_node_t* cfgdoc = xml_load_file(cfg_file);
if (!cfgdoc)
{
return NULL;
}
// lsi head
mxml_node_t* cfghandler = xml_find_child_element(cfgdoc, cfgdoc, "LsiCfg");
mxml_node_t* shmkey = xml_find_child_element(cfghandler, cfgdoc, "ShmKey");
assert(shmkey);
lsi_ctl->m_head.m_shm_key = atoi(xml_element_get_text(shmkey));
mxml_node_t* count = xml_find_child_element(cfghandler, cfgdoc, "ChannelCount");
assert(shmkey);
lsi_ctl->m_head.m_chan_count = atoi(xml_element_get_text(count)) * 2;
mxml_node_t* version = xml_find_child_element(cfghandler, cfgdoc, "Version");
lsi_ctl->m_head.m_version = atoi(xml_element_get_text(version));
lsi_ctl->m_head.m_size += sizeof(lsi_ctl->m_head);
// lsi channel
mxml_node_t* chan, *addr_1, *addr_2, *size;
int i = 0;
chan = version;
while (1)
{
chan = xml_find_sibling_element(chan, cfgdoc, "Channel");
if (!chan)
{
break;
}
addr_1 = xml_find_child_element(chan, cfgdoc, "Address");
assert(addr_1);
lsi_ip_t lsi_addr_1 = lsi_addr_aton(xml_element_get_text(addr_1));
addr_2 = xml_find_sibling_element(addr_1, cfgdoc, "Address");
assert(addr_2);
lsi_ip_t lsi_addr_2 = lsi_addr_aton(xml_element_get_text(addr_2));
size = xml_find_child_element(chan, cfgdoc, "Size");
int chan_size = atoi(xml_element_get_text(size));
lsi_ctl->m_chan[i * 2].m_from = lsi_addr_1;
lsi_ctl->m_chan[i * 2].m_to = lsi_addr_2;
lsi_ctl->m_chan[i * 2].m_size = ROUNDUP_POWOF_2(chan_size);
lsi_ctl->m_chan[i * 2 + 1].m_from = lsi_addr_2;
lsi_ctl->m_chan[i * 2 + 1].m_to = lsi_addr_1;
lsi_ctl->m_chan[i * 2 + 1].m_size = ROUNDUP_POWOF_2(chan_size);
lsi_ctl->m_head.m_size += (ROUNDUP_POWOF_2(chan_size) + sizeof(LsiChanHead)) * 2;
i ++;
}
return lsi_ctl;
}
static int
load_service_config (const char *binary_name)
{
XML_ITEM
*root = NULL,
*item,
*child;
int
res = 0,
rc;
if (! file_exists (application_config))
{
log_printf ("ERROR: cannot find config file '%s'", application_config);
return -1;
}
rc = xml_load_file (&root, NULL, application_config, FALSE);
if (rc != XML_NOERROR)
{
log_printf ("ERROR: cannot load XML file '%s' (%s)", application_config, xml_error());
return -1;
}
item = xml_first_child (root);
if (item)
{
FORCHILDREN (child, item)
{
if (streq (xml_item_name(child), "service"))
{
service_name =
mem_strdup (xml_get_attr (child, "name", NULL));
service_display_name =
mem_strdup (xml_get_attr (child, "display_name", NULL));
service_trace_file =
mem_strdup (xml_get_attr (child, "trace_file", "smt_service.log"));
service_debug =
atoi (xml_get_attr(child, "debug", "0"));
break;
}
}
}
#if (defined(WIN32))
/* service_name and service_display_name are only used with windows */
/* services, when registering or removing the service. */
/* these fields are mandatory in Windows service configuration, but */
/* not used in UNIX daemons */
if (!service_name)
{
log_printf (
"ERROR: item 'service_name' is missing in XML file '%s'",
application_config);
res = -1;
}
if (!service_display_name)
{
log_printf (
"ERROR: item 'service_text' is missing in XML file '%s'",
application_config);
res = -1;
}
#endif
xml_free (root);
if (!res)
{
debug_printf ("Service configuration successfully loaded");
}
else
free_resources ();
return res;
}
