int main(int argc, char* argv[])
{
int i;
if((EzxmlBase = OpenLibrary("ezxml.library", 8)))
{
ezxml_t xml;
char *s;
if (argc != 2) return Printf("usage: %s xmlfile\n", argv[0]);
xml = ezxml_parse_file(argv[1]);
Printf("%s\n", (s = ezxml_toxml(xml)));
FreeVec(s);
i = Printf("%s", ezxml_error(xml));
ezxml_free(xml);
CloseLibrary(EzxmlBase);
}
else
PutStr("Error: Could not open ezxml.library\n");
return (i) ? 1 : 0;
}
int main()
{
int kanji[200][2];
int i = 0;
int8_t test = 8;
ezxml_t f1 = ezxml_parse_file("4e86.xml"), stroke, point;
const char *teamname;
for (stroke = ezxml_child(f1, "stroke"); stroke; stroke = stroke->next) {
printf("new stroke\n");
for (point = ezxml_child(stroke, "point"); point; point = point->next) {
kanji[i][0] = atoi(ezxml_attr(point,"x"));
kanji[i][1] = atoi(ezxml_attr(point,"y"));
i++;
// printf("%i",i);
// printf("%s \n", ezxml_attr(point,"x"));
}
}
ezxml_free(f1);
for(int j = 0;j<50;j++) {
printf("j: %i, x: %i, y: %i\n", j, kanji[j][0], kanji[j][1]);
}
return 0;
}
Book *book_load_file(const char *path)
{
Book *book;
ezxml_t beyonwiz_xml, timerlist_xml, timer_xml;
Timer *timer;
int i;
const char *fname;
book = (Book *)malloc(sizeof(Book));
book->n_timers = 0;
book->timers = NULL;
beyonwiz_xml = ezxml_parse_file(path);
timerlist_xml = ezxml_child(beyonwiz_xml, "TimerList");
//FIXME check to make sure we are reading a version 5 timerlist.
if(timerlist_xml)
{
for(timer_xml = ezxml_child(timerlist_xml, "Timer"); timer_xml; timer_xml = timer_xml->next)
{
book->n_timers++;
}
printf("number of timers = %d\n", book->n_timers);
timer = (Timer *)malloc(sizeof(Timer) * book->n_timers);
book->timers = timer;
for(i=0,timer_xml = ezxml_child(timerlist_xml, "Timer"); timer_xml; timer_xml = timer_xml->next,i++)
{
fname = ezxml_attr(timer_xml, "fname");
timer->filename = (char *)malloc(strlen(fname) + 1);
strcpy(timer->filename, fname);
timer->startmjd = atoi(ezxml_attr(timer_xml, "startMjd"));
timer->nextmjd = atoi(ezxml_attr(timer_xml, "nextMjd"));
timer->start = atoi(ezxml_attr(timer_xml, "start"));
timer->duration = atoi(ezxml_attr(timer_xml, "duration"));
timer->repeat = atoi(ezxml_attr(timer_xml, "repeat"));
timer->play = atoi(ezxml_attr(timer_xml, "play"));
timer->lock = atoi(ezxml_attr(timer_xml, "lock"));
timer->onid = atoi(ezxml_attr(timer_xml, "onId"));
timer->tsid = atoi(ezxml_attr(timer_xml, "tsId"));
timer->svcid = atoi(ezxml_attr(timer_xml, "svcId"));
printf("timer fname = %s, startMjd = %d, start = %d\n", timer->filename, timer->startmjd, timer->start);
timer++;
}
}
ezxml_free(beyonwiz_xml);
return book;
}
/* ------------------------------------------------------------------------- */
Reg_TRegistry* Reg_CreateFromFile(const char* file_name)
{
Reg_TRegistry *const reg = Mem_Alloc(sizeof(Reg_TRegistry));
if (!reg)
return NULL;
memset(reg, 0, sizeof(*reg));
reg->m_file_name = strdup(file_name);
if ((reg->m_root = ezxml_parse_file(file_name)))
return reg;
if (!(reg->m_root = ezxml_new("registry")))
{
Mem_Free(reg);
return NULL;
}
return reg;
}
/**
* parse_menu_XML(char *file, app_info_s * app_info)
* @brief parse the XML menu and confirm tags are present
* @param file
* @param app_info
* @return < 0 for error, 0 for success
*/
static int parse_menu_XML(char *file, appconfig_t * app_info)
{
ezxml_t app_config = ezxml_parse_file(file);
ezxml_t app_attributes = NULL;
int err = 0;
// Are app attributes defined?
if ((app_attributes = ezxml_child(app_config, "appAttributes")) == NULL) {
printf("appAttributes is missing\n");
return (-1);
}
// Parse application attributes from XML
if (get_app_attributes(app_attributes, app_info) < 0) {
printf("appAttributes error\n");
return (-1);
}
ezxml_free(app_config);
return err;
}
int config_load()
{
ezxml_t config_xml, root;
// Clear configuration structure
memset(import_patch_map, 0, sizeof(import_patch_map));
memset(import_percussion_map, 0, sizeof(import_percussion_map));
// Attempt to load configuration XML
if((config_xml = ezxml_parse_file(CONFIG_XML)) == NULL)
{
if(errno == ENOENT || errno == EACCES)
// Handle file errors
fprintf(stderr, "Unable to open " CONFIG_XML);
else
fprintf(stderr, ezxml_error(config_xml));
return 0;
}
if((root = required_child(config_xml, "patches")) == NULL)
return 0;
process_import_map(root, import_patch_map, "patch");
if((root = required_child(config_xml, "noises")) == NULL)
return 0;
process_import_map(root, import_noise_map, "noise");
if((root = required_child(config_xml, "percussions")) == NULL)
return 0;
process_import_map(root, import_percussion_map, "percussion");
ezxml_free(config_xml);
return 1;
}
/* Load a BSDF struct from the given file (free first and keep name) */
SDError
SDloadFile(SDData *sd, const char *fname)
{
SDError lastErr;
ezxml_t fl, wtl;
if ((sd == NULL) | (fname == NULL || !*fname))
return SDEargument;
/* free old data, keeping name */
SDfreeBSDF(sd);
/* parse XML file */
fl = ezxml_parse_file(fname);
if (fl == NULL) {
sprintf(SDerrorDetail, "Cannot open BSDF \"%s\"", fname);
return SDEfile;
}
if (ezxml_error(fl)[0]) {
sprintf(SDerrorDetail, "BSDF \"%s\" %s", fname, ezxml_error(fl));
ezxml_free(fl);
return SDEformat;
}
if (strcmp(ezxml_name(fl), "WindowElement")) {
sprintf(SDerrorDetail,
"BSDF \"%s\": top level node not 'WindowElement'",
sd->name);
ezxml_free(fl);
return SDEformat;
}
wtl = ezxml_child(fl, "FileType");
if (wtl != NULL && strcmp(ezxml_txt(wtl), "BSDF")) {
sprintf(SDerrorDetail,
"XML \"%s\": wrong FileType (must be 'BSDF')",
sd->name);
ezxml_free(fl);
return SDEformat;
}
wtl = ezxml_child(ezxml_child(fl, "Optical"), "Layer");
if (wtl == NULL) {
sprintf(SDerrorDetail, "BSDF \"%s\": no optical layers'",
sd->name);
ezxml_free(fl);
return SDEformat;
}
/* load geometry if present */
lastErr = SDloadGeometry(sd, wtl);
if (lastErr) {
ezxml_free(fl);
return lastErr;
}
/* try loading variable resolution data */
lastErr = SDloadTre(sd, wtl);
/* check our result */
if (lastErr == SDEsupport) /* try matrix BSDF if not tree data */
lastErr = SDloadMtx(sd, wtl);
/* done with XML file */
ezxml_free(fl);
if (lastErr) { /* was there a load error? */
SDfreeBSDF(sd);
return lastErr;
}
/* remove any insignificant components */
if (sd->rf != NULL && sd->rf->maxHemi <= .001) {
SDfreeSpectralDF(sd->rf); sd->rf = NULL;
}
if (sd->rb != NULL && sd->rb->maxHemi <= .001) {
SDfreeSpectralDF(sd->rb); sd->rb = NULL;
}
if (sd->tf != NULL && sd->tf->maxHemi <= .001) {
SDfreeSpectralDF(sd->tf); sd->tf = NULL;
}
if (sd->tb != NULL && sd->tb->maxHemi <= .001) {
SDfreeSpectralDF(sd->tb); sd->tb = NULL;
}
/* return success */
return SDEnone;
}
int main() {
printf("Reading XML.. .. ..\n");
ezxml_t f1 = ezxml_parse_file("test.xml"), classification, temp, algo, temp2;
classification = ezxml_child(f1, "classification");
temp = ezxml_child(classification, "algorithm");
algo = ezxml_child(temp, "MultiLayerPerceptron");
const unsigned int num_input = atoi(ezxml_child(classification, "input")->txt);
const unsigned int num_output = atoi(ezxml_child(classification, "output")->txt);
const unsigned int num_layers = atoi(ezxml_child(classification, "numberOfLayers")->txt);
const unsigned int num_neurons_hidden = atoi(ezxml_child(algo, "hiddenNeurons")->txt);
const float desired_error = (const float) (atof(ezxml_child(algo, "desiredError")->txt));
const unsigned int max_epochs = atoi(ezxml_child(algo, "maxEpochs")->txt);
const unsigned int epochs_between_reports = atoi(ezxml_child(algo, "epochsBetweenReports")->txt);
fann_type *calc_out;
struct fann *ann;
struct fann_train_data *data;
unsigned int i = 0;
unsigned int decimal_point;
printf("Creating network.\n");
ann = fann_create_standard(num_layers, num_input, num_neurons_hidden, num_output);
data = fann_read_train_from_file(ezxml_child(classification, "datafile")->txt);
fann_set_activation_steepness_hidden(ann, atoi(ezxml_child(algo, "hiddenActivationSteepness")->txt));
fann_set_activation_steepness_output(ann, atoi(ezxml_child(algo, "outputActivationSteepness")->txt));
fann_set_activation_function_hidden(ann, FANN_SIGMOID_SYMMETRIC);
fann_set_activation_function_output(ann, FANN_SIGMOID_SYMMETRIC);
temp2 = ezxml_child(algo, "trainStopFuction");
const char *stopFunc = temp2->txt;
if(stopFunc == "FANN_STOPFUNC_BIT"){
fann_set_train_stop_function(ann, FANN_STOPFUNC_BIT);
} else {
fann_set_train_stop_function(ann, FANN_STOPFUNC_MSE);
}
fann_set_bit_fail_limit(ann, 0.01f);
fann_set_training_algorithm(ann, FANN_TRAIN_RPROP);
fann_init_weights(ann, data);
printf("Training network.\n");
fann_train_on_data(ann, data, max_epochs, epochs_between_reports, desired_error);
printf("Testing network. %f\n", fann_test_data(ann, data));
for(i = 0; i < fann_length_train_data(data); i++)
{
calc_out = fann_run(ann, data->input[i]);
printf("Test Results (%f,%f,%f) -> %f, should be %f, difference=%f\n",
data->input[i][0], data->input[i][1], data->input[i][2], calc_out[0], data->output[i][0],
fann_abs(calc_out[0] - data->output[i][0]));
}
printf("Saving network.\n");
fann_save(ann, "xor_float.net");
decimal_point = fann_save_to_fixed(ann, "xor_fixed.net");
fann_save_train_to_fixed(data, "xor_fixed.data", decimal_point);
printf("Cleaning up.\n");
fann_destroy_train(data);
fann_destroy(ann);
ezxml_free(f1);
return 0;
}
struct governor_config *
config_init (const char *path)
{
ezxml_t xml = ezxml_parse_file (path);
ezxml_t tmp_xml, inner_xml, tmp_xml_limit;
const char *error_str;
const char *ptr;
if (xml == NULL)
{
fprintf (stderr, "Error reading config file %s\n", path);
exit (-1);
}
if (strlen (error_str = ezxml_error (xml)))
{
fprintf (stderr, "Error in config file (%s): %s\n", path, error_str);
ezxml_free (xml);
exit (-1);
}
cfg = calloc (1, sizeof (struct governor_config));
memset (cfg, 0, sizeof (struct governor_config));
cfg->is_gpl = check_liblve();
cfg->account_limits = g_hash_table_new_full (g_str_hash, g_str_equal,
(GDestroyNotify) free,
(GDestroyNotify) free);
tmp_xml = ezxml_child (xml, "log");
if (tmp_xml == NULL)
{
fprintf (stderr, "No log path\n");
exit (-1);
}
cfg->log = strdup (ezxml_attr (tmp_xml, "file"));
cfg->log_mode =
((ptr =
ezxml_attr (tmp_xml,
"mode")) ==
NULL) ? ERROR_MODE : mode_type_str_to_enum (ptr);
tmp_xml = ezxml_child (xml, "intervals");
if (tmp_xml == NULL)
{
fprintf (stderr, "No 'intervals' parameter\n");
exit (-1);
}
cfg->interval_short =
((ptr = ezxml_attr (tmp_xml, "short")) == NULL) ? 5 : atoi (ptr);
cfg->interval_mid =
((ptr = ezxml_attr (tmp_xml, "mid")) == NULL) ? 15 : atoi (ptr);
cfg->interval_long =
((ptr = ezxml_attr (tmp_xml, "long")) == NULL) ? 30 : atoi (ptr);
tmp_xml = ezxml_child (xml, "lve");
cfg->use_lve = 0;
cfg->all_lve = 0;
cfg->separate_lve = 0;
if(tmp_xml != NULL){
if (ezxml_attr (tmp_xml, "use")){
if(!strcasecmp(ezxml_attr (tmp_xml, "use"),"On") ||
!strcasecmp(ezxml_attr (tmp_xml, "use"),"Single")){
cfg->use_lve = 1;
}
if(!strcasecmp(ezxml_attr (tmp_xml, "use"),"AbUsers")){
cfg->use_lve = 1;
cfg->separate_lve = 1;
}
if(!strcasecmp(ezxml_attr (tmp_xml, "use"),"All")){
cfg->use_lve = 1;
cfg->all_lve = 1;
cfg->separate_lve = 1;
}
}
}
tmp_xml = ezxml_child (xml, "statistic");
cfg->statistic_mode = 1;
if( tmp_xml != NULL )
{
if( ezxml_attr( tmp_xml, "mode" ) )
{
if( !strcasecmp( ezxml_attr( tmp_xml, "mode" ), "Off" ) )
{
cfg->statistic_mode = 0;
}
}
}
tmp_xml = ezxml_child (xml, "debug_user");
cfg->debug_user = NULL;
if( tmp_xml != NULL )
{
if( ezxml_attr( tmp_xml, "name" ) )
{
cfg->debug_user = strdup (ezxml_attr (tmp_xml, "name"));
}
}
tmp_xml = ezxml_child( xml, "logqueries" );
cfg->logqueries_use = 0;
if( tmp_xml != NULL )
{
if( ezxml_attr( tmp_xml, "use" ) )
{
if( !strcasecmp( ezxml_attr( tmp_xml, "use" ), "On" ) )
{
cfg->logqueries_use = 1;
}
if( !strcasecmp( ezxml_attr( tmp_xml, "use" ), "Before" ) )
{
cfg->logqueries_use = 2;
}
}
}
tmp_xml = ezxml_child (xml, "daemon");
cfg->daemon_monitor = 1;
if( tmp_xml != NULL )
{
if( ezxml_attr( tmp_xml, "monitor" ) )
{
if( !strcasecmp( ezxml_attr( tmp_xml, "monitor" ), "Off" ) )
{
cfg->daemon_monitor = 0;
}
}
}
tmp_xml = ezxml_child (xml, "slow_queries");
cfg->slow_queries = 0;
if( tmp_xml != NULL )
{
if( ezxml_attr( tmp_xml, "run" ) )
{
if( !strcasecmp( ezxml_attr( tmp_xml, "run" ), "On" ) )
{
cfg->slow_queries = 1;
}
}
if( ezxml_attr( tmp_xml, "log" ) )
{
cfg->slow_queries_log = strdup( ezxml_attr( tmp_xml, "log" ) );
}
else
{
cfg->slow_queries_log = NULL;
}
}
tmp_xml = ezxml_child( xml, "restrict_mode" );
cfg->restrict_mode = 1;
cfg->l_unlimit = parse_period( "60s" );
if( tmp_xml != NULL )
{
if( ezxml_attr( tmp_xml, "use" ) )
{
if( !strcasecmp( ezxml_attr( tmp_xml, "use" ), "period" ) )
{
cfg->restrict_mode = 0;
}
}
if( ( ptr = ezxml_attr( tmp_xml, "unlimit" ) ) != NULL )
{
cfg->l_unlimit = parse_period( ptr );
}
}
cfg->killuser = 0;
cfg->max_user_connections = 30;
tmp_xml = ezxml_child (xml, "restrict");
if (tmp_xml == NULL)
{
fprintf (stderr, "No 'restrict' parameter\n");
exit (-1);
}
if (ezxml_attr (tmp_xml, "log"))
{
cfg->restrict_log = strdup (ezxml_attr (tmp_xml, "log"));
}
else
{
cfg->restrict_log = NULL;
}
if(ezxml_attr (tmp_xml, "killuser")){
if(!strcasecmp(ezxml_attr (tmp_xml, "killuser"), "on")){
cfg->killuser = 1;
}
}
if(ezxml_attr (tmp_xml, "user_max_connections")){
cfg->max_user_connections = atoi(ezxml_attr (tmp_xml, "user_max_connections"));
if(cfg->max_user_connections<0) cfg->max_user_connections = 30;
}
cfg->restrict_format = getRestrictFormat (ezxml_attr (tmp_xml, "format"));
cfg->level1 =
((ptr =
ezxml_attr (tmp_xml,
"level1")) ==
NULL) ? parse_period ("60s") : parse_period (ptr);
cfg->level2 =
((ptr =
ezxml_attr (tmp_xml,
"level2")) ==
NULL) ? parse_period ("15m") : parse_period (ptr);
cfg->level3 =
((ptr =
ezxml_attr (tmp_xml,
"level3")) ==
NULL) ? parse_period ("1h") : parse_period (ptr);
cfg->level4 =
((ptr =
ezxml_attr (tmp_xml,
"level4")) ==
NULL) ? parse_period ("1d") : parse_period (ptr);
cfg->timeout =
((ptr =
ezxml_attr (tmp_xml,
"timeout")) ==
NULL) ? parse_period ("1h") : parse_period (ptr);
if (ezxml_attr (tmp_xml, "script"))
{
cfg->exec_script = strdup (ezxml_attr (tmp_xml, "script"));
if (cfg->exec_script)
{
int status_script;
struct stat buffer_script;
status_script = stat (cfg->exec_script, &buffer_script);
if (status_script)
{
fprintf (stderr, "Wrong script name - %s\n", cfg->exec_script);
exit (-1);
}
else
{
if (S_ISDIR (buffer_script.st_mode))
{
fprintf (stderr, "Script is directory - %s\n",
cfg->exec_script);
exit (-1);
}
}
}
}
else
{
cfg->exec_script = NULL;
}
tmp_xml = ezxml_child (xml, "connector");
if (tmp_xml == NULL)
{
fprintf (stderr, "No connector parameter");
exit (-1);
}
cfg->db_login =
strdup (!ezxml_attr (tmp_xml, "login") ? "" :
ezxml_attr (tmp_xml, "login"));
cfg->db_password =
strdup (!ezxml_attr (tmp_xml, "password") ? "" :
ezxml_attr (tmp_xml, "password"));
cfg->host =
strdup (!ezxml_attr (tmp_xml, "host") ? "" :
ezxml_attr (tmp_xml, "host"));
cfg->separator =
!ezxml_attr (tmp_xml,
"prefix_separator") ? '_' : *(ezxml_attr (tmp_xml,
"prefix_separator"));
tmp_xml = ezxml_child (xml, "default");
if (tmp_xml == NULL)
{
fprintf (stderr, "No default limits");
exit (-1);
}
cfg->default_limit.mode = RESTRICT_MODE;
for (tmp_xml_limit = ezxml_child (tmp_xml, "limit"); tmp_xml_limit;
tmp_xml_limit = tmp_xml_limit->next)
{
set_stats_limit (tmp_xml_limit, &cfg->default_limit);
}
cfg->default_limit.mode = RESTRICT_MODE;
cfg->default_limit.account_flag = true;
for (tmp_xml = ezxml_child (xml, "user"); tmp_xml; tmp_xml = tmp_xml->next)
{
const char *account = ezxml_attr (tmp_xml, "name");
const char *mysql_name = ezxml_attr (tmp_xml, "mysql_name");
if ((account == NULL) && (mysql_name == NULL))
{
fprintf (stderr,
"Error: both 'name' and 'mysql_name' attributes are absent\n");
exit (-1);
}
if ((account != NULL) && (mysql_name != NULL))
{
fprintf (stderr,
"Error: both 'name' and 'mysql_name' attributes are present\n");
exit (-1);
}
stats_limit_cfg *l = calloc (1, sizeof (stats_limit_cfg));
// inheritance of limits from default
memcpy (l, &cfg->default_limit, sizeof (stats_limit_cfg));
l->account_flag = account != NULL;
l->mode =
((ptr =
ezxml_attr (tmp_xml,
"mode")) ==
NULL) ? RESTRICT_MODE : mode_type_str_to_enum (ptr);
for (tmp_xml_limit = ezxml_child (tmp_xml, "limit"); tmp_xml_limit;
tmp_xml_limit = tmp_xml_limit->next)
{
set_stats_limit (tmp_xml_limit, l);
}
g_hash_table_replace (cfg->account_limits,
(gpointer) strdup ((account == NULL) ? mysql_name
: account), l);
}
ezxml_free (xml);
return cfg;
}
/* ------------------------------------------------------------------------- */
int main(int argc, char* argv[])
{
int ret;
ezxml_t xml;
bool retrieve;
TMessage message;
int connection;
if (argc < 2)
{
printf("usage: %s <xml file>\n", argv[0]);
return -EXIT_FAILURE;
}
xml = ezxml_parse_file(argv[1]);
if (!xml)
{
printf("Failed to parse the file '%s'.\n", argv[1]);
return -EXIT_FAILURE;
}
message.m_body = ezxml_toxml(xml, false);
message.m_len = strlen(message.m_body);
{
const char *const name = ezxml_name(xml);
retrieve = (0 == strcmp("retrieve", name));
}
ezxml_free(xml);
ret = -EXIT_FAILURE;
do
{
if (-1 == (connection = Connect(SERVER_IP, SERVER_PORT)))
break;
if (SendMessage(connection, &message))
{
printf("Failed to send the message.\n");
break;
}
if (!retrieve)
{
ret = -EXIT_SUCCESS;
break;
}
if (ReceiveMessage(connection, &message))
{
printf("Failed to receive the reply message.\n");
break;
}
xml = ezxml_parse_str(message.m_body, message.m_len);
if (xml)
{
const char *const str = ezxml_toxml(xml, true);
if (str)
{
puts(str);
free((char*)str);
}
ezxml_free(xml);
}
else
{
printf("Failed to parse the reply message.\n");
break;
}
ret = -EXIT_SUCCESS;
} while(0);
free(message.m_body);
close(connection);
return ret;
}
ClParserPtrT clParserParseFile(const char *file)
{
return ezxml_parse_file(file);
}
/*
* parse_automaton_set_xml_file
*
* Parse the entire of an automaton set xml file.
*
* This is called once per xml file. It creates the automaton structure and
* fills it in joining up the links. Any error is considered fatal and will
* cause a return code along with debug remarks.
*
* Parameters: filename - If this cannot be read then the function will fail.
* automaton_set - The set to fill in a structure for.
* state_callback - Callback to generate the states.
* event_callback - Callback to generate the events.
* match_state - Used to set up lua globals.
*/
int parse_automaton_set_xml_file(char *filename,
AUTOMATON_SET *automaton_set,
int (*state_callback)(AUTOMATON_STATE ***,int),
int (*event_callback)(AUTOMATON_EVENT ***),
MATCH_STATE *match_state)
{
/*
* Local Variables.
*/
int ret_code = AUTOMATON_XML_FILE_OK;
ezxml_t xml_file;
ezxml_t xml_automaton;
ezxml_t xml_start_automaton;
int ii;
int rc;
/*
* The transition file is strictly an xml file so we use an external xml
* library to load it and look for values.
*
* If the file comes back null then it failed to load for some reason.
*/
xml_file = ezxml_parse_file(filename);
if (NULL == xml_file)
{
DT_DEBUG_LOG("Failed to load xml_automaton file %s: error %s\n",
filename,
ezxml_error(xml_file));
ret_code = AUTOMATON_XML_FILE_LOAD_FAIL;
goto EXIT_LABEL;
}
/*
* This allocates the memory required for the automaton array and creates
* the automaton structures. It does not fill in any information.
*/
create_automatons_from_xml(&xml_file,
automaton_set,
state_callback,
event_callback);
/*
* Fill in the names of the automatons and transitions from the file. This
* is required so that we can refer to them from each other when building
* up the links later.
*/
ret_code = parse_automaton_names(&xml_file, automaton_set);
if (AUTOMATON_XML_FILE_OK != ret_code)
{
DT_DEBUG_LOG("Failed to parse automaton names\n");
goto EXIT_LABEL;
}
/*
* Finally now that the automatons are created and have their names filled in
* we can set up all the links between transitions, states, events and other
* automatons.
*/
ii = 0;
for (xml_automaton = ezxml_child(xml_file, "automaton");
xml_automaton;
xml_automaton = xml_automaton->next)
{
/*
* Attempt to set up the automaton links.
*/
rc = init_automaton_links(automaton_set->automaton_array[ii],
xml_automaton,
automaton_set,
match_state);
if (INIT_AUTOMATON_LINKS_OK != rc)
{
DT_DEBUG_LOG("Failed setting up automaton links for automaton %s\n",
automaton_set->automaton_array[ii]->name);
ret_code = AUTOMATON_XML_FILE_LINKS_FAIL;
goto EXIT_LABEL;
}
ii++;
}
/*
* The automaton that this set starts in is hardcoded into the xml file so
* retrieve it now and verify that it exists.
*/
xml_start_automaton = ezxml_child(xml_file, "start_automaton");
if (NULL == xml_start_automaton)
{
DT_DEBUG_LOG("There is no starting automaton in the set.\n");
ret_code = AUTOMATON_XML_FILE_START_AUTOMATON_BAD;
goto EXIT_LABEL;
}
/*
* There was a starting automaton so retrieve it by name.
*/
automaton_set->start_automaton = get_automaton_by_name(
automaton_set,
xml_start_automaton->txt);
if (NULL == automaton_set->start_automaton)
{
DT_DEBUG_LOG("The starting automaton listed (%s) does not exist in the " \
"set.\n",
xml_start_automaton->txt);
ret_code = AUTOMATON_XML_FILE_START_AUTOMATON_BAD;
goto EXIT_LABEL;
}
EXIT_LABEL:
return(ret_code);
}
void mapcache_configuration_parse_xml(mapcache_context *ctx, const char *filename, mapcache_cfg *config) {
ezxml_t doc, node;
const char *mode;
doc = ezxml_parse_file(filename);
if (doc == NULL) {
ctx->set_error(ctx,400, "failed to parse file %s. Is it valid XML?", filename);
goto cleanup;
} else {
const char *err = ezxml_error(doc);
if(err && *err) {
ctx->set_error(ctx,400, "failed to parse file %s: %s", filename, err);
goto cleanup;
}
}
if(strcmp(doc->name,"mapcache")) {
ctx->set_error(ctx,400, "failed to parse file %s. first node is not <mapcache>", filename);
goto cleanup;
}
mode = ezxml_attr(doc,"mode");
if(mode) {
if(!strcmp(mode,"combined_mirror")) {
config->mode = MAPCACHE_MODE_MIRROR_COMBINED;
} else if(!strcmp(mode,"split_mirror")) {
config->mode = MAPCACHE_MODE_MIRROR_SPLIT;
} else if(!strcmp(mode,"normal")) {
config->mode = MAPCACHE_MODE_NORMAL;
} else {
ctx->set_error(ctx,400,"unknown mode \"%s\" for <mapcache>",mode);
goto cleanup;
}
} else {
config->mode = MAPCACHE_MODE_NORMAL;
}
for(node = ezxml_child(doc,"metadata"); node; node = node->next) {
parseMetadata(ctx, node, config->metadata);
if(GC_HAS_ERROR(ctx)) goto cleanup;
}
for(node = ezxml_child(doc,"source"); node; node = node->next) {
parseSource(ctx, node, config);
if(GC_HAS_ERROR(ctx)) goto cleanup;
}
for(node = ezxml_child(doc,"grid"); node; node = node->next) {
parseGrid(ctx, node, config);
if(GC_HAS_ERROR(ctx)) goto cleanup;
}
for(node = ezxml_child(doc,"format"); node; node = node->next) {
parseFormat(ctx, node, config);
if(GC_HAS_ERROR(ctx)) goto cleanup;
}
for(node = ezxml_child(doc,"cache"); node; node = node->next) {
parseCache(ctx, node, config);
if(GC_HAS_ERROR(ctx)) goto cleanup;
}
for(node = ezxml_child(doc,"tileset"); node; node = node->next) {
parseTileset(ctx, node, config);
if(GC_HAS_ERROR(ctx)) goto cleanup;
}
if ((node = ezxml_child(doc,"service")) != NULL) {
ezxml_t service_node;
for(service_node = node; service_node; service_node = service_node->next) {
char *enabled = (char*)ezxml_attr(service_node,"enabled");
char *type = (char*)ezxml_attr(service_node,"type");
if(!strcasecmp(enabled,"true")) {
if (!strcasecmp(type,"wms")) {
mapcache_service *new_service = mapcache_service_wms_create(ctx);
if(new_service->configuration_parse_xml) {
new_service->configuration_parse_xml(ctx,service_node,new_service,config);
}
config->services[MAPCACHE_SERVICE_WMS] = new_service;
}
else if (!strcasecmp(type,"tms")) {
mapcache_service *new_service = mapcache_service_tms_create(ctx);
if(new_service->configuration_parse_xml) {
new_service->configuration_parse_xml(ctx,service_node,new_service,config);
}
config->services[MAPCACHE_SERVICE_TMS] = new_service;
}
else if (!strcasecmp(type,"wmts")) {
mapcache_service *new_service = mapcache_service_wmts_create(ctx);
if(new_service->configuration_parse_xml) {
new_service->configuration_parse_xml(ctx,service_node,new_service,config);
}
config->services[MAPCACHE_SERVICE_WMTS] = new_service;
}
else if (!strcasecmp(type,"kml")) {
mapcache_service *new_service = mapcache_service_kml_create(ctx);
if(new_service->configuration_parse_xml) {
new_service->configuration_parse_xml(ctx,service_node,new_service,config);
}
config->services[MAPCACHE_SERVICE_KML] = new_service;
}
else if (!strcasecmp(type,"gmaps")) {
mapcache_service *new_service = mapcache_service_gmaps_create(ctx);
if(new_service->configuration_parse_xml) {
new_service->configuration_parse_xml(ctx,service_node,new_service,config);
}
config->services[MAPCACHE_SERVICE_GMAPS] = new_service;
}
else if (!strcasecmp(type,"ve")) {
mapcache_service *new_service = mapcache_service_ve_create(ctx);
if(new_service->configuration_parse_xml) {
new_service->configuration_parse_xml(ctx,service_node,new_service,config);
}
config->services[MAPCACHE_SERVICE_VE] = new_service;
}
else if (!strcasecmp(type,"demo")) {
mapcache_service *new_service = mapcache_service_demo_create(ctx);
if(new_service->configuration_parse_xml) {
new_service->configuration_parse_xml(ctx,service_node,new_service,config);
}
config->services[MAPCACHE_SERVICE_DEMO] = new_service;
} else {
ctx->set_error(ctx,400,"unknown <service> type %s",type);
}
if(GC_HAS_ERROR(ctx)) goto cleanup;
}
}
}
else if ((node = ezxml_child(doc,"services")) != NULL) {
ctx->log(ctx,MAPCACHE_WARN,"<services> tag is deprecated, use <service type=\"wms\" enabled=\"true|false\">");
parseServices(ctx, node, config);
} else {
ctx->set_error(ctx, 400, "no <services> configured");
}
if(GC_HAS_ERROR(ctx)) goto cleanup;
node = ezxml_child(doc,"default_format");
if(!node)
node = ezxml_child(doc,"merge_format");
if (node) {
mapcache_image_format *format = mapcache_configuration_get_image_format(config,node->txt);
if(!format) {
ctx->set_error(ctx, 400, "default_format tag references format %s but it is not configured",
node->txt);
goto cleanup;
}
config->default_image_format = format;
}
if ((node = ezxml_child(doc,"errors")) != NULL) {
if(!strcmp(node->txt,"log")) {
config->reporting = MAPCACHE_REPORT_LOG;
} else if(!strcmp(node->txt,"report")) {
config->reporting = MAPCACHE_REPORT_MSG;
} else if(!strcmp(node->txt,"empty_img")) {
config->reporting = MAPCACHE_REPORT_EMPTY_IMG;
mapcache_image_create_empty(ctx, config);
if(GC_HAS_ERROR(ctx)) goto cleanup;
} else if(!strcmp(node->txt, "report_img")) {
config->reporting = MAPCACHE_REPORT_ERROR_IMG;
ctx->set_error(ctx,501,"<errors>: report_img not implemented");
goto cleanup;
} else {
ctx->set_error(ctx,400,"<errors>: unknown value %s (allowed are log, report, empty_img, report_img)",
node->txt);
goto cleanup;
}
}
if((node = ezxml_child(doc,"lock_dir")) != NULL) {
config->lockdir = apr_pstrdup(ctx->pool, node->txt);
} else {
config->lockdir = apr_pstrdup(ctx->pool,"/tmp");
}
if((node = ezxml_child(doc,"lock_retry")) != NULL) {
char *endptr;
config->lock_retry_interval = (unsigned int)strtol(node->txt,&endptr,10);
if(*endptr != 0 || config->lock_retry_interval < 0) {
ctx->set_error(ctx, 400, "failed to parse lock_retry microseconds \"%s\". Expecting a positive integer",
node->txt);
return;
}
}
if((node = ezxml_child(doc,"threaded_fetching")) != NULL) {
if(!strcasecmp(node->txt,"true")) {
config->threaded_fetching = 1;
} else if(strcasecmp(node->txt,"false")) {
ctx->set_error(ctx, 400, "failed to parse threaded_fetching \"%s\". Expecting true or false",node->txt);
return;
}
}
if((node = ezxml_child(doc,"log_level")) != NULL) {
if(!strcasecmp(node->txt,"debug")) {
config->loglevel = MAPCACHE_DEBUG;
} else if(!strcasecmp(node->txt,"info")) {
config->loglevel = MAPCACHE_INFO;
} else if(!strcasecmp(node->txt,"notice")) {
config->loglevel = MAPCACHE_NOTICE;
} else if(!strcasecmp(node->txt,"warn")) {
config->loglevel = MAPCACHE_WARN;
} else if(!strcasecmp(node->txt,"error")) {
config->loglevel = MAPCACHE_ERROR;
} else if(!strcasecmp(node->txt,"crit")) {
config->loglevel = MAPCACHE_CRIT;
} else if(!strcasecmp(node->txt,"alert")) {
config->loglevel = MAPCACHE_ALERT;
} else if(!strcasecmp(node->txt,"emerg")) {
config->loglevel = MAPCACHE_EMERG;
} else {
ctx->set_error(ctx,500,"failed to parse <log_level> \"%s\". Expecting debug, info, notice, warn, error, crit, alert or emerg",node->txt);
return;
}
}
if((node = ezxml_child(doc,"auto_reload")) != NULL) {
if(!strcasecmp(node->txt,"true")) {
config->autoreload = 1;
} else if(!strcasecmp(node->txt,"false")) {
config->autoreload = 0;
} else {
ctx->set_error(ctx,500,"failed to parse <auto_reload> \"%s\". Expecting true or false",node->txt);
return;
}
}
cleanup:
ezxml_free(doc);
return;
}
static int parseConfigFile(const char *pConfigFile,
const char *pNodeName,
const char *pNodeType,
char ***comps,
int *numComps)
{
int err = -1;
ezxml_t top, xml, xmlver;
char **pComps = NULL;
int c = 0;
if(!pConfigFile || !pNodeName || !pNodeType || !comps || !numComps)
return -1;
top = xml = ezxml_parse_file(pConfigFile);
if(!xml)
{
fprintf(stderr, "Error parsing xml file\n");
return -1;
}
/*
* Parse the cpmconfigs for the nodename first. to get asp component list.
*/
xml = ezxml_child(xml, "version");
if(!xml)
{
fprintf(stderr, "Unable to find version tag. Assuming old config file format\n");
xmlver = top;
}
else
{
xmlver = xml->child;
}
xml = ezxml_child(xmlver, "cpmConfigs");
if(!xml)
{
fprintf(stderr, "Unable to find cpmConfigs tag\n");
goto out_free;
}
xml = ezxml_child(xml, "cpmConfig");
if(!xml)
{
fprintf(stderr, "Unable to find cpmConfig tag\n");
goto out_free;
}
while(xml)
{
char *nodetype = (char*)ezxml_attr(xml, "nodeType");
if(!nodetype)
{
fprintf(stderr, "Unable to find nodeType attribute for cpmConfig tag\n");
goto out_free;
}
if(!strncmp(nodetype, pNodeType, strlen(pNodeType)))
{
/*
* found the hit for the node type. Copy the asp component list now
*/
xml = ezxml_child(xml, "aspServiceUnits");
if(!xml)
{
fprintf(stderr, "Unable to find asp service units\n");
goto out_free;
}
xml = ezxml_child(xml, "aspServiceUnit");
while(xml)
{
char *aspUnit = (char*)ezxml_attr(xml, "name");
const char **compMap = NULL;
if(!aspUnit)
{
fprintf(stderr, "Unable to find asp service unit\n");
goto out_free;
}
compMap = aspMapSU(aspUnit);
assert(compMap != NULL);
while(*compMap)
{
pComps = realloc(pComps, (c+1)*sizeof(*pComps));
assert(pComps);
pComps[c] = strdup(*compMap);
assert(pComps[c]);
++c;
++compMap;
}
xml = xml->next;
}
goto out_find;
}
xml = xml->next;
}
goto out_free;
out_find:
xml = ezxml_child(xmlver, "nodeInstances");
if(!xml)
{
fprintf(stderr, "Unable to find nodeInstances tag\n");
goto out_free;
}
xml = ezxml_child(xml, "nodeInstance");
while(xml)
{
char *nodename = (char*)ezxml_attr(xml, "name");
if(!nodename)
{
fprintf(stderr, "Unable to find nodename tag\n");
goto out_free;
}
if(!strncmp(nodename, pNodeName, strlen(pNodeName)))
{
/*
* node matched. Gather components in this node.
*/
xml = ezxml_child(xml, "serviceUnitInstances");
if(!xml)
{
fprintf(stderr, "Unable to parse service unit instances\n");
goto out_free;
}
xml = ezxml_child(xml, "serviceUnitInstance");
if(!xml)
{
fprintf(stderr, "Unable to parse service unit tag\n");
goto out_free;
}
while(xml)
{
ezxml_t xmlComp;
ezxml_t xmlComps = ezxml_child(xml, "componentInstances");
if(!xmlComps)
{
goto next;
}
xmlComp = ezxml_child(xmlComps, "componentInstance");
while(xmlComp)
{
char *compName = (char*)ezxml_attr(xmlComp, "type");
if(!compName)
{
fprintf(stderr, "Unable to find comp name type\n");
goto out_free;
}
pComps = realloc(pComps, (c+1)*sizeof(*pComps));
assert(pComps);
pComps[c] = strdup(compName);
assert(pComps[c]);
++c;
xmlComp = xmlComp->next;
}
next:
xml = xml->next;
}
goto out_free;
}
xml = xml->next;
}
out_free:
ezxml_free(top);
if(!c)
{
if(pComps)
free(pComps);
}
else
{
*comps = pComps;
*numComps = c;
err = 0;
}
return err;
}
int main() {
printf("Reading XML.. .. ..\n");
ezxml_t f1 = ezxml_parse_file("test.xml"), classification, temp, algo, temp2;
classification = ezxml_child(f1, "classification");
temp = ezxml_child(classification, "datafile");
printf("Datafile is ");
printf("%s", temp->txt);
printf("\n");
temp = ezxml_child(classification, "input");
printf("I/P is ");
printf("%s", temp->txt);
printf("\n");
temp = ezxml_child(classification, "output");
printf("O/P is ");
printf("%s", temp->txt);
printf("\n");
temp = ezxml_child(classification, "numberOfLayers");
printf("# of Neurons is ");
printf("%s", temp->txt);
printf("\n");
temp = ezxml_child(classification, "algorithm");
algo = ezxml_child(temp, "MultiLayerPerceptron");
temp2 = ezxml_child(algo, "hiddenLayerActivation");
printf("Activation Func. is ");
printf("%s", temp2->txt);
printf("\n");
temp2 = ezxml_child(algo, "hiddenActivationSteepness");
printf("Activation Func. is ");
printf("%s", temp2->txt);
printf("\n");
temp2 = ezxml_child(algo, "outputLayerActivation");
printf("Activation Func. is ");
printf("%s", temp2->txt);
printf("\n");
temp2 = ezxml_child(algo, "outputActivationSteepness");
printf("Activation Func. is ");
printf("%s", temp2->txt);
printf("\n");
temp2 = ezxml_child(algo, "trainStopFuction");
printf("Activation Func. is ");
printf("%s", temp2->txt);
printf("\n");
temp2 = ezxml_child(algo, "hiddenNeurons");
printf("Activation Func. is ");
printf("%s", temp2->txt);
printf("\n");
temp2 = ezxml_child(algo, "desiredError");
printf("Activation Func. is ");
printf("%s", temp2->txt);
printf("\n");
temp2 = ezxml_child(algo, "maxEpochs");
printf("Activation Func. is ");
printf("%s", temp2->txt);
printf("\n");
temp2 = ezxml_child(algo, "epochsBetweenReports");
printf("Activation Func. is ");
printf("%s", temp2->txt);
printf("\n");
ezxml_free(f1);
return 0;
}
void LISACode::config(char * fNInXML)
{
if(LISA == NULL)
LISA = new LCDetector(MT);
//! ****** Check that the file exist
Cout << ">>>>> Read configuration " << fNInXML << " ..." << Endl;
std::ifstream fIn;
fIn.open(fNInXML);
if(fIn == NULL){
Cout << "ERROR: LISACode::config : Can not open the file " << fNInXML << " !" << Endl;
throw std::invalid_argument("ERROR: LISACode::config : Can not open the file.");
}
fIn.close();
fIn.clear();
//! ****** Read XML
ezxml_t tree, section, param, subsection, orbitdata;
tree = ezxml_parse_file(fNInXML);
for (section = ezxml_child(tree, "XSIL"); section; section = section->next) {
if(MT->wcmp(ezxml_attr(section, "Type"),"Simulate")){
//! **** Configuration of simulation parameters
for(param = ezxml_child(section,"Param"); param; param = param->next){
if(MT->wcmp(ezxml_attr(param,"Name"),"TimeOffset"))
t0 = MT->gXMLTime(param);
if(MT->wcmp(ezxml_attr(param,"Name"),"Cadence"))
dtMes = MT->gXMLTime(param);
if(MT->wcmp(ezxml_attr(param,"Name"),"Duration"))
tDur = MT->gXMLTime(param);
}
for (subsection = ezxml_child(section, "XSIL"); subsection; subsection = subsection->next) {
if(MT->wcmp(ezxml_attr(subsection, "Type"),"Output")){
configOuput(subsection);
}
}
}
//! **** Configuration of gravitational waves
if(MT->wcmp(ezxml_attr(section, "Type"),"SourceData")){
ezxml_t gwdata;
for (gwdata = ezxml_child(section, "XSIL"); gwdata; gwdata = gwdata->next) {
ezxml_t param;
//! * Configure GW read in file
if(MT->wcmp(ezxml_attr(gwdata,"Type"),"SampledPlaneWave")){
AddGW("SampledPlaneWave");
GWs[NGWs-1]->config(gwdata);
}else{
if(MT->wcmp(ezxml_attr(gwdata,"Type"),"PlaneWave")){
for(param = ezxml_child(gwdata,"Param"); param; param = param->next){
//! * Configure GW modeled in the code
char * SourceType(NULL);
if(MT->wcmp(ezxml_attr(param,"Name"),"SourceType")){
MT->stripcopy((*param).txt, SourceType);
if(MT->wcmp(SourceType, "Stochastic")){
AddGW("Stochastic");
GWs[NGWs-1]->config(gwdata);
GWOptimizeTime = true;
}
if((MT->wcmp(SourceType, "GalacticBinaryV"))||(MT->wcmp(SourceType, "GalacticBinary"))){
AddGW("GalacticBinary");
GWs[NGWs-1]->config(gwdata);
}
if((MT->wcmp(SourceType, "SpinBBHHighHarm"))||(MT->wcmp(SourceType, "SpinBBHHH"))){
AddGW("SpinBBHHighHarm");
GWs[NGWs-1]->config(gwdata);
}
if((MT->wcmp(SourceType, "NRwave"))){
AddGW("NRwave");
GWs[NGWs-1]->config(gwdata);
}
if((MT->wcmp(SourceType, "CosmicString"))||(MT->wcmp(SourceType, "CosmicString"))){
AddGW("CosmicString");
GWs[NGWs-1]->config(gwdata);
}
}
if(SourceType != NULL)
MT->Free(SourceType, (strlen(SourceType)+1) * sizeof(char));
}
}
}
}
}
//! **** Configuration of orbits
if(MT->wcmp(ezxml_attr(section, "Type"),"LISAData")){
for(orbitdata = ezxml_child(section, "XSIL"); orbitdata; orbitdata = orbitdata->next) {
if(MT->wcmp(ezxml_attr(orbitdata,"Type"),"LISACode_Orbits")){
if (Orb != NULL)
throw std::invalid_argument("ERROR in LISACode::config : The orbit have already been created ! If you want to had complement informations to the orbits use an xml bloc with Type='OrbitsInfo' . ");
Orb = new LCOrbitsAnaLISA(MT);
Orb->config(orbitdata);
}
if(MT->wcmp(ezxml_attr(orbitdata,"Type"),"MLDC_Orbits")){
if (Orb != NULL)
throw std::invalid_argument("ERROR in LISACode::config : The orbit have already been created ! If you want to had complement informations to the orbits use an xml bloc with Type='OrbitsInfo' . ");
Orb = new LCOrbitsAnaMLDC(MT);
Orb->config(orbitdata);
}
if(MT->wcmp(ezxml_attr(orbitdata,"Type"),"OrbitsFile")){
if (Orb != NULL)
throw std::invalid_argument("ERROR in LISACode::config : The orbit have already been created ! If you want to had complement informations to the orbits use an xml bloc with Type='OrbitsInfo' . ");
Orb = new LCOrbitsData(MT);
Orb->config(orbitdata);
}
if(MT->wcmp(ezxml_attr(orbitdata,"Type"),"Octahedron_FirstOrbits")){
if (Orb != NULL)
throw std::invalid_argument("ERROR in LISACode::config : The orbit have already been created ! If you want to had complement informations to the orbits use an xml bloc with Type='OrbitsInfo' . ");
Orb = new LCOrbitsAnaOctahedron(MT);
Orb->config(orbitdata);
}
if(MT->wcmp(ezxml_attr(orbitdata,"Type"),"OrbitsInfo")){
if (Orb == NULL)
throw std::invalid_argument("ERROR in LISACode::config : You have to define orbits before reading an 'OrbitsInfo' bloc !");
Orb->config(orbitdata);
}
}
}
//! **** Configuration of noises
if(MT->wcmp(ezxml_attr(section, "Type"),"NoiseData"))
LISA->configNoise(section);
if(MT->wcmp(ezxml_attr(section, "Type"),"LISACode")){
for (subsection = ezxml_child(section, "XSIL"); subsection; subsection = subsection->next) {
//Cout << ezxml_attr(subsection,"Type") << Endl;
//! *** Configuration of the detector
if(MT->wcmp(ezxml_attr(subsection,"Type"),"Detector"))
LISA->configDetector(subsection);
//! *** Configuration of intermediate TDI
if(MT->wcmp(ezxml_attr(subsection,"Type"),"TDIIntermediate"))
configTDIIntermediate(subsection);
//! *** Configuration of TDI generator
if(MT->wcmp(ezxml_attr(subsection,"Type"),"TDIGenerator")){
NTDIG++;
TDIG = (LCTDIGen**) MT->ReAllocMemory(TDIG, (NTDIG-1)*sizeof(LCTDIGen*), NTDIG*sizeof(LCTDIGen*));
TDIG[NTDIG-1] = new LCTDIGen(MT);
TDIG[NTDIG-1]->config(subsection);
}
}
}
}
ezxml_free(tree);
}
int main(int argc, char *argv[])
{
pid_t pid = getpid();
int str_end,hash_beg,i = 0, sm, lo, rs, dr, hash_len;
char dir[200],report[1000],mdString[40]= {0}, *parcel, tmp[100], *from_str, *from_str_tmp, *hash_et, *help_ptr, *arglist_sm[100], *arglist_lo[100], *arglist_rs[100], *arglist_dr[100];
unsigned char *hash_cand = malloc(50*sizeof(char));
t_elements parsed_elements;
sprintf(dir,"%s%d_log.log",LOG_DIR,pid);
FILE *log = fopen(dir,"w");
if(log == NULL) exit(-4);
from_str_tmp = malloc(sizeof(char)*100000);
sprintf(tmp, "/tmp/%d/", pid);
mkdir(tmp, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
chdir(tmp);
fprintf(log, "PID: %d, dir changed\nthats what we got:\n", pid);
do
{
from_str_tmp[i] = getc(stdin);
fputc(from_str_tmp[i],log);
if(from_str_tmp[i] == '-' && from_str_tmp[i-1] == '-')
{
str_end=i-1;
hash_beg=i+1;
from_str_tmp[str_end]=0;
}
}
while(from_str_tmp[i++] != EOF);
hash_et = from_str_tmp + sizeof(char)*hash_beg;
hash_et[40]=0;
from_str_tmp += 8*sizeof(char);
from_str = curl_decode(from_str_tmp);
help_ptr = from_str;
from_str_tmp = decode(from_str); /*base64 conversion*/
fprintf(log,"\nAfter url_decode:%s",from_str);
//\r\n
from_str=from_str_tmp;
fprintf(log,"\nhashed string:%s\n",help_ptr);
HMAC(EVP_sha1(),SALT, strlen(SALT), (unsigned char*)help_ptr, strlen(help_ptr),hash_cand,(unsigned int*)&hash_len);
for(i = 0; i < 20; i++)
sprintf(&mdString[i*2], "%02x",hash_cand[i]);
//FIXME leaks everywhere
if(strcmp(mdString,hash_et)==0)
{
fprintf(log,"\nhash correct\n");
fprintf(log,"decoded string: %s\n", from_str);
printf("Content-Type: text/plain;charset=us-ascii\n\n");
}
else
{
fprintf(log, "%s\n%s\n hash incorrect\n",mdString,hash_et);
printf("Content-Type: text/html\nStatus: 422 Bad Request\n\n");
free(hash_cand);
free(from_str);
fclose(log);
exit(-1);
}
/*we have now string to parse*/
cJSON *root = cJSON_Parse(from_str);
if (!root)
{
fprintf(log,"Error before: [%s]\n", cJSON_GetErrorPtr());
}
fprintf(log,"exec part\n");
parse_into_elements(&parsed_elements, root, log);
fflush(NULL);
lo = make_arglist_for_login(arglist_lo, parsed_elements);
fork_exec_with_inp_redir(arglist_lo, 1, "whatever");
sm = make_arglist_for_submit_and_run(arglist_sm, parsed_elements, arglist_lo[4]);
fork_exec_with_inp_redir(arglist_sm, 1, "num.txt");
rs = make_arglist_for_run_status(arglist_rs, parsed_elements, arglist_lo[4]);
int rep_num;
if((rep_num=wait_for_report(5, arglist_rs, parsed_elements.status))==-1)
{
strcpy(parsed_elements.status,"error");
strcpy(report,"ejudge marking error");
}
else
{
int flag=0,some;
some = submit_checked(parsed_elements.status, ejudge_common);
if(strcmp(parsed_elements.status,"OK")==0)
{
strcpy(parsed_elements.status,"ok");
flag=1;
}
else if(submit_checked(parsed_elements.status, ejudge_error)!=-1)
{
strcpy(parsed_elements.status,"error");
strcpy(report,ejudge_detailed[some]);
if(some == 1) flag = 2; /*let report be when compilation error*/
}
else
{
strcpy(parsed_elements.status, "fail");
flag=1;
}
if(flag)
{
dr = make_arglist_for_dump_report(arglist_dr, parsed_elements, arglist_lo[4]); //BACKTRACE part
fork_exec_with_inp_redir(arglist_dr, 1, "return_report.xml");
/*xml parse part*/
if(flag==1){
ezxml_t trace = ezxml_parse_file("return_report.xml");
const char * points = ezxml_attr(trace, "score");
const char * tp = ezxml_attr(trace, "tests-passed");
const char * to = ezxml_attr(trace, "run-tests");
sprintf(report, "%s. Your score is = %s, %s/%s tests passed",ejudge_detailed[some], points , tp, to);
ezxml_free(trace);
/* parse part end */
/* BTW ezxml lib used so you have possibility to add smth to report */
}
else if(flag==2)
{
char *iftmp;
iftmp = read_string("return_report.xml");
strcat(report, iftmp);
free(iftmp);
}
}
}
fprintf(log, "exec part end\n");
cJSON_AddStringToObject(root, "trace", report);
cJSON_AddStringToObject(root, "status", parsed_elements.status);
cJSON_DeleteItemFromObject(root,"programming_language");
cJSON_DeleteItemFromObject(root,"file_name");
cJSON_DeleteItemFromObject(root,"file_content");
parcel = cJSON_Print(root);
fprintf(log,"output:%s\n",parcel);
free(from_str);
from_str=encode(parcel);
fprintf(log,"encoded output:%s\n", from_str);
parcel=curl_encode(from_str);
fprintf(log,"curl_encoded output:%s\n", parcel);
HMAC(EVP_sha1(),SALT, strlen(SALT), (unsigned char*)from_str, strlen(from_str),hash_cand,(unsigned int*)&hash_len);
for(i = 0; i < 20; i++)
sprintf(&mdString[i*2], "%02x", (unsigned int)hash_cand[i]);
fprintf(log,"hash HMAC:%s\n", mdString);
sprintf(from_str,"session=%s--%s",parcel,mdString);
fprintf(log,"final output:%s\n", from_str);
/*ready to send backparcel*/
sendJSON(parsed_elements.url, from_str);
sendJSON("http://ejudge.100ege.ru/cgi-bin/a.out", from_str); //FIXME: for logging purposes
//printf("%s",from_str);
/*now clean part*/
fprintf(log,"\n%s\n",from_str);
str_vector_free(arglist_lo, lo);
str_vector_free(arglist_rs, rs);
str_vector_free(arglist_sm, sm);
free(root);
free(from_str);
free(parcel);
fclose(log);
chdir("/tmp/");
execl("/bin/rm", "/bin/rm", "-rf", tmp, NULL);
return 0;
}
/**
* Reads the transistor properties from the .xml file
*/
void power_tech_load_xml_file(char * cmos_tech_behavior_filepath) {
ezxml_t cur, child, prev;
const char * prop;
char msg[BUFSIZE];
if (!file_exists(cmos_tech_behavior_filepath)) {
/* .xml transistor characteristics is missing */
sprintf(msg,
"The CMOS technology behavior file ('%s') does not exist. No power information will be calculated.",
cmos_tech_behavior_filepath);
power_log_msg(POWER_LOG_ERROR, msg);
g_power_tech->NMOS_inf.num_size_entries = 0;
g_power_tech->NMOS_inf.long_trans_inf = NULL;
g_power_tech->NMOS_inf.size_inf = NULL;
g_power_tech->PMOS_inf.num_size_entries = 0;
g_power_tech->PMOS_inf.long_trans_inf = NULL;
g_power_tech->PMOS_inf.size_inf = NULL;
g_power_tech->Vdd = 0.;
g_power_tech->temperature = 85;
g_power_tech->PN_ratio = 1.;
return;
}
cur = ezxml_parse_file(cmos_tech_behavior_filepath);
prop = FindProperty(cur, "file", TRUE);
ezxml_set_attr(cur, "file", NULL);
prop = FindProperty(cur, "size", TRUE);
g_power_tech->tech_size = atof(prop);
ezxml_set_attr(cur, "size", NULL);
child = FindElement(cur, "operating_point", TRUE);
g_power_tech->temperature = GetFloatProperty(child, "temperature", TRUE, 0);
g_power_tech->Vdd = GetFloatProperty(child, "Vdd", TRUE, 0);
FreeNode(child);
child = FindElement(cur, "p_to_n", TRUE);
g_power_tech->PN_ratio = GetFloatProperty(child, "ratio", TRUE, 0);
FreeNode(child);
/* Transistor Information */
child = FindFirstElement(cur, "transistor", TRUE);
process_tech_xml_load_transistor_info(child);
prev = child;
child = child->next;
FreeNode(prev);
process_tech_xml_load_transistor_info(child);
FreeNode(child);
/* Multiplexer Voltage Information */
child = FindElement(cur, "multiplexers", TRUE);
power_tech_xml_load_multiplexer_info(child);
FreeNode(child);
/* Vds Leakage Information */
child = FindElement(cur, "nmos_leakages", TRUE);
power_tech_xml_load_nmos_st_leakages(child);
FreeNode(child);
/* Buffer SC Info */
child = FindElement(cur, "buffer_sc", TRUE);
power_tech_xml_load_sc(child);
FreeNode(child);
/* Components */
child = FindElement(cur, "components", TRUE);
power_tech_xml_load_components(child);
FreeNode(child);
FreeNode(cur);
}
